⚡ zap

Golang
628
0
0
2022-07-18
go-zero之支付回调问题
上一篇
xorm自动生成model
下一篇

Zap日志库

Go 中快速、结构化、分级的日志记录。

在许多Go语言项目中，我们需要一个好的日志记录器能够提供下面这些功能：

  • 能够将事件记录到文件中，而不是应用程序控制台。
  • 日志切割-能够根据文件大小、时间或间隔等来切割日志文件。
  • 支持不同的日志级别。例如INFO，DEBUG，ERROR等。
  • 能够打印基本信息，如调用文件/函数名和行号，日志时间等。

1.安装

go get -u go.uber.org/zap
请注意，zap只支持Go的两个最新的小版本。

2.默认的Go Logger

在介绍Uber-go的zap包之前，让我们先看看Go语言提供的基本日志功能。

Go语言提供的默认日志包是golang.org/pkg/log/

2.1 实现Go Logger

实现一个Go语言中的日志记录器非常简单:

创建一个新的日志文件，然后设置它为日志的输出位置

涉及到的api

  • OpenFile 既能打开一个已经存在的文件，也能创建并打开一个新文件。
  • func OpenFile(name string, flag int, perm FileMode) (*File, error)
package main

import (
    "log" 
    "os"
)

func initGoLogger()  {
  locatonPath := "/Users/codehope/remote-es-server-code/zap-demo/test.log"
    locationLoggerFile, _ := os.OpenFile(locatonPath,os.O_CREATE|os.O_APPEND|os.O_RDWR,0744)
    log.SetOutput(locationLoggerFile)
}
func main()  {
    initGoLogger()
    log.Printf("info %s","message")
}

当我们执行上面的代码，我们能看到一个test.log文件被创建，下面的内容会被添加到这个日志文件中

2021/11/02 14:08:43 info message

2.2 Go Logger的优势和劣势

优势

  • 它最大的优点是使用非常简单。我们可以设置任何io.Writer作为日志记录输出并向其发送要写入的日志。

劣势

  • 仅限基本的日志级别
  • 只有一个Print选项。不支持INFO/DEBUG等多个级别。
  • 对于错误日志，它有Fatal和Panic,Fatal日志通过调用os.Exit(1)来结束程序
  • Panic日志在写入日志消息之后抛出一个panic,但是它缺少一个ERROR日志级别，这个级别可以在不抛出panic或退出程序的情况下而记录错误
  • 缺乏日志格式化的能力——例如记录调用者的函数名和行号，格式化日期和时间格式。等等。
  • 不提供日志切割的能力。

3.Uber-go Zap

【Zap是非常快的、结构化的，分日志级别的Go日志库。】

3.1 安装

运行下面的命令安装zap

go get -u go.uber.org/zap

3.2 配置Zap Logger

Zap提供了两种类型的日志记录器—Sugared Logger和Logger。

在性能很好但不是很关键的上下文中，使用SugaredLogger

它比其他结构化日志记录包快4-10倍，并且支持结构化和printf风格的日志记录。

在每一微秒和每一次内存分配都很重要的上下文中，使用Logger。

它甚至比SugaredLogger更快，内存分配次数也更少，但它只支持强类型的结构化日志记录。

  • 通过调用zap.NewProduction()/zap.NewDevelopment()或者zap.Example()创建一个Logger。
  • 上面的每一个函数都将创建一个logger。唯一的区别在于它将记录的信息不同。例如production logger默认记录调用函数信息、日期和时间等。
  • 通过Logger调用Info/Error等。
  • 默认情况下日志都会打印到应用程序的console界面。
package main

import (
    "go.uber.org/zap" 
    "net/http"
)

var logger *zap.Logger 

func simpleHttpGet(url string) {
    resp, err := http.Get(url)
    if err != nil {
        logger.Error(
            "Error fetching url..",
            zap.String("url", url),
            zap.Error(err))
    } else {
        logger.Info("Success..",
            zap.String("statusCode", resp.Status),
            zap.String("url", url))
        err := resp.Body.Close()
        if err != nil {
            return
        }
    }
}
func main()  {
    logger, _ = zap.NewProduction()
    simpleHttpGet("https://www.baidu.com")
    simpleHttpGet("https://www.google.com")
}

