日志zap

发表于 更新于 分类于 ， ，

zap日志级别

zap日志级别，一共7级：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
const (
 // DebugLevel logs are typically voluminous, and are usually disabled in production.
 DebugLevel Level = iota - 1
 // InfoLevel is the default logging priority.
 InfoLevel
 // WarnLevel logs are more important than Info, but don't need individual human review.
 WarnLevel
 // ErrorLevel logs are high-priority. If an application is running smoothly, it shouldn't generate any error-level logs.
 ErrorLevel
 // DPanicLevel logs are particularly important errors. In development the logger panics after writing the message.
 DPanicLevel
 // PanicLevel logs a message, then panics.
 PanicLevel
 // FatalLevel logs a message, then calls os.Exit(1).
 FatalLevel

 _minLevel = DebugLevel
 _maxLevel = FatalLevel
)

zap官方案例

zap 的官方案例中，介绍了三种使用方式：

  • AdvancedConfiguration：高级配置
  • BasicConfiguration：基本配置
  • Presets：预置

Presets

Presets（预置函数） 是 zap 日志包最简单的用法，不需要过多的自定义配置就可以用起来。

Presets 官网示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import (
 "time"

 "go.uber.org/zap"
)

func main() {
 logger := zap.NewExample() // or NewProduction, or NewDevelopment
 defer logger.Sync()

 const url = "http://example.com"

 sugar := logger.Sugar()
 sugar.Infow("Failed to fetch URL.",
  "url", url,
  "attempt", 3,
  "backoff", time.Second,
 )
 sugar.Infof("Failed to fetch URL: %s", url)

 logger.Info("Failed to fetch URL.",
  zap.String("url", url),
  zap.Int("attempt", 3),
  zap.Duration("backoff", time.Second),
 )
}

BasicConfiguration

当预置函数的logger配置不满足我们的需求时，可以自定义配置logger 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package main

import (
 "encoding/json"

 "go.uber.org/zap"
)

func main() {
 // For some users, the presets offered by the NewProduction, NewDevelopment,
 // and NewExample constructors won't be appropriate. For most of those
 // users, the bundled Config struct offers the right balance of flexibility
 // and convenience. (For more complex needs, see the AdvancedConfiguration
 // example.)
 //
 // See the documentation for Config and zapcore.EncoderConfig for all the
 // available options.
 rawJSON := []byte(`{
   "level": "debug",
   "encoding": "json",
   "outputPaths": ["stdout", "/tmp/logs"],
   "errorOutputPaths": ["stderr"],
   "initialFields": {"foo": "bar"},
   "encoderConfig": {
     "messageKey": "message",
     "levelKey": "level",
     "levelEncoder": "lowercase"
   }
 }`)

 var cfg zap.Config
 if err := json.Unmarshal(rawJSON, &cfg); err != nil {
  panic(err)
 }
 logger, err := cfg.Build()
 if err != nil {
  panic(err)
 }
 defer logger.Sync()

 logger.Info("logger construction succeeded")
}

AdvancedConfiguration

如果需要更多的功能，例如：分隔文件、将日志发送到消息队列等，需要引入 go.uber.org/zap/zapcore。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
package main

import (
 "io/ioutil"
 "os"

 "go.uber.org/zap"
 "go.uber.org/zap/zapcore"
)

func main() {
 // The bundled Config struct only supports the most common configuration
 // options. More complex needs, like splitting logs between multiple files
 // or writing to non-file outputs, require use of the zapcore package.
 //
 // In this example, imagine we're both sending our logs to Kafka and writing
 // them to the console. We'd like to encode the console output and the Kafka
 // topics differently, and we'd also like special treatment for
 // high-priority logs.

 // First, define our level-handling logic.
 highPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
  return lvl >= zapcore.ErrorLevel
 })
 lowPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
  return lvl < zapcore.ErrorLevel
 })

 // Assume that we have clients for two Kafka topics. The clients implement
 // zapcore.WriteSyncer and are safe for concurrent use. (If they only
 // implement io.Writer, we can use zapcore.AddSync to add a no-op Sync
 // method. If they're not safe for concurrent use, we can add a protecting
 // mutex with zapcore.Lock.)
 topicDebugging := zapcore.AddSync(ioutil.Discard)
 topicErrors := zapcore.AddSync(ioutil.Discard)

 // High-priority output should also go to standard error, and low-priority
 // output should also go to standard out.
 consoleDebugging := zapcore.Lock(os.Stdout)
 consoleErrors := zapcore.Lock(os.Stderr)

 // Optimize the Kafka output for machine consumption and the console output
 // for human operators.
 kafkaEncoder := zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
 consoleEncoder := zapcore.NewConsoleEncoder(zap.NewDevelopmentEncoderConfig())

 // Join the outputs, encoders, and level-handling functions into
 // zapcore.Cores, then tee the four cores together.
 core := zapcore.NewTee(
  zapcore.NewCore(kafkaEncoder, topicErrors, highPriority),
  zapcore.NewCore(consoleEncoder, consoleErrors, highPriority),
  zapcore.NewCore(kafkaEncoder, topicDebugging, lowPriority),
  zapcore.NewCore(consoleEncoder, consoleDebugging, lowPriority),
 )

 // From a zapcore.Core, it's easy to construct a Logger.
 logger := zap.New(core)
 defer logger.Sync()
 logger.Info("constructed a logger")
}

zap&zapcore知识点详解

生产配置参考