Log包

Go语言提供的默认日志包：https://golang.org/pkg/log/

根本用法

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系列函数会在写入日志信息后paniclog.Panicln("这是一个会触发panic的日志。") //执行后会主动触发一个异样

flag属性

默认状况下的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: 这是一条优雅的日志。

prefix属性

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属性

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

创立新的Logger

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记录的日志

自定义Go 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

Zap是十分快的、结构化的，分日志级别的Go日志库。

装置

go get -u go.uber.org/zap

配置Zap Logger

Zap提供了两种类型的日志记录器—Sugared Logger和Logger。
  • Logger更快，但只反对强类型的结构化日志记录。
  • Sugared Logger反对结构化和printf格调的日志记录。

Logger

  • 通过调用zap.NewProduction()/zap.NewDevelopment()或者zap.Example()创立一个Logger。
  • Example和Production应用的是 json 格局输入，Development 应用行的模式输入
  • Development从正告级别(Warn)向上打印到堆栈中来跟踪，
  • ProductionError , Dpanic 级别的记录，会在堆栈中跟踪文件， Warn 不会
  • 通过Logger调用Info/Error等。
  • 默认状况下日志都会打印到应用程序的console界面。
var logger *zap.Loggerfunc 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"}

Sugared Logger

slogger := logger.Sugar()

suger logger基于 printf 宰割的反射类型检测，提供更简略的语法来增加混合类型的标签。

var sugarLogger *zap.SugaredLoggerfunc 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"}

定制logger

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.com1.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.com1.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.com2019-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.com2019-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：在进行切割之前，日志文件的最大大小（以MB为单位）
  • MaxBackups：保留旧文件的最大个数
  • MaxAges：保留旧文件的最大天数
  • Compress：是否压缩/归档旧文件

Zap接管Gin默认日志

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

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

基于zap的中间件

替换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掉我的项目可能呈现的panicfunc 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-contri...。

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

在gin我的项目中应用zap

最初咱们再退出咱们我的项目中罕用的日志切割，完整版的logger.go代码如下：

package loggerimport (    "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 初始化Loggerfunc 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 mainimport (    "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语言Log应用

在Go语言我的项目中应用Zap日志库

应用zap接管gin框架默认的日志并配置日志归档