一文带你由浅入深地解读 Go Zap 的高性能

最新推荐文章于 2024-05-26 17:23:18 发布
最新推荐文章于 2024-05-26 17:23:18 发布
阅读量3.2k 收藏 7
点赞数 5
文章标签： java go slf4j log4net log4j
原文链接：https://github.com/studygolang/go-collection/blob/main/go-lib/zap.md
版权

我是一只可爱的土拨鼠，专注于分享 Go 职场、招聘和求职，解 Gopher 之忧！欢迎关注我。

欢迎大家加入Go招聘交流群，来这里找志同道合的小伙伴！跟土拨鼠们一起交流学习。

简介

zap 是什么?

⚡ZAP[1] 是uber 开源的提供快速，结构化，高性能的日志记录包。

zap 高性能体现在哪里?

在介绍zap包的优化部分之前，让我们看下zap日志库的工作流程图

大多数日志库提供的方式是基于反射的序列化和字符串格式化，这种方式代价高昂，而 Zap 采取不同的方法。

  • 避免 interface{} 使用强类型设计

  • 封装强类型，无反射

  • 使用零分配内存的 JSON 编码器，尽可能避免序列化开销，它比其他结构化日志包快 4 - 10 倍。

logger.Info("failed to fetch URL",
  zap.String("url", "https://baidu.com"),
  zap.Int("attempt", 3),
  zap.Duration("backoff", time.Second),
)

  • 使用 sync.Pool 以避免记录消息时的内存分配

详情在下文 zapcore 模块介绍。

Example

安装

go get -u go.uber.org/zap

Zap 提供了两种类型的 logger

  • SugaredLogger

  • Logger

在性能良好但不是关键的情况下，使用 SugaredLogger，它比其他结构化的日志包快 4-10 倍，并且支持结构化和 printf 风格的APIs。

例一 调用 NewProduction 创建logger对象

func TestSugar(t *testing.T) {
 logger, _ := zap.NewProduction()
 // 默认 logger 不缓冲。
 // 但由于底层 api 允许缓冲，所以在进程退出之前调用 Sync 是一个好习惯。
 defer logger.Sync()
 sugar := logger.Sugar()
 sugar.Infof("Failed to fetch URL: %s", "https://baidu.com")
}

对性能和类型安全要求严格的情况下，可以使用 Logger ，它甚至比前者SugaredLogger更快，内存分配次数也更少，但它仅支持强类型的结构化日志记录。

例二 调用 NewDevelopment 创建logger对象

func TestLogger(t *testing.T) {
 logger, _ := zap.NewDevelopment()
 defer logger.Sync()
 logger.Info("failed to fetch URL",
  // 强类型字段
  zap.String("url", "https://baidu.com"),
  zap.Int("attempt", 3),
  zap.Duration("backoff", time.Second),
 )
}

不需要为整个应用程序决定选择使用 Logger 还是 SugaredLogger ，两者之间都可以轻松转换。

例三 Logger 与 SugaredLogger 相互转换

// 创建 logger
logger := zap.NewExample()
defer logger.Sync()

// 转换 SugaredLogger
sugar := logger.Sugar()
// 转换 logger
plain := sugar.Desugar()

例四 自定义格式

自定义一个日志消息格式，带着问题看下列代码。

  1. debug 级别的日志打印到控制台了吗?

  2. 最后的 error 会打印到控制台吗 ?

package main

import (
 "os"

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

func NewCustomEncoderConfig() zapcore.EncoderConfig {
 return zapcore.EncoderConfig{
  TimeKey:        "ts",
  LevelKey:       "level",
  NameKey:        "logger",
  CallerKey:      "caller",
  FunctionKey:    zapcore.OmitKey,
  MessageKey:     "msg",
  StacktraceKey:  "stacktrace",
  LineEnding:     zapcore.DefaultLineEnding,
  EncodeLevel:    zapcore.CapitalColorLevelEncoder,
  EncodeTime:     zapcore.TimeEncoderOfLayout("2006-01-02 15:04:05"),
  EncodeDuration: zapcore.SecondsDurationEncoder,
  EncodeCaller:   zapcore.ShortCallerEncoder,
 }
}

func main() {
 atom := zap.NewAtomicLevelAt(zap.DebugLevel)
 core := zapcore.NewCore(
  zapcore.NewConsoleEncoder(NewCustomEncoderConfig()),
  zapcore.NewMultiWriteSyncer(zapcore.AddSync(os.Stdout)),
  atom,
 )
 logger := zap.New(core, zap.AddCaller(), zap.Development())
 defer logger.Sync()

 // 配置 zap 包的全局变量
 zap.ReplaceGlobals(logger)

 // 运行时安全地更改 logger 日记级别
 atom.SetLevel(zap.InfoLevel)
 sugar := logger.Sugar()
 // 问题 1: debug 级别的日志打印到控制台了吗?
 sugar.Debug("debug")
 sugar.Info("info")
 sugar.Warn("warn")
 sugar.DPanic("dPanic")
 // 问题 2: 最后的 error 会打印到控制台吗?
 sugar.Error("error")
}

结果见下图

image-20210525201656456

问题 1:

没有打印。AtomicLevel 是原子性可更改的动态日志级别，通过调用 atom.SetLevel 更改日志级别为 infoLevel 。

问题 2:

没有打印。zap.Development() 启用了开发模式，在开发模式下 DPanic 函数会引发 panic，所以最后的 error 不会打印到控制台。

源码分析

此次源码分析基于 Zap 1.16

zap概览

上图仅表示 zap 可调用两种 logger，没有表达 Logger 与 SugaredLogger 的关系，继续往下看，你会更理解。

Logger

logger 提供快速，分级，结构化的日志记录。所有的方法都是安全的，内存分配很重要，因此它的 API 有意偏向于性能和类型安全。

zap@v1.16.0 - logger.go

type Logger struct {
  // 实现编码和输出的接口
 core zapcore.Core  
  // 记录器开发模式，DPanic 等级将记录 panic
 development bool
  // 开启记录调用者的行号和函数名
 addCaller   bool  
  // 致命日志采取的操作，默认写入日志后 os.Exit()
  onFatal     zapcore.CheckWriteAction 
 name        string 
  // 设置记录器生成的错误目的地
 errorOutput zapcore.WriteSyncer  
  // 记录 >= 该日志等级的堆栈追踪
 addStack zapcore.LevelEnabler 
  // 避免记录器认为封装函数为调用方
 callerSkip int 
  // 默认为系统时间 
 clock Clock  
}

在 Example 中分别使用了 NewProduction 和 NewDevelopment ，接下来以这两个函数开始分析。下图表示 A 函数调用了 B 函数，其中箭头表示函数调用关系。图中函数都会分析到。

NewProduction

从下面代码中可以看出，此函数是对 NewProductionConfig().Build(...) 封装的快捷方式。

zap@v1.16.0 - logger.go

func NewProduction(options ...Option) (*Logger, error) {
 return NewProductionConfig().Build(options...)
}

NewProductionConfig

在 InfoLevel 及更高级别上启用了日志记录。它使用 JSON 编码器，写入 stderr，启用采样。

zap@v1.16.0 - config.go

func NewProductionConfig() Config {
 return Config{
    // info 日志级别
  Level:       NewAtomicLevelAt(InfoLevel),
    // 非开发模式
  Development: false,
    // 采样设置
  Sampling: &SamplingConfig{
   Initial:    100, // 相同日志级别下相同内容每秒日志输出数量
   Thereafter: 100, // 超过该数量，才会再次输出
  },
    // JSON 编码器
  Encoding:         "json",
    // 后面介绍
  EncoderConfig:    NewProductionEncoderConfig(),
    // 输出到 stderr
  OutputPaths:      []string{"stderr"},
  ErrorOutputPaths: []string{"stderr"},
 }
}

Config 结构体

通过 Config 可以设置通用的配置项。

zap@v1.16.0 - config.go

type Config struct {
 // 日志级别
 Level AtomicLevel `json:"level" yaml:"level"`
 // 开发模式
 Development bool `json:"development" yaml:"development"`
 // 停止使用调用方的函数和行号
 DisableCaller bool `json:"disableCaller" yaml:"disableCaller"`
 // 完全停止使用堆栈跟踪，默认为  `>=WarnLevel` 使用堆栈跟踪
 DisableStacktrace bool `json:"disableStacktrace" yaml:"disableStacktrace"`
 // 采样设置策略
 Sampling *SamplingConfig `json:"sampling" yaml:"sampling"`
 // 记录器的编码，有效值为 'json' 和 'console' 以及通过 `RegisterEncoder` 注册的有效编码
 Encoding string `json:"encoding" yaml:"encoding"`
 // 编码器选项
 EncoderConfig zapcore.EncoderConfig `json:"encoderConfig" yaml:"encoderConfig"`
 // 日志的输出路径
 OutputPaths []string `json:"outputPaths" yaml:"outputPaths"`
 // zap 内部错误的输出路径
 ErrorOutputPaths []string `json:"errorOutputPaths" yaml:"errorOutputPaths"`
 // 添加到根记录器的字段的集合
 InitialFields map[string]interface{} `json:"initialFields" yaml:"initialFields"`
}

NewDevelopment

从下面代码中可以看出，此函数是对 NewDevelopmentConfig().Build(...) 封装的快捷方式

zap@v1.16.0 - logger.go

func NewDevelopment(options ...Option) (*Logger, error) {
 return NewDevelopmentConfig().Build(options...)
}

NewDevelopmentConfig

此函数在 DebugLevel 及更高版本上启用日志记录，它使用 console 编码器，写入 stderr，禁用采样。

zap@v1.16.0 - config.go

func NewDevelopmentConfig() Config {
 return Config{
    // debug 等级
  Level:            NewAtomicLevelAt(DebugLevel),
    // 开发模式
  Development:      true,
    // console 编码器
  Encoding:         "console",
  EncoderConfig:    NewDevelopmentEncoderConfig(),
    // 输出到 stderr
  OutputPaths:      []string{"stderr"},
  ErrorOutputPaths: []string{"stderr"},
 }
}

NewProductionEncoderConfig 和 NewDevelopmentEncoderConfig 都是返回编码器配置。

zap@v1.16.0 - config.go

type EncoderConfig struct {
 // 设置 编码为 JSON 时的 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"`
  // 配置行分隔符
 LineEnding    string `json:"lineEnding" yaml:"lineEnding"`
 // 配置常见复杂类型的基本表示形式。
 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"`
 // 配置 console 编码器使用的字段分隔符，默认 tab
 ConsoleSeparator string `json:"consoleSeparator" yaml:"consoleSeparator"`
}

NewProductionEncoderConfig

zap@v1.16.0 - config.go

func NewProductionEncoderConfig() zapcore.EncoderConfig {
 return zapcore.EncoderConfig{
  TimeKey:        "ts",
  LevelKey:       "level",
  NameKey:        "logger",
  CallerKey:      "caller",
  FunctionKey:    zapcore.OmitKey,
  MessageKey:     "msg",
  StacktraceKey:  "stacktrace",
    // 默认换行符 \n
  LineEnding:     zapcore.DefaultLineEnding,
    // 日志等级序列为小写字符串，如:InfoLevel被序列化为 "info"
  EncodeLevel:    zapcore.LowercaseLevelEncoder,
    // 时间序列化成浮点秒数
  EncodeTime:     zapcore.EpochTimeEncoder,
    // 时间序列化，Duration为经过的浮点秒数
  EncodeDuration: zapcore.SecondsDurationEncoder,
    // 以 包名/文件名:行数 格式序列化
  EncodeCaller:   zapcore.ShortCallerEncoder,
 }
}

该配置会输出如下结果，此结果出处参见 Example 中的例一

{"level":"info","ts":1620367988.461055,"caller":"test/use_test.go:24","msg":"Failed to fetch URL: https://baidu.com"}

NewDevelopmentEncoderConfig

zap@v1.16.0 - config.go

func NewDevelopmentEncoderConfig() zapcore.EncoderConfig {
 return zapcore.EncoderConfig{
  // keys 值可以是任意非空的值
  TimeKey:        "T",
  LevelKey:       "L",
  NameKey:        "N",
  CallerKey:      "C",
  FunctionKey:    zapcore.OmitKey,
  MessageKey:     "M",
  StacktraceKey:  "S",
     // 默认换行符 \n
  LineEnding:     zapcore.DefaultLineEnding,
    // 日志等级序列为大写字符串，如:InfoLevel被序列化为 "INFO"
  EncodeLevel:    zapcore.CapitalLevelEncoder,
    // 时间格式化为  ISO8601 格式
  EncodeTime:     zapcore.ISO8601TimeEncoder,
  EncodeDuration: zapcore.StringDurationEncoder,
    // // 以 包名/文件名:行数 格式序列化
  EncodeCaller:   zapcore.ShortCallerEncoder,
 }
}

该配置会输出如下结果，此结果出处参见 Example 中的例二

2021-05-07T14:14:12.434+0800 INFO test/use_test.go:31 failed to fetch URL {"url": "https://baidu.com", "attempt": 3, "backoff": "1s"}

NewProductionConfig 和 NewDevelopmentConfig 返回 config 调用 Build 函数返回 logger，接下来我们看看这个函数。

zap@v1.16.0 - config.go

func (cfg Config) Build(opts ...Option) (*Logger, error) {
  enc, err := cfg.buildEncoder()
 if err != nil {
  return nil, err
 }

 sink, errSink, err := cfg.openSinks()
 if err != nil {
  return nil, err
 }
 
 if cfg.Level == (AtomicLevel{}) {
  return nil, fmt.Errorf("missing Level")
 }
 
 log := New(
  zapcore.NewCore(enc, sink, cfg.Level),
  cfg.buildOptions(errSink)...,
 )
 if len(opts) > 0 {
  log = log.WithOptions(opts...)
 }
 return log, nil
}

从上面的代码中，通过解析 config 的参数，调用 New 方法来创建 Logger。在 Example 中例四，就是调用 New 方法来自定义 Logger。

SugaredLogger

Logger 作为 SugaredLogger 的属性，这个封装优点在于不是很在乎性能的情况下，可以快速调用Logger。所以名字为加了糖的 Logger。

zap@v1.16.0 - logger.go

type SugaredLogger struct {
 base *Logger
}

zap.ReplaceGlobals(logger)   // 重新配置全局变量
zap.S().Info("SugaredLogger")   // S 返回全局 SugaredLogger
zap.L().Info("logger")      // L 返回全局 logger

与Logger不同，SugaredLogger不强制日志结构化。所以对于每个日志级别，都提供了三种方法。

level

zap@v1.16.0 - sugar.go

以 info 级别为例，相关的三种方法。

// Info 使用 fmt.Sprint 构造和记录消息。
func (s *SugaredLogger) Info(args ...interface{}) {
 s.log(InfoLevel, "", args, nil)
}

// Infof 使用 fmt.Sprintf 记录模板消息。
func (s *SugaredLogger) Infof(template string, args ...interface{}) {
 s.log(InfoLevel, template, args, nil)
}

// Infow 记录带有其他上下文的消息
func (s *SugaredLogger) Infow(msg string, keysAndValues ...interface{}) {
 s.log(InfoLevel, msg, nil, keysAndValues)
}

在 sugar.Infof("...") 打上断点，从这开始追踪源码。

image-20210519111252185

在调试代码之前，先给大家看一下SugaredLogger 的  Infof 函数的调用的大致工作流，其中不涉及采样等。

infof工作流程

Info , Infof, Infow 三个函数都调用了 log 函数，log 函数代码如下

zap@v1.16.0 - sugar.go

func (s *SugaredLogger) log(lvl zapcore.Level, template string, fmtArgs []interface{}, context []interface{}) {
 // 判断是否启用的日志级别
 if lvl < DPanicLevel && !s.base.Core().Enabled(lvl) {
  return
 }
 // 将参数合并到语句中
 msg := getMessage(template, fmtArgs)
  // Check 可以帮助避免分配一个分片来保存字段。
 if ce := s.base.Check(lvl, msg); ce != nil {
  ce.Write(s.sweetenFields(context)...)
 }
}

函数的第一个参数 InfoLevel 是日志级别，其源码如下

zap@v1.16.0 - zapcore/level.go

const (
 // Debug 应是大量的，且通常在生产状态禁用.
 DebugLevel = zapcore.DebugLevel
 // Info 是默认的记录优先级.
 InfoLevel = zapcore.InfoLevel
 // Warn 比 info 更重要.
 WarnLevel = zapcore.WarnLevel
 // Error 是高优先级的,如果程序顺利不应该产生任何 err 级别日志.
 ErrorLevel = zapcore.ErrorLevel
 // DPanic 特别重大的错误，在开发模式下引起 panic. 
 DPanicLevel = zapcore.DPanicLevel
 // Panic 记录消息后调用 panic.
 PanicLevel = zapcore.PanicLevel
 // Fatal 记录消息后调用 os.Exit(1).
 FatalLevel = zapcore.FatalLevel
)

getMessage 函数处理 template 和 fmtArgs 参数，主要为不同的参数选择最合适的方式拼接消息

zap@v1.16.0 - sugar.go

func getMessage(template string, fmtArgs []interface{}) string {
  // 没有参数直接返回 template
 if len(fmtArgs) == 0 {
  return template
 }
 
  // 此处调用 Sprintf 会使用反射
 if template != "" {
  return fmt.Sprintf(template, fmtArgs...)
 }
 
  // 消息为空并且有一个参数，返回该参数
 if len(fmtArgs) == 1 {
  if str, ok := fmtArgs[0].(string); ok {
   return str
  }
 }
  // 返回所有 fmtArgs
 return fmt.Sprint(fmtArgs...)
}

关于 s.base.Check ，这就需要介绍zapcore ，下面分析相关模块。

zapcore

zapcore包 定义并实现了构建 zap 的低级接口。通过提供这些接口的替代实现，外部包可以扩展 zap 的功能。

zap@v1.16.0 - zapcore/core.go

// Core 是一个最小的、快速的记录器接口。
type Core interface {
  // 接口，决定一个日志等级是否启用
 LevelEnabler
 // 向 core 添加核心上下文
 With([]Field) Core
 // 检查是否应记录提供的条目
  // 在调用 write 之前必须先调用 Check
 Check(Entry, *CheckedEntry) *CheckedEntry
 // 写入日志
 Write(Entry, []Field) error
  // 同步刷新缓存日志(如果有)
 Sync() error
}

Check 函数有两个入参。第一个参数表示一条完整的日志消息，第二个参数为 nil 时会从 sync.Pool 创建的池中取出*CheckedEntry对象复用，避免重新分配内存。该函数内部调用 AddCore 实现获取 *CheckedEntry对象，最后调用 Write 写入日志消息。

相关代码全部贴在下面，更多介绍请看代码中的注释。

zap@v1.16.0 - zapcore/entry.go

// 一个 entry 表示一个完整的日志消息
type Entry struct {
 Level      Level
 Time       time.Time
 LoggerName string
 Message    string
 Caller     EntryCaller
 Stack      string
}

// 使用 sync.Pool 复用临时对象
var (
 _cePool = sync.Pool{New: func() interface{} {
  return &CheckedEntry{
   cores: make([]Core, 4),
  }
 }}
)

// 从池中取出 CheckedEntry 并初始化值
func getCheckedEntry() *CheckedEntry {
 ce := _cePool.Get().(*CheckedEntry)
 ce.reset()
 return ce
}


// CheckedEntry 是 enter 和 cores 集合。
type CheckedEntry struct {
 Entry
 ErrorOutput WriteSyncer
 dirty       bool  // 用于检测是否重复使用对象
 should      CheckWriteAction // 结束程序的动作
 cores       []Core
}

// 重置对象
func (ce *CheckedEntry) reset() {
 ce.Entry = Entry{}
 ce.ErrorOutput = nil
 ce.dirty = false
 ce.should = WriteThenNoop
 for i := range ce.cores {
  // 不要保留对 core 的引用!!
  ce.cores[i] = nil
 }
 ce.cores = ce.cores[:0]
}

// 将 entry 写入存储的 cores
// 最后将 CheckedEntry 添加到池中
func (ce *CheckedEntry) Write(fields ...Field) {
 if ce == nil {
  return
 }

 if ce.dirty {
  if ce.ErrorOutput != nil {
      // 检查 CheckedEntry 的不安全重复使用
   fmt.Fprintf(ce.ErrorOutput, "%v Unsafe CheckedEntry re-use near Entry %+v.\n", ce.Time, ce.Entry)
   ce.ErrorOutput.Sync()
  }
  return
 }
 ce.dirty = true

 var err error
  // 写入日志消息
 for i := range ce.cores {
  err = multierr.Append(err, ce.cores[i].Write(ce.Entry, fields))
 }
  // 处理内部发生的错误
 if ce.ErrorOutput != nil {
  if err != nil {
   fmt.Fprintf(ce.ErrorOutput, "%v write error: %v\n", ce.Time, err)
   ce.ErrorOutput.Sync()
  }
 }

 should, msg := ce.should, ce.Message
  // 将 CheckedEntry 添加到池中，下次复用
 putCheckedEntry(ce)
 
  // 判断是否需要 panic 或其它方式终止程序..
 switch should {
 case WriteThenPanic:
  panic(msg)
 case WriteThenFatal:
  exit.Exit()
 case WriteThenGoexit:
  runtime.Goexit()
 }
}

func (ce *CheckedEntry) AddCore(ent Entry, core Core) *CheckedEntry {
 if ce == nil {
    // 从池中取 CheckedEntry，减少内存分配
  ce = getCheckedEntry()
  ce.Entry = ent
 }
 ce.cores = append(ce.cores, core)
 return ce
}

Doc

https://pkg.go.dev/go.uber.org/zap

QA

设计问题

为什么要在Logger性能上花费这么多精力呢？

当然，大多数应用程序不会注意到Logger慢的影响：因为它们每次操作会需要几十或几百毫秒，所以额外的几毫秒很无关紧要。

另一方面，为什么不使用结构化日志快速开发呢？与其他日志包相比SugaredLogger的使用并不难，Logger使结构化记录在对性能要求严格的环境中成为可能。在 Go 微服务的架构体系中，使每个应用程序甚至稍微更有效地加速执行。

为什么没有Logger和SugaredLogger接口？

不像熟悉的io.Writer和http.Handler、Logger和SugaredLogger接口将包括很多方法。正如 Rob Pike 谚语指出[2]的，"The bigger the interface, the weaker the abstraction"(接口越大，抽象越弱)。接口也是严格的，任何更改都需要发布一个新的主版本，因为它打破了所有第三方实现。

Logger和SugaredLogger成为具体类型并不会牺牲太多抽象，而且它允许我们在不引入破坏性更改的情况下添加方法。您的应用程序应该定义并依赖只包含您使用的方法的接口。

为什么我的一些日志会丢失？

在启用抽样时，通过zap有意地删除日志。生产配置(如NewProductionConfig()返回的那样)支持抽样，这将导致在一秒钟内对重复日志进行抽样。有关为什么启用抽样的更多详细信息，请参见"为什么使用示例应用日志"中启用采样.

为什么要使用示例应用程序日志？

应用程序经常会遇到错误，无论是因为错误还是因为用户使用错误。记录错误日志通常是一个好主意，但它很容易使这种糟糕的情况变得更糟：不仅您的应用程序应对大量错误，它还花费额外的CPU周期和I/O记录这些错误日志。由于写入通常是序列化的，因此在最需要时，logger会限制吞吐量。

采样通过删除重复的日志条目来解决这个问题。在正常情况下，您的应用程序会输出每个记录。但是，当类似的记录每秒输出数百或数千次时，zap 开始丢弃重复以保存吞吐量。

为什么结构化的日志 API 除了接受字段之外还可以接收消息？

主观上，我们发现在结构化上下文中附带一个简短的描述是有帮助的。这在开发过程中并不关键，但它使调试和操作不熟悉的系统更加容易。

更具体地说，zap 的采样算法使用消息来识别重复的条目。根据我们的经验，这是一个介于随机抽样（通常在调试时删除您需要的确切条目）和哈希完整条目（代价高）之间的一个中间方法。

为什么要包括全局 loggers？

由于许多其他日志包都包含全局变量logger，许多应用程序没有设计成接收logger作为显式参数。更改函数签名通常是一种破坏性的更改，因此zap包含全局logger以简化迁移。

尽可能避免使用它们。

为什么包括专用的Panic和Fatal日志级别？

一般来说，应用程序代码应优雅地处理错误，而不是使用panic或os.Exit。但是，每个规则都有例外，当错误确实无法恢复时，崩溃是很常见的。为了避免丢失任何信息（尤其是崩溃的原因），记录器必须在进程退出之前冲洗任何缓冲条目。

Zap 通过提供在退出前自动冲洗的Panic和Fatal记录方法来使这一操作变得简单。当然，这并不保证日志永远不会丢失，但它消除了常见的错误。

有关详细信息，请参阅 Uber-go/zap#207 中的讨论。

什么是DPanic?

DPanic代表"panic in development."。在development中，它会打印Panic级别的日志：反之，它将发生在Error级别的日志，DPanic更加容易捕获可能但实际上不应该发生的错误，而不是在生产环境中Panic。

如果你曾经写过这样的代码，就可以使用DPanic:

if err != nil {
  panic(fmt.Sprintf("shouldn't ever get here: %v", err))
}

安装问题

错误expects import "go.uber.org/zap"是什么意思？

要么zap安装错误，要么您引用了代码中的错误包名。

Zap 的源代码托管在 GitHub 上，但  import path[3]是  go.uber.org/zap，让我们项目维护者，可以更方便地自由移动源代码。所以在安装和使用包时需要注意这一点。

如果你遵循两个简单的规则，就会正常工作：安装zapgo get -u go.uber.org/zap并始终导入它在你的代码import "go.uber.org/zap"，代码不应包含任何对github.com/uber-go/zap的引用.

用法问题

Zap是否支持日志切割？

Zap 不支持切割日志文件，因为我们更喜欢将此交给外部程序，如logrotate.

但是，日志切割包很容易集成，如  `gopkg.in/natefinch/lumberjack.v2`[4] 作为zapcore.WriteSyncer.

// lumberjack.Logger is already safe for concurrent use, so we don't need to
// lock it.
w := zapcore.AddSync(&lumberjack.Logger{
  Filename:   "/var/log/myapp/foo.log",
  MaxSize:    500, // megabytes
  MaxBackups: 3,
  MaxAge:     28, // days
})
core := zapcore.NewCore(
  zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()),
  w,
  zap.InfoLevel,
)
logger := zap.New(core)
插件

我们很希望zap 本身能满足的每一个logging需求，但我们只熟悉少数日志摄入(log ingestion)系统、参数解析(flag-parsing)包等。所以我们更愿意发展 zap 插件生态系统。

下面扩展包，可以作为参考使用：

包集成
github.com/tchap/zapextSentry, syslog
github.com/fgrosse/zaptestGinkgo
github.com/blendle/zapdriverStackdriver
github.com/moul/zapgormGorm

性能比较

说明 : 以下资料来源于 zap 官方，Zap 提供的基准测试清楚地表明，zerolog[5]是与 Zap 竞争最激烈的。zerolo还提供结果非常相似的基准测试[6]：

记录一个10个kv字段的消息：

PackageTimeTime % to zapObjects Allocated
⚡ zap862 ns/op+0%5 allocs/op
⚡ zap (sugared)1250 ns/op+45%11 allocs/op
zerolog4021 ns/op+366%76 allocs/op
go-kit4542 ns/op+427%105 allocs/op
apex/log26785 ns/op+3007%115 allocs/op
logrus29501 ns/op+3322%125 allocs/op
log1529906 ns/op+3369%122 allocs/op

使用一个已经有10个kv字段的logger记录一条消息：

PackageTimeTime % to zapObjects Allocated
⚡ zap126 ns/op+0%0 allocs/op
⚡ zap (sugared)187 ns/op+48%2 allocs/op
zerolog88 ns/op-30%0 allocs/op
go-kit5087 ns/op+3937%103 allocs/op
log1518548 ns/op+14621%73 allocs/op
apex/log26012 ns/op+20544%104 allocs/op
logrus27236 ns/op+21516%113 allocs/op

记录一个字符串，没有字段或printf风格的模板：

PackageTimeTime % to zapObjects Allocated
⚡ zap118 ns/op+0%0 allocs/op
⚡ zap (sugared)191 ns/op+62%2 allocs/op
zerolog93 ns/op-21%0 allocs/op
go-kit280 ns/op+137%11 allocs/op
standard library499 ns/op+323%2 allocs/op
apex/log1990 ns/op+1586%10 allocs/op
logrus3129 ns/op+2552%24 allocs/op
log153887 ns/op+3194%23 allocs/op

相似的库

logrus[7] 功能强大

zerolog[8] 性能相当好的日志库

参考资料

[1] 

⚡ZAP: https://github.com/uber-go/zap

[2] 

Rob Pike 谚语指出: https://go-proverbs.github.io/

[3] 

import path: https://golang.org/cmd/go/#hdr-Remote_import_paths

[4] 

gopkg.in/natefinch/lumberjack.v2: https://godoc.org/gopkg.in/natefinch/lumberjack.v2

[5] 

zerolog: https://github.com/rs/zerolog

[6] 

基准测试: https://github.com/rs/zerolog#benchmarks

[7] 

logrus: https://github.com/sirupsen/logrus

[8] 

zerolog: https://github.com/rs/zerolog

欢迎关注Go招聘公众号，获取更多精彩内容。

后台资料分享

（后台回复以下数字获取对应资源）

 100:Go简历模板 | 101:Go最全面试集锦 | 102:Go超级简历 | 103:Go安全指南 | 1024:LeetCode刷题指南 | 6379:redis集锦 

往期精彩回顾

（点击关键词查看文章）

招聘内推

北京 | 上海 | 深圳 | 杭州  | 广州 | 成都 | 西安 |  重庆 | 珠海  | 非996 | 外企.远程办公 

大厂招聘

百度 | 阿里 | 腾讯 | 字节跳动 | 360  | 安全企业 | 京东 | 贝壳 | 滴滴 | 搜狗 | 新浪 | 探探 | 好未来 | 金山云 | 伴鱼 | 联通数科  | ApiSix | AiBee | 游戏公司 | 区块链 | 跨境电商 | 电商 

资源分享

Go项目 | Go资源 |  Rust项目 | Python项目 | 前端项目 |

面试专题

面经 | 面试题 | 每日一股 

Go专题

每周一库 |  Go好文 

煎鱼（EDDYCJY）
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
深度 | 从Go高性能日志库zap看如何实现高性能Go组件
weixin_45583158的博客
08-15 1382
导语：zap是uber开源的Go高性能日志库。本文作者深入分析了zap的架构设计和具体实现，揭示了zap高效的原因。并且对如何构建高性能Go语言库给出自己的建议。作者简介...
一文搞懂 Golang 高性能日志库 - Zap
rubys007的博客
02-02 1920
到目前为止，我们已经展示了如何通过 Zap 提供的生产和开发预设来使用默认配置。现在让我们来看看如何使用自定义配置选项创建一个实例。使用Zap创建自定义Logger有两种主要方法。第一种方法是使用其Configimport ("os""stderr",},"stderr",},},")上面的函数返回一个新的zap.Logger，它的功能类似于Logger，但有一些不同之处。我们将 Zap 的生产配置作为我们自定义日志记录器的基础，通过调用并稍微修改它，将ts字段更改为。
3. 在Go语言项目中使用Zap日志库
YouMing_Li的博客
03-06 1715
在许多Go能够将事件记录到文件中，而不是应用程序控制台。日志切割：能够根据文件大小、时间或间隔等来切割日志文件。支持不同的日志级别。例如等。能够打印基本信息，如调用文件/函数名和行号，日志时间等。
Go语言快速上手Zap日志库
最新发布
qq_63644576的博客
05-26 513
Zap是由Uber开源的Go语言日志库，以其高性能和易用性在Go社区中广受欢迎。它提供了丰富的日志记录功能，包括不同级别的日志记录、结构化日志输出、日志轮转等。对于Go语言开发者来说，Zap是一个非常好的选择，特别是在需要处理大量日志数据的应用场景中。Zap是一个强大而灵活的Go语言日志库，它提供了丰富的功能和良好的性能。通过简单的配置和使用，你就可以在Go项目中快速上手Zap，记录高质量的日志。无论是对于新手还是有经验的开发者，Zap都是一个值得推荐的日志库。的便捷版本，它提供了更多的方法，如。
Golang高性能日志库zap + lumberjack 日志切割组件详解
脑袋装水的博客
09-01 7436
Golang 高性能日志库 zap 的详细使用！！！ Gin集成zap！！！ lumberjack 日志切割组件的详细使用！！！
Go日志-Uber开源库zap使用
程序猿CKeen的专栏
06-24 2723
目录 1. zap包介绍 2. zap的使用 3. 使用Namespace构建嵌套格式 4. 构造的Logger对象的选项Option 5. 参考资料 上一篇我们讲到go日志官方标准库的log的使用方法介绍，官方log标准库虽然简单，也不依赖第三方实现，但是功能相对较弱，不支持日志级别、日志分割、日志格式等,所以在项目中很少直接使用，通用于快速调试和验证。这一篇我们来介绍一下Uber官方开源日志库zap。 1. zap包介绍 zap是uber开源的日志包，以高性能著称。zap除了具有日.
zap：在Go中实现快速，结构化，分级的日志记录
02-09
安装go get -u go.uber.org/zap 请注意，zap仅支持Go的两个最新次要版本。快速开始在性能不错但不是很关键的情况下，请使用SugaredLogger 。 它比其他结构化日志记录包快4-10倍，并且包括结构化和printf样式的API。 ...
zap-examples:使用Uber的zap Go日志记录库的示例
05-16
使用zap日志记录库 该存储库提供了一些使用 Go日志记录库的示例 在尝试示例之前，请安装zap库： $ source env.sh $ go get -u go.uber.org/zap $ go run src/simple1/main.go 例子
golang基于zap日志库封装.rar
01-14
`zap`是Uber公司开发的一个高性能、结构化的日志库，它的设计目标是提供简单、快速且强大的日志解决方案。本文将详细讨论如何基于`zap`日志库进行封装，以及如何与`gin`、`xorm`和`gorm`等框架集成，以实现日志的...
logger:用于zap的简单go-chi日志记录中间件
05-08
记录器 用于zap的简单go-chi日志记录中间件安装go get github.com/treastech/logger用法package mainimport (l "github.com/treastech/logger""github.com/go-chi/chi""go.uber.org/zap""net/http")func main () {...
深入浅析golang zap 日志库使用（含文件切割、分级别存储和全局使用等）
11-21
建议使用使用Uber-go的Zap Logger，大神李文周大博客已经说的非常明确了，请先参考李老师的博客： https://www.liwenzhou.com/posts/Go/zap/ 问题二和问题三需要补充描述： 一、日志按照级别分文件切割存储 1.1 首先...
在Go语言项目中使用Zap日志库
Ch3nnn的博客
05-26 1091
在Go语言项目中使用Zap日志库 Go语言原生的日志库的使用，然后详细介绍了非常流行的Uber开源的zap日志库，同时介绍了如何搭配Lumberjack实现日志的切割和归档。 一、在Go语言项目中使用Zap日志库 介绍 在许多Go语言项目中，我们需要一个好的日志记录器能够提供下面这些功能： 能够将事件记录到文件中，而不是应用程序控制台。 日志切割-能够根据文件大小、时间或间隔等来切割日志文件。 支持不同的日志级别。例如INFO，DEBUG，ERROR等。 能够打印基本信息，如调用文件/函数名
golang log日志库优化
weixin_56766616的博客
04-04 357
通过在此基础上构建高级SugaredLogger，zap允许用户选择何时需要计算每个分配，以及何时他们更喜欢更熟悉、类型松散的API。基于反射的序列化和字符串格式昂贵得令人望而却步——它们是CPU密集型的，并进行许多小的分配。换句话说，使用encoding/json和fmt.Fprintf来记录大量的interface{}s会使您的应用程序变慢。正如其自身的基准套件所衡量的那样，zap不仅比可比的结构化日志包性能更高，而且比标准库更快。zap日志输出，确定类型的输出确实很快，那么不确定类型会怎么处理呢？
golang高性能日志库zap配置示例
dz45693的专栏
01-22 1876
zap是uber开源的Go高性能日志库，gitlab地址 安装 go get -u go.uber.org/zap 请注意，zap仅支持两个最新的Go版本。 示例 简单示例 格式化输出 package main import ( "go.uber.org/zap" "time" ) func main() { // zap.NewDevelopment 格式化输出 logger, _ := zap.NewDevelopment() defer
一文带你入门golang中zap日志基本应用
天天water的专栏
06-30 6217
关于golang中其他各种日志插件对比，这里不再赘述，直奔zap主题，啊哈哈，理论小结+实战，不扯淡，纯干货，嘎嘎，动起来。 目录 前言 使用小结 动手实战 基于zap+file-rotatelogs实现按天分隔日志 基于zap+lumberjack实现按天分隔日志 写在最后 前言 为什么选择zap： zap是非常快的、结构化的，分日志级别的Go日志库 它同时提供了结构化日志记录和printf风格的日志记录 以下是Zap发布的基准测试信息 记录一条消息和10个字段: P...
uber log 使用
niyuelin1990的博客
09-22 1742
log
Gin + Zap + Go Module 的结合使用
Kingtu_linux的博客
05-06 1383
zap项目地址：https://github.com/uber-go/zap 1、自定义配置项及引入第三方库lumberjack实现日志归档功能 项目根目录下，新建log目录，新建log.go和constant.go，配置如下： 1.1 log.go package log import ( "github.com/natefinch/lumberjack" "go.uber.org/z...
ZAP使用
YIMT的博客
06-26 2854
ZAP使用 uber开源高性能日志库 一、快速开始 1.非结构化 性能比结构化的要差（性能比较：https://github.com/uber-go/zap） （1）友好的日志打印 url := "https://www.baidu.com" logger, _ := zap.NewDevelopment() defer logger.Sync() sugar := logger.Suga...
webpack.config.js配置（development&production）
weixin_44290787的博客
03-18 1303
development.config.js //引入html-webpack-plugin模块，目的是生成index.html模板 const HtmlWebpackPlugin=require('html-webpack-plugin'); //引入vue-loader中的plugin，才能成功编译.vue文件 const VueLoaderPlugin=require('vue-loader/...
ZAP高性能日志库简要介绍
03-08
ZAP是一款高性能的日志库，它采用了零内存分配的设计，能够在高并发场景下保持稳定的性能表现。它支持多种日志级别，可以方便地进行日志输出和管理。此外，ZAP还提供了多种输出格式和输出目标，可以满足不同场景下的需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值