Golang日志操作库zap的使用详解

logger, _ := zap.newproduction()
defer logger.sync() // zap底层有缓冲。在任何情况下执行 defer logger.sync() 是一个很好的习惯
sugar := logger.sugar()
sugar.infow("failed to fetch url",
 // 字段是松散类型，不是强类型
  "url", url,
  "attempt", 3,
  "backoff", time.second,
)
sugar.infof("failed to fetch url: %s", url)

logger, _ := zap.newproduction()
defer logger.sync()
logger.info("failed to fetch url",
  // 字段是强类型，不是松散类型
  zap.string("url", url),
  zap.int("attempt", 3),
  zap.duration("backoff", time.second),
)

// https://github.com/uber-go/zap/blob/v1.24.0/logger.go#l127
func newexample(options ...option) *logger {
	encodercfg := zapcore.encoderconfig{
        messagekey:     "msg",  // 日志内容key:val， 前面的key设为msg
		levelkey:       "level", // 日志级别的key设为level
		namekey:        "logger", // 日志名
		encodelevel:    zapcore.lowercaselevelencoder, //日志级别，默认小写
		encodetime:     zapcore.iso8601timeencoder, // 日志时间
		encodeduration: zapcore.stringdurationencoder,
	}
	core := zapcore.newcore(zapcore.newjsonencoder(encodercfg), os.stdout, debuglevel)
	return new(core).withoptions(options...)
}

package main

import (
	"go.uber.org/zap"
)

func main() {
	logger := zap.newexample()
	logger.debug("this is debug message")
	logger.info("this is info message")
	logger.info("this is info message with fileds",
		zap.int("age", 37), 
        zap.string("agender", "man"),
    )
	logger.warn("this is warn message")
	logger.error("this is error message")
}

package main

import (
	"time"

	"go.uber.org/zap"
)

func main() {
	logger, _ := zap.newdevelopment()
	defer logger.sync()

	logger.info("failed to fetch url",
		// 强类型字段
		zap.string("url", "http://example.com"),
		zap.int("attempt", 3),
		zap.duration("duration", time.second),
	)

	logger.with(
		// 强类型字段
		zap.string("url", "http://development.com"),
		zap.int("attempt", 4),
		zap.duration("duration", time.second*5),
	).info("[with] failed to fetch url")
}

package main

import (
	"time"

	"go.uber.org/zap"
)

func main() {
	logger, _ := zap.newproduction()
	defer logger.sync()

	url := "http://zap.uber.io"
	sugar := logger.sugar()
	sugar.infow("failed to fetch url",
		"url", url,
		"attempt", 3,
		"time", time.second,
	)

	sugar.infof("failed to fetch url: %s", url)

	// 或更简洁 sugar() 使用
	// sugar := zap.newproduction().sugar()
	// defer sugar.sync()
}

package main

import (
	"go.uber.org/zap"
)

func main() {
	logger, _ := zap.newproduction(zap.fields(
		zap.string("log_name", "testlog"),
		zap.string("log_author", "prometheus"),
	))
	defer logger.sync()

	logger.info("test fields output")

	logger.warn("warn info")
}

package main

