Go logrus日志框架详解

【导读】本文介绍了 logrus 日志库和与 iris web 框架的结合。 

logrus特性

• 完全兼容golang标准库日志模块：logrus拥有六种日志级别：debug、info、warn、error、fatal和panic，这是golang标准库日志模块的API的超集。如果您的项目使用标准库日志模块，完全可以以最低的代价迁移到logrus上。

• 可扩展的Hook机制：允许使用者通过hook的方式将日志分发到任意地方，如本地文件系统、标准输出、logstash、elasticsearch或者mq等，或者通过hook定义日志内容和格式等。

• 可选的日志输出格式：logrus内置了两种日志格式，JSONFormatter和TextFormatter，如果这两个格式不满足需求，可以自己动手实现接口Formatter，来定义自己的日志格式。

• Field机制：logrus鼓励通过Field机制进行精细化的、结构化的日志记录，而不是通过冗长的消息来记录日志。

• logrus是一个可插拔的、结构化的日志框架。

logrus使用

简单示例

package main

import (
  log "github.com/sirupsen/logrus"
)

func main() {
  log.WithFields(log.Fields{
    "animal": "walrus",
  }).Info("A walrus appears")
}

输出结果：

time="2018-08-11T15:42:22+08:00" level=info msg="A walrus appears" animal=walrus

简单配置

package main

import (
    "os"
    log "github.com/sirupsen/logrus"
)

func init() {
    // 设置日志格式为json格式
    log.SetFormatter(&log.JSONFormatter{})

    // 设置将日志输出到标准输出（默认的输出为stderr，标准错误）
    // 日志消息输出可以是任意的io.writer类型
    log.SetOutput(os.Stdout)

    // 设置日志级别为warn以上
    log.SetLevel(log.WarnLevel)
}

func main() {
    log.WithFields(log.Fields{
        "animal": "walrus",
        "size":   10,
    }).Info("A group of walrus emerges from the ocean")

    log.WithFields(log.Fields{
        "omg":    true,
        "number": 122,
    }).Warn("The group's number increased tremendously!")

    log.WithFields(log.Fields{
        "omg":    true,
        "number": 100,
    }).Fatal("The ice breaks!")
}

Logger

logger是一种相对高级的用法, 对于一个大型项目, 往往需要一个全局的logrus实例，即logger对象来记录项目所有的日志。

package main

import (
    "github.com/sirupsen/logrus"
    "os"
)

// logrus提供了New()函数来创建一个logrus的实例。
// 项目中，可以创建任意数量的logrus实例。
var log = logrus.New()

func main() {
    // 为当前logrus实例设置消息的输出，同样地，
    // 可以设置logrus实例的输出到任意io.writer
    log.Out = os.Stdout

    // 为当前logrus实例设置消息输出格式为json格式。
    // 同样地，也可以单独为某个logrus实例设置日志级别和hook，这里不详细叙述。
    log.Formatter = &logrus.JSONFormatter{}

    log.WithFields(logrus.Fields{
        "animal": "walrus",
        "size":   10,
    }).Info("A group of walrus emerges from the ocean")
}

Fields

logrus不推荐使用冗长的消息来记录运行信息，它推荐使用Fields来进行精细化的、结构化的信息记录。

log.WithFields(log.Fields{
  "event": event,
  "topic": topic,
  "key": key,
}).Fatal("Failed to send event")

前面的WithFields API可以规范使用者按照其提倡的方式记录日志。但是WithFields依然是可选的，因为某些场景下，使用者确实只需要记录仪一条简单的消息。

通常，在一个应用中、或者应用的一部分中，都有一些固定的Field。比如在处理用户http请求时，上下文中，所有的日志都会有request_id和user_ip。为了避免每次记录日志都要使用log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})，我们可以创建一个logrus.Entry实例，为这个实例设置默认Fields，在上下文中使用这个logrus.Entry实例记录日志即可。

