接口实现

为了方便业务自适配不同的 log 接入使用，Logger 只包含了最简单的 Log 接口。当业务需要在 Kratos 框架内部使用自定义的 log 的时候，只需要简单实现 Log 方法即可。同时 kratos log 也提供了一些日志的辅助功能，如 value、helper、 filter 等，当我们需要用到这些功能时可以直接使用框架的内置实现，或自行实现相应的功能。

  1. type Logger interface {
  2.     Log(level Level, keyvals ...interface{}) error
  3. }

如何实现

实现 logger

  1. // https://github.com/go-kratos/kratos/blob/main/log/std.go
  2. var _ Logger = (*stdLogger)(nil)
  4. type stdLogger struct {
  5.     log  *log.Logger
  6.     pool *sync.Pool
  7. }
  9. // NewStdLogger new a logger with writer.
  10. func NewStdLogger(w io.Writer) Logger {
  11.     return &stdLogger{
  12.         log: log.New(w, "", 0),
  13.         pool: &sync.Pool{
  14.             New: func() interface{} {
  15.                 return new(bytes.Buffer)
  16.             },
  17.         },
  18.     }
  19. }
  21. // Log print the kv pairs log.
  22. func (l *stdLogger) Log(level Level, keyvals ...interface{}) error {
  23.     if len(keyvals) == 0 {
  24.         return nil
  25.     }
  26.     if len(keyvals)%2 != 0 {
  27.         keyvals = append(keyvals, "")
  28.     }
  29.     buf := l.pool.Get().(*bytes.Buffer)
  30.     buf.WriteString(level.String())
  31.     for i := 0; i < len(keyvals); i += 2 {
  32.         fmt.Fprintf(buf, " %s=%v", keyvals[i], keyvals[i+1])
  33.     }
  34.     l.log.Output(4, buf.String())~~~~
  35.     buf.Reset()
  36.     l.pool.Put(buf)
  37.     return nil
  38. }

实现 valuer

  1. func Timestamp(layout string) Valuer {
  2.     return func(context.Context) interface{} {
  3.         return time.Now().Format(layout)
  4.     }
  5. }

使用方式

使用 Logger 打印日志

  1. logger := log.DefaultLogger
  2. logger.Log(LevelInfo, "key1", "value1")

使用 Helper 打印日志

  1. log := log.NewHelper(DefaultLogger)
  2. log.Debug("test debug")
  3. log.Info("test info")
  4. log.Warn("test warn")
  5. log.Error("test error")

使用 valuer

  1. logger := DefaultLogger
  2. logger = With(logger, "ts", DefaultTimestamp, "caller", DefaultCaller)
  3. logger.Log(LevelInfo, "msg", "helloworld")

同时打印多个 logger

  1. out := log.NewStdLogger(os.Stdout)
  2. err := log.NewStdLogger(os.Stderr)
  3. l := log.With(MultiLogger(out, err))
  4. l.Log(LevelInfo, "msg", "test")

使用 context

  1. logger := log.With(NewStdLogger(os.Stdout),
  2.     "trace", Trace(),
  3. )
  4. log := log.NewHelper(logger)
  5. ctx := context.WithValue(context.Background(), "trace_id", "2233")
  6. log.WithContext(ctx).Info("got trace!")

使用 filter 过滤日志

如果需要过滤日志中某些不应该被打印明文的字段如 password 等,可以通过 log.NewFilter() 来实现过滤功能

通过 level 过滤日志
  1. l := log.NewHelper(log.NewFilter(log.DefaultLogger, log.FilterLevel(log.LevelWarn)))
  2. l.Log(LevelDebug, "msg1", "te1st debug")
  3. l.Debug("test debug")
  4. l.Debugf("test %s", "debug")
  5. l.Debugw("log", "test debug")
  6. l.Warn("warn log")
通过 key 过滤日志
  1. l := log.NewHelper(log.NewFilter(log.DefaultLogger, log.FilterKey("password")))
  2. l.Debugw("password", "123456")
通过 value 过滤日志
  1. l := log.NewHelper(log.NewFilter(log.DefaultLogger, log.FilterValue("kratos")))
  2. l.Debugw("name", "kratos")
通过 hook func 过滤日志
  1. l := log.NewHelper(log.NewFilter(log.DefaultLogger, log.FilterFunc(testFilterFunc)))
  2. l.Debug("debug level")
  3. l.Infow("password", "123456")
  4. func testFilterFunc(level Level, keyvals ...interface{}) bool {
  5.     if level == LevelWarn {
  6.         return true
  7.     }
  8.     for i := 0; i < len(keyvals); i++ {
  9.         if keyvals[i] == "password" {
  10.             keyvals[i+1] = "***"
  11.         }
  12.     }
  13.     return false
  14. }

输出日志到stdout

使用自带的 StdLogger 可以创建标准输出日志对象. 通过 NewHelper 构造日志模块，Helper 生成的日志模块可以提供不同等级的日志输出。

  1. logger := log.NewStdLogger()
  2. log := log.NewHelper(logger)
  3. // Levels
  4. log.Info("some log")
  5. log.Infof("format %s", "some log")
  6. log.Infow("field_name", "some log")

输出日志到fluentd

引入 fluent sdk

  1. import "github.com/go-kratos/fluent"
  3. addr := "unix:///var/run/fluent/fluent.sock"
  4. logger,err := fluent.NewLogger(addr)
  5. if err != nil {
  6.     return 
  7. }
  8. log := log.NewHelper(logger)
  9. // Levels
  10. log.Info("some log")
  11. log.Infof("format %s", "some log")
  12. log.Infow("field_name", "some log")

扩展阅读

使用 Zap 实现 Logger

  1. var _ log.Logger = (*ZapLogger)(nil)
  3. type ZapLogger struct {
  4.     log  *zap.Logger
  5.     Sync func() error
  6. }
  8. // NewZapLogger return ZapLogger
  9. func NewZapLogger(encoder zapcore.EncoderConfig, level zap.AtomicLevel, opts ...zap.Option) *ZapLogger {
  10.     core := zapcore.NewCore(
  11.         zapcore.NewConsoleEncoder(encoder),
  12.         zapcore.NewMultiWriteSyncer(
  13.             zapcore.AddSync(os.Stdout),
  14.         ), level)
  15.     zapLogger := zap.New(core, opts...)
  16.     return &ZapLogger{log: zapLogger, Sync: zapLogger.Sync}
  17. }
  19. // Log Implementation of logger interface
  20. func (l *ZapLogger) Log(level log.Level, keyvals ...interface{}) error {
  21.     if len(keyvals) == 0 || len(keyvals)%2 != 0 {
  22.         l.log.Warn(fmt.Sprint("Keyvalues must appear in pairs: ", keyvals))
  23.         return nil
  24.     }
  26.     // Zap.Field is used when keyvals pairs appear
  27.     var data []zap.Field
  28.     for i := 0; i < len(keyvals); i += 2 {
  29.         data = append(data, zap.Any(fmt.Sprint(keyvals[i]), fmt.Sprint(keyvals[i+1])))
  30.     }
  31.     switch level {
  32.     case log.LevelDebug:
  33.         l.log.Debug("", data...)
  34.     case log.LevelInfo:
  35.         l.log.Info("", data...)
  36.     case log.LevelWarn:
  37.         l.log.Warn("", data...)
  38.     case log.LevelError:
  39.         l.log.Error("", data...)
  40.     }
  41.     return nil
  42. }