关于golang:golang的zap的SugaredLogger

2次阅读

共计 6062 个字符，预计需要花费 16 分钟才能阅读完成。

本文次要钻研一下 golang 的 zap 的 SugaredLogger

zap@v1.16.0/sugar.go

type SugaredLogger struct {base *Logger}

func (s *SugaredLogger) Named(name string) *SugaredLogger {return &SugaredLogger{base: s.base.Named(name)}
}

func (s *SugaredLogger) With(args ...interface{}) *SugaredLogger {return &SugaredLogger{base: s.base.With(s.sweetenFields(args)...)}
}

func (s *SugaredLogger) Debug(args ...interface{}) {s.log(DebugLevel, "", args, nil)
}

func (s *SugaredLogger) Info(args ...interface{}) {s.log(InfoLevel, "", args, nil)
}

func (s *SugaredLogger) Warn(args ...interface{}) {s.log(WarnLevel, "", args, nil)
}

func (s *SugaredLogger) Error(args ...interface{}) {s.log(ErrorLevel, "", args, nil)
}

func (s *SugaredLogger) DPanic(args ...interface{}) {s.log(DPanicLevel, "", args, nil)
}

func (s *SugaredLogger) Panic(args ...interface{}) {s.log(PanicLevel, "", args, nil)
}

func (s *SugaredLogger) Fatal(args ...interface{}) {s.log(FatalLevel, "", args, nil)
}

func (s *SugaredLogger) Debugf(template string, args ...interface{}) {s.log(DebugLevel, template, args, nil)
}

func (s *SugaredLogger) Infof(template string, args ...interface{}) {s.log(InfoLevel, template, args, nil)
}

func (s *SugaredLogger) Warnf(template string, args ...interface{}) {s.log(WarnLevel, template, args, nil)
}

func (s *SugaredLogger) Errorf(template string, args ...interface{}) {s.log(ErrorLevel, template, args, nil)
}

func (s *SugaredLogger) DPanicf(template string, args ...interface{}) {s.log(DPanicLevel, template, args, nil)
}

func (s *SugaredLogger) Panicf(template string, args ...interface{}) {s.log(PanicLevel, template, args, nil)
}

func (s *SugaredLogger) Fatalf(template string, args ...interface{}) {s.log(FatalLevel, template, args, nil)
}

func (s *SugaredLogger) Debugw(msg string, keysAndValues ...interface{}) {s.log(DebugLevel, msg, nil, keysAndValues)
}

func (s *SugaredLogger) Infow(msg string, keysAndValues ...interface{}) {s.log(InfoLevel, msg, nil, keysAndValues)
}

func (s *SugaredLogger) Warnw(msg string, keysAndValues ...interface{}) {s.log(WarnLevel, msg, nil, keysAndValues)
}

func (s *SugaredLogger) Errorw(msg string, keysAndValues ...interface{}) {s.log(ErrorLevel, msg, nil, keysAndValues)
}

func (s *SugaredLogger) DPanicw(msg string, keysAndValues ...interface{}) {s.log(DPanicLevel, msg, nil, keysAndValues)
}

func (s *SugaredLogger) Panicw(msg string, keysAndValues ...interface{}) {s.log(PanicLevel, msg, nil, keysAndValues)
}

func (s *SugaredLogger) Fatalw(msg string, keysAndValues ...interface{}) {s.log(FatalLevel, msg, nil, keysAndValues)
}

func (s *SugaredLogger) Sync() error {return s.base.Sync()
}

SugaredLogger 提供了 debug、info、warn、error、panic、dpanic、fatal 这几种办法 ( 应用 fmt.Sprint 的默认格局)，另外还有带 f 的反对 format，带 w 的办法则反对 with 键值对

zap@v1.16.0/level.go

const (
    // DebugLevel logs are typically voluminous, and are usually disabled in
    // production.
    DebugLevel = zapcore.DebugLevel
    // InfoLevel is the default logging priority.
    InfoLevel = zapcore.InfoLevel
    // WarnLevel logs are more important than Info, but don't need individual
    // human review.
    WarnLevel = zapcore.WarnLevel
    // ErrorLevel logs are high-priority. If an application is running smoothly,
    // it shouldn't generate any error-level logs.
    ErrorLevel = zapcore.ErrorLevel
    // DPanicLevel logs are particularly important errors. In development the
    // logger panics after writing the message.
    DPanicLevel = zapcore.DPanicLevel
    // PanicLevel logs a message, then panics.
    PanicLevel = zapcore.PanicLevel
    // FatalLevel logs a message, then calls os.Exit(1).
    FatalLevel = zapcore.FatalLevel
)

zap 外部的 level 分为 debug、info、warn、error、dpanic、panic、fatal 这几种

DPanic stands for “panic in development.” In development, it logs at PanicLevel; otherwise, it logs at ErrorLevel. DPanic makes it easier to catch errors that are theoretically possible, but shouldn’t actually happen, without crashing in production.

func dpanicInDevelopment() {logger, _ := zap.NewDevelopment()
    defer logger.Sync() // flushes buffer, if any
    sugar := logger.Sugar()
    sugar.DPanic("test dpanic")
    sugar.Info("this will not be logged")
}

DPanic 在 development 下的成果跟 panic 成果相似，最初的 info 不会被输入

func dpanicInProduction() {logger, _ := zap.NewProduction()
    defer logger.Sync() // flushes buffer, if any
    sugar := logger.Sugar()
    sugar.DPanic("test dpanic logged as error in not development mode")
    sugar.Info("this will be logged")
}

DPanic 在非 development 下则进化为 error 模式，最初的 info 照样会输入，这样子在 production 下比拟平安一点。

zap@v1.16.0/logger.go

func (log *Logger) check(lvl zapcore.Level, msg string) *zapcore.CheckedEntry {
    // check must always be called directly by a method in the Logger interface
    // (e.g., Check, Info, Fatal).
    const callerSkipOffset = 2

    // Check the level first to reduce the cost of disabled log calls.
    // Since Panic and higher may exit, we skip the optimization for those levels.
    if lvl < zapcore.DPanicLevel && !log.core.Enabled(lvl) {return nil}

    // Create basic checked entry thru the core; this will be non-nil if the
    // log message will actually be written somewhere.
    ent := zapcore.Entry{
        LoggerName: log.name,
        Time:       time.Now(),
        Level:      lvl,
        Message:    msg,
    }
    ce := log.core.Check(ent, nil)
    willWrite := ce != nil

    // Set up any required terminal behavior.
    switch ent.Level {
    case zapcore.PanicLevel:
        ce = ce.Should(ent, zapcore.WriteThenPanic)
    case zapcore.FatalLevel:
        onFatal := log.onFatal
        // Noop is the default value for CheckWriteAction, and it leads to
        // continued execution after a Fatal which is unexpected.
        if onFatal == zapcore.WriteThenNoop {onFatal = zapcore.WriteThenFatal}
        ce = ce.Should(ent, onFatal)
    case zapcore.DPanicLevel:
        if log.development {ce = ce.Should(ent, zapcore.WriteThenPanic)
        }
    }

    // Only do further annotation if we're going to write this message; checked
    // entries that exist only for terminal behavior don't benefit from
    // annotation.
    if !willWrite {return ce}

    // Thread the error output through to the CheckedEntry.
    ce.ErrorOutput = log.errorOutput
    if log.addCaller {frame, defined := getCallerFrame(log.callerSkip + callerSkipOffset)
        if !defined {fmt.Fprintf(log.errorOutput, "%v Logger.check error: failed to get caller\n", time.Now().UTC())
            log.errorOutput.Sync()}

        ce.Entry.Caller = zapcore.EntryCaller{
            Defined:  defined,
            PC:       frame.PC,
            File:     frame.File,
            Line:     frame.Line,
            Function: frame.Function,
        }
    }
    if log.addStack.Enabled(ce.Entry.Level) {ce.Entry.Stack = StackSkip("", log.callerSkip+callerSkipOffset).String
    }

    return ce
}

logger.check 办法会判断 lvl，如果是 zapcore.DPanicLevel，则会进一步判断是否是 development 模式，如果是会设置ce.Should(ent, zapcore.WriteThenPanic)

zap 外部的 level 分为 debug、info、warn、error、dpanic、panic、fatal 这几种
SugaredLogger 提供了 debug、info、warn、error、panic、dpanic、fatal 这几种办法 ( 应用 fmt.Sprint 的默认格局)，另外还有带 f 的反对 format，带 w 的办法则反对 with 键值对
DPanic 在 development 下的成果跟 panic 成果相似，在非 development 下则进化为 error 模式