Go 语言之在 gin 框架中使用 zap 日志库

Go 语言之在 gin 框架中使用 zap 日志库

gin 框架默认使用的是自带的日志

gin.Default()的源码 Logger(), Recovery()

1. func Default() *Engine {
2.         debugPrintWARNINGDefault()
3.         engine := New()
4.         engine.Use(Logger(), Recovery())
5.         return engine
6. }
8. // Logger instances a Logger middleware that will write the logs to gin.DefaultWriter.
9. // By default, gin.DefaultWriter = os.Stdout.
10. func Logger() HandlerFunc {
11.         return LoggerWithConfig(LoggerConfig{})
12. }
14. // Recovery returns a middleware that recovers from any panics and writes a 500 if there was one.
15. func Recovery() HandlerFunc {
16.         return RecoveryWithWriter(DefaultErrorWriter)
17. }
19. // RecoveryWithWriter returns a middleware for a given writer that recovers from any panics and writes a 500 if there was one.
20. func RecoveryWithWriter(out io.Writer, recovery ...RecoveryFunc) HandlerFunc {
21.         if len(recovery) > 0 {
22.                 return CustomRecoveryWithWriter(out, recovery[0])
23.         }
24.         return CustomRecoveryWithWriter(out, defaultHandleRecovery)
25. }
27. // CustomRecoveryWithWriter returns a middleware for a given writer that recovers from any panics and calls the provided handle func to handle it.
28. func CustomRecoveryWithWriter(out io.Writer, handle RecoveryFunc) HandlerFunc {
29.         var logger *log.Logger
30.         if out != nil {
31.                 logger = log.New(out, "\n\n\x1b[31m", log.LstdFlags)
32.         }
33.         return func(c *Context) {
34.                 defer func() {
35.                         if err := recover(); err != nil {
36.                                 // Check for a broken connection, as it is not really a
37.                                 // condition that warrants a panic stack trace.
38.                                 var brokenPipe bool
39.                                 if ne, ok := err.(*net.OpError); ok {
40.                                         var se *os.SyscallError
41.                                         if errors.As(ne, &se) {
42.                                                 seStr := strings.ToLower(se.Error())
43.                                                 if strings.Contains(seStr, "broken pipe") ||
44.                                                         strings.Contains(seStr, "connection reset by peer") {
45.                                                         brokenPipe = true
46.                                                 }
47.                                         }
48.                                 }
49.                                 if logger != nil {
50.                                         stack := stack(3)
51.                                         httpRequest, _ := httputil.DumpRequest(c.Request, false)
52.                                         headers := strings.Split(string(httpRequest), "\r\n")
53.                                         for idx, header := range headers {
54.                                                 current := strings.Split(header, ":")
55.                                                 if current[0] == "Authorization" {
56.                                                         headers[idx] = current[0] + ": *"
57.                                                 }
58.                                         }
59.                                         headersToStr := strings.Join(headers, "\r\n")
60.                                         if brokenPipe {
61.                                                 logger.Printf("%s\n%s%s", err, headersToStr, reset)
62.                                         } else if IsDebugging() {
63.                                                 logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s",
64.                                                         timeFormat(time.Now()), headersToStr, err, stack, reset)
65.                                         } else {
66.                                                 logger.Printf("[Recovery] %s panic recovered:\n%s\n%s%s",
67.                                                         timeFormat(time.Now()), err, stack, reset)
68.                                         }
69.                                 }
70.                                 if brokenPipe {
71.                                         // If the connection is dead, we can't write a status to it.
72.                                         c.Error(err.(error)) //nolint: errcheck
73.                                         c.Abort()
74.                                 } else {
75.                                         handle(c, err)
76.                                 }
77.                         }
78.                 }()
79.                 c.Next()
80.         }
81. }

复制代码

自定义 Logger(), Recovery()

实操

