共计 14567 个字符,预计需要花费 37 分钟才能阅读完成。
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 系列函数会在写入日志信息后 panic
log.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) 向上打印到堆栈中来跟踪,Production
Error , 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"}
Sugared Logger
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"}
定制 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.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
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 掉我的项目可能呈现的 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-contri…。
这样咱们就能够在 gin 框架中应用咱们下面定义好的两个中间件来代替 gin 框架默认的 Logger()
和Recovery()
了。
在 gin 我的项目中应用 zap
最初咱们再退出咱们我的项目中罕用的日志切割,完整版的 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 语言 Log 应用
在 Go 语言我的项目中应用 Zap 日志库
应用 zap 接管 gin 框架默认的日志并配置日志归档