测试执行输出结果：

{"level":"info","ts":1635834613.299716,"caller":"zap-demo/main.go:23","msg":"Success..","statusCode":"200 OK","url":"https://www.baidu.com"}
{"level":"error","ts":1635834643.3006458,"caller":"zap-demo/main.go:18","msg":"Error fetching url..","url":"https://www.google.com","error":"Get \"https://www.google.com\": dial tcp 185.45.6.103:443: i/o timeout","stacktrace":"main.simpleHttpGet\n\t/Users/codehope/remote-es-server-code/zap-demo/main.go:18\nmain.main\n\t/Users/codehope/remote-es-server-code/zap-demo/main.go:38\nruntime.main\n\t/usr/local/go/src/runtime/proc.go:255"}

在上面的代码中，我们首先创建了一个Logger，然后使用Info/ Error等Logger方法记录消息。

日志记录器方法的语法是这样的：

func (log *Logger) MethodXXX(msg string, fields ...Field)

其中MethodXXX是一个可变参数函数，可以是Info / Error/ Debug / Panic等。每个方法都接受一个消息字符串和任意数量的zapcore.Field场参数。

每个zapcore.Field其实就是一组键值对参数。

image-20211102144203335

3.3 Sugared Logger

现在让我们使用Sugared Logger来实现相同的功能。

  • 大部分的实现基本都相同。
  • 惟一的区别是，我们通过调用主logger的. Sugar()方法来获取一个SugaredLogger。
  • 然后使用SugaredLogger以printf格式记录语句
package main

import (
  "go.uber.org/zap" 
  "net/http"
)

var sluggerLogger *zap.SugaredLogger
/*
    simpleHttpGet 带有日志的http请求
*/
func simpleHttpGet(url string) {
    resp, err := http.Get(url)
    if err != nil {
        sluggerLogger.Errorf(
            "Error fetching url..,url = %s,err= %d",
            url,
            err)
    } else {
        sluggerLogger.Infof("Success..,statusCode=%s.url=%s",
            resp.Status,
            url)
        err := resp.Body.Close()
        if err != nil {
            return
        }
    }
}
func main()  {
    logger, _ := zap.NewProduction()
    sluggerLogger = logger.Sugar()
    simpleHttpGet("https://www.baidu.com")
}

当你执行上面的代码会得到如下输出：

{ 
  "level":"info", 
  "ts":1635835735.4530501, 
  "caller":"zap-demo/sugerLoger.go:20", 
  "msg":"Success..,statusCode=200 OK.url=https://www.baidu.com"
}

【你应该注意到的了，到目前为止这两个logger都打印输出JSON结构格式。】

4.定制logger

4.1 将日志写入文件而不是终端

我们要做的第一个更改是把日志写入文件，而不是打印到应用程序控制台。

【 我们将使用zap.New(…)方法来手动传递所有配置，而不是使用像zap.NewProduction()这样的预置方法来创建logger 】

func New(core zapcore.Core, options ...Option) *Logger

zapcore.Core需要三个配置:

  • Encoder 编码器(如何写入日志)
  • 我们将使用开箱即用的NewJSONEncoder()，并使用预先设置的ProductionEncoderConfig()
zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
  • WriteSyncer 指定日志将写到哪里去
  • 我们使用zapcore.AddSync()函数并且将打开的文件句柄传进去
file, _ := os.Create("./test.log")
writeSyncer := zapcore.AddSync(file)
  • LogLevel 哪种级别的日志将被写入
package main

import (
    "fmt" 
    "go.uber.org/zap" 
    "go.uber.org/zap/zapcore" 
    "os"
)

/*
    setJSONEncoder 设置logger编码
*/
func setJSONEncoder() zapcore.Encoder {
    return zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
}
/*
    setLoggerWrite 设置logger写入文件
 */
func setLoggerWrite() zapcore.WriteSyncer {
    //create, _ := os.OpenFile("./test.log",os.O_CREATE|os.O_APPEND|os.O_RDWR,0744)
    create, err := os.OpenFile("./test.log", os.O_CREATE|os.O_APPEND|os.O_RDWR, 0755)
    if err != nil {
        fmt.Println(err)
    }
    return zapcore.AddSync(create)
}

