关于golang:zap-接收-gin-框架默认的日志

17次阅读

共计 9554 个字符，预计需要花费 24 分钟才能阅读完成。

后面两篇曾经为大家介绍了 golang 中的日志如何应用，并在诸多日志框架库中抉择了 zap 作为咱们的日志框架，本篇将会解说：

  1. 如何联合当下支流的 Web 框架 gin 进行申请日志的打印
  2. 对 zap 进行二次封装，注入 trace 信息，一遍咱们能够在业务中查问一次申请的所有残缺日志

这里是前两篇的链接：

  1. https://www.yuque.com/jinsesi…
  2. https://www.yuque.com/jinsesi…

1、gin 默认的中间件

首先咱们来看一个最简略的 gin 我的项目：

func main() {r := gin.Default()
    r.GET("/hello", func(c *gin.Context) {c.String("hello jianfan.com!")
    })
    r.Run(}

接下来咱们看一下 gin.Default() 的源码：

func Default() *Engine {debugPrintWARNINGDefault()
    engine := New()
    engine.Use(Logger(), Recovery())
    return engine
}

也就是咱们在应用 gin.Default() 的同时是用到了 gin 框架内的两个默认中间件 Logger() 和Recovery()。

其中 Logger() 是把 gin 框架自身的日志输入到规范输入（咱们本地开发调试时在终端输入的那些日志就是它的功绩），而 Recovery() 是在程序呈现 panic 的时候复原现场并写入 500 响应的。

2、基于 zap 的中间件

gin 框架反对用户自定义的 middleware，咱们能够模拟 Logger() 和Recovery()的实现，应用咱们的日志库来接管 gin 框架默认输入的日志。
这里以 zap 为例，咱们实现两个中间件如下：

// 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
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()}
}

如果不想本人实现，能够应用 github 上有他人封装好的 https://github.com/gin-contrib/zap。

这样咱们就能够在 gin 框架中应用咱们下面定义好的两个中间件来代替 gin 框架默认的 Logger() 和Recovery()了。

r := gin.New()
r.Use(GinLogger(), GinRecovery())

3、减少 Trace 信息

3.1 定义 trace 信息

// 定义 trace 构造体
type Trace struct {
    TraceId   string  `json:"trace_id"`
    SpanId    string  `json:"span_id"`
    Caller    string  `json:"caller"`
    SrcMethod *string `json:"srcMethod,omitempty"`
    UserId    int   `json:"user_id"`
}

// 依据 gin 的 context 获取 context，使 log trace 更加通用
func GetTraceCtx(c *gin.Context) context.Context {return c.MustGet(consts.TraceCtx).(context.Context)
}

3.2 包装基于 zap 的日志工具

  • 包装办法将 context 传入

  • 解析 trace 信息，打印到 logger 中

    package log

import (
  "best-practics/common"
  "best-practics/common/consts"
  "context"
  "go.uber.org/zap"
)

type LogWrapper struct {logger *zap.Logger}

var Log LogWrapper

func Debug(tag string, fields ...zap.Field) {Log.logger.Debug(tag, fields...)
}

func DebugF(ctx context.Context, tag string, fields ...zap.Field) {trace := ctx.Value(consts.TraceKey).(*common.Trace)
  Log.logger.Debug(tag,
      append(fields, zap.String("trace_id", trace.TraceId), zap.Int("user_id", trace.UserId))...,
  )
}

func Info(tag string, fields ...zap.Field) {Log.logger.Info(tag, fields...)
}

func InfoF(ctx context.Context, tag string, fields ...zap.Field) {trace := ctx.Value(consts.TraceKey).(*common.Trace)
  Log.logger.Info(tag,
      append(fields, zap.String("trace_id", trace.TraceId), zap.Int("user_id", trace.UserId))...,
  )
}

func Warn(tag string, fields ...zap.Field) {Log.logger.Warn(tag, fields...)
}

func WarnF(ctx context.Context, tag string, fields ...zap.Field) {trace := ctx.Value(consts.TraceKey).(*common.Trace)
  Log.logger.Warn(tag,
      append(fields, zap.String("trace_id", trace.TraceId), zap.Int("user_id", trace.UserId))...,
  )
}

func Error(tag string, fields ...zap.Field) {Log.logger.Error(tag, fields...)
}

func ErrorF(ctx context.Context, tag string, fields ...zap.Field) {trace := ctx.Value(consts.TraceKey).(*common.Trace)
  Log.logger.Error(tag,
      append(fields, zap.String("trace_id", trace.TraceId), zap.Int("user_id", trace.UserId))...,
  )
}

func Fatal(tag string, fields ...zap.Field) {Log.logger.Fatal(tag, fields...)
}

