zap细节拾遗——日志信息内容的具体顺序问题

前言

在之前的篇章中主要按照几个核心使用点进行源码的分析，有些细节未能覆盖到，因此对使用时可能需要注意的细节补充说明下。

输出日志信息内容的key具体顺序问题

先说结论，先后顺序为：

Level-Time-LoggerName-Caller-Message-已排序的InitialFields-fields->Stack
           

注意：以上部分信息可缺省，和具体的配置有关。

具体处理过程如下：

1.config build预处理部分信息

build中对InitialFields按照key排序处理，存入logger的core.enc.buf

func (cfg Config) Build(opts ...Option) (*Logger, error) {
    ...
    log := New(
        zapcore.NewCore(enc, sink, cfg.Level),
        cfg.buildOptions(errSink)...,
    )
    ...
    return log, nil
}

func (cfg Config) buildOptions(errSink zapcore.WriteSyncer) []Option {
    opts := []Option{ErrorOutput(errSink)}
    ...
    if len(cfg.InitialFields) > 0 {
        fs := make([]Field, 0, len(cfg.InitialFields))
        keys := make([]string, 0, len(cfg.InitialFields))
        for k := range cfg.InitialFields {
            keys = append(keys, k)
        }
        sort.Strings(keys)//按key排序
        for _, k := range keys {//根据已排序的key处理对应的val
            fs = append(fs, Any(k, cfg.InitialFields[k]))
        }
        opts = append(opts, Fields(fs...))//添加fields的处理func
    }

    return opts
}

// Fields adds fields to the Logger.
//封装fields
func Fields(fs ...Field) Option {
    return optionFunc(func(log *Logger) {
        log.core = log.core.With(fs)
    })
}
// 构造core
func (c *ioCore) With(fields []Field) Core {
    clone := c.clone()
    addFields(clone.enc, fields)
    return clone
}
//fields的真正处理的func，将fields添加到编码器
func addFields(enc ObjectEncoder, fields []Field) {
    for i := range fields {
        fields[i].AddTo(enc)
    }
}

// 根据具体的类型选择对应的处理方式
func (f Field) AddTo(enc ObjectEncoder) {
    var err error

    switch f.Type {
    ...
    case Int64Type:
        enc.AddInt64(f.Key, f.Integer)
    ...
    default:
        panic(fmt.Sprintf("unknown field type: %v", f))
    }

    if err != nil {
        enc.AddString(fmt.Sprintf("%sError", f.Key), err.Error())
    }
}

func (enc *jsonEncoder) AppendInt64(val int64) {
    enc.addElementSeparator()
    enc.buf.AppendInt(val)
}

//开始调用再构建core后
func New(core zapcore.Core, options ...Option) *Logger {
    if core == nil {
        return NewNop()
    }
    log := &Logger{
        core:        core,
        errorOutput: zapcore.Lock(os.Stderr),
        addStack:    zapcore.FatalLevel + 1,
    }
    return log.WithOptions(options...)//此处进行InitialFields处理的调用
}

func (log *Logger) WithOptions(opts ...Option) *Logger {
    c := log.clone()
    for _, opt := range opts {
        opt.apply(c)
    }
    return c
}

func (f optionFunc) apply(log *Logger) {
    f(log)
}

           

2.Write时进行整体信息顺序控制

EncodeEntry中按照固定的顺序依次对key及其value进行编码。key的顺序依次为：

LevelKey->TimeKey->NameKey->CallerKey->MessageKey->InitialFields->fields->StacktraceKey

func (log *Logger) Info(msg string, fields ...Field) {
    if ce := log.check(InfoLevel, msg); ce != nil {
        ce.Write(fields...)
    }
}

func (ce *CheckedEntry) Write(fields ...Field) {
    ...
    var err error
    for i := range ce.cores {
        err = multierr.Append(err, ce.cores[i].Write(ce.Entry, fields))
    }
    ...
}

func (c *ioCore) Write(ent Entry, fields []Field) error {
    buf, err := c.enc.EncodeEntry(ent, fields)
    ...
    return nil
}

func (enc *jsonEncoder) EncodeEntry(ent Entry, fields []Field) (*buffer.Buffer, error) {
    final := enc.clone()
    final.buf.AppendByte('{')

    if final.LevelKey != "" {
        final.addKey(final.LevelKey)
        cur := final.buf.Len()
        final.EncodeLevel(ent.Level, final)
        if cur == final.buf.Len() {
            // User-supplied EncodeLevel was a no-op. Fall back to strings to keep
            // output JSON valid.
            final.AppendString(ent.Level.String())
        }
    }
    if final.TimeKey != "" {
        final.AddTime(final.TimeKey, ent.Time)
    }
    if ent.LoggerName != "" && final.NameKey != "" {
        final.addKey(final.NameKey)
        cur := final.buf.Len()
        nameEncoder := final.EncodeName

        // if no name encoder provided, fall back to FullNameEncoder for backwards
        // compatibility
        if nameEncoder == nil {
            nameEncoder = FullNameEncoder
        }

        nameEncoder(ent.LoggerName, final)
        if cur == final.buf.Len() {
            // User-supplied EncodeName was a no-op. Fall back to strings to
            // keep output JSON valid.
            final.AppendString(ent.LoggerName)
        }
    }
    if ent.Caller.Defined && final.CallerKey != "" {
        final.addKey(final.CallerKey)
        cur := final.buf.Len()
        final.EncodeCaller(ent.Caller, final)
        if cur == final.buf.Len() {
            // User-supplied EncodeCaller was a no-op. Fall back to strings to
            // keep output JSON valid.
            final.AppendString(ent.Caller.String())
        }
    }
    if final.MessageKey != "" {
        final.addKey(enc.MessageKey)
        final.AppendString(ent.Message)
    }
    if enc.buf.Len() > 0 {//处理InitialFields
        final.addElementSeparator()
        final.buf.Write(enc.buf.Bytes())
    }
    addFields(final, fields)
    final.closeOpenNamespaces()
    if ent.Stack != "" && final.StacktraceKey != "" {
        final.AddString(final.StacktraceKey, ent.Stack)
    }
    final.buf.AppendByte('}')
    if final.LineEnding != "" {
        final.buf.AppendString(final.LineEnding)
    } else {
        final.buf.AppendString(DefaultLineEnding)
    }

    ret := final.buf
    putJSONEncoder(final)
    return ret, nil
}
           

公众号

鄙人刚刚开通了公众号，专注于分享Go开发相关内容，望大家感兴趣的支持一下，在此特别感谢。