func main() {
    var logger *zap.SugaredLogger
    core := zapcore.NewCore(setJSONEncoder(), setLoggerWrite(), zap.InfoLevel)
    logger = zap.New(core).Sugar()
    for i := 0; i < 10; i++ {
        logger.Infof("Info%d", i)
        logger.Errorf("Error%d", i)
        logger.Debugf("Debug%d", i)
        logger.Warnf("Warn%d", i)
    }
}

上面代码执行后，发现多了一个test.log,发现只写入了Info，Error，Warn级别的log，Debug级别没有写入

{"level":"info","ts":1635837845.908652,"msg":"Info0"}
{"level":"error","ts":1635837845.908742,"msg":"Error0"}
{"level":"warn","ts":1635837845.9087548,"msg":"Warn0"}
{"level":"info","ts":1635837845.9087648,"msg":"Info1"}
{"level":"error","ts":1635837845.908774,"msg":"Error1"}
{"level":"warn","ts":1635837845.9087832,"msg":"Warn1"}
{"level":"info","ts":1635837845.908791,"msg":"Info2"}
{"level":"error","ts":1635837845.908799,"msg":"Error2"}
{"level":"warn","ts":1635837845.908808,"msg":"Warn2"}
{"level":"info","ts":1635837845.9088159,"msg":"Info3"}
{"level":"error","ts":1635837845.908824,"msg":"Error3"}
{"level":"warn","ts":1635837845.908832,"msg":"Warn3"}
{"level":"info","ts":1635837845.908841,"msg":"Info4"}
{"level":"error","ts":1635837845.908849,"msg":"Error4"}
{"level":"warn","ts":1635837845.908857,"msg":"Warn4"}
{"level":"info","ts":1635837845.908865,"msg":"Info5"}
{"level":"error","ts":1635837845.9088728,"msg":"Error5"}
{"level":"warn","ts":1635837845.908881,"msg":"Warn5"}
{"level":"info","ts":1635837845.908889,"msg":"Info6"}
{"level":"error","ts":1635837845.908897,"msg":"Error6"}
{"level":"warn","ts":1635837845.908905,"msg":"Warn6"}
{"level":"info","ts":1635837845.908913,"msg":"Info7"}
{"level":"error","ts":1635837845.908921,"msg":"Error7"}
{"level":"warn","ts":1635837845.908929,"msg":"Warn7"}
{"level":"info","ts":1635837845.908937,"msg":"Info8"}
{"level":"error","ts":1635837845.9089448,"msg":"Error8"}
{"level":"warn","ts":1635837845.9089532,"msg":"Warn8"}
{"level":"info","ts":1635837845.908961,"msg":"Info9"}
{"level":"error","ts":1635837845.908969,"msg":"Error9"}
{"level":"warn","ts":1635837845.9089768,"msg":"Warn9"}

4.2 将JSON Encoder更改为普通的Log Encoder

现在，我们希望将编码器从JSON Encoder更改为普通Encoder。

为此，我们需要将NewJSONEncoder()更改为NewConsoleEncoder()。

zapcore.NewConsoleEncoder

/*
    setJSONEncoder 设置logger编码
*/
func setJSONEncoder() zapcore.Encoder {
    return zapcore.NewConsoleEncoder(zap.NewProductionEncoderConfig())
}

当使用这些修改过的logger配置调用上述部分的main()函数时，以下输出将打印在文件——test.log中。

1.635838141476396e+09    info    Info0
1.635838141476515e+09    error    Error0
1.6358381414765272e+09    warn    Warn0
1.635838141476535e+09    info    Info1
1.635838141476552e+09    error    Error1
1.6358381414765608e+09    warn    Warn1
1.635838141476567e+09    info    Info2
1.635838141476574e+09    error    Error2
1.635838141476581e+09    warn    Warn2
1.635838141476587e+09    info    Info3
1.6358381414765928e+09    error    Error3
1.635838141476599e+09    warn    Warn3
1.635838141476606e+09    info    Info4
1.635838141476612e+09    error    Error4
1.635838141476618e+09    warn    Warn4

4.3 更改编码（格式化时间，日志级别大写）

鉴于我们对配置所做的更改，有下面问题：

  • 时间是以非人类可读的方式展示，例如1.572161051846623e+09

我们要做的第一件事是覆盖默认的ProductionConfig()，并进行以下更改:

  • 修改时间编码器
  • 在日志文件中使用大写字母记录日志级别
/*
    setJSONEncoder 设置logger编码
*/

func setJSONEncoder() zapcore.Encoder {
    encoderConfig := zap.NewProductionEncoderConfig()
    encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder //转换编码的时间戳
    encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder //编码级别调整为大写的级别输出  
    return zapcore.NewConsoleEncoder(encoderConfig)
}

修改编码配置后，重新执行后，test.log的内容：可以看到时间也被调整了，日志级别的格式也都为大写

2021-11-02T15:33:46.712+0800    INFO    Info0
2021-11-02T15:33:46.712+0800    ERROR    Error0
2021-11-02T15:33:46.712+0800    WARN    Warn0
2021-11-02T15:33:46.712+0800    INFO    Info1
2021-11-02T15:33:46.712+0800    ERROR    Error1
2021-11-02T15:33:46.712+0800    WARN    Warn1
2021-11-02T15:33:46.712+0800    INFO    Info2
2021-11-02T15:33:46.712+0800    ERROR    Error2
2021-11-02T15:33:46.712+0800    WARN    Warn2
2021-11-02T15:33:46.712+0800    INFO    Info3
2021-11-02T15:33:46.712+0800    ERROR    Error3
2021-11-02T15:33:46.712+0800    WARN    Warn3
2021-11-02T15:33:46.712+0800    INFO    Info4
2021-11-02T15:33:46.712+0800    ERROR    Error4
2021-11-02T15:33:46.712+0800    WARN    Warn4

4.4 添加调用者详细信息

我们将修改zap logger代码，添加将调用函数信息记录到日志中的功能。为此，我们将在zap.New(..)函数中添加一个Option。

执行后test.log的内容,加入了对应目录/文件 行数的日志信息

2021-11-02T15:37:42.035+0800    INFO    zap-demo/customLogger.go:36    Info0
2021-11-02T15:37:42.035+0800    ERROR    zap-demo/customLogger.go:37    Error0
2021-11-02T15:37:42.035+0800    WARN    zap-demo/customLogger.go:39    Warn0
2021-11-02T15:37:42.035+0800    INFO    zap-demo/customLogger.go:36    Info1
2021-11-02T15:37:42.035+0800    ERROR    zap-demo/customLogger.go:37    Error1
2021-11-02T15:37:42.035+0800    WARN    zap-demo/customLogger.go:39    Warn1
2021-11-02T15:37:42.035+0800    INFO    zap-demo/customLogger.go:36    Info2
2021-11-02T15:37:42.035+0800    ERROR    zap-demo/customLogger.go:37    Error2
2021-11-02T15:37:42.035+0800    WARN    zap-demo/customLogger.go:39    Warn2
2021-11-02T15:37:42.035+0800    INFO    zap-demo/customLogger.go:36    Info3
2021-11-02T15:37:42.035+0800    ERROR    zap-demo/customLogger.go:37    Error3
2021-11-02T15:37:42.035+0800    WARN    zap-demo/customLogger.go:39    Warn3
2021-11-02T15:37:42.035+0800    INFO    zap-demo/customLogger.go:36    Info4
2021-11-02T15:37:42.035+0800    ERROR    zap-demo/customLogger.go:37    Error4
2021-11-02T15:37:42.035+0800    WARN    zap-demo/customLogger.go:39    Warn4

5.使用Lumberjack进行日志切割归档

这个日志程序中唯一缺少的就是日志切割归档功能。

Zap本身不支持切割归档日志文件

为了添加日志切割归档功能，我们将使用第三方库Lumberjack来实现。

安装执行下面的命令安装Lumberjack

go get -u github.com/natefinch/lumberjack