func FatalF(ctx context.Context, tag string, fields ...zap.Field) {trace := ctx.Value(consts.TraceKey).(*common.Trace)
  Log.logger.Fatal(tag,
      append(fields, zap.String("trace_id", trace.TraceId), zap.Int("user_id", trace.UserId))...,
  )
}

    3.3 解决 Caller 问题

    此形式存在个问题，就是打印的 caller 信息全都是对应日志工具类的代码行，而不是调用处。看了下 zap 的源码，zap 打印时将整个调用的 stack 链路会寄存到内存中，默认打印调用处的 caller 信息。所以为了解决解决这个问题，须要再初始化 zap 时额定减少 AddCallerSkip 跳过指定层级的 caller，外围代码如下：

    logger = logger.WithOptions(zap.AddCaller(),zap.AddCallerSkip(1))

    残缺的 zap 工具类如下：

    /*
 * Copyright (C) 2021 Baidu, Inc. All Rights Reserved.
 */
package log

import (
  "best-practics/common"
  "best-practics/utils"
  "fmt"
  "os"
  "time"

  rotatelogs "github.com/lestrrat-go/file-rotatelogs"
  "go.uber.org/zap"
  "go.uber.org/zap/zapcore"
)

func InitZap() {if ok, _ := utils.PathExists(common.GlobalConfig.Zap.Director); !ok { // 判断是否有 Director 文件夹
      fmt.Printf("create %v directory\n", common.GlobalConfig.Zap.Director)
      _ = os.Mkdir(common.GlobalConfig.Zap.Director, os.ModePerm)
  }
  // 调试级别
  debugPriority := zap.LevelEnablerFunc(func(lev zapcore.Level) bool {return lev == zap.DebugLevel})
  // 日志级别
  infoPriority := zap.LevelEnablerFunc(func(lev zapcore.Level) bool {return lev == zap.InfoLevel})
  // 正告级别
  warnPriority := zap.LevelEnablerFunc(func(lev zapcore.Level) bool {return lev == zap.WarnLevel})
  // 谬误级别
  errorPriority := zap.LevelEnablerFunc(func(lev zapcore.Level) bool {return lev >= zap.ErrorLevel})

  cores := [...]zapcore.Core{getEncoderCore(fmt.Sprintf("./%s/server_debug.log", common.GlobalConfig.Zap.Director), debugPriority),
      getEncoderCore(fmt.Sprintf("./%s/server_info.log", common.GlobalConfig.Zap.Director), infoPriority),
      getEncoderCore(fmt.Sprintf("./%s/server_warn.log", common.GlobalConfig.Zap.Director), warnPriority),
      getEncoderCore(fmt.Sprintf("./%s/server_error.log", common.GlobalConfig.Zap.Director), errorPriority),
  }
  logger := zap.New(zapcore.NewTee(cores[:]...), zap.AddCaller(), zap.AddCallerSkip(1))

  common.Logger = logger
}

// getEncoderConfig 获取 zapcore.EncoderConfig
func getEncoderConfig() (config zapcore.EncoderConfig) {
  config = zapcore.EncoderConfig{
      MessageKey:     "message",
      LevelKey:       "level",
      TimeKey:        "time",
      NameKey:        "logger",
      CallerKey:      "caller",
      StacktraceKey:  common.GlobalConfig.Zap.StacktraceKey,
      LineEnding:     zapcore.DefaultLineEnding,
      EncodeLevel:    zapcore.LowercaseLevelEncoder,
      EncodeTime:     CustomTimeEncoder,
      EncodeDuration: zapcore.SecondsDurationEncoder,
      EncodeCaller:   zapcore.FullCallerEncoder,
  }
  switch {case common.GlobalConfig.Zap.EncodeLevel == "LowercaseLevelEncoder": // 小写编码器(默认)
      config.EncodeLevel = zapcore.LowercaseLevelEncoder
  case common.GlobalConfig.Zap.EncodeLevel == "LowercaseColorLevelEncoder": // 小写编码器带色彩
      config.EncodeLevel = zapcore.LowercaseColorLevelEncoder
  case common.GlobalConfig.Zap.EncodeLevel == "CapitalLevelEncoder": // 大写编码器
      config.EncodeLevel = zapcore.CapitalLevelEncoder
  case common.GlobalConfig.Zap.EncodeLevel == "CapitalColorLevelEncoder": // 大写编码器带色彩
      config.EncodeLevel = zapcore.CapitalColorLevelEncoder
  default:
      config.EncodeLevel = zapcore.LowercaseLevelEncoder
  }
  return config
}

// getEncoder 获取 zapcore.Encoder
func getEncoder() zapcore.Encoder {
  if common.GlobalConfig.Zap.Format == "json" {return zapcore.NewJSONEncoder(getEncoderConfig())
  }
  return zapcore.NewConsoleEncoder(getEncoderConfig())
}

// getEncoderCore 获取 Encoder 的 zapcore.Core
func getEncoderCore(fileName string, level zapcore.LevelEnabler) (core zapcore.Core) {writer := GetWriteSyncer(fileName) // 应用 file-rotatelogs 进行日志宰割
  return zapcore.NewCore(getEncoder(), writer, level)
}

// 自定义日志输入工夫格局
func CustomTimeEncoder(t time.Time, enc zapcore.PrimitiveArrayEncoder) {enc.AppendString(t.Format("2006/01/02 15:04:05"))
}

//@function: GetWriteSyncer
//@description: zap logger 中退出 file-rotatelogs
//@return: zapcore.WriteSyncer, error
func GetWriteSyncer(file string) zapcore.WriteSyncer {
  // 每小时一个文件
  logf, _ := rotatelogs.New(file +".%Y%m%d%H",
      rotatelogs.WithLinkName(file),
      rotatelogs.WithMaxAge(7*24*time.Hour),
      rotatelogs.WithRotationTime(time.Minute),
  )

  if common.GlobalConfig.Zap.LogInConsole {return zapcore.NewMultiWriteSyncer(zapcore.AddSync(os.Stdout), zapcore.AddSync(logf))
  }
  return zapcore.AddSync(logf)
}

    3.4 Gin 的 middleware 中减少 trace 信息

    func SetLoggerMiddleware() gin.HandlerFunc {return func(c *gin.Context) {start := time.Now()
      uuidStr := strings.ReplaceAll(uuid.New().String(), "-", "")
      path := c.Request.URL.Path
      userId := c.GetInt("user_id")
      ctx := context.WithValue(context.Background(), consts.TraceKey, &common.Trace{TraceId: uuidStr, Caller: path, UserId: userId})
      c.Set(consts.TraceCtx,ctx)

      c.Next()
      cost := time.Since(start)
      common.Logger.Info("_com_request_info",
          zap.Int("Status", c.Writer.Status()),
          zap.String("Method", c.Request.Method),
          zap.String("IP",c.ClientIP()),
          zap.String("Path",path),
          zap.String("TraceId", uuidStr),
          zap.Int("UserId", userId),
          zap.String("query", c.Request.URL.RawQuery),
          zap.String("UserAgent",c.Request.UserAgent()),
          zap.Duration("Cost",cost),
      )
  }
}

    3.5 Controller 层生成 trace_context

    func main() {r := gin.Default()
  r.GET("/hello", func(c *gin.Context) {
      // 3.1 中封装的转换方法
      ctx := common.GetTraceCtx(c)
      log.WarnF(ctx,"BookNotFoundError",zap.String("test","666"))
      c.String("hello jianfan.com!")
  })
  r.Run(}

至此咱们就实现了在一个 gin 我的项目中接入 zap 作为日志框架，并可能打印残缺的链路日志信息。联合前两节咱们曾经满足了对常见日志框架的需要：

  1. 良好日志写入性能
  2. 反对不同的日志级别。并且可拆散成多个日志文件
  3. 多输入 - 同时反对规范输入，文件等
  4. 可能打印根本信息，如调用文件 / 函数名和行号，日志工夫等
  5. 可读性与结构化，Json 格局或有分隔符，不便后续的日志采集、监控等
  6. 文件切割，可按小时、天进行日志拆分，或者按文件大小
  7. 日志书写敌对，反对通过 context 主动 log trace 等
  8. 文件定时删除
  9. 开源性，与其余开源框架反对较好

参考资料：

  • https://liwenzhou.com/posts/Go/use_zap_in_gin/

咱们下期见，Peace😘

我是简凡，一个励志用最简略的语言，形容最简单问题的新时代农民工。求点赞，求关注，如果你对此篇文章有什么纳闷，欢送在我的微信公众号中留言，我还能够为你提供以下帮忙：

  • 帮忙建设本人的常识体系
  • 互联网实在高并发场景实战解说
  • 不定期分享 Golang、Java 相干业内的经典场景实际

我的博客：https://besthpt.github.io/
我的微信：bestbear666
微信公众号：

正文完
golang
发表至： golang
2021-11-24
 0
关于golang:Go进阶基础特性错误
关于golang:Go-语言中的一等公民看似普通的函数凭什么
关于golang:带你十天轻松搞定-Go-微服务系列九链路追踪
关于golang:链表深拷贝