Go學(xué)習(xí)筆記之Zap日志的使用

更新時(shí)間：2022年07月15日 16:02:12 作者：IT小馬

這篇文章主要為大家詳細(xì)介紹了Go語(yǔ)言中Zap日志的使用以及安裝，文中的示例代碼講解詳細(xì)，對(duì)我們學(xué)習(xí)Go語(yǔ)言有一定的幫助，需要的可以參考一下

Log包

Go語(yǔ)言提供的默認(rèn)日志包：https://golang.org/pkg/log/

基本用法

log包定義了Logger類(lèi)型，該類(lèi)型提供了一些格式化輸出的方法。

type Logger struct {
    mu     sync.Mutex // ensures atomic writes; protects the following fields
    prefix string     // prefix on each line to identify the logger (but see                            Lmsgprefix)
    flag   int        // properties
    out    io.Writer  // destination for output
    buf    []byte     // for accumulating text to write
}

mu屬性主要是為了確保原子操作，prefix設(shè)置每一行的前綴，flag設(shè)置輸出的各種屬性，比如時(shí)間、行號(hào)、文件路徑等。out輸出的方向，用于把日志存儲(chǔ)文件。

例如，我們可以像下面的代碼一樣直接通過(guò)log包來(lái)調(diào)用上面提到的方法，默認(rèn)它們會(huì)將日志信息打印到終端界面：

log.Println("這是一條優(yōu)雅的日志。")
v := "優(yōu)雅的"
log.Printf("這是一個(gè)%s日志\n", v)
//fatal系列函數(shù)會(huì)在寫(xiě)入日志信息后調(diào)用os.Exit(1)
log.Fatalln("這是一天會(huì)觸發(fā)fatal的日志") 
//Panic系列函數(shù)會(huì)在寫(xiě)入日志信息后panic
log.Panicln("這是一個(gè)會(huì)觸發(fā)panic的日志。") //執(zhí)行后會(huì)自動(dòng)觸發(fā)一個(gè)異常

flag屬性

默認(rèn)情況下的logger只會(huì)提供日志的時(shí)間信息，但是很多情況下我們希望得到更多信息，比如記錄該日志的文件名和行號(hào)等。log標(biāo)準(zhǔn)庫(kù)中為我們提供了定制這些設(shè)置的方法。

log標(biāo)準(zhǔn)庫(kù)中的Flags函數(shù)會(huì)返回標(biāo)準(zhǔn)logger的輸出配置，而SetFlags函數(shù)用來(lái)設(shè)置標(biāo)準(zhǔn)logger的輸出配置。下面是flag屬性對(duì)應(yīng)的常量

const (
    Ldate    = 1 << iota     // the date in the local time zone: 2009/01/23
    Ltime                    // the time in the local time zone: 01:23:23
    Lmicroseconds           // microsecond resolution: 01:23:23.123123.  assumes Ltime.
    Llongfile               // full file name and line number: /a/b/c/d.go:23
    Lshortfile   // final file name element and line number: d.go:23. overrides Llongfile
    LUTC         // if Ldate or Ltime is set, use UTC rather than the local time zone
    Lmsgprefix  // move the "prefix" from the beginning of the line to before the message
    LstdFlags = Ldate | Ltime // initial values for the standard logger
)

設(shè)置輸出屬性的代碼如下：

func main() {
    log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
    log.Println("這是一條優(yōu)雅的日志。")
}

編譯輸出：

2020/07/14 22:51:06.079594 D:/xxx/test_log.go:24: 這是一條優(yōu)雅的日志。

prefix屬性

log標(biāo)準(zhǔn)庫(kù)中還提供了關(guān)于日志信息前綴的兩個(gè)方法：其中Prefix函數(shù)用來(lái)查看標(biāo)準(zhǔn)logger的輸出前綴，SetPrefix函數(shù)用來(lái)設(shè)置輸出前綴。

func Prefix() string
 func SetPrefix(prefix string)

設(shè)置日志輸出前綴的代碼如下：

func main() {
    log.SetPrefix("[PS]")
    log.Println("這是一條很普通的日志。")
}

編譯輸出：