要在zap中加入Lumberjack支持，我们需要修改WriteSyncer代码。我们将按照下面的代码修改getLogWriter()函数：

func setLoggerWrite() zapcore.WriteSyncer {
    //create, _ := os.OpenFile("./test.log",os.O_CREATE|os.O_APPEND|os.O_RDWR,0744)  
    //create, err := os.OpenFile("./test.log", os.O_CREATE|os.O_APPEND|os.O_RDWR, 0755)  
    //if err != nil {  
    //    fmt.Println(err)  
    //}
    l :=&lumberjack.Logger{
        Filename:"./test.log", //Filename 是要写入日志的文件。
        MaxSize:    1, //MaxSize 是日志文件在轮换之前的最大大小（以兆字节为单位）。它默认为 100 兆字节
        MaxBackups: 1,//MaxBackups 是要保留的最大旧日志文件数。默认是保留所有旧的日志文件（尽管 MaxAge 可能仍会导致它们被删除。）
        MaxAge:     30,//MaxAge 是根据文件名中编码的时间戳保留旧日志文件的最大天数。
        Compress:   true,//压缩
        LocalTime: true, //LocalTime 确定用于格式化备份文件中的时间戳的时间是否是计算机的本地时间。默认是使用 UTC 时间。
    }
    return zapcore.AddSync(l)
}

测试一下代码：每次写入5000条日志，多次写入后

func main() {
    var logger *zap.SugaredLogger
    core := zapcore.NewCore(setJSONEncoder(), setLoggerWrite(), zap.InfoLevel)
    logger = zap.New(core,zap.AddCaller()).Sugar()
    for i := 0; i < 5000; i++ {
        logger.Infof("Info%d", i)
        logger.Errorf("Error%d", i)
        logger.Debugf("Debug%d", i)
        logger.Warnf("Warn%d", i)
    }
}

image-20211102154908691

test.log是我们自己一开始创建的log,test-2021-11…是lumberjack帮我们切割出来的新的日志文件，x x.log.gz是备份文件

6.Gin框架添加Zap日志库

6.1 整理日志包

首先我们创建一个单独的项目，并且把日志配置相关的放到项目单独的一个包中

目录结构：

 ~/remote-es-server-code/zap-demo  tree
.
├── go.mod
├── go.sum
├── logs
├── main.go
└── setup
    └── CwLogger.go

2 directories, 4 files

CwLogger.go

package setup

import (
    "github.com/natefinch/lumberjack" 
    "go.uber.org/zap" 
    "go.uber.org/zap/zapcore"
)
var logger *zap.SugaredLogger

/*
    setJSONEncoder 设置logger编码
*/
func setJSONEncoder() zapcore.Encoder {
    encoderConfig := zap.NewProductionEncoderConfig()
    encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder //转换编码的时间戳
    encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder //编码级别调整为大写的级别输出  
    return zapcore.NewConsoleEncoder(encoderConfig)
}
/*
    setLoggerWrite 设置logger写入文件
 */
func setLoggerWrite() zapcore.WriteSyncer {
    l :=&lumberjack.Logger{
        Filename:"./logs/test.log",
        MaxSize:    1,
        MaxBackups: 1,
        MaxAge:     30,
        Compress:   true,
        LocalTime: true,
    }
    return zapcore.AddSync(l)
}
/*
    InitLogger 初始化 logger
*/
func InitLogger() {
    core := zapcore.NewCore(setJSONEncoder(), setLoggerWrite(), zap.InfoLevel)
    logger = zap.New(core, zap.AddCaller()).Sugar()
}
func CwLog() *zap.SugaredLogger{
    return logger
}

先简单测试一下执行：

package main

import "zap-demo/setup"

func init() {
    setup.InitLogger() //初始化log
}
func main()  {
    setup.CwLog().Warn("this is a test!") //测试log
}
 ~/remote-es-server-code/zap-demo  tree
.
├── go.mod
├── go.sum
├── logs
│   └── test.log # 日志文件生成成功
├── main.go
└── setup
    └── CwLogger.go

2 directories, 5 files

test.log 测试日志文件内容：

2021-11-02T16:27:41.032+0800    WARN    zap-demo/main.go:9    this is a test!