import (
	"fmt"

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

func main() {
	logger := zap.newexample(zap.hooks(func(entry zapcore.entry) error {
		fmt.println("[zap.hooks]test hooks")
		return nil
	}))
	defer logger.sync()

	logger.info("test output")

	logger.warn("warn info")
}

// 创建 logger
logger := zap.newexample()
defer logger.sync()

// 转换 sugaredlogger
sugar := logger.sugar()

// 转换 logger
plain := sugar.desugar()

// zap v1.24.0
type config struct {
    // 动态改变日志级别，在运行时你可以安全改变日志级别
	level atomiclevel `json:"level" yaml:"level"`
    // 将日志记录器设置为开发模式，在 warnlevel 及以上级别日志会包含堆栈跟踪信息
	development bool `json:"development" yaml:"development"`
    // 在日志中停止调用函数所在文件名、行数
	disablecaller bool `json:"disablecaller" yaml:"disablecaller"`
    // 完全禁止自动堆栈跟踪。默认情况下，在 development 中，warnlevel及以上日志级别会自动捕获堆栈跟踪信息
    // 在 production 中，errorlevel 及以上也会自动捕获堆栈信息
	disablestacktrace bool `json:"disablestacktrace" yaml:"disablestacktrace"`
    // 设置采样策略。没有 samplingconfing 将禁止采样
	sampling *samplingconfig `json:"sampling" yaml:"sampling"`
    // 设置日志编码。可以设置为 console 和 json。也可以通过 registerencoder 设置第三方编码格式
	encoding string `json:"encoding" yaml:"encoding"`
    // 为encoder编码器设置选项。详细设置信息在 zapcore.zapcore.encoderconfig
	encoderconfig zapcore.encoderconfig `json:"encoderconfig" yaml:"encoderconfig"`
    // 日志输出地址可以是一个 urls 地址或文件路径，可以设置多个
	outputpaths []string `json:"outputpaths" yaml:"outputpaths"`
    // 错误日志输出地址。默认输出标准错误信息
	erroroutputpaths []string `json:"erroroutputpaths" yaml:"erroroutputpaths"`
    // 可以添加自定义的字段信息到 root logger 中。也就是每条日志都会携带这些字段信息，公共字段
	initialfields map[string]interface{} `json:"initialfields" yaml:"initialfields"`
}

// zapcore@v1.24.0
type encoderconfig struct {
    // 为log entry设置key。如果 key 为空，那么在日志中的这部分信息也会省略
	messagekey     string `json:"messagekey" yaml:"messagekey"`//日志信息的健名，默认为msg
	levelkey       string `json:"levelkey" yaml:"levelkey"`//日志级别的健名，默认为level
	timekey        string `json:"timekey" yaml:"timekey"`//记录日志时间的健名，默认为time
	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"`
    // 日志编码的一些设置项
	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{} 类型编码器。如果没设置，将用 json.encoder 进行编码
	newreflectedencoder func(io.writer) reflectedencoder `json:"-" yaml:"-"`
    // 配置 console 中字段分隔符。默认使用 tab 
	consoleseparator string `json:"consoleseparator" yaml:"consoleseparator"`
}
type entry struct {
	level      level
	time       time.time
	loggername string
	message    string
	caller     entrycaller
	stack      string
}

package main

import (
	"encoding/json"

	"go.uber.org/zap"
)

// https://pkg.go.dev/go.uber.org/zap@v1.24.0#hdr-configuring_zap
func main() {
	// 表示 zap.config 的 json 原始编码
	// outputpath: 设置日志输出路径，日志内容输出到标准输出和文件 logs.log
	// erroroutputpaths：设置错误日志输出路径
	rawjson := []byte(`{
      "level": "debug",
      "encoding": "json",
      "outputpaths": ["stdout", "./logs.log"],
      "erroroutputpaths": ["stderr"],
      "initialfields": {"foo": "bar"},
      "encoderconfig": {
        "messagekey": "message-customer",
        "levelkey": "level",
        "levelencoder": "lowercase"
      }
    }`)

	// 把 json 格式数据解析到 zap.config struct
	var cfg zap.config
	if err := json.unmarshal(rawjson, &cfg); err != nil {
		panic(err)
	}
	// cfg.build() 为配置对象创建一个 logger
	// zap.must() 封装了 logger，must()函数如果返回值不是 nil，就会报 panic。也就是检查build是否错误
	logger := zap.must(cfg.build())
	defer logger.sync()

	logger.info("logger construction succeeded")
}

/*
must() 函数
//  var logger = zap.must(zap.newproduction())
func must(logger *logger, err error) *logger {
    if err != nil {
        panic(err)
    }

    return logger
}
*/

package main

import (
	"io"
	"os"

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

func main() {
	// 首先，定义不同级别日志处理逻辑
	highpriority := zap.levelenablerfunc(func(lvl zapcore.level) bool {
		return lvl >= zapcore.errorlevel
	})
	lowpriority := zap.levelenablerfunc(func(lvl zapcore.level) bool {
		return lvl < zapcore.errorlevel
	})

	// 假设有2个kafka 的 topic，一个 debugging，一个 errors

	// zapcore.addsync 添加一个文件句柄。
	topicdebugging := zapcore.addsync(io.discard)
	topicerrors := zapcore.addsync(io.discard)

	// 如果他们对并发使用不安全，我们可以用 zapcore.lock 添加一个 mutex 互斥锁。
	consoledebugging := zapcore.lock(os.stdout)
	consoleerrors := zapcore.lock(os.stderr)

	// 设置 kafka 和 console 输出配置
	kafkaencoder := zapcore.newjsonencoder(zap.newproductionencoderconfig())
	consoleencoder := zapcore.newconsoleencoder(zap.newdevelopmentencoderconfig())

	// 把上面的设置加入到 zapcore.newcore() 函数里，然后再把他们加入到 zapcore.newtee() 函数里
	core := zapcore.newtee(
		zapcore.newcore(kafkaencoder, topicerrors, highpriority),
		zapcore.newcore(consoleencoder, consoleerrors, highpriority),
		zapcore.newcore(kafkaencoder, topicdebugging, lowpriority),
		zapcore.newcore(consoleencoder, consoledebugging, lowpriority),
	)

	// 最后调用 zap.new() 函数
	logger := zap.new(core)
	defer logger.sync()
	logger.info("constructed a logger")
}

package main

import (
	"os"

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

func main() {
	writetofile()
}

func writetofile() {
	// 设置一些配置参数
	config := zap.newproductionencoderconfig()
	config.encodetime = zapcore.iso8601timeencoder
	fileencoder := zapcore.newjsonencoder(config)
	defaultloglevel := zapcore.debuglevel // 设置 loglevel

	logfile, _ := os.openfile("./log-test-zap.json", os.o_wronly|os.o_create|os.o_append, 06666)
	// or os.create()
	writer := zapcore.addsync(logfile)

	logger := zap.new(
		zapcore.newcore(fileencoder, writer, defaultloglevel),
		zap.addcaller(),
		zap.addstacktrace(zapcore.errorlevel),
	)
	defer logger.sync()

	url := "http://www.test.com"
	logger.info("write log to file",
		zap.string("url", url),
		zap.int("attemp", 3),
	)
}

package main

import (
	"os"

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

func main() {
	writetofilewithloglevel()
}

func writetofilewithloglevel() {
	// 设置配置
	config := zap.newproductionencoderconfig()
	config.encodetime = zapcore.iso8601timeencoder
	fileencoder := zapcore.newjsonencoder(config)

	logfile, _ := os.openfile("./log-debug-zap.json", os.o_wronly|os.o_create|os.o_append, 0666) //日志记录debug信息

	errfile, _ := os.openfile("./log-err-zap.json", os.o_wronly|os.o_create|os.o_append, 0666) //日志记录error信息

	teecore := zapcore.newtee(
		zapcore.newcore(fileencoder, zapcore.addsync(logfile), zap.debuglevel),
		zapcore.newcore(fileencoder, zapcore.addsync(errfile), zap.errorlevel),
	)

	logger := zap.new(teecore, zap.addcaller())
	defer logger.sync()

	url := "http://www.diff-log-level.com"
	logger.info("write log to file",
		zap.string("url", url),
		zap.int("time", 3),
	)

	logger.with(
		zap.string("url", url),
		zap.string("name", "jimmmyr"),
	).error("test error ")
}

package main

import (
	"fmt"

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

func main() {
	logger := zap.newexample(zap.hooks(func(entry zapcore.entry) error {
		fmt.println("[zap.hooks]test hooks")
		return nil
	}))
	defer logger.sync()

	logger.info("test output")

	logger.warn("warn info")
}

package main

import (
	"go.uber.org/zap"
)

func main() {
	logger := zap.newexample()
	defer logger.sync()

	logger.info("some message",
		zap.namespace("shop"),
		zap.string("name", "lilei"),
		zap.string("grade", "no2"),
	)

	logger.error("some error message",
		zap.namespace("shop"),
		zap.string("name", "lilei"),
		zap.string("grade", "no3"),
	)
}

log.setoutput(&lumberjack.logger{
    filename:   "/var/log/myapp/foo.log", // 文件位置
    maxsize:    500,  // megabytes，m 为单位，达到这个设置数后就进行日志切割
    maxbackups: 3,    // 保留旧文件最大份数
    maxage:     28,   //days ， 旧文件最大保存天数
    compress:   true, // disabled by default，是否压缩日志归档，默认不压缩
})

package main

import (
	"fmt"

	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"gopkg.in/natefinch/lumberjack.v2"
)

func main() {
	lumberjacklogger := &lumberjack.logger{
		filename:   "./log-rotate-test.json",
		maxsize:    1, // megabytes
		maxbackups: 3,
		maxage:     28,   //days
		compress:   true, // disabled by default
	}
	defer lumberjacklogger.close()

	config := zap.newproductionencoderconfig()

	config.encodetime = zapcore.iso8601timeencoder // 设置时间格式
	fileencoder := zapcore.newjsonencoder(config)

	core := zapcore.newcore(
		fileencoder,                       //编码设置
		zapcore.addsync(lumberjacklogger), //输出到文件
		zap.infolevel,                     //日志等级
	)

	logger := zap.new(core)
	defer logger.sync()

    // 测试分割日志
	for i := 0; i < 8000; i++ {
		logger.with(
			zap.string("url", fmt.sprintf("www.test%d.com", i)),
			zap.string("name", "jimmmyr"),
			zap.int("age", 23),
			zap.string("agradege", "no111-000222"),
		).info("test info ")
	}

}

// https://github.com/uber-go/zap/blob/v1.24.0/global.go

var (
	_globalmu sync.rwmutex
	_globall  = newnop()
	_globals  = _globall.sugar()
)

func l() *logger {
	_globalmu.rlock() // 加了读锁，所以并发使用是安全的
	l := _globall
	_globalmu.runlock()
	return l
}

func s() *sugaredlogger {
	_globalmu.rlock() // 加了读锁，所以并发使用是安全的
	s := _globals
	_globalmu.runlock()
	return s
}

func replaceglobals(logger *logger) func() {
	_globalmu.lock()
	prev := _globall
	_globall = logger
	_globals = logger.sugar()
	_globalmu.unlock()
	return func() { replaceglobals(prev) } // 返回一个函数类型
}

// https://github.com/uber-go/zap/blob/v1.24.0/logger.go#l85

func newnop() *logger {
	return &logger{
		core:        zapcore.newnopcore(),
		erroroutput: zapcore.addsync(io.discard),
		addstack:    zapcore.fatallevel + 1,
		clock:       zapcore.defaultclock,
	}
}

package main

import (
	"go.uber.org/zap"
)

func main() {
	// 直接调用是不会记录日志信息的，所以下面日志信息不会输出
	zap.l().info("no log info")
	zap.s().info("no log info [sugared]")

	logger := zap.newexample()
	defer logger.sync()

	zap.replaceglobals(logger) // 全局logger，zap.l() 和 zap.s() 需要调用 replaceglobals 函数才会记录日志信息
	zap.l().info("log info")
	zap.s().info("log info [sugared]")
}

package main

import (
	"go.uber.org/zap"
)

func main() {
	logger := zap.newexample()
	defer logger.sync()

	std := zap.newstdlog(logger)
	std.print("standard logger wrapper")
}

newstdlogat(l *logger, level zapcore.level) (*log.logger, error)

package main

import (
	"log"

	"go.uber.org/zap"
)

func main() {
	logger := zap.newexample()
	defer logger.sync()

	undo := zap.redirectstdlog(logger)
	log.print("redirected standard library")
	undo()

	log.print("this zap logger")
}

func redirectstdlogat(l *logger, level zapcore.level) (func(), error)

package main

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

func hello() {
	warn("hello", zap.string("h", "world"), zap.int("c", 1))
}

func warn(msg string, fields ...zap.field) {
	zap.l().warn(msg, fields...)
}

func main() {
	logger, _ := zap.newproduction(zap.addstacktrace(zapcore.warnlevel))
	defer logger.sync()

	zap.replaceglobals(logger)

	hello()
}

package main

import (
	"go.uber.org/zap"
)

func main() {
	logger, _ := zap.newproduction(zap.addcaller())
	defer logger.sync()

	logger.info("addcaller：line no and filename")
}

package main

import (
	"go.uber.org/zap"
)

func main() {
	logger, _ := zap.newproduction(zap.addcaller(), zap.addcallerskip(1))
	defer logger.sync()

	zap.replaceglobals(logger)

	hello()
}

func hello() {
	warn("hello", zap.string("h", "world"), zap.int("c", 1))
}

func warn(msg string, fields ...zap.field) {
	zap.l().warn(msg, fields...)
}

sugar := logger.sugar()
sugar.infow("failed to fetch url",
            "url", url,
            "attempt", 3,
            "backoff", time.second,
)

logger.info("failed to fetch url",
		// 强类型字段
		zap.string("url", "http://example.com"),
		zap.int("attempt", 3),
		zap.duration("backoff", time.second),
)

logger.info("some message",
    zap.namespace("shop"),
    zap.string("shopid", "s1234323"),
  )