requestLogger := log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})
requestLogger.Info("something happened on that request") # will log request_id and user_ip
requestLogger.Warn("something not great happened")

日志本地文件分割

logrus本身不带日志本地文件分割功能，但是我们可以通过file-rotatelogs进行日志本地文件分割。每次当我们写入日志的时候，logrus都会调用file-rotatelogs来判断日志是否要进行切分。

import (
    "github.com/lestrrat-go/file-rotatelogs"
    "github.com/rifflock/lfshook"
    log "github.com/sirupsen/logrus"
    "time"
)

func newLfsHook(logLevel *string, maxRemainCnt uint) log.Hook {
    writer, err := rotatelogs.New(
        logName+".%Y%m%d%H",
        // WithLinkName为最新的日志建立软连接，以方便随着找到当前日志文件
        rotatelogs.WithLinkName(logName),

        // WithRotationTime设置日志分割的时间，这里设置为一小时分割一次
        rotatelogs.WithRotationTime(time.Hour),

        // WithMaxAge和WithRotationCount二者只能设置一个，
        // WithMaxAge设置文件清理前的最长保存时间，
        // WithRotationCount设置文件清理前最多保存的个数。
        //rotatelogs.WithMaxAge(time.Hour*24),
        rotatelogs.WithRotationCount(maxRemainCnt),
    )

    if err != nil {
        log.Errorf("config local file system for logger error: %v", err)
    }

    level, ok := logLevels[*logLevel]

    if ok {
        log.SetLevel(level)
    } else {
        log.SetLevel(log.WarnLevel)
    }

    lfsHook := lfshook.NewHook(lfshook.WriterMap{
        log.DebugLevel: writer,
        log.InfoLevel:  writer,
        log.WarnLevel:  writer,
        log.ErrorLevel: writer,
        log.FatalLevel: writer,
        log.PanicLevel: writer,
    }, &log.TextFormatter{DisableColors: true})

    return lfsHook
}

结合IRIS使用

先初始化一个Logger出来

config/config.go 定义一个log配置的结构体

type LogConfig struct {
 Level string `yaml:"level"`
 Path  string `yaml:"path"`
 Save  uint   `yaml:"save"`
}

config/logger.go` 根据配置的日志级别，日志路径，日志保留天数初始化一个Logger

package config

import (
 "github.com/lestrrat-go/file-rotatelogs"
 "github.com/rifflock/lfshook"
 "github.com/sirupsen/logrus"
 "os"
 "path"
 "time"
)

var (
 Log = logrus.New()
)

func initLog(logConfig LogConfig) {
 Log.Out = os.Stdout
 var loglevel logrus.Level
 err := loglevel.UnmarshalText([]byte(logConfig.Level))
 if err != nil {
  Log.Panicf("设置log级别失败：%v", err)
 }
 Log.SetLevel(loglevel)
 Log.Formatter = &logrus.TextFormatter{}
 LocalFilesystemLogger(Log, logConfig.Path, logConfig.Save)
 //Log.ReportCaller = true
}

func logWriter(logPath string, level string, save uint) *rotatelogs.RotateLogs {
 logFullPath := path.Join(logPath, level)
 logwriter, err := rotatelogs.New(
  logFullPath+".%Y%m%d",
  rotatelogs.WithLinkName(logFullPath),      // 生成软链，指向最新日志文件
  rotatelogs.WithRotationCount(save),        // 文件最大保存份数
  rotatelogs.WithRotationTime(24*time.Hour), // 日志切割时间间隔
 )
 if err != nil {
  panic(err)
 }
 return logwriter
}

func LocalFilesystemLogger(log *logrus.Logger, logPath string, save uint) {
 lfHook := lfshook.NewHook(lfshook.WriterMap{
  logrus.DebugLevel: logWriter(logPath, "debug", save), // 为不同级别设置不同的输出目的
  logrus.InfoLevel:  logWriter(logPath, "info", save),
  logrus.WarnLevel:  logWriter(logPath, "warn", save),
  logrus.ErrorLevel: logWriter(logPath, "error", save),
  logrus.FatalLevel: logWriter(logPath, "fatal", save),
  logrus.PanicLevel: logWriter(logPath, "panic", save),
 }, &logrus.JSONFormatter{})
 log.AddHook(lfHook)
}

再撸一个中间件打印请求记录middleware/logger_middleware.go

package middleware

import (
 "bytes"
 "github.com/dgrijalva/jwt-go"
 "github.com/kataras/iris/v12"
 "goms/config"
 "io/ioutil"
 "net/http"
 "path"
 "time"
)

func LoggerHandler(ctx iris.Context) {
 p := ctx.Request().URL.Path
 method := ctx.Request().Method
 start := time.Now()
 fields := make(map[string]interface{})
 fields["title"] = "访问日志"
 fields["fun_name"] = path.Join(method, p)
 fields["ip"] = ctx.Request().RemoteAddr
 fields["method"] = method
 fields["url"] = ctx.Request().URL.String()
 fields["proto"] = ctx.Request().Proto
 //fields["header"] = ctx.Request().Header
 fields["user_agent"] = ctx.Request().UserAgent()
 fields["x_request_id"] = ctx.GetHeader("X-Request-Id")

 // 如果是POST/PUT请求，并且内容类型为JSON，则读取内容体
 if method == http.MethodPost || method == http.MethodPut || method == http.MethodPatch {
  body, err := ioutil.ReadAll(ctx.Request().Body)
  if err == nil {
   defer ctx.Request().Body.Close()
   buf := bytes.NewBuffer(body)
   ctx.Request().Body = ioutil.NopCloser(buf)
   fields["content_length"] = ctx.GetContentLength()
   fields["body"] = string(body)
  }
 }
 ctx.Next()

 //下面是返回日志
 fields["res_status"] = ctx.ResponseWriter().StatusCode()
 if ctx.Values().GetString("out_err") != "" {
  fields["out_err"] = ctx.Values().GetString("out_err")
 }
 fields["res_length"] = ctx.ResponseWriter().Header().Get("size")
 if v := ctx.Values().Get("res_body"); v != nil {
  if b, ok := v.([]byte); ok {
   fields["res_body"] = string(b)
  }
 }
 token := ctx.Values().Get("jwt")
 if token != nil {
  fields["uid"] = token.(*jwt.Token).Claims
 }
 timeConsuming := time.Since(start).Nanoseconds() / 1e6
 config.Log.WithFields(fields).Infof("[http] %s-%s-%s-%d(%dms)",
  p, ctx.Request().Method, ctx.Request().RemoteAddr, ctx.ResponseWriter().StatusCode(), timeConsuming)
}

加进路由route/route.go

package route

import (
 "github.com/kataras/iris/v12"
 "github.com/kataras/iris/v12/mvc"
 "goms/controllers"
 "goms/middleware"
)

func InitRoute(app *iris.Application) {
 app.Use(middleware.LoggerHandler)

 mvc.Configure(app.Party("/account"), func(m *mvc.Application) {
  m.Handle(controllers.NewLoginController())
 })
    
    ......
}

最后感觉还是不咋好用，用Json格式不太好看，用Text格式又没有时间，再寻找一下别的Log库看看！

转自：

wisp888.gitee.io/golang-iris-%E5%AD%A6%E4%B9%A0%E5%9B%9B-log%E6%97%A5%E5%BF%97.html

 - EOF -

Go 开发大全

参与维护一个非常全面的Go开源技术资源库。日常分享 Go, 云原生、k8s、Docker和微服务方面的技术文章和行业动态。

关注后获取

回复 Go 获取6万star的Go资源库

分享、点赞和在看

支持我们分享更多好文章，谢谢！