6.2 替换gin框架的默认日志中间件

安装gin go get -u github.com/gin-gonic/gin

模版初始化

package main

import (
    "github.com/gin-gonic/gin" 
    "zap-demo/setup"
)

func init() {
    setup.InitLogger()
}
func main()  {
    router := gin.Default()
    router.GET("/", func(context *gin.Context) {
        context.JSON(200,"Hello Gin")
    })
    err := router.Run(":8008")
    if err != nil {
        return
    }
}

运行时，可以发现Default的初始化方式，自带log的中间件，但是这个中间件我们没有办法去控制，所以要替换成我们的

image-20211102163438687

//默认返回一个 Engine 实例，其中已经附加了 Logger 和 Recovery 中间件。
func Default() *Engine {
    debugPrintWARNINGDefault()
    engine := New()
    engine.Use(Logger(), Recovery()) //这里我们也需要改造Recovery中间件  
    return engine
}

func New() *Engine {} 使用New的话是默认没有任何日志中间件在里面的，所以我们就使用这个来初始化gin引擎，并自己添加我们日志的中间件

// GinLogger 接收gin框架默认的日志

func GinLogger(logger *zap.Logger) gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        path := c.Request.URL.Path
        query := c.Request.URL.RawQuery
        c.Next()
        cost := time.Since(start)
        logger.Info(path,
            zap.Int("status", c.Writer.Status()),
            zap.String("method", c.Request.Method),
            zap.String("path", path),
            zap.String("query", query),
            zap.String("ip", c.ClientIP()),
            zap.String("user-agent", c.Request.UserAgent()),
            zap.String("errors", c.Errors.ByType(gin.ErrorTypePrivate).String()),
            zap.Duration("cost", cost),
        )
    }
}
// GinRecovery recover掉项目可能出现的panic(根据gin框架源码recover中间件改的)

func GinRecovery(logger *zap.Logger, stack bool) gin.HandlerFunc {
    return func(c *gin.Context) {
        defer func() {
            if err := recover(); err != nil {
                // Check for a broken connection, as it is not really a  
                // condition that warrants a panic stack trace.  
                var brokenPipe bool 
                if ne, ok := err.(*net.OpError); ok {
                    if se, ok := ne.Err.(*os.SyscallError); ok {
                        if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
                            brokenPipe = true
                        }
                    }
                }

                httpRequest, _ := httputil.DumpRequest(c.Request, false)
                if brokenPipe {
                    logger.Error(c.Request.URL.Path,
                        zap.Any("error", err),
                        zap.String("request", string(httpRequest)),
                    )
                    // If the connection is dead, we can't write a status to it.
                    c.Error(err.(error)) // nolint: errcheck
                    c.Abort()
                    return
                }

                if stack {
                    logger.Error("[Recovery from panic]",
                        zap.Any("error", err),
                        zap.String("request", string(httpRequest)),
                        zap.String("stack", string(debug.Stack())),
                    )
                } else {
                    logger.Error("[Recovery from panic]",
                        zap.Any("error", err),
                        zap.String("request", string(httpRequest)),
                    )
                }
                c.AbortWithStatus(http.StatusInternalServerError)
            }
        }()
        c.Next()
    }
}

测试：

package main

import (
    "github.com/gin-gonic/gin" 
    "zap-demo/setup"
)

func init() {
    setup.InitLogger()
}
func main()  {
    router := gin.New()
    router.Use(setup.GinLogger(setup.CwLog()),setup.GinRecovery(setup.CwLog(),true))
    router.GET("/", func(context *gin.Context) {
        context.JSON(200,"Hello Gin")
    })
    err := router.Run(":8008")
    if err != nil {
        return
    }
}

访问：localhost:8008/ 测试 生成了新的test.log,内容：可以看到我们的请求被我们自定义的日志中间件控制啦！

2021-11-02T16:56:06.092+0800    INFO    setup/CwLogger.go:60    /    {"status": 200, "method": "GET", "path": "/", "query": "", "ip": "::1", "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36", "errors": "", "cost": 0.000044822}
go-zero之支付回调问题
上一篇
xorm自动生成model
下一篇