日志是程序中必不可少的一个环节，由于Go语言内置的日志库功能比较简洁，我们在实际开发中通常会选择使用第三方的日志库来进行开发。本文介绍了logrus这个日志库的基本使用。

logrus介绍

Logrus是Go（golang）的结构化logger，与标准库logger完全API兼容。
它有以下特点：

  • 完全兼容标准日志库，拥有七种日志级别：Trace, Debug, Info, Warning, Error, Fataland Panic。
  • 可扩展的Hook机制，允许使用者通过Hook的方式将日志分发到任意地方，如本地文件系统，logstash，elasticsearch或者mq等，或者通过Hook定义日志内容和格式等
  • 可选的日志输出格式，内置了两种日志格式JSONFormater和TextFormatter，还可以自定义日志格式
  • Field机制，通过Filed机制进行结构化的日志记录

  • 线程安全

    安装

    1. go get github.com/sirupsen/logrus

    基本示例

    使用Logrus最简单的方法是简单的包级导出日志程序:

    1. package main
    2. import (
    3. log "github.com/sirupsen/logrus"
    4. )
    5. func main() {
    6. log.WithFields(log.Fields{
    7.   "animal": "dog",
    8. }).Info("一条舔狗出现了。")
    9. }

    进阶示例

    对于更高级的用法，例如在同一应用程序记录到多个位置，你还可以创建logrus Logger的实例：

    1. package main
    2. import (
    3. "os"
    4. "github.com/sirupsen/logrus"
    5. )
    6. // 创建一个新的logger实例。可以创建任意多个。
    7. var log = logrus.New()
    8. func main() {
    9. // 设置日志输出为os.Stdout
    10. log.Out = os.Stdout
    11. // 可以设置像文件等任意`io.Writer`类型作为日志输出
    12. // file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    13. // if err == nil {
    14. //  log.Out = file
    15. // } else {
    16. //  log.Info("Failed to log to file, using default stderr")
    17. // }
    18. log.WithFields(logrus.Fields{
    19.   "animal": "dog",
    20.   "size":   10,
    21. }).Info("一群舔狗出现了。")
    22. }

    日志级别

    Logrus有七个日志级别：Trace, Debug, Info, Warning, Error, Fataland Panic。

    1. log.Trace("Something very low level.")
    2. log.Debug("Useful debugging information.")
    3. log.Info("Something noteworthy happened!")
    4. log.Warn("You should probably take a look at this.")
    5. log.Error("Something failed but I'm not quitting.")
    6. // 记完日志后会调用os.Exit(1) 
    7. log.Fatal("Bye.")
    8. // 记完日志后会调用 panic() 
    9. log.Panic("I'm bailing.")

    设置日志级别

    你可以在Logger上设置日志记录级别，然后它只会记录具有该级别或以上级别任何内容的条目：

    1. // 会记录info及以上级别 (warn, error, fatal, panic)
    2. log.SetLevel(log.InfoLevel)

    如果你的程序支持debug或环境变量模式，设置log.Level = logrus.DebugLevel会很有帮助。

    字段

    Logrus鼓励通过日志字段进行谨慎的结构化日志记录，而不是冗长的、不可解析的错误消息。
    例如，区别于使用log.Fatalf("Failed to send event %s to topic %s with key %d")，你应该使用如下方式记录更容易发现的内容:

    1. log.WithFields(log.Fields{
    2. "event": event,
    3. "topic": topic,
    4. "key": key,
    5. }).Fatal("Failed to send event")

    WithFields的调用是可选的。

    默认字段

    通常，将一些字段始终附加到应用程序的全部或部分的日志语句中会很有帮助。例如，你可能希望始终在请求的上下文中记录request_id和user_ip。
    区别于在每一行日志中写上log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})，你可以向下面的示例代码一样创建一个logrus.Entry去传递这些字段。

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

    日志条目

    除了使用WithField或WithFields添加的字段外，一些字段会自动添加到所有日志记录事中:

  • time：记录日志时的时间戳

  • msg：记录的日志信息
  • level：记录的日志级别

    Hooks

    你可以添加日志级别的钩子（Hook）。例如，向异常跟踪服务发送Error、Fatal和Panic、信息到StatsD或同时将日志发送到多个位置，例如syslog。
    Logrus配有内置钩子。在init中添加这些内置钩子或你自定义的钩子：
    1. import (
    2. log "github.com/sirupsen/logrus"
    3. "gopkg.in/gemnasium/logrus-airbrake-hook.v2" // the package is named "airbrake"
    4. logrus_syslog "github.com/sirupsen/logrus/hooks/syslog"
    5. "log/syslog"
    6. )
    7. func init() {
    8. // Use the Airbrake hook to report errors that have Error severity or above to
    9. // an exception tracker. You can create custom hooks, see the Hooks section.
    10. log.AddHook(airbrake.NewHook(123, "xyz", "production"))
    11. hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
    12. if err != nil {
    13.   log.Error("Unable to connect to local syslog daemon")
    14. } else {
    15.   log.AddHook(hook)
    16. }
    17. }
    意：Syslog钩子还支持连接到本地syslog（例如. “/dev/log” or “/var/run/syslog” or “/var/run/log”)。有关详细信息，请查看syslog hook README。

    格式化

    logrus内置以下两种日志格式化程序：
    logrus.TextFormatter logrus.JSONFormatter
    还支持一些第三方的格式化程序，详见项目首页。

    记录函数名

    如果你希望将调用的函数名添加为字段，请通过以下方式设置：
    1. log.SetReportCaller(true)
    这会将调用者添加为”method”，如下所示：
    1. {"animal":"penguin","level":"fatal","method":"github.com/sirupsen/arcticcreatures.migrate","msg":"a penguin swims by",
    2. "time":"2014-03-10 19:57:38.562543129 -0400 EDT"}
    注意：，开启这个模式会增加性能开销。

    线程安全

    默认的logger在并发写的时候是被mutex保护的，比如当同时调用hook和写log时mutex就会被请求，有另外一种情况，文件是以appending mode打开的， 此时的并发操作就是安全的，可以用logger.SetNoLock()来关闭它。

    gin框架使用logrus

    1. // a gin with logrus demo
    2. var log = logrus.New()
    3. func init() {
    4.   // Log as JSON instead of the default ASCII formatter.
    5.   log.Formatter = &logrus.JSONFormatter{}
    6.   // Output to stdout instead of the default stderr
    7.   // Can be any io.Writer, see below for File example
    8.   f, _ := os.Create("./gin.log")
    9.   log.Out = f
    10.   gin.SetMode(gin.ReleaseMode)
    11.   gin.DefaultWriter = log.Out
    12.   // Only log the warning severity or above.
    13.   log.Level = logrus.InfoLevel
    14. }
    15. func main() {
    16.   // 创建一个默认的路由引擎
    17.   r := gin.Default()
    18.   // GET：请求方式；/hello：请求的路径
    19.   // 当客户端以GET方法请求/hello路径时，会执行后面的匿名函数
    20.   r.GET("/hello", func(c *gin.Context) {
    21.       log.WithFields(logrus.Fields{
    22.           "animal": "walrus",
    23.           "size":   10,
    24.       }).Warn("A group of walrus emerges from the ocean")
    25.       // c.JSON：返回JSON格式的数据
    26.       c.JSON(200, gin.H{
    27.           "message": "Hello world!",
    28.       })
    29.   })
    30.   // 启动HTTP服务，默认在0.0.0.0:8080启动服务
    31.   r.Run()
    32. }