1. package main
3. import (
4.         "github.com/gin-gonic/gin"
5.         "go.uber.org/zap"
6.         "go.uber.org/zap/zapcore"
7.         "gopkg.in/natefinch/lumberjack.v2"
8.         "net"
9.         "net/http"
10.         "net/http/httputil"
11.         "os"
12.         "runtime/debug"
13.         "strings"
14.         "time"
15. )
17. // 定义一个全局 logger 实例
18. // Logger提供快速、分级、结构化的日志记录。所有方法对于并发使用都是安全的。
19. // Logger是为每一微秒和每一个分配都很重要的上下文设计的，
20. // 因此它的API有意倾向于性能和类型安全，而不是简便性。
21. // 对于大多数应用程序，SugaredLogger在性能和人体工程学之间取得了更好的平衡。
22. var logger *zap.Logger
24. // SugaredLogger将基本的Logger功能封装在一个较慢但不那么冗长的API中。任何Logger都可以通过其Sugar方法转换为sugardlogger。
25. //与Logger不同，SugaredLogger并不坚持结构化日志记录。对于每个日志级别，它公开了四个方法:
26. //   - methods named after the log level for log.Print-style logging
27. //   - methods ending in "w" for loosely-typed structured logging
28. //   - methods ending in "f" for log.Printf-style logging
29. //   - methods ending in "ln" for log.Println-style logging
31. // For example, the methods for InfoLevel are:
32. //
33. //        Info(...any)           Print-style logging
34. //        Infow(...any)          Structured logging (read as "info with")
35. //        Infof(string, ...any)  Printf-style logging
36. //        Infoln(...any)         Println-style logging
37. var sugarLogger *zap.SugaredLogger
39. //func main() {
40. //        // 初始化
41. //        InitLogger()
42. //        // Sync调用底层Core的Sync方法，刷新所有缓冲的日志条目。应用程序在退出之前应该注意调用Sync。
43. //        // 在程序退出之前，把缓冲区里的日志刷到磁盘上
44. //        defer logger.Sync()
45. //        simpleHttpGet("www.baidu.com")
46. //        simpleHttpGet("http://www.baidu.com")
47. //
48. //        for i := 0; i < 10000; i++ {
49. //                logger.Info("test lumberjack for log rotate....")
50. //        }
51. //}
53. func main() {
54.         InitLogger()
55.         //r := gin.Default()
57.         r := gin.New()
58.         r.Use(GinLogger(logger), GinRecovery(logger, true))
59.         r.GET("/hello", func(c *gin.Context) {
60.                 c.String(http.StatusOK, "hello xiaoqiao!")
61.         })
62.         r.Run()
63. }
65. // GinLogger
66. func GinLogger(logger *zap.Logger) gin.HandlerFunc {
67.         return func(c *gin.Context) {
68.                 start := time.Now()
69.                 path := c.Request.URL.Path
70.                 query := c.Request.URL.RawQuery
71.                 c.Next() // 执行后续中间件
73.                 // Since returns the time elapsed since t.
74.                 // It is shorthand for time.Now().Sub(t).
75.                 cost := time.Since(start)
76.                 logger.Info(path,
77.                         zap.Int("status", c.Writer.Status()),
78.                         zap.String("method", c.Request.Method),
79.                         zap.String("path", path),
80.                         zap.String("query", query),
81.                         zap.String("ip", c.ClientIP()),
82.                         zap.String("user-agent", c.Request.UserAgent()),
83.                         zap.String("errors", c.Errors.ByType(gin.ErrorTypePrivate).String()),
84.                         zap.Duration("cost", cost), // 运行时间
85.                 )
86.         }
87. }
89. // GinRecovery
90. func GinRecovery(logger *zap.Logger, stack bool) gin.HandlerFunc {
91.         return func(c *gin.Context) {
92.                 defer func() {
93.                         if err := recover(); err != nil {
94.                                 // Check for a broken connection, as it is not really a
95.                                 // condition that warrants a panic stack trace.
96.                                 var brokenPipe bool
97.                                 if ne, ok := err.(*net.OpError); ok {
98.                                         if se, ok := ne.Err.(*os.SyscallError); ok {
99.                                                 if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
100.                                                         brokenPipe = true
101.                                                 }
102.                                         }
103.                                 }
105.                                 httpRequest, _ := httputil.DumpRequest(c.Request, false)
106.                                 if brokenPipe {
107.                                         logger.Error(c.Request.URL.Path,
108.                                                 zap.Any("error", err),
109.                                                 zap.String("request", string(httpRequest)),
110.                                         )
111.                                         // If the connection is dead, we can't write a status to it.
112.                                         c.Error(err.(error)) // nolint: errcheck
113.                                         c.Abort()
114.                                         return
115.                                 }
117.                                 if stack {
118.                                         logger.Error("[Recovery from panic]",
119.                                                 zap.Any("error", err),
120.                                                 zap.String("request", string(httpRequest)),
121.                                                 zap.String("stack", string(debug.Stack())),
122.                                         )
123.                                 } else {
124.                                         logger.Error("[Recovery from panic]",
125.                                                 zap.Any("error", err),
126.                                                 zap.String("request", string(httpRequest)),
127.                                         )
128.                                 }
129.                                 c.AbortWithStatus(http.StatusInternalServerError)
130.                         }
131.                 }()
132.                 c.Next()
133.         }
134. }
136. func InitLogger() {
137.         writeSyncer := getLogWriter()
138.         encoder := getEncoder()
139.         // NewCore创建一个向WriteSyncer写入日志的Core。
141.         // A WriteSyncer is an io.Writer that can also flush any buffered data. Note
142.         // that *os.File (and thus, os.Stderr and os.Stdout) implement WriteSyncer.
144.         // LevelEnabler决定在记录消息时是否启用给定的日志级别。
145.         // Each concrete Level value implements a static LevelEnabler which returns
146.         // true for itself and all higher logging levels. For example WarnLevel.Enabled()
147.         // will return true for WarnLevel, ErrorLevel, DPanicLevel, PanicLevel, and
148.         // FatalLevel, but return false for InfoLevel and DebugLevel.
149.         core := zapcore.NewCore(encoder, writeSyncer, zapcore.DebugLevel)
151.         // New constructs a new Logger from the provided zapcore.Core and Options. If
152.         // the passed zapcore.Core is nil, it falls back to using a no-op
153.         // implementation.
155.         // AddCaller configures the Logger to annotate each message with the filename,
156.         // line number, and function name of zap's caller. See also WithCaller.
157.         logger = zap.New(core, zap.AddCaller())
158.         // Sugar封装了Logger，以提供更符合人体工程学的API，但速度略慢。糖化一个Logger的成本非常低，
159.         // 因此一个应用程序同时使用Loggers和SugaredLoggers是合理的，在性能敏感代码的边界上在它们之间进行转换。
160.         sugarLogger = logger.Sugar()
161. }
163. func getEncoder() zapcore.Encoder {
164.         // NewJSONEncoder创建了一个快速、低分配的JSON编码器。编码器适当地转义所有字段键和值。
165.         // NewProductionEncoderConfig returns an opinionated EncoderConfig for
166.         // production environments.
167.         //return zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
169.         // NewConsoleEncoder创建一个编码器，其输出是为人类而不是机器设计的。
170.         // 它以纯文本格式序列化核心日志条目数据(消息、级别、时间戳等)，并将结构化上下文保留为JSON。
171.         encoderConfig := zapcore.EncoderConfig{
172.                 TimeKey:        "ts",
173.                 LevelKey:       "level",
174.                 NameKey:        "logger",
175.                 CallerKey:      "caller",
176.                 FunctionKey:    zapcore.OmitKey,
177.                 MessageKey:     "msg",
178.                 StacktraceKey:  "stacktrace",
179.                 LineEnding:     zapcore.DefaultLineEnding,
180.                 EncodeLevel:    zapcore.LowercaseLevelEncoder,
181.                 EncodeTime:     zapcore.ISO8601TimeEncoder,
182.                 EncodeDuration: zapcore.SecondsDurationEncoder,
183.                 EncodeCaller:   zapcore.ShortCallerEncoder,
184.         }
186.         return zapcore.NewConsoleEncoder(encoderConfig)
187. }
189. //func getLogWriter() zapcore.WriteSyncer {
190. //        // Create创建或截断指定文件。如果文件已经存在，它将被截断。如果该文件不存在，则以模式0666(在umask之前)创建。
191. //        // 如果成功，返回的File上的方法可以用于IO;关联的文件描述符模式为O_RDWR。如果有一个错误，它的类型将是PathError。
192. //        //file, _ := os.Create("./test.log")
193. //        file, err := os.OpenFile("./test.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
194. //        if err != nil {
195. //                log.Fatalf("open log file failed with error: %v", err)
196. //        }
197. //        // AddSync converts an io.Writer to a WriteSyncer. It attempts to be
198. //        // intelligent: if the concrete type of the io.Writer implements WriteSyncer,
199. //        // we'll use the existing Sync method. If it doesn't, we'll add a no-op Sync.
200. //        return zapcore.AddSync(file)
201. //}
203. func getLogWriter() zapcore.WriteSyncer {
204.         // Logger is an io.WriteCloser that writes to the specified filename.
205.         // 日志记录器在第一次写入时打开或创建日志文件。如果文件存在并且小于MaxSize兆字节，则lumberjack将打开并追加该文件。
206.         // 如果该文件存在并且其大小为>= MaxSize兆字节，
207.         // 则通过将当前时间放在文件扩展名(或者如果没有扩展名则放在文件名的末尾)的名称中的时间戳中来重命名该文件。
208.         // 然后使用原始文件名创建一个新的日志文件。
209.         // 每当写操作导致当前日志文件超过MaxSize兆字节时，将关闭当前文件，重新命名，并使用原始名称创建新的日志文件。
210.         // 因此，您给Logger的文件名始终是“当前”日志文件。
211.         // 如果MaxBackups和MaxAge均为0，则不会删除旧的日志文件。
212.         lumberJackLogger := &lumberjack.Logger{
213.                 // Filename是要写入日志的文件。备份日志文件将保留在同一目录下
214.                 Filename: "./test.log",
215.                 // MaxSize是日志文件旋转之前的最大大小(以兆字节为单位)。默认为100兆字节。
216.                 MaxSize: 1, // M
217.                 // MaxBackups是要保留的旧日志文件的最大数量。默认是保留所有旧的日志文件(尽管MaxAge仍然可能导致它们被删除)。
218.                 MaxBackups: 5, // 备份数量
219.                 // MaxAge是根据文件名中编码的时间戳保留旧日志文件的最大天数。
220.                 // 请注意，一天被定义为24小时，由于夏令时、闰秒等原因，可能与日历日不完全对应。默认情况下，不根据时间删除旧的日志文件。
221.                 MaxAge: 30, // 备份天数
222.                 // Compress决定是否应该使用gzip压缩旋转的日志文件。默认情况下不执行压缩。
223.                 Compress: false, // 是否压缩
224.         }
226.         return zapcore.AddSync(lumberJackLogger)
227. }
229. func simpleHttpGet(url string) {
230.         // Get向指定的URL发出Get命令。如果响应是以下重定向代码之一，则Get跟随重定向，最多可重定向10个:
231.         //        301 (Moved Permanently)
232.         //        302 (Found)
233.         //        303 (See Other)
234.         //        307 (Temporary Redirect)
235.         //        308 (Permanent Redirect)
236.         // Get is a wrapper around DefaultClient.Get.
237.         // 使用NewRequest和DefaultClient.Do来发出带有自定义头的请求。
238.         resp, err := http.Get(url)
239.         if err != nil {
240.                 // Error在ErrorLevel记录消息。该消息包括在日志站点传递的任何字段，以及日志记录器上积累的任何字段。
241.                 //logger.Error(
243.                 // 错误使用fmt。以Sprint方式构造和记录消息。
244.                 sugarLogger.Error(
245.                         "Error fetching url..",
246.                         zap.String("url", url), // 字符串用给定的键和值构造一个字段。
247.                         zap.Error(err))         // // Error is shorthand for the common idiom NamedError("error", err).
248.         } else {
249.                 // Info以infollevel记录消息。该消息包括在日志站点传递的任何字段，以及日志记录器上积累的任何字段。
250.                 //logger.Info("Success..",
252.                 // Info使用fmt。以Sprint方式构造和记录消息。
253.                 sugarLogger.Info("Success..",
254.                         zap.String("statusCode", resp.Status),
255.                         zap.String("url", url))
256.                 resp.Body.Close()
257.         }
258. }

复制代码

运行并访问：http://localhost:8080/hello
[code]Code/go/zap_demo via
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！