溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇“Go之Zap日志如何使用”文章的知識點大部分人都不太理解，所以小編給大家總結了以下內容，內容詳細，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“Go之Zap日志如何使用”文章吧。
log包定義了Logger類型，該類型提供了一些格式化輸出的方法。
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設置每一行的前綴，flag設置輸出的各種屬性，比如時間、行號、文件路徑等。out輸出的方向，用于把日志存儲文件。
本包也提供了一個預定義的“標準”logger，可以通過調用函數Print系列(Print|Printf|Println）、Fatal系列（Fatal|Fatalf|Fatalln）、和Panic系列（Panic|Panicf|Panicln）來使用，比自行創建一個logger對象更容易使用。
例如，我們可以像下面的代碼一樣直接通過log包來調用上面提到的方法，默認它們會將日志信息打印到終端界面：
log.Println("這是一條優雅的日志。")
v := "優雅的"
log.Printf("這是一個%s日志\n", v)
//fatal系列函數會在寫入日志信息后調用os.Exit(1)
log.Fatalln("這是一天會觸發fatal的日志")
//Panic系列函數會在寫入日志信息后panic
log.Panicln("這是一個會觸發panic的日志。") //執行后會自動觸發一個異常默認情況下的logger只會提供日志的時間信息，但是很多情況下我們希望得到更多信息，比如記錄該日志的文件名和行號等。log標準庫中為我們提供了定制這些設置的方法。
log標準庫中的Flags函數會返回標準logger的輸出配置，而SetFlags函數用來設置標準logger的輸出配置。下面是flag屬性對應的常量
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 )
設置輸出屬性的代碼如下：
func main() {
log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
log.Println("這是一條優雅的日志。")
}編譯輸出：
2020/07/14 22:51:06.079594 D:/xxx/test_log.go:24: 這是一條優雅的日志。
log標準庫中還提供了關于日志信息前綴的兩個方法：其中Prefix函數用來查看標準logger的輸出前綴，SetPrefix函數用來設置輸出前綴。
func Prefix() string func SetPrefix(prefix string)
設置日志輸出前綴的代碼如下：
func main() {
log.SetPrefix("[PS]")
log.Println("這是一條很普通的日志。")
}編譯輸出：
[PS]2020/07/14 22:56:15.652555 D:/xxx/test_log.go:26: 這是一個普通的日志
out屬性是一個io.Writer輸出流，使用它可以把日志輸出為文件。
需要用的方法為：設置標準logger的輸出目的地，默認是標準錯誤輸出。
func SetOutput(w io.Writer)
例如，下面的代碼會把日志輸出到同目錄下的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("這是一條很普通的日志。")
}如果你要使用標準的logger，我們通常會把上面的配置操作寫到init函數中。
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)
}log標準庫中還提供了一個創建新logger對象的構造函數 New，支持我們創建自己的logger示例。New函數的簽名如下：
func New(out io.Writer, prefix string, flag int) *Logger
New創建一個Logger對象。其中，參數out設置日志信息寫入的目的地。參數prefix會添加到生成的每一條日志前面。參數flag定義日志的屬性（時間、文件等等）。
舉個例子：
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記錄的日志
可以設置任何io.Writer作為日志記錄輸出并向其發送要寫入的日志
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")
}func main() {
SetupLogger()
test()
}Zap是非常快的、結構化的，分日志級別的Go日志庫。
go get -u go.uber.org/zap
Zap提供了兩種類型的日志記錄器—Sugared Logger和Logger。
Logger更快，但只支持強類型的結構化日志記錄。
Sugared Logger支持結構化和printf風格的日志記錄。
通過調用zap.NewProduction()/zap.NewDevelopment()或者zap.Example()創建一個Logger。
Example和Production使用的是 json 格式輸出，Development 使用行的形式輸出
Development從警告級別(Warn)向上打印到堆棧中來跟蹤，
ProductionError , Dpanic 級別的記錄，會在堆棧中跟蹤文件， Warn 不會
通過Logger調用Info/Error等。
默認情況下日志都會打印到應用程序的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()
}
}在上面的代碼中，我們首先創建了一個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.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"}
slogger := logger.Sugar()
suger logger基于 printf 分割的反射類型檢測，提供更簡單的語法來添加混合類型的標簽。
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()
}
}執行結果：
{"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"}
1. 日志寫入文件
使用zap.New(…)方法來手動傳遞所有配置，而不是使用像zap.NewProduction()這樣的預置方法來創建logger。
func New(core zapcore.Core, options ...Option) *Logger
Encoder:編碼器(如何寫入日志)。我們將使用開箱即用的NewJSONEncoder()，并使用預先設置的ProductionEncoderConfig()。
zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
WriterSyncer ：指定日志將寫到哪里去。我們使用zapcore.AddSync()函數并且將打開的文件句柄傳進去。
file, _ := os.Create("./test.log")
writeSyncer := zapcore.AddSync(file)Log Level：哪種級別的日志將被寫入。
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.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())
當使用這些修改過的logger配置調用上述部分的main()函數時，以下輸出將打印在文件——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. 更改時間編碼并添加調用者詳細信息
修改時間編碼器：
func getEncoder() zapcore.Encoder {
encoderConfig := zap.NewProductionEncoderConfig()
encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
return zapcore.NewConsoleEncoder(encoderConfig)
}添加調用方信息：在zap.New(..)函數中添加一個Option。
logger := zap.New(core, zap.AddCaller())
最終結果：
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
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：在進行切割之前，日志文件的最大大小（以MB為單位）
MaxBackups：保留舊文件的最大個數
MaxAges：保留舊文件的最大天數
Compress：是否壓縮/歸檔舊文件
我們在使用gin.Default()的同時是用到了gin框架內的兩個默認中間件Logger()和Recovery()。
Logger()是把gin框架本身的日志輸出到標準輸出（我們本地開發調試時在終端輸出的那些日志就是它的功勞）
Recovery()是在程序出現panic的時候恢復現場并寫入500響應的。
替換gin.Default()
r := gin.New() r.Use(GinLogger(), GinRecovery())
中間件：
// 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()了。
最后我們再加入我們項目中常用的日志切割，完整版的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實例，后續在其他包中只需使用zap.L()調用即可
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()
}
}然后定義日志相關配置：
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"`
}在項目中先從配置文件加載配置信息，再調用logger.InitLogger(config.Conf.LogConfig)即可完成logger實例的初識化。其中，通過r.Use(logger.GinLogger(), logger.GinRecovery(true))注冊我們的中間件來使用zap接收gin框架自身的日志，在項目中需要的地方通過使用zap.L().Xxx()方法來記錄自定義日志信息。
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()
// 注冊zap相關中間件
r.Use(logger.GinLogger(), logger.GinRecovery(true))
r.GET("/hello", func(c *gin.Context) {
// 假設你有一些數據需要記錄到日志中
var (
name = "itxiaoma"
age = 18
)
// 記錄日志并使用zap.Xxx(key, val)記錄相關字段
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)
}以上就是關于“Go之Zap日志如何使用”這篇文章的內容，相信大家都有了一定的了解，希望小編分享的內容對大家有幫助，若想了解更多相關的知識內容，請關注億速云行業資訊頻道。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