[PS]2020/07/14 22:56:15.652555 D:/xxx/test_log.go:26: 這是一個(gè)普通的日志

out屬性

out屬性是一個(gè)io.Writer輸出流，使用它可以把日志輸出為文件。

需要用的方法為：設(shè)置標(biāo)準(zhǔn)logger的輸出目的地，默認(rèn)是標(biāo)準(zhǔn)錯(cuò)誤輸出。

func SetOutput(w io.Writer)

例如，下面的代碼會(huì)把日志輸出到同目錄下的xx.log文件中。

func main() {
    logFile, err := os.OpenFile("./xx.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
    if err != nil {
        fmt.Println("open log file failed, err:", err)
        return
    }
    log.SetOutput(logFile)
    log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
    log.Println("這是一條很普通的日志。")
    log.SetPrefix("[PS]")
    log.Println("這是一條很普通的日志。")
}

如果你要使用標(biāo)準(zhǔn)的logger，我們通常會(huì)把上面的配置操作寫(xiě)到init函數(shù)中。

func init() {
    logFile, err := os.OpenFile("./xx.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
    if err != nil {
        fmt.Println("open log file failed, err:", err)
        return
    }
    log.SetOutput(logFile)
    log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
}

創(chuàng)建新的Logger

log標(biāo)準(zhǔn)庫(kù)中還提供了一個(gè)創(chuàng)建新logger對(duì)象的構(gòu)造函數(shù) New，支持我們創(chuàng)建自己的logger示例。New函數(shù)的簽名如下：

func New(out io.Writer, prefix string, flag int) *Logger

New創(chuàng)建一個(gè)Logger對(duì)象。其中，參數(shù)out設(shè)置日志信息寫(xiě)入的目的地。參數(shù)prefix會(huì)添加到生成的每一條日志前面。參數(shù)flag定義日志的屬性（時(shí)間、文件等等）。

舉個(gè)例子：

func main() {
    logger := log.New(os.Stdout, "<PS>", log.Lshortfile|log.Ldate|log.Ltime)
    logger.Println("這是自定義的logger記錄的日志。")
}

編譯輸出：

<PS>2020/07/14 23:02:59 test_log.go:43: 這是自定義的logger記錄的日志

自定義Go Logger

可以設(shè)置任何io.Writer作為日志記錄輸出并向其發(fā)送要寫(xiě)入的日志

設(shè)置

func SetupLogger() {
    logFileLocation, _ := os.OpenFile("./test.log", os.O_CREATE|os.O_APPEND|os.O_RDWR, 0744)
    log.SetOutput(logFileLocation)
}

使用

func test(){
   log.Printf("Test log: %s %s", "Hello", "World")
}

運(yùn)行

func main() {
    SetupLogger()
  test()
}

Zap

Zap是非常快的、結(jié)構(gòu)化的，分日志級(jí)別的Go日志庫(kù)。

安裝

go get -u go.uber.org/zap

配置Zap Logger

Zap提供了兩種類(lèi)型的日志記錄器—Sugared Logger和Logger。

Logger更快，但只支持強(qiáng)類(lèi)型的結(jié)構(gòu)化日志記錄。
Sugared Logger支持結(jié)構(gòu)化和printf風(fēng)格的日志記錄。

Logger

通過(guò)調(diào)用zap.NewProduction()/zap.NewDevelopment()或者zap.Example()創(chuàng)建一個(gè)Logger。
Example和Production使用的是 json 格式輸出，Development 使用行的形式輸出
Development從警告級(jí)別(Warn)向上打印到堆棧中來(lái)跟蹤，
ProductionError , Dpanic 級(jí)別的記錄，會(huì)在堆棧中跟蹤文件， Warn 不會(huì)
通過(guò)Logger調(diào)用Info/Error等。
默認(rèn)情況下日志都會(huì)打印到應(yīng)用程序的console界面。

var logger *zap.Logger

func main() {
    InitLogger()
  defer logger.Sync()
    simpleHttpGet("www.google.com")
    simpleHttpGet("http://www.google.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()
    }
}

在上面的代碼中，我們首先創(chuàng)建了一個(gè)Logger，然后使用Info/ Error等Logger方法記錄消息。

日志記錄器方法的語(yǔ)法是這樣的：

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

其中MethodXXX是一個(gè)可變參數(shù)函數(shù)，可以是Info / Error/ Debug / Panic等。每個(gè)方法都接受一個(gè)消息字符串和任意數(shù)量的zapcore.Field場(chǎng)參數(shù)。

每個(gè)zapcore.Field其實(shí)就是一組鍵值對(duì)參數(shù)。

我們執(zhí)行上面的代碼會(huì)得到如下輸出結(jié)果：

{"level":"error","ts":1572159218.912792,"caller":"zap_demo/temp.go:25","msg":"Error fetching url..","url":"www.sogo.com","error":"Get www.sogo.com: unsupported protocol scheme \"\"","stacktrace":"main.simpleHttpGet\n\t/Users/itxiaoma/zap_demo/temp.go:25\nmain.main\n\t/Users/itxiaoma/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.sogo.com"}

Sugared Logger

slogger := logger.Sugar()

suger logger基于 printf 分割的反射類(lèi)型檢測(cè)，提供更簡(jiǎn)單的語(yǔ)法來(lái)添加混合類(lèi)型的標(biāo)簽。

var sugarLogger *zap.SugaredLogger

func main() {
    InitLogger()
    defer sugarLogger.Sync()
    simpleHttpGet("www.google.com")
    simpleHttpGet("http://www.google.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()
    }
}

執(zhí)行結(jié)果：

{"level":"error","ts":1572159149.923002,"caller":"logic/temp2.go:27","msg":"Error fetching URL www.sogo.com : Error = Get www.sogo.com: unsupported protocol scheme \"\"","stacktrace":"main.simpleHttpGet\n\t/Users/itxiaoma/zap_demo/logic/temp2.go:27\nmain.main\n\t/Users/itxiaoma/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.sogo.com"}

定制logger

1. 日志寫(xiě)入文件

使用zap.New(…)方法來(lái)手動(dòng)傳遞所有配置，而不是使用像zap.NewProduction()這樣的預(yù)置方法來(lái)創(chuàng)建logger。

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

Encoder:編碼器(如何寫(xiě)入日志)。我們將使用開(kāi)箱即用的NewJSONEncoder()，并使用預(yù)先設(shè)置的ProductionEncoderConfig()。

zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())

WriterSyncer ：指定日志將寫(xiě)到哪里去。我們使用zapcore.AddSync()函數(shù)并且將打開(kāi)的文件句柄傳進(jìn)去。

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

Log Level：哪種級(jí)別的日志將被寫(xiě)入。

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

當(dāng)使用這些修改過(guò)的logger配置調(diào)用上述部分的main()函數(shù)時(shí)，以下輸出將打印在文件——test.log中。

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

2.將JSON Encoder更改為普通的Log Encoder

將NewJSONEncoder()更改為NewConsoleEncoder()。

return zapcore.NewConsoleEncoder(zap.NewProductionEncoderConfig())

當(dāng)使用這些修改過(guò)的logger配置調(diào)用上述部分的main()函數(shù)時(shí)，以下輸出將打印在文件——test.log中。

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

3. 更改時(shí)間編碼并添加調(diào)用者詳細(xì)信息

修改時(shí)間編碼器：

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

添加調(diào)用方信息：在zap.New(..)函數(shù)中添加一個(gè)Option。

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

最終結(jié)果：

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

Lumberjack 日志切割

安裝

go get -u github.com/natefinch/lumberjack

使用

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：在進(jìn)行切割之前，日志文件的最大大?。ㄒ訫B為單位）
MaxBackups：保留舊文件的最大個(gè)數(shù)
MaxAges：保留舊文件的最大天數(shù)
Compress：是否壓縮/歸檔舊文件

Zap接收Gin默認(rèn)日志

我們?cè)谑褂?code>gin.Default()的同時(shí)是用到了gin框架內(nèi)的兩個(gè)默認(rèn)中間件Logger()和Recovery()。

Logger()是把gin框架本身的日志輸出到標(biāo)準(zhǔn)輸出（我們本地開(kāi)發(fā)調(diào)試時(shí)在終端輸出的那些日志就是它的功勞）
Recovery()是在程序出現(xiàn)panic的時(shí)候恢復(fù)現(xiàn)場(chǎng)并寫(xiě)入500響應(yīng)的。

基于zap的中間件

替換gin.Default()

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

中間件：

// GinLogger 接收gin框架默認(rèn)的日志
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掉項(xiàng)目可能出現(xiàn)的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()
    }
}

如果不想自己實(shí)現(xiàn)，可以使用github上有別人封裝好的https://github.com/gin-contrib/zap。

這樣我們就可以在gin框架中使用我們上面定義好的兩個(gè)中間件來(lái)代替gin框架默認(rèn)的Logger()和Recovery()了。

在gin項(xiàng)目中使用zap

最后我們?cè)偌尤胛覀冺?xiàng)目中常用的日志切割，完整版的logger.go代碼如下：

package logger

import (
    "gin_zap_demo/config"
    "net"
    "net/http"
    "net/http/httputil"
    "os"
    "runtime/debug"
    "strings"
    "time"

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

var lg *zap.Logger

// InitLogger 初始化Logger
func InitLogger(cfg *config.LogConfig) (err error) {
    writeSyncer := getLogWriter(cfg.Filename, cfg.MaxSize, cfg.MaxBackups, cfg.MaxAge)
    encoder := getEncoder()
    var l = new(zapcore.Level)
    err = l.UnmarshalText([]byte(cfg.Level))
    if err != nil {
        return
    }
    core := zapcore.NewCore(encoder, writeSyncer, l)

    lg = zap.New(core, zap.AddCaller())
    zap.ReplaceGlobals(lg) // 替換zap包中全局的logger實(shí)例，后續(xù)在其他包中只需使用zap.L()調(diào)用即可
    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框架默認(rèn)的日志
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掉項(xiàng)目可能出現(xiàn)的panic，并使用zap記錄相關(guān)日志
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()
    }
}

然后定義日志相關(guān)配置：

type LogConfig struct {
    Level string `json:"level"`
    Filename string `json:"filename"`
    MaxSize int `json:"maxsize"`
    MaxAge int `json:"max_age"`
    MaxBackups int `json:"max_backups"`
}

在項(xiàng)目中先從配置文件加載配置信息，再調(diào)用logger.InitLogger(config.Conf.LogConfig)即可完成logger實(shí)例的初識(shí)化。其中，通過(guò)r.Use(logger.GinLogger(), logger.GinRecovery(true))注冊(cè)我們的中間件來(lái)使用zap接收gin框架自身的日志，在項(xiàng)目中需要的地方通過(guò)使用zap.L().Xxx()方法來(lái)記錄自定義日志信息。

package main

import (
    "fmt"
    "gin_zap_demo/config"
    "gin_zap_demo/logger"
    "net/http"
    "os"

    "go.uber.org/zap"

    "github.com/gin-gonic/gin"
)

func main() {
    // load config from config.json
    if len(os.Args) < 1 {
        return
    }

    if err := config.Init(os.Args[1]); err != nil {
        panic(err)
    }
    // init logger
    if err := logger.InitLogger(config.Conf.LogConfig); err != nil {
        fmt.Printf("init logger failed, err:%v\n", err)
        return
    }

    gin.SetMode(config.Conf.Mode)

    r := gin.Default()
    // 注冊(cè)zap相關(guān)中間件
    r.Use(logger.GinLogger(), logger.GinRecovery(true))

    r.GET("/hello", func(c *gin.Context) {
        // 假設(shè)你有一些數(shù)據(jù)需要記錄到日志中
        var (
            name = "itxiaoma"
            age  = 18
        )
        // 記錄日志并使用zap.Xxx(key, val)記錄相關(guān)字段
        zap.L().Debug("this is hello func", zap.String("user", name), zap.Int("age", age))

        c.String(http.StatusOK, "hello itxiaoma!")
    })

    addr := fmt.Sprintf(":%v", config.Conf.Port)
    r.Run(addr)
}

到此這篇關(guān)于Go學(xué)習(xí)筆記之Zap日志的使用的文章就介紹到這了,更多相關(guān)Go Zap日志內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: