Zap 日志库实践

本文详细介绍了非常流行的 Uber 开源的 zap 日志库，同时介绍了如何搭配 Lumberjack、Rotatelogs 实现日志的切割和归档。

1、日志需求

我们重温一下一个好的日志记录器都需要能够提供下面哪些功能？

良好日志写入性能
支持不同的日志级别。并且可分离成多个日志文件
多输出－同时支持标准输出，文件等
能够打印基本信息，如调用文件 / 函数名和行号，日志时间等
可读性与结构化，Json格式或有分隔符，方便后续的日志采集、监控等
文件切割，可按小时、天进行日志拆分，或者按文件大小
日志书写友好，支持通过context自动log trace等
文件定时删除
开源性，与其他开源框架支持较好

2、Uber-go Zap

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

2.1 为什么选择 Uber-go zap

有关技术选型可以见：https://www.yuque.com/jinsesihuanian/gpwou5/aduc5c

2.2 安装

运行下面的命令安装 zap

go get -u go.uber.org/zap

2.3 配置 Zap Logger

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

在性能很好但不是很关键的上下文中，使用SugaredLogger。它比其他结构化日志记录包快 4-10 倍，并且支持结构化和 printf 风格的日志记录。
在每一微秒和每一次内存分配都很重要的上下文中，使用Logger。它甚至比SugaredLogger更快，内存分配次数也更少，但它只支持强类型的结构化日志记录。

2.3.1 Logger

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

var logger *zap.Logger

func main() {
    InitLogger()
  defer logger.Sync()
    simpleHttpGet("www.baidu.com")
    simpleHttpGet("http://www.baidu.com")
}

func InitLogger() {
    logger, _ = zap.NewProduction()
}

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))
        resp.Body.Close()
    }
}

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

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

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

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

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

我们执行上面的代码会得到如下输出结果：

{"level":"error","ts":1572159218.912792,"caller":"zap_demo/temp.go:25","msg":"Error fetching url..","url":"www.baidu.com","error":"Get www.sogo.com: unsupported protocol scheme \"\"","stacktrace":"main.simpleHttpGet\n\t/Users/q1mi/zap_demo/temp.go:25\nmain.main\n\t/Users/q1mi/zap_demo/temp.go:14\nruntime.main\n\t/usr/local/go/src/runtime/proc.go:203"}
{"level":"info","ts":1572159219.1227388,"caller":"zap_demo/temp.go:30","msg":"Success..","statusCode":"200 OK","url":"http://www.baidu.com"}

2.3.2 Sugared Logger

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

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

下面是修改过后使用SugaredLogger代替Logger的代码：

var sugarLogger *zap.SugaredLogger

func main() {
    InitLogger()
    defer sugarLogger.Sync()
    simpleHttpGet("www.baidu.com")
    simpleHttpGet("http://www.baidu.com")
}

func InitLogger() {
  logger, _ := zap.NewProduction()
    sugarLogger = logger.Sugar()
}

func simpleHttpGet(url string) {
    sugarLogger.Debugf("Trying to hit GET request for %s", url)
    resp, err := http.Get(url)
    if err != nil {
        sugarLogger.Errorf("Error fetching URL %s : Error = %s", url, err)
    } else {
        sugarLogger.Infof("Success! statusCode = %s for URL %s", resp.Status, url)
        resp.Body.Close()
    }
}

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

{"level":"error","ts":1572159149.923002,"caller":"logic/temp2.go:27","msg":"Error fetching URL www.baidu.com : Error = Get www.baidu.com: unsupported protocol scheme \"\"","stacktrace":"main.simpleHttpGet\n\t/Users/zap_demo/logic/temp2.go:27\nmain.main\n\t/Users/zap_demo/logic/temp2.go:14\nruntime.main\n\t/usr/local/go/src/runtime/proc.go:203"}
{"level":"info","ts":1572159150.192585,"caller":"logic/temp2.go:29","msg":"Success! statusCode = 200 OK for URL http://www.baidu.com"}

你应该注意到的了，到目前为止这两个 logger 都打印输出 JSON 结构格式。
在本博客的后面部分，我们将更详细地讨论 SugaredLogger，并了解如何进一步配置它。

2.4 定制 logger

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

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

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

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

zapcore.Core需要三个配置——Encoder，WriteSyncer，LogLevel。

1.Encoder: 编码器 (写入日志格式)。我们将使用开箱即用的NewJSONEncoder()，并使用预先设置的ProductionEncoderConfig()。

zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())

2.WriterSyncer ：指定日志写到哪里去。我们使用zapcore.AddSync()函数并且将打开的文件句柄传进去。

file, _ := os.Create("./test.log")
   writeSyncer := zapcore.AddSync(file)

3.Log Level：哪种级别的日志将被写入。
我们将修改上述部分中的 Logger 代码，并重写InitLogger()方法。其余方法—main() /SimpleHttpGet()保持不变。

func InitLogger() {
    writeSyncer := getLogWriter()
    encoder := getEncoder()
    core := zapcore.NewCore(encoder, writeSyncer, zapcore.DebugLevel)

    logger := zap.New(core)
    sugarLogger = logger.Sugar()
}

func getEncoder() zapcore.Encoder {
    return zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
}

func getLogWriter() zapcore.WriteSyncer {
    file, _ := os.Create("./test.log")
    return zapcore.AddSync(file)
}

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

{"level":"debug","ts":1572160754.994731,"msg":"Trying to hit GET request for www.baidu.com"}
{"level":"error","ts":1572160754.994982,"msg":"Error fetching URL www.sogo.com : Error = Get www.baidu.com: unsupported protocol scheme \"\""}
{"level":"debug","ts":1572160754.994996,"msg":"Trying to hit GET request for http://www.baidu.com"}
{"level":"info","ts":1572160757.3755069,"msg":"Success! statusCode = 200 OK for URL http://www.baidu.com"}

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

现在，我们希望将编码器从 JSON Encoder 更改为普通 Encoder。为此，我们需要将NewJSONEncoder()更改为NewConsoleEncoder()。

return zapcore.NewConsoleEncoder(zap.NewProductionEncoderConfig())

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

1.572161051846623e+09    debug    Trying to hit GET request for www.baidu.com
1.572161051846828e+09    error    Error fetching URL www.sogo.com : Error = Get www.baidu.com: unsupported protocol scheme ""
1.5721610518468401e+09    debug    Trying to hit GET request for http://www.baidu.com
1.572161052068744e+09    info    Success! statusCode = 200 OK for URL http://www.baidu.com

2.4.3 更改时间编码并添加调用者详细信息

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

时间是以非人类可读的方式展示，例如 1.572161051846623e+09
调用方函数的详细信息没有显示在日志中

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

修改时间编码器
在日志文件中使用大写字母记录日志级别

func getEncoder() zapcore.Encoder {
    encoderConfig := zap.NewProductionEncoderConfig()
    encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
    return zapcore.NewConsoleEncoder(encoderConfig)
}

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

logger := zap.New(core, zap.AddCaller())

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

2019-10-27T15:33:29.855+0800    DEBUG    logic/temp2.go:47    Trying to hit GET request for www.baidu.com
2019-10-27T15:33:29.855+0800    ERROR    logic/temp2.go:50    Error fetching URL www.sogo.com : Error = Get www.baidu.com: unsupported protocol scheme ""
2019-10-27T15:33:29.856+0800    DEBUG    logic/temp2.go:47    Trying to hit GET request for http://www.baidu.com
2019-10-27T15:33:30.125+0800    INFO    logic/temp2.go:52    Success! statusCode = 200 OK for URL http://www.baidu.com

3、使用 Lumberjack 进行日志切割归档

_Zap 本身不支持切割归档日志文件，_为了添加日志切割归档功能，我们将使用第三方库 Lumberjack 来实现。

3.1 安装

执行下面的命令安装 Lumberjack

go get -u github.com/natefinch/lumberjack

3.2 zap logger中加入Lumberjack

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

func getLogWriter() zapcore.WriteSyncer {
    lumberJackLogger := &lumberjack.Logger{
        Filename:   "./test.log",
        MaxSize:    10,
        MaxBackups: 5,
        MaxAge:     30,
        Compress:   false,
    }
    return zapcore.AddSync(lumberJackLogger)
}

Lumberjack Logger 采用以下属性作为输入:

Filename: 日志文件的位置
MaxSize：在进行切割之前，日志文件的最大大小（以 MB 为单位）
MaxBackups：保留旧文件的最大个数
MaxAges：保留旧文件的最大天数
Compress：是否压缩 / 归档旧文件

3.3 测试

最终，使用 Zap/Lumberjack logger 的完整示例代码如下：

package main

import (
    "net/http"

    "github.com/natefinch/lumberjack"
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
)

var sugarLogger *zap.SugaredLogger

func main() {
    InitLogger()
    defer sugarLogger.Sync()
    simpleHttpGet("www.sogo.com")
    simpleHttpGet("http://www.sogo.com")
}

func InitLogger() {
    writeSyncer := getLogWriter()
    encoder := getEncoder()
    core := zapcore.NewCore(encoder, writeSyncer, zapcore.DebugLevel)

    logger := zap.New(core, zap.AddCaller())
    sugarLogger = logger.Sugar()
}

func getEncoder() zapcore.Encoder {
    encoderConfig := zap.NewProductionEncoderConfig()
    encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
    return zapcore.NewConsoleEncoder(encoderConfig)
}

func getLogWriter() zapcore.WriteSyncer {
    lumberJackLogger := &lumberjack.Logger{
        Filename:   "./test.log",
        MaxSize:    1,
        MaxBackups: 5,
        MaxAge:     30,
        Compress:   false,
    }
    return zapcore.AddSync(lumberJackLogger)
}

func simpleHttpGet(url string) {
    sugarLogger.Debugf("Trying to hit GET request for %s", url)
    resp, err := http.Get(url)
    if err != nil {
        sugarLogger.Errorf("Error fetching URL %s : Error = %s", url, err)
    } else {
        sugarLogger.Infof("Success! statusCode = %s for URL %s", resp.Status, url)
        resp.Body.Close()
    }
}

执行上述代码，下面的内容会输出到文件——test.log 中。

2019-10-27T15:50:32.944+0800    DEBUG    logic/temp2.go:48    Trying to hit GET request for www.sogo.com
2019-10-27T15:50:32.944+0800    ERROR    logic/temp2.go:51    Error fetching URL www.sogo.com : Error = Get www.sogo.com: unsupported protocol scheme ""
2019-10-27T15:50:32.944+0800    DEBUG    logic/temp2.go:48    Trying to hit GET request for http://www.sogo.com
2019-10-27T15:50:33.165+0800    INFO    logic/temp2.go:53    Success! statusCode = 200 OK for URL http://www.sogo.com

同时，可以在main函数中循环记录日志，测试日志文件是否会自动切割和归档（日志文件每 1MB 会切割并且在当前目录下最多保存 5 个备份）。

4、使用rotatelogs实现日志文件处理

4.1 当前问题

我们当前还存在着两个问题：

生成的日志并未包含日期后缀，Lumberjack在备份时会包含
所有级别的日志都写在一个文件中了，需要根据日志级别写入不同文件

这里我写了一个基于zap + "github.com/lestrrat/go-file-rotatelogs" 工具的工具类，完成自动追加日期后缀，并将不同日志级别的日志写入不同的文件。效果如下：

4.2 日志工具类：

package zaplog

import (
    rotatelogs "github.com/lestrrat/go-file-rotatelogs"
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "os"
    "path/filepath"
    "sync"
    "time"
)

type Options struct {
    LogFileDir    string    //日志路径
    AppName       string    // Filename是要写入日志的文件前缀
    ErrorFileName string
    WarnFileName  string
    InfoFileName  string
    DebugFileName string
    MaxSize       int    // 一个文件多少Ｍ大于该数字开始切分文件
    MaxBackups    int    // MaxBackups是要保留的最大旧日志文件数
    MaxAge        int    // MaxAge是根据日期保留旧日志文件的最大天数
    zap.Config
}

var (
    logger                         *Logger
    sp                             = string(filepath.Separator)
    errWS, warnWS, infoWS, debugWS zapcore.WriteSyncer       // IO输出
    debugConsoleWS                 = zapcore.Lock(os.Stdout) // 控制台标准输出
    errorConsoleWS                 = zapcore.Lock(os.Stderr)
)

func init() {
    logger = &Logger{
        Opts: &Options{},
    }
}

type Logger struct {
    *zap.SugaredLogger
    sync.RWMutex
    Opts      *Options `json:"opts"`
    zapConfig zap.Config
    inited    bool
}

func initLogger(cf ...*Options) {
    logger.Lock()
    defer logger.Unlock()
    if logger.inited {
        logger.Info("[initLogger] logger Inited")
        return
    }
    if len(cf) > 0 {
        logger.Opts = cf[0]
    }
    logger.loadCfg()
    logger.init()
    logger.Info("[initLogger] zap plugin initializing completed")
    logger.inited = true
}


// GetLogger returns logger
func GetLogger() (ret *Logger) {
    return logger
}

func (l *Logger) init() {
    l.setSyncers()
    var err error
    mylogger, err := l.zapConfig.Build(l.cores())
    if err != nil {
        panic(err)
    }
    l.SugaredLogger = mylogger.Sugar()
    defer l.SugaredLogger.Sync()
}

func (l *Logger) loadCfg() {
    if l.Opts.Development {
        l.zapConfig = zap.NewDevelopmentConfig()
        l.zapConfig.EncoderConfig.EncodeTime = timeEncoder
    } else {
        l.zapConfig = zap.NewProductionConfig()
        l.zapConfig.EncoderConfig.EncodeTime = timeUnixNano
    }
    if l.Opts.OutputPaths == nil || len(l.Opts.OutputPaths) == 0 {
        l.zapConfig.OutputPaths = []string{"stdout"}
    }
    if l.Opts.ErrorOutputPaths == nil || len(l.Opts.ErrorOutputPaths) == 0 {
        l.zapConfig.OutputPaths = []string{"stderr"}
    }
    // 默认输出到程序运行目录的logs子目录
    if l.Opts.LogFileDir == "" {
        l.Opts.LogFileDir, _ = filepath.Abs(filepath.Dir(filepath.Join(".")))
        l.Opts.LogFileDir += sp + "logs" + sp
    }
    if l.Opts.AppName == "" {
        l.Opts.AppName = "app"
    }
    if l.Opts.ErrorFileName == "" {
        l.Opts.ErrorFileName = "error.log"
    }
    if l.Opts.WarnFileName == "" {
        l.Opts.WarnFileName = "warn.log"
    }
    if l.Opts.InfoFileName == "" {
        l.Opts.InfoFileName = "info.log"
    }
    if l.Opts.DebugFileName == "" {
        l.Opts.DebugFileName = "debug.log"
    }
    if l.Opts.MaxSize == 0 {
        l.Opts.MaxSize = 100
    }
    if l.Opts.MaxBackups == 0 {
        l.Opts.MaxBackups = 30
    }
    if l.Opts.MaxAge == 0 {
        l.Opts.MaxAge = 30
    }
}

func (l *Logger) setSyncers() {
    f := func(fN string) zapcore.WriteSyncer {
        //return zapcore.AddSync(&lumberjack.Logger{
        //    Filename:   logger.Opts.LogFileDir + sp + logger.Opts.AppName + "-" + fN,
        //    MaxSize:    logger.Opts.MaxSize,
        //    MaxBackups: logger.Opts.MaxBackups,
        //    MaxAge:     logger.Opts.MaxAge,
        //    Compress:   true,
        //    LocalTime:  true,
        //})
        // 每小时一个文件
        logf, _ := rotatelogs.New(l.Opts.LogFileDir + sp + l.Opts.AppName + "-" + fN +".%Y_%m%d_%H",
            rotatelogs.WithLinkName(l.Opts.LogFileDir + sp + l.Opts.AppName + "-" + fN),
            rotatelogs.WithMaxAge(30*24*time.Hour),
            rotatelogs.WithRotationTime(time.Minute),
        )
        return zapcore.AddSync(logf)
    }
    errWS = f(l.Opts.ErrorFileName)
    warnWS = f(l.Opts.WarnFileName)
    infoWS = f(l.Opts.InfoFileName)
    debugWS = f(l.Opts.DebugFileName)
    return
}

func (l *Logger) cores() zap.Option {
    fileEncoder := zapcore.NewJSONEncoder(l.zapConfig.EncoderConfig)
    //consoleEncoder := zapcore.NewConsoleEncoder(logger.zapConfig.EncoderConfig)
    encoderConfig := zap.NewDevelopmentEncoderConfig()
    encoderConfig.EncodeTime = timeEncoder
    consoleEncoder := zapcore.NewConsoleEncoder(encoderConfig)

    errPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
        return lvl > zapcore.WarnLevel && zapcore.WarnLevel-l.zapConfig.Level.Level() > -1
    })
    warnPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
        return lvl == zapcore.WarnLevel && zapcore.WarnLevel-l.zapConfig.Level.Level() > -1
    })
    infoPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
        return lvl == zapcore.InfoLevel && zapcore.InfoLevel-l.zapConfig.Level.Level() > -1
    })
    debugPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
        return lvl == zapcore.DebugLevel && zapcore.DebugLevel-l.zapConfig.Level.Level() > -1
    })
    cores := []zapcore.Core{
        zapcore.NewCore(fileEncoder, errWS, errPriority),
        zapcore.NewCore(fileEncoder, warnWS, warnPriority),
        zapcore.NewCore(fileEncoder, infoWS, infoPriority),
        zapcore.NewCore(fileEncoder, debugWS, debugPriority),
    }
    if l.Opts.Development {
        cores = append(cores, []zapcore.Core{
            zapcore.NewCore(consoleEncoder, errorConsoleWS, errPriority),
            zapcore.NewCore(consoleEncoder, debugConsoleWS, warnPriority),
            zapcore.NewCore(consoleEncoder, debugConsoleWS, infoPriority),
            zapcore.NewCore(consoleEncoder, debugConsoleWS, debugPriority),
        }...)
    }
    return zap.WrapCore(func(c zapcore.Core) zapcore.Core {
        return zapcore.NewTee(cores...)
    })
}
func timeEncoder(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
    enc.AppendString(t.Format("2006-01-02 15:04:05"))
}

func timeUnixNano(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
    enc.AppendInt64(t.UnixNano() / 1e6)
}

4.3 测试

package zaplog

import (
    "fmt"
    "go.uber.org/zap"
    "testing"
    "time"
)

func TestZapLog(t *testing.T) {
    data := &Options{
        LogFileDir: "/Users/didi/code/golang/learn-go/zap_log/v3/logs",
        AppName:    "logtool",
        MaxSize:    30,
        MaxBackups: 7,
        MaxAge:     7,
        Config:     zap.Config{},
    }
    data.Development = true
    initLogger(data)
    for i := 0; i < 2; i++ {
        time.Sleep(time.Second)
        logger.Debug(fmt.Sprint("debug log ", i), zap.Int("line", 999))
        logger.Info(fmt.Sprint("Info log ", i), zap.Any("level", "1231231231"))
        logger.Warn(fmt.Sprint("warn log ", i), zap.String("level", `{"a":"4","b":"5"}`))
        logger.Error(fmt.Sprint("err log ", i), zap.String("level", `{"a":"7","b":"8"}`))
    }
}

至此，我们总结了如何将 Zap 日志程序集成到 Go 应用程序项目中。现在整个golang的日志体系就比较完备了，唯一欠缺一点的就是日志中未接入trace，不能形成完整的日志链路追踪，后续我会在zap结合gin框架使用一文中将此功能分享出来。我们下期见，Peace😘

我是简凡，一个励志用最简单的语言，描述最复杂问题的新时代农民工。求点赞，求关注，如果你对此篇文章有什么疑惑，欢迎在我的微信公众号中留言，我还可以为你提供以下帮助：
帮助建立自己的知识体系
互联网真实高并发场景实战讲解
不定期分享Golang、Java相关业内的经典场景实践
我的博客：https://besthpt.github.io/
我的微信：bestbear666
微信公众号：

参考文档：https://liwenzhou.com/posts/Go/zap/

Zap 日志库实践

1、日志需求

2、Uber-go Zap

2.1 为什么选择 Uber-go zap

2.2 安装

2.3 配置 Zap Logger

2.3.1 Logger

2.3.2 Sugared Logger

2.4 定制 logger

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

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

2.4.3 更改时间编码并添加调用者详细信息

3、使用 Lumberjack 进行日志切割归档

3.1 安装

3.2 zap logger中加入Lumberjack

3.3 测试

4、使用rotatelogs实现日志文件处理

4.1 当前问题

4.2 日志工具类：

4.3 测试

用户bPbv4SA

引用和评论

zap 接收 gin 框架默认的日志

在Java程序中监听mysql的binlog

Spring 实现 3 种异步流式接口，干掉接口超时烦恼

Go 语言-计算密集型服务性能优化

IO 密集型服务耗时优化

Go 语言 JSON 与 Cache 库调研与选型

每一个前端，都要拥有属于自己的埋点库~

Zap 日志库实践

1、日志需求

2、Uber-go Zap

2.1 为什么选择 Uber-go zap

2.2 安装

2.3 配置 Zap Logger

2.3.1 Logger

2.3.2 Sugared Logger

2.4 定制 logger

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

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

2.4.3 更改时间编码并添加调用者详细信息

3、使用 Lumberjack 进行日志切割归档

3.1 安装

3.2 zap logger中加入Lumberjack

3.3 测试

4、使用rotatelogs实现日志文件处理

4.1 当前问题

4.2 日志工具类：

4.3 测试

用户bPbv4SA

引用和评论

zap 接收 gin 框架默认的日志

在Java程序中监听mysql的binlog

Spring 实现 3 种异步流式接口，干掉接口超时烦恼

Go 语言-计算密集型服务 性能优化

IO 密集型服务 耗时优化

Go 语言 JSON 与 Cache 库 调研与选型

每一个前端，都要拥有属于自己的埋点库~

Go 语言-计算密集型服务性能优化

IO 密集型服务耗时优化

Go 语言 JSON 与 Cache 库调研与选型