Go日志框架zap增強(qiáng)及源碼解讀
更新時(shí)間：2022年07月29日 10:47:01 作者：捉蟲(chóng)大師
這篇文章主要為大家介紹了Go日志框架zap增強(qiáng)及源碼解讀，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪
正文
本文包括兩部分，一部分是源碼解讀，另一部分是對(duì)zap的增強(qiáng)。
由于zap是一個(gè)log庫(kù)，所以從兩方面來(lái)深入閱讀zap的源碼，一個(gè)是初始化logger的流程，一個(gè)是打一條log的流程。
初始化Logger
zap的Logger是一般通過(guò)一個(gè)Config結(jié)構(gòu)體初始化的，首先看下這個(gè)結(jié)構(gòu)體有哪些字段
type Config struct {
// 日志Level，因?yàn)榭梢詣?dòng)態(tài)更改，所以是atomic類型的，畢竟比鎖的性能好
Level AtomicLevel `json:"level" yaml:"level"`
// dev模式，啟用后會(huì)更改在某些使用情形下的行為，后面源碼解讀模塊會(huì)具體看到有什么作用
Development bool `json:"development" yaml:"development"`
// 禁用caller，caller就是會(huì)在打的log里加一條屬性，表示這條日志是在哪里打的，例如"httpd/svc.go:123"
DisableCaller bool `json:"disableCaller" yaml:"disableCaller"`
// 是否要在log里加上調(diào)用棧，dev模式下只有WarnLevel模式以上有調(diào)用棧，prod模式下只有ErrorLevel以上有調(diào)用棧
DisableStacktrace bool `json:"disableStacktrace" yaml:"disableStacktrace"`
// 采樣策略，控制打log的速率，也可以做一些其他自定義的操作，不難理解，具體看下面的SamplingConfig
Sampling *SamplingConfig `json:"sampling" yaml:"sampling"`
// log格式，自帶的有json和console兩種格式，可以通過(guò)使用RegisterEncoder來(lái)自定義log格式
Encoding string `json:"encoding" yaml:"encoding"`
// log格式具體配置，詳細(xì)看下面的EncoderConfig
EncoderConfig zapcore.EncoderConfig `json:"encoderConfig" yaml:"encoderConfig"`
// log輸出路徑，看結(jié)構(gòu)表示可以有多個(gè)輸出路徑
OutputPaths []string `json:"outputPaths" yaml:"outputPaths"`
// 內(nèi)部錯(cuò)誤輸出路徑，默認(rèn)是stderr
ErrorOutputPaths []string `json:"errorOutputPaths" yaml:"errorOutputPaths"`
// 每條log都會(huì)加上InitialFields里的內(nèi)容，顧名思義
InitialFields map[string]interface{} `json:"initialFields" yaml:"initialFields"`
}
// 采樣策略配置，大致的邏輯是每秒超過(guò)Thereafter個(gè)相同msg的log會(huì)執(zhí)行自定義的Hook函數(shù)(第二個(gè)參數(shù)為一個(gè)標(biāo)志，LogDropped)，具體邏輯可以看下面的源碼解析
type SamplingConfig struct {
Initial int `json:"initial" yaml:"initial"`
Thereafter int `json:"thereafter" yaml:"thereafter"`
Hook func(zapcore.Entry, zapcore.SamplingDecision) `json:"-" yaml:"-"`
}
const (
_numLevels = _maxLevel - _minLevel + 1
_countersPerLevel = 4096
)
// 用來(lái)記錄日志打了多少條
type counter struct {
resetAt atomic.Int64
counter atomic.Uint64
}
type counters [_numLevels][_countersPerLevel]counter
// 這里可以看到sampler就是Core外面包了一層Wrapper
type sampler struct {
Core
counts *counters
tick time.Duration // 這里的tick在初始化Logger的時(shí)候已經(jīng)寫死了是time.Second，也就是1秒
first, thereafter uint64
hook func(Entry, SamplingDecision)
}
// 所有的Core.Check都會(huì)先走sampler.Check，然后再走Core.Check
func (s *sampler) Check(ent Entry, ce *CheckedEntry) *CheckedEntry {
if !s.Enabled(ent.Level) {
return ce
}
if ent.Level >= _minLevel && ent.Level <= _maxLevel {
// 根據(jù)Message獲取counter，也就是這個(gè)Message打過(guò)幾次日志了
counter := s.counts.get(ent.Level, ent.Message)
// 打一條Message就會(huì)記錄一次到counters里，不過(guò)每秒會(huì)重置一次counter，具體看IncCheckReset里的邏輯
n := counter.IncCheckReset(ent.Time, s.tick)
// first表示最初的first條日志調(diào)用hook時(shí)第二個(gè)參數(shù)傳LogSampled，超過(guò)first的日志，每threrafter條日志第二個(gè)參數(shù)傳LogSampled，否則傳LogDropped
// 假設(shè)first是100，thereafter是50，表示同一個(gè)Message的log，最初的100條全都會(huì)記錄，之后的log在每秒鐘內(nèi)，每50條記錄一次
if n > s.first && (s.thereafter == 0 || (n-s.first)%s.thereafter != 0) {
s.hook(ent, LogDropped)
return ce
}
s.hook(ent, LogSampled)
}
return s.Core.Check(ent, ce)
}
// 這里可能會(huì)出現(xiàn)意想不到的情況
// 因?yàn)開(kāi)countersPerLevel寫死了是4096，那么必然會(huì)存在不同的key做完hash后取模會(huì)路由到相同的counter里
// 那么就會(huì)有概率丟棄掉沒(méi)有達(dá)到丟棄閾值的log
// 假設(shè)abc和def的hash值一樣，first是0，thereafter是10，表示每秒鐘每種log每10條才會(huì)記錄1次，那么abc和def這兩種log就會(huì)共享同一個(gè)counter，這就是問(wèn)題所在
func (cs *counters) get(lvl Level, key string) *counter {
i := lvl - _minLevel
// fnv32a是一個(gè)hash函數(shù)
// _countersPerLevel固定是4096
j := fnv32a(key) % _countersPerLevel
return &cs[i][j]
}
func (c *counter) IncCheckReset(t time.Time, tick time.Duration) uint64 {
tn := t.UnixNano()
resetAfter := c.resetAt.Load()
if resetAfter > tn {
return c.counter.Inc()
}
c.counter.Store(1)
newResetAfter := tn + tick.Nanoseconds()
if !c.resetAt.CAS(resetAfter, newResetAfter) {
return c.counter.Inc()
}
return 1
}
// log格式的詳細(xì)設(shè)置
type EncoderConfig struct {
// 設(shè)置log內(nèi)容里的一些屬性的key
MessageKey string `json:"messageKey" yaml:"messageKey"`
LevelKey string `json:"levelKey" yaml:"levelKey"`
TimeKey string `json:"timeKey" yaml:"timeKey"`
NameKey string `json:"nameKey" yaml:"nameKey"`
CallerKey string `json:"callerKey" yaml:"callerKey"`
FunctionKey string `json:"functionKey" yaml:"functionKey"`
StacktraceKey string `json:"stacktraceKey" yaml:"stacktraceKey"`
// 顧名思義不解釋
SkipLineEnding bool `json:"skipLineEnding" yaml:"skipLineEnding"`
LineEnding string `json:"lineEnding" yaml:"lineEnding"`
// Configure the primitive representations of common complex types. For
// example, some users may want all time.Times serialized as floating-point
// seconds since epoch, while others may prefer ISO8601 strings.
// 自定義一些屬性的格式，例如指定Time字段格式化為2022-05-23 16:16:16
EncodeLevel LevelEncoder `json:"levelEncoder" yaml:"levelEncoder"`
EncodeTime TimeEncoder `json:"timeEncoder" yaml:"timeEncoder"`
EncodeDuration DurationEncoder `json:"durationEncoder" yaml:"durationEncoder"`
EncodeCaller CallerEncoder `json:"callerEncoder" yaml:"callerEncoder"`
EncodeName NameEncoder `json:"nameEncoder" yaml:"nameEncoder"`
// 用于interface類型的encoder，可以自定義，默認(rèn)為jsonEncoder
NewReflectedEncoder func(io.Writer) ReflectedEncoder `json:"-" yaml:"-"`
// console格式的分隔符，默認(rèn)是tab
ConsoleSeparator string `json:"consoleSeparator" yaml:"consoleSeparator"`
}
Config里的大部分字段都有tag，可以通過(guò)UnmarshalJson或者UnmarshalYaml來(lái)配置，可以在全局的config文件來(lái)配置，非常方便。
通過(guò)以上的config就可以初始化一個(gè)logger，下面貼代碼
// 通過(guò)Config結(jié)構(gòu)體Build出一個(gè)Logger
func (cfg Config) Build(opts ...Option) (*Logger, error) {
// 核心函數(shù)buildEncoder
enc, err := cfg.buildEncoder()
if err != nil {
return nil, err
}
// 核心函數(shù)openSinks
sink, errSink, err := cfg.openSinks()
if err != nil {
return nil, err
}
if cfg.Level == (AtomicLevel{}) {
return nil, fmt.Errorf("missing Level")
}
// 核心函數(shù)New
log := New(
// 核心函數(shù)NewCore
zapcore.NewCore(enc, sink, cfg.Level),
cfg.buildOptions(errSink)...,
)
if len(opts) > 0 {
log = log.WithOptions(opts...)
}
return log, nil
}
// 核心函數(shù)buildEncoder
func (cfg Config) buildEncoder() (zapcore.Encoder, error) {
return newEncoder(cfg.Encoding, cfg.EncoderConfig)
}
// _encoderNameToConstructor是一個(gè)map[string]constructor，plugin式寫法，可以通過(guò)RegisterEncoder函數(shù)注冊(cè)自定義的Encoder，默認(rèn)只有console和json
_encoderNameToConstructor = map[string]func(zapcore.EncoderConfig) (zapcore.Encoder, error){
"console": func(encoderConfig zapcore.EncoderConfig) (zapcore.Encoder, error) {
return zapcore.NewConsoleEncoder(encoderConfig), nil
},
"json": func(encoderConfig zapcore.EncoderConfig) (zapcore.Encoder, error) {
return zapcore.NewJSONEncoder(encoderConfig), nil
},
}
func newEncoder(name string, encoderConfig zapcore.EncoderConfig) (zapcore.Encoder, error) {
if encoderConfig.TimeKey != "" && encoderConfig.EncodeTime == nil {
return nil, fmt.Errorf("missing EncodeTime in EncoderConfig")
}
_encoderMutex.RLock()
defer _encoderMutex.RUnlock()
if name == "" {
return nil, errNoEncoderNameSpecified
}
// 通過(guò)name，也就是Config.Encoding來(lái)決定使用哪種encoder
constructor, ok := _encoderNameToConstructor[name]
if !ok {
return nil, fmt.Errorf("no encoder registered for name %q", name)
}
return constructor(encoderConfig)
}
// 這里只展示jsonEncoder的邏輯，consoleEncoder和jsonEncoder差別不大
func NewJSONEncoder(cfg EncoderConfig) Encoder {
return newJSONEncoder(cfg, false)
}
func newJSONEncoder(cfg EncoderConfig, spaced bool) *jsonEncoder {
if cfg.SkipLineEnding {
cfg.LineEnding = ""
} else if cfg.LineEnding == "" {
cfg.LineEnding = DefaultLineEnding
}
// If no EncoderConfig.NewReflectedEncoder is provided by the user, then use default
if cfg.NewReflectedEncoder == nil {
cfg.NewReflectedEncoder = defaultReflectedEncoder
}
return &jsonEncoder{
EncoderConfig: &cfg,
// 這個(gè)buf是高性能的關(guān)鍵之一，使用了簡(jiǎn)化的bytesBuffer和sync.Pool，代碼貼在下面
buf: bufferpool.Get(),
spaced: spaced,
}
}
type Buffer struct {
bs []byte
pool Pool
}
type Pool struct {
p *sync.Pool
}
func NewPool() Pool {
return Pool{p: &sync.Pool{
New: func() interface{} {
return &Buffer{bs: make([]byte, 0, _size)}
},
}}
}
// 從Pool里拿一個(gè)Buffer，初始化里面的[]byte
func (p Pool) Get() *Buffer {
buf := p.p.Get().(*Buffer)
buf.Reset()
// 這里賦值pool為當(dāng)前Pool，用于使用完Buffer后把Buffer后放回pool里，也就是下面的put函數(shù)
buf.pool = p
return buf
}
func (p Pool) put(buf *Buffer) {
p.p.Put(buf)
}
// 核心函數(shù)openSinks
func (cfg Config) openSinks() (zapcore.WriteSyncer, zapcore.WriteSyncer, error) {
sink, closeOut, err := Open(cfg.OutputPaths...)
if err != nil {
return nil, nil, err
}
errSink, _, err := Open(cfg.ErrorOutputPaths...)
if err != nil {
closeOut()
return nil, nil, err
}
return sink, errSink, nil
}
func Open(paths ...string) (zapcore.WriteSyncer, func(), error) {
writers, close, err := open(paths)
if err != nil {
return nil, nil, err
}
writer := CombineWriteSyncers(writers...)
return writer, close, nil
}
func open(paths []string) ([]zapcore.WriteSyncer, func(), error) {
writers := make([]zapcore.WriteSyncer, 0, len(paths))
closers := make([]io.Closer, 0, len(paths))
close := func() {
for _, c := range closers {
c.Close()
}
}
var openErr error
for _, path := range paths {
// 核心函數(shù)newSink
sink, err := newSink(path)
if err != nil {
openErr = multierr.Append(openErr, fmt.Errorf("couldn't open sink %q: %v", path, err))
continue
}
writers = append(writers, sink)
closers = append(closers, sink)
}
if openErr != nil {
close()
return writers, nil, openErr
}
return writers, close, nil
}
// 這里也是plugin式寫法，可以通過(guò)RegisterSink來(lái)自定義sink，比如自定義一個(gè)支持http協(xié)議的sink，在文章的尾部會(huì)實(shí)現(xiàn)一個(gè)自定義的sink
_sinkFactories = map[string]func(*url.URL) (Sink, error){
schemeFile: newFileSink,
}
func newSink(rawURL string) (Sink, error) {
// 通過(guò)rawURL判斷初始化哪種sink，實(shí)際上zap只支持file，看上面的_sinkFactories
u, err := url.Parse(rawURL)
if err != nil {
return nil, fmt.Errorf("can't parse %q as a URL: %v", rawURL, err)
}
// 如果url是類似于/var/abc.log這種的字符串，那么經(jīng)過(guò)Parse后的u.Scheme就是""，然后會(huì)被賦值schemeFile
// 如果url是類似于http://127.0.0.1:1234這種的字符串，那么經(jīng)過(guò)Parse后的u.Scheme就是"http"，不過(guò)zap本身不支持http，可以自定義一個(gè)支持http的sink
if u.Scheme == "" {
u.Scheme = schemeFile
}
_sinkMutex.RLock()
factory, ok := _sinkFactories[u.Scheme]
_sinkMutex.RUnlock()
if !ok {
return nil, &errSinkNotFound{u.Scheme}
}
return factory(u)
}
// 這里的sink實(shí)際上就是一個(gè)*File
func newFileSink(u *url.URL) (Sink, error) {
// ...
switch u.Path {
case "stdout":
return nopCloserSink{os.Stdout}, nil
case "stderr":
return nopCloserSink{os.Stderr}, nil
}
return os.OpenFile(u.Path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
}
// 核心函數(shù)NewCore
func NewCore(enc Encoder, ws WriteSyncer, enab LevelEnabler) Core {
return &ioCore{
LevelEnabler: enab,
enc: enc,
out: ws,
}
}
// 核心函數(shù)New
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,
clock: zapcore.DefaultClock,
}
return log.WithOptions(options...)
}
到New這里，就完成了一個(gè)logger的初始化，核心的結(jié)構(gòu)體就是Encoder、Sink和ioCore，邏輯還是比較簡(jiǎn)單易懂的
打一條Log
下面寫一段簡(jiǎn)單的demo
l, _ := zap.NewProduction()
l.Error("Message Content", zap.String("tagA", "tagAValue"))
func (log *Logger) Error(msg string, fields ...Field) {
// 核心函數(shù) check
if ce := log.check(ErrorLevel, msg); ce != nil {
// 核心函數(shù) Write
ce.Write(fields...)
}
}
// 核心函數(shù)check，實(shí)際邏輯就是檢查了下Level要不要打log，順便添加了調(diào)用棧和caller
func (log *Logger) check(lvl zapcore.Level, msg string) *zapcore.CheckedEntry {
// 跳過(guò)當(dāng)前這個(gè)check函數(shù)以及調(diào)用check的Error/Info/Fatal等函數(shù)
const callerSkipOffset = 2
// 檢查level
if lvl < zapcore.DPanicLevel && !log.core.Enabled(lvl) {
return nil
}
ent := zapcore.Entry{
LoggerName: log.name,
Time: log.clock.Now(),
Level: lvl,
Message: msg,
}
// 核心函數(shù) ioCore.Check
ce := log.core.Check(ent, nil)
willWrite := ce != nil
// ...
if !willWrite {
return ce
}
// 添加stacktrace和caller相關(guān)
// ...
return ce
}
// 實(shí)際就是把core添加到了CheckedEntry里，在后續(xù)的CheckedEntry.Write里會(huì)被調(diào)用
func (c *ioCore) Check(ent Entry, ce *CheckedEntry) *CheckedEntry {
if c.Enabled(ent.Level) {
return ce.AddCore(ent, c)
}
return ce
}
func (ce *CheckedEntry) AddCore(ent Entry, core Core) *CheckedEntry {
if ce == nil {
// getCheckedEntry使用了sync.Pool
ce = getCheckedEntry()
ce.Entry = ent
}
ce.cores = append(ce.cores, core)
return ce
}
// 核心函數(shù) Write
func (ce *CheckedEntry) Write(fields ...Field) {
// ...
var err error
// 實(shí)際就是調(diào)用了Core.Write
for i := range ce.cores {
err = multierr.Append(err, ce.cores[i].Write(ce.Entry, fields))
}
if err != nil && ce.ErrorOutput != nil {
fmt.Fprintf(ce.ErrorOutput, "%v write error: %v\n", ce.Time, err)
ce.ErrorOutput.Sync()
}
should, msg := ce.should, ce.Message
// 把CheckedEntry放回到pool里
putCheckedEntry(ce)
// ...
}
func (c *ioCore) Write(ent Entry, fields []Field) error {
// 首先Encode，高性能的核心就在EncodeEntry里
buf, err := c.enc.EncodeEntry(ent, fields)
if err != nil {
return err
}
// 然后Write，out就是sink
_, err = c.out.Write(buf.Bytes())
// 然后把buf放回到pool里
buf.Free()
if err != nil {
return err
}
if ent.Level > ErrorLevel {
// Since we may be crashing the program, sync the output. Ignore Sync
// errors, pending a clean solution to issue #370.
c.Sync()
}
return nil
}
// zap并沒(méi)有使用類似marshalJson的方法來(lái)encode，而是使用了拼接字符串的方式手動(dòng)拼出了一個(gè)json字符串，這種方式的性能比marshalJson的性能要好很多
// 里面的具體邏輯很簡(jiǎn)單，就是append一個(gè)key，append一個(gè)value
func (enc *jsonEncoder) EncodeEntry(ent Entry, fields []Field) (*buffer.Buffer, error) {
final := enc.clone()
final.buf.AppendByte('{')
if final.LevelKey != "" && final.EncodeLevel != nil {
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 {
if 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.FunctionKey != "" {
final.addKey(final.FunctionKey)
final.AppendString(ent.Caller.Function)
}
}
if final.MessageKey != "" {
final.addKey(enc.MessageKey)
final.AppendString(ent.Message)
}
if enc.buf.Len() > 0 {
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('}')
final.buf.AppendString(final.LineEnding)
ret := final.buf
putJSONEncoder(final)
return ret, nil
}
encode完之后就是Write了，實(shí)際調(diào)用的就是Sink.Write，如果log是寫到文件里的，那么調(diào)用的就是File.Write，至此一條日志記錄完成
小結(jié)
zap記錄一條日志的流程可以概括為3步
- check
- encode
- write
zap在性能優(yōu)化方面有一些值得借鑒的地方
- 多處使用sync.Pool和bytes.Buffer優(yōu)化GC
- 使用了自實(shí)現(xiàn)的jsonEncoder，簡(jiǎn)化了encode邏輯
不過(guò)zap的log抑制，也就是sampler實(shí)現(xiàn)有些過(guò)于簡(jiǎn)單，可能會(huì)出現(xiàn)log丟失的問(wèn)題，下面的代碼可以完美復(fù)現(xiàn)這個(gè)問(wèn)題
lc := zap.NewProductionConfig()
lc.Encoding = "console"
lc.Sampling.Initial = 1 // 當(dāng)Initial為1時(shí)，第二條日志不會(huì)打印出來(lái)，改為大于1時(shí)第二條日志才會(huì)打印出來(lái)
lc.Sampling.Thereafter = 10
l, _ := lc.Build()
l.Info("abc")
l.Info("yTI")
l.Info("def")
增強(qiáng)zap
自定義sink
在閱讀源碼部分已經(jīng)提到了zap只支持log寫到文件里，一般業(yè)務(wù)日志都會(huì)統(tǒng)一收集到日志中心，那么就需要自定義一個(gè)sink，通過(guò)網(wǎng)絡(luò)發(fā)送到某個(gè)地方統(tǒng)一收集起來(lái)，下面寫一個(gè)簡(jiǎn)單的http協(xié)議的sink。
func init() {
// 這里注冊(cè)http sink
err := zap.RegisterSink("http", httpSink)
if err != nil {
fmt.Println("Register http sink fail", err)
}
}
func httpSink(url *url.URL) (zap.Sink, error) {
return &Http{
// httpc是我封裝的httpClient，沒(méi)什么別的邏輯，直接當(dāng)成http.Client就好
httpc: httpc.New(httpc.NewConfig(), context.Background()),
url: url,
}, nil
}
type Http struct {
httpc *httpc.HttpC
url *url.URL
}
// 主要邏輯就是Write
func (h *Http) Write(p []byte) (n int, err error) {
// 初始化request
req, err := http.NewRequest("POST", h.url.String(), bytes.NewReader(p))
if err != nil {
return 0, err
}
// 執(zhí)行http請(qǐng)求
resp, err := h.httpc.Do(req)
if err != nil {
return 0, err
}
defer resp.Body.Close()
// 獲取response
respBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
return 0, err
}
if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK {
return 0, errors.New(util.Bytes2String(respBody))
}
return len(p), nil
}
// 可以搞個(gè)內(nèi)置的queue或者[]log，在Sync函數(shù)里用來(lái)做批量發(fā)送提升性能，這里只是簡(jiǎn)單的實(shí)現(xiàn)，所以Sync沒(méi)什么邏輯
func (h *Http) Sync() error {
return nil
}
func (h *Http) Close() error {
return h.httpc.Close()
}
寫完sink后，只需要在Config里的outputPaths里添加一條"http://xxx:xxx" ，所有的log就會(huì)走到自定義的sink邏輯，通過(guò)http發(fā)送出去。
來(lái)點(diǎn)騷操作，在源碼閱讀部分，可以看到zap是把url.Parse后的scheme當(dāng)作sink名稱的，例如在Config里的outputPaths里添加一條"wtf://xxx:xxx"，zap就會(huì)去尋找名稱為wtf的sink，我們把上面的http sink的zap.RegisterSink("http", httpSink)改為zap.RegisterSink("wtf", httpSink)，然后在Write函數(shù)的邏輯里把"wtf://"后面的內(nèi)容拼成一個(gè)完整的http url，同樣可以運(yùn)行，操作是不是很騷。
error調(diào)用棧
當(dāng)使用zap打Error日志時(shí)，如果配置了addStack，那么zap會(huì)自動(dòng)把調(diào)用棧寫到log里，下面是一個(gè)例子
package main
import (
"go.uber.org/zap"
)
var l *zap.Logger
func test_a() {
test_b()
}
func test_b() {
test_c()
}
func test_c() {
l.Error("err content")
}
func main() {
l, _ = zap.NewDevelopment()
test_a()
}
這是log內(nèi)容，當(dāng)使用jsonEncoder時(shí)，調(diào)用棧會(huì)在stacktrace字段里，下面是console格式的
2022-05-23T23:16:36.598+0800 ERROR gtil/main.go:20 err content
main.test_c
D:/workspace/code/go/gtil/main.go:20
main.test_b
D:/workspace/code/go/gtil/main.go:16
main.test_a
D:/workspace/code/go/gtil/main.go:12
main.main
D:/workspace/code/go/gtil/main.go:25
runtime.main
D:/workspace/env/scoop/apps/go/current/src/runtime/proc.go:250
這么一看好像很完美，有error日志了還可以看到調(diào)用棧，但是我們一般打log時(shí)，總是會(huì)在最上層打log，而不是每一層都打log，拿上面的代碼舉例子
func test_a() error {
return test_b()
}
func test_b() error {
return test_c()
}
func test_c() error {
// 底層的函數(shù)出現(xiàn)error應(yīng)該return，而不是打log
return errors.new("do test_c fail")
}
func main() {
l, _ = zap.NewProduction()
err := test_a()
if err != nil {
l.Error("main error", zap.Error(err))
}
}
下面是log內(nèi)容
2022-05-23T23:16:54.955+0800 ERROR gtil/main.go:27 main error {"error": "do test_c fail"}
main.main
D:/workspace/code/go/gtil/main.go:27
runtime.main
D:/workspace/env/scoop/apps/go/current/src/runtime/proc.go:250
這就出現(xiàn)了幾個(gè)問(wèn)題，1. 調(diào)用棧只到了main，沒(méi)有更底層的， 2. 如果test_b接受到test_c的error時(shí)，想加上一些自己的error content返回出去，這兩個(gè)問(wèn)題就體現(xiàn)出了golang在錯(cuò)誤處理方面的不足，不過(guò)有一個(gè)庫(kù)可以解決這兩個(gè)問(wèn)題，github.com/pkg/errors ，這個(gè)庫(kù)自定義了error，可以在error里添加調(diào)用棧或額外的信息，下面寫個(gè)demo
func test_a() error {
err := test_b()
if err != nil {
return errors.Wrap(err, "do test_a fail")
}
return nil
}
func test_b() error {
err := test_c()
if err != nil {
return errors.Wrap(err, "do test_b fail")
}
return nil
}
func test_c() error {
return errors.New("do test_c fail")
}
func main() {
l, _ = zap.NewDevelopment()
err := test_a()
if err != nil {
l.Error("main error", zap.Error(err))
}
}
下面是輸出內(nèi)容，可以看到在errorVerbose字段里每一個(gè)函數(shù)的error都返回了出來(lái)，并帶上了調(diào)用棧，不過(guò)error字段有點(diǎn)亂七八糟，并且還顯示了zap自帶的調(diào)用棧
2022-05-23T23:34:13.339+0800 ERROR gtil/main.go:34 main error {"error": "do test_a fail: do test_b fail: do test_c fail", "errorVerbose": "do test_c fail\nmain.test_c\n\tD:/workspace/code/go/gtil/main.go:27\nmain.test_b\n\tD:/workspace/code/go/gtil/main.go:19\nmain.test_a\n\tD:/workspace/code/go/gtil/main.go:11\nmain.main\n\tD:/workspace/code/go/gtil/main.go:32\nruntime.main\n\tD:/workspace/env/scoop/apps/go/current/src/runtime/proc.go:250\nruntime.goexit\n\tD:/workspace/env/scoop/apps/go/current/src/runtime/asm_amd64.s:1571\ndo test_b fail\nmain.test_b\n\tD:/workspace/code/go/gtil/main.go:21\nmain.test_a\n\tD:/workspace/code/go/gtil/main.go:11\nmain.main\n\tD:/workspace/code/go/gtil/main.go:32\nruntime.main\n\tD:/workspace/env/scoop/apps/go/current/src/runtime/proc.go:250\nruntime.goexit\n\tD:/workspace/env/scoop/apps/go/current/src/runtime/asm_amd64.s:1571\ndo test_a fail\nmain.test_a\n\tD:/workspace/code/go/gtil/main.go:13\nmain.main\n\tD:/workspace/code/go/gtil/main.go:32\nruntime.main\n\tD:/workspace/env/scoop/apps/go/current/src/runtime/proc.go:250\nruntime.goexit\n\tD:/workspace/env/scoop/apps/go/current/src/runtime/asm_amd64.s:1571"}
main.main
D:/workspace/code/go/gtil/main.go:34
runtime.main
D:/workspace/env/scoop/apps/go/current/src/runtime/proc.go:250
要做的就是去掉自帶的調(diào)用棧，把error字段搞地好看點(diǎn)，只需要自定義一個(gè)Core就可以，下面貼出代碼
func NewErrStackCore(c zapcore.Core) zapcore.Core {
return &errStackCore{c}
}
type errStackCore struct {
zapcore.Core
}
func (c *errStackCore) With(fields []zapcore.Field) zapcore.Core {
return &errStackCore{
c.Core.With(fields),
}
}
func (c *errStackCore) Write(ent zapcore.Entry, fields []zapcore.Field) error {
// 判斷fields里有沒(méi)有error字段
if !hasStackedErr(fields) {
return c.Core.Write(ent, fields)
}
// 這里是重點(diǎn)，從fields里取出error字段，把內(nèi)容放到ent.Stack里，邏輯就是這樣，具體代碼就不給出了
ent.Stack, fields = getStacks(fields)
return c.Core.Write(ent, fields)
}
func (c *errStackCore) Check(ent zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry {
return c.Core.Check(ent, ce)
}以上就是Go日志框架zap增強(qiáng)及源碼解讀的詳細(xì)內(nèi)容，更多關(guān)于Go日志框架zap增強(qiáng)的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！
您可能感興趣的文章:
- Go每日一庫(kù)之zap日志庫(kù)的安裝使用指南
- Golang定制化zap日志庫(kù)使用過(guò)程分析
- Go語(yǔ)言Zap日志庫(kù)使用教程
- golang?xorm?自定義日志記錄器之使用zap實(shí)現(xiàn)日志輸出、切割日志(最新)
- Go學(xué)習(xí)筆記之Zap日志的使用
- Go語(yǔ)言Zap庫(kù)Logger的定制化和封裝使用詳解
- golang默認(rèn)Logger日志庫(kù)在項(xiàng)目中使用Zap日志庫(kù)
- golang有用的庫(kù)及工具 之 zap.Logger包的使用指南
- GoLang基于zap日志庫(kù)的封裝過(guò)程詳解
相關(guān)文章
go語(yǔ)言定時(shí)器Timer及Ticker的功能使用示例詳解
這篇文章主要為大家介紹了go語(yǔ)言定時(shí)器的功能使用示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步早日升職加薪2022-04-04
go語(yǔ)言中基本數(shù)據(jù)類型及應(yīng)用快速了解
這篇文章主要為大家介紹了go語(yǔ)言中基本數(shù)據(jù)類型應(yīng)用詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2022-07-07
golang?chan傳遞數(shù)據(jù)的性能開(kāi)銷詳解
這篇文章主要為大家詳細(xì)介紹了Golang中chan在接收和發(fā)送數(shù)據(jù)時(shí)因?yàn)椤皬?fù)制”而產(chǎn)生的開(kāi)銷,文中的示例代碼講解詳細(xì),感興趣的小伙伴可以了解下2024-01-01
自Go1.6起,Go語(yǔ)言正式啟用vendor機(jī)制,允許將項(xiàng)目依賴放入項(xiàng)目?jī)?nèi)的vendor目錄,類似私有GOPATH,本文就來(lái)介紹一下Vendo機(jī)制的使用,感興趣的可以了解一下2024-10-10
這篇文章主要為大家詳細(xì)介紹了Go實(shí)現(xiàn)文件上傳和下載，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2022-07-07
Golang中漏洞數(shù)據(jù)庫(kù)的使用詳解
govulncheck是Golang中的漏洞掃描工具,它強(qiáng)大功能的背后,離不開(kāi)?Go?漏洞數(shù)據(jù)庫(kù)（Go?vulnerability?database）的支持,所以本文就來(lái)為大家詳細(xì)講解下?Go?漏洞數(shù)據(jù)庫(kù)相關(guān)的知識(shí)2023-09-09
一文帶你了解Go語(yǔ)言中的指針和結(jié)構(gòu)體
前面的兩篇文章對(duì)?Go?語(yǔ)言的基礎(chǔ)語(yǔ)法和基本數(shù)據(jù)類型以及幾個(gè)復(fù)合數(shù)據(jù)類型進(jìn)行介紹，本文將對(duì)?Go?里面的指針和結(jié)構(gòu)體進(jìn)行介紹，也為后續(xù)文章做鋪墊，感興趣的可以了解一下2022-11-11
這篇文章主要為大家介紹了go操作Kafka使用示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2022-12-12
這篇文章主要介紹了golang端口占用檢測(cè)的使用，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2021-03-03
在項(xiàng)目開(kāi)發(fā)中,經(jīng)常需要把一些配置文件常量提取到統(tǒng)一配置文件進(jìn)行維護(hù),go項(xiàng)目在開(kāi)發(fā)中常常把需要維護(hù)的常量或者配置提取到y(tǒng)aml文件,所以本文主要來(lái)為大家介紹一下golang如何讀取yaml配置文件吧2023-11-11