go-zap

Go go zap log lumberjack gin

发布时间 : 2024-09-06 21:07

字数:1.8k 阅读 :

zap 和 lumberjack 结合使用

使用方法
解释
配合的优势

zap和lumberjack和gin案例

zap

go-zap 是一个高性能、结构化的日志库，由 Uber 开发。它在保证性能的同时，还支持丰富的日志格式，特别适合在生产环境中使用。下面是 go-zap 的基本用法及其特性。

安装

使用以下命令安装 go-zap：

go get -u go.uber.org/zap

基本使用

1. 创建一个简单的 logger

zap 提供了两种模式：开发模式 和 生产模式。开发模式输出格式更易于阅读，而生产模式则更加注重性能。

package main

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

func main() {
    // 创建一个开发模式的 logger
    logger, _ := zap.NewDevelopment()
    defer logger.Sync() // 确保日志在程序结束时被刷新

    logger.Info("This is an info message",
        zap.String("key", "value"),
    )
}

2. 生产模式的 logger

生产模式的 logger 默认是 JSON 格式，适合在高性能环境下使用。

package main

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

func main() {
    // 创建一个生产模式的 logger
    logger, _ := zap.NewProduction()
    defer logger.Sync()

    logger.Info("Production log",
        zap.String("status", "success"),
    )
}

3. 自定义 logger 配置

你可以使用 zap.Config 来自定义 logger 的配置，比如设置日志级别、编码格式等。

package main

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

func main() {
    config := zap.NewProductionConfig()
    config.Encoding = "console" // 将输出改为控制台格式
    config.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder

    logger, _ := config.Build()
    defer logger.Sync()

    logger.Warn("This is a warning message")
}

4. 结构化日志

zap 支持结构化日志，你可以通过 zap.Field 提供额外的上下文信息。

package main

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

func main() {
    logger, _ := zap.NewProduction()
    defer logger.Sync()

    // 记录结构化日志
    logger.Info("User logged in",
        zap.String("username", "john"),
        zap.Int("age", 28),
        zap.Bool("isAdmin", false),
    )
}

5. 性能优化的 Sugared Logger

如果你不需要每条日志都是结构化的，zap 也提供了一个更加灵活的 SugaredLogger，它使用 fmt.Printf 风格的日志记录方式。

package main

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

func main() {
    logger, _ := zap.NewProduction()
    sugar := logger.Sugar()
    defer sugar.Sync()

    // 使用 Sugared Logger 记录日志
    sugar.Infof("User %s has logged in", "john")
}

总结

go-zap 提供了高效的日志处理方案，特别适合需要处理大规模日志和追求高性能的应用。无论是在开发环境还是生产环境，它都能很好地满足不同场景下的需求。

可以在 zap GitHub 仓库以及官方文档中找到更多详细的说明和使用案例.

zap 和 lumberjack 结合使用

zap 和 lumberjack 可以结合使用来处理日志文件的滚动存储（即根据文件大小、时间等条件自动进行日志文件的切割）。lumberjack 提供了日志文件的滚动功能，而 zap 负责高效的日志记录。通过将 lumberjack 与 zap 的 WriteSyncer 结合使用，你可以在高效记录日志的同时，自动管理日志文件的大小和备份。

使用方法

首先，安装 lumberjack：

go get gopkg.in/natefinch/lumberjack.v2

接下来，通过代码将 lumberjack 和 zap 结合：

package main

import (
    "gopkg.in/natefinch/lumberjack.v2"
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "os"
)

func main() {
    // 配置 lumberjack 用于日志切割
    lumberjackLogger := &lumberjack.Logger{
        Filename:   "./logs/app.log", // 日志文件路径
        MaxSize:    10,               // 每个日志文件最大10MB
        MaxBackups: 3,                // 保留最多3个备份
        MaxAge:     28,               // 保留28天的日志
        Compress:   true,             // 启用压缩
    }

    // 将 lumberjack 与 zap 结合
    writeSyncer := zapcore.AddSync(lumberjackLogger)
    encoder := zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
    core := zapcore.NewCore(encoder, writeSyncer, zapcore.InfoLevel)

    logger := zap.New(core)
    defer logger.Sync()

    // 测试日志记录
    logger.Info("This is a test log message",
        zap.String("module", "main"),
        zap.Int("line", 42),
    )

    logger.Error("This is an error message")
}

解释

lumberjack.Logger: 配置了日志文件路径、最大文件大小、最大备份数量、最大保存天数和是否压缩等参数。
zapcore.AddSync: 将 lumberjack.Logger 和 zap 的 WriteSyncer 结合，用于日志文件的滚动。
zapcore.NewCore: 创建 zap 的核心，使用 JSON 编码格式，并指定日志级别。

配合的优势

高效日志记录：zap 保证了高性能的日志记录。
日志滚动：通过 lumberjack 实现日志文件自动切割，避免日志文件过大。

结合这两者可以在保持高效日志记录的同时，确保日志管理的简洁和自动化。你可以根据项目需求调整 lumberjack 的配置参数，满足特定的日志存储策略。

有关更多详细说明，请参考 lumberjack 官方文档和 zap 官方文档

zap和lumberjack和gin案例

代码如下

package logger

import (
    "github.com/gin-gonic/gin"
    "github.com/spf13/viper"
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "gopkg.in/natefinch/lumberjack.v2"
    "net"
    "net/http"
    "net/http/httputil"
    "os"
    "runtime/debug"
    "strings"
    "time"
)

var lg *zap.Logger

// Init 初始化Logger
func Init(mode string) (err error) {
    writeSyncer := getLogWriter(
        viper.GetString("log.filename"),
        viper.GetInt("log.max_size"),
        viper.GetInt("log.max_backups"),
        viper.GetInt("log.max_age"),
    ) // io.Writer
    encoder := getEncoder() // 编码

    var l = new(zapcore.Level)
    err = l.UnmarshalText([]byte(viper.GetString("log.level")))
    if err != nil {
        return
    }

    var core zapcore.Core
    if mode == "dev" {
        // 进入开发模式,日志输出到终端
        consoleEnbcoder := zapcore.NewConsoleEncoder(zap.NewDevelopmentEncoderConfig())
        core = zapcore.NewTee(
            zapcore.NewCore(encoder, writeSyncer, l))
        zapcore.NewCore(consoleEnbcoder, zapcore.Lock(os.Stdout), zapcore.DebugLevel)

    } else {
        core = zapcore.NewCore(encoder, writeSyncer, l)
    }

    lg = zap.New(core, zap.AddCaller())

    // 将zap 库的 logger 全局化
    zap.ReplaceGlobals(lg)
    zap.L().Info("init logger success")

    return
}

func getEncoder() zapcore.Encoder {
    encoderConfig := zap.NewProductionEncoderConfig()
    encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    encoderConfig.TimeKey = "time"
    encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
    encoderConfig.EncodeDuration = zapcore.SecondsDurationEncoder
    encoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
    return zapcore.NewJSONEncoder(encoderConfig)
}

func getLogWriter(filename string, maxSize, maxBackup, maxAge int) zapcore.WriteSyncer {
    lumberJackLogger := &lumberjack.Logger{
        Filename:   filename,
        MaxSize:    maxSize,
        MaxBackups: maxBackup,
        MaxAge:     maxAge,
    }
    return zapcore.AddSync(lumberJackLogger)
}

// GinLogger 接收gin框架默认的日志
func GinLogger() 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)
        lg.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，并使用zap记录相关日志
func GinRecovery(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 {
                    lg.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 {
                    lg.Error("[Recovery from panic]",
                        zap.Any("error", err),
                        zap.String("request", string(httpRequest)),
                        zap.String("stack", string(debug.Stack())),
                    )
                } else {
                    lg.Error("[Recovery from panic]",
                        zap.Any("error", err),
                        zap.String("request", string(httpRequest)),
                    )
                }
                c.AbortWithStatus(http.StatusInternalServerError)
            }
        }()
        c.Next()
    }
}