Golang 日志框架 Zap 入坑指南

最新推荐文章于 2024-05-17 00:09:24 发布
最新推荐文章于 2024-05-17 00:09:24 发布
阅读量4.9k 收藏 4
点赞数 7
分类专栏： Go 文章标签： go zap 日志 log 日志框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012124304/article/details/111405222
版权

文章目录

简介

众所周知，Zap 是个很 nb 的日志框架，作为入门篇，本文主要用几个例子来直观地感受下 Zap 写出来的日志长什么样，符不符合我们的需求（主要是审美需求），性能什么的我们攒钱不 care。

以下栗子由浅入深，循序渐进，大部分栗子可以直接 copy 运行。

Cases

case 1: Hello World

Zap 的 Hello World 代码大概长下面这样：

package main

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

func main() {
	var logger *zap.Logger
	logger, _ = zap.NewProduction()
	logger.Debug("i am debug")   // 这行不会打印，因为默认日志级别是 INFO
	logger.Info("i am info")     // INFO  级别日志，这个会正常打印
	logger.Warn("i am warn")     // WARN  级别日志，这个会正常打印
	logger.Error("i am error")   // ERROR 级别日志，这个会打印，并附带堆栈信息
	logger.Fatal("i am fatal")   // FATAL 级别日志，这个会打印，附带堆栈信息，并调用 os.Exit 退出
	fmt.Println("can i be printed?")  // 这行不会打印，呃...上面已经退出了
}

编译运行该程序，输出大概如下：

{"level":"info","ts":1608362501.672074,"caller":"zap2/main.go:11","msg":"i am info"}
{"level":"warn","ts":1608362501.672139,"caller":"zap2/main.go:12","msg":"i am warn"}
{"level":"error","ts":1608362501.672147,"caller":"zap2/main.go:13","msg":"i am error","stacktrace":"main.main\n\t/Users/jack/go/src/helloworld/zap2/main.go:13\nruntime.main\n\t/usr/local/Cellar/go/1.15.2/libexec/src/runtime/proc.go:204"}
{"level":"fatal","ts":1608362501.6721768,"caller":"zap2/main.go:14","msg":"i am fatal","stacktrace":"main.main\n\t/Users/jack/go/src/helloworld/zap2/main.go:14\nruntime.main\n\t/usr/local/Cellar/go/1.15.2/libexec/src/runtime/proc.go:204"}

以上代码应该是相当简洁易懂了，在这里需要再唠嗑一下的是关于输出的日志的几个字段的说明：

  • level: 顾名思义，就是日志的级别了，默认的日志级别是 INFO，所以我们的第一行日志没有被打印出来
  • ts: timestamp，时间戳的意思
  • caller: 调用者，就是打印日志的那行代码的位置
  • stacktrace: 调用堆栈，及打印日志的那行代码所在的堆栈信息，默认 ERROR 级别及以上的日志会附带堆栈信息，可以修改

case 2: SugaredLogger

Sugar 是糖的意思，顾名思义，zap.SugaredLogger 就是对 zap.Logger 进行了封装，提供了一些高级的语法糖特性，如支持使用类似 fmt.Printf 的形式进行格式化输出，使用 zap.SugaredLogger 改造一下上面的例子：

package main

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

func main() {
	var sugaredLogger *zap.SugaredLogger
	logger, _ := zap.NewProduction()
	sugaredLogger = logger.Sugar()
	sugaredLogger.Debugf("i am debug, using %s", "sugar")   // 这行不会打印，因为默认日志级别是 INFO
	sugaredLogger.Infof("i am info, using %s", "sugar")      // INFO  级别日志，这个会正常打印
	sugaredLogger.Warnf("i am warn, using %s", "sugar")    // WARN  级别日志，这个会正常打印
	sugaredLogger.Errorf("i am error, using %s", "sugar")   // ERROR 级别日志，这个会打印，并附带堆栈信息
	sugaredLogger.Fatalf("i am fatal, using %s", "sugar")    // FATAL 级别日志，这个会打印，附带堆栈信息，并调用 os.Exit 退出
	fmt.Println("can i be printed?")  // 这行不会打印，呃...上面已经退出了
}

编译运行该程序，输出类似如下：

{"level":"info","ts":1608365481.615607,"caller":"zap3/main.go:13","msg":"i am info, using sugar"}
{"level":"warn","ts":1608365481.615681,"caller":"zap3/main.go:14","msg":"i am warn, using sugar"}
{"level":"error","ts":1608365481.6156878,"caller":"zap3/main.go:15","msg":"i am error, using sugar","stacktrace":"main.main\n\t/Users/jack/go/src/helloworld/zap3/main.go:15\nruntime.main\n\t/usr/local/Cellar/go/1.15.2/libexec/src/runtime/proc.go:204"}
{"level":"fatal","ts":1608365481.6157131,"caller":"zap3/main.go:16","msg":"i am fatal, using sugar","stacktrace":"main.main\n\t/Users/jack/go/src/helloworld/zap3/main.go:16\nruntime.main\n\t/usr/local/Cellar/go/1.15.2/libexec/src/runtime/proc.go:204"}

case 3: 定制化 SugaredLogger

使用 zap.NewProduction() 实际上是创建了一个带了预置配置的 zap.Logger，我们可以使用 zap.New(core zapcore.Core, options ...Option) 来手动传递所有配置项，zapcore.Core 需要 3 个配置：

  • Encoder: 编码器，用于告诉 zap 以什么样的形式写入日志。zap 提供了 jsonEncoder 和 consoleEncoder 两种内置的编码器
  • WriterSyncer: 告诉 zap 将日志写到哪里，比如文件(os.File) 或标准输出(os.stdout)
  • LevelEnabler: 用于设置 zap.Logger 的日志级别

我们用定制化的方式来改写上述栗子：

package main

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

func main() {

	// 配置 sugaredLogger
	var sugaredLogger *zap.SugaredLogger
	writer := zapcore.AddSync(os.Stdout)  // 设置日志输出的设备，这里还是使用标准输出，也可以传一个 File 类型让它写入到文件
	encoder := zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())  // 设置编码器，即日志输出的格式，默认提供了 json 和 console 两种编码器，这里我们还是使用 json 的编码器
	core := zapcore.NewCore(encoder, writer, zapcore.InfoLevel) // 设置日志的默认级别
	logger := zap.New(core)
	sugaredLogger = logger.Sugar()

	// 打印日志
	sugaredLogger.Debugf("i am debug, using %s", "sugar")   // 这行不会打印，因为日志级别是 INFO
	sugaredLogger.Infof("i am info, using %s", "sugar")      // INFO  级别日志，这个会正常打印
	sugaredLogger.Warnf("i am warn, using %s", "sugar")    // WARN  级别日志，这个会正常打印
	sugaredLogger.Errorf("i am error, using %s", "sugar")   // ERROR 级别日志，这个会打印，并附带堆栈信息
	sugaredLogger.Fatalf("i am fatal, using %s", "sugar")    // FATAL 级别日志，这个会打印，附带堆栈信息，并调用 os.Exit 退出
	fmt.Println("can i be printed?")  // 这行不会打印，呃...上面已经退出了
}

编译运行该程序，输出类似如下：

{"level":"info","ts":1608367820.9526541,"msg":"i am info, using sugar"}
{"level":"warn","ts":1608367820.952697,"msg":"i am warn, using sugar"}
{"level":"error","ts":1608367820.9527,"msg":"i am error, using sugar"}
{"level":"fatal","ts":1608367820.952702,"msg":"i am fatal, using sugar"}

和上面的相比，这里不会打印 caller 和 stackstace，因为我们没有配置，需要我们显式去配置它们。

使用 Console 格式

默认的 json 格式非常方面用于专业的第三日志分析工具（如 elk）处理，但可读性就不是非常好，如果日志是用来给人看的话，设置成 console 格式的可读性会好一点，特别是存在换行的时候（json 格式的每条日志只会显示一行），将上述栗子改成 console 格式：

package main

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

func main() {

	// 配置 sugaredLogger
	var sugaredLogger *zap.SugaredLogger
	writer := zapcore.AddSync(os.Stdout)
	encoder := zapcore.NewConsoleEncoder(zap.NewProductionEncoderConfig())  // 设置 console 编码器
	core := zapcore.NewCore(encoder, writer, zapcore.InfoLevel)
	logger := zap.New(core)
	sugaredLogger = logger.Sugar()

	// 打印日志
	sugaredLogger.Debugf("i am debug, using %s", "sugar")   // 这行不会打印，因为日志级别是 INFO
	sugaredLogger.Infof("i am info, using %s", "sugar")      // INFO  级别日志，这个会正常打印
	sugaredLogger.Warnf("i am warn, using %s", "sugar")    // WARN  级别日志，这个会正常打印
	sugaredLogger.Errorf("i am error, using %s", "sugar")   // ERROR 级别日志，这个会打印，并附带堆栈信息
	sugaredLogger.Fatalf("i am fatal, using %s", "sugar")    // FATAL 级别日志，这个会打印，附带堆栈信息，并调用 os.Exit 退出
	fmt.Println("can i be printed?")  // 这行不会打印，呃...上面已经退出了
}

编译运行该程序，输出类似如下：

1.60837067575392e+09    info    i am info, using sugar
1.6083706757539682e+09  warn    i am warn, using sugar
1.608370675753972e+09   error   i am error, using sugar
1.6083706757539752e+09  fatal   i am fatal, using sugar

修改日期显示格式

上面栗子的时间戳看起来不是人能看得懂的对不对？所有我们要修改成人能看懂的(human readable)，继续修改上述栗子：

package main

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

func main() {
	// 配置 sugaredLogger
	var sugaredLogger *zap.SugaredLogger
	writer := zapcore.AddSync(os.Stdout)

	// 格式相关的配置
	encoderConfig := zap.NewProductionEncoderConfig()
	encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder  // 修改时间戳的格式
	encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder // 日志级别使用大写显示

	encoder := zapcore.NewConsoleEncoder(encoderConfig)

	core := zapcore.NewCore(encoder, writer, zapcore.InfoLevel)
	logger := zap.New(core)
	sugaredLogger = logger.Sugar()

	// 打印日志
	sugaredLogger.Debugf("i am debug, using %s", "sugar")   // 这行不会打印，因为日志级别是 INFO
	sugaredLogger.Infof("i am info, using %s", "sugar")      // INFO  级别日志，这个会正常打印
	sugaredLogger.Warnf("i am warn, using %s", "sugar")    // WARN  级别日志，这个会正常打印
	sugaredLogger.Errorf("i am error, using %s", "sugar")   // ERROR 级别日志，这个会打印，并附带堆栈信息
	sugaredLogger.Fatalf("i am fatal, using %s", "sugar")    // FATAL 级别日志，这个会打印，附带堆栈信息，并调用 os.Exit 退出
	fmt.Println("can i be printed?")  // 这行不会打印，呃...上面已经退出了
}

编译运行该程序，输出类似如下：

2020-12-19T17:44:19.031+0800    INFO    i am info, using sugar
2020-12-19T17:44:19.031+0800    WARN    i am warn, using sugar
2020-12-19T17:44:19.031+0800    ERROR   i am error, using sugar
2020-12-19T17:44:19.031+0800    FATAL   i am fatal, using sugar

呃…看起来正常点了，上述栗子顺便把日志级别显示改成大写了，看起来更习惯一点~

增加 caller 信息

在最前面的栗子中我们可以看到，使用默认的配置打印出来的日志是带有 caller （即打印日志的代码所在的位置信息）的，如果需要的话我们可以把它加上去：

package main

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

func main() {

	// 配置 sugaredLogger
	var sugaredLogger *zap.SugaredLogger
	writer := zapcore.AddSync(os.Stdout)

	// 格式相关的配置
	encoderConfig := zap.NewProductionEncoderConfig()
	encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder  // 修改时间戳的格式
	encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder // 日志级别使用大写显示
	encoder := zapcore.NewConsoleEncoder(encoderConfig)

	core := zapcore.NewCore(encoder, writer, zapcore.InfoLevel)
	logger := zap.New(core, zap.AddCaller())  // 增加 caller 信息
	sugaredLogger = logger.Sugar()

	// 打印日志
	sugaredLogger.Debugf("i am debug, using %s", "sugar")   // 这行不会打印，因为日志级别是 INFO
	sugaredLogger.Infof("i am info, using %s", "sugar")      // INFO  级别日志，这个会正常打印
	sugaredLogger.Warnf("i am warn, using %s", "sugar")    // WARN  级别日志，这个会正常打印
	sugaredLogger.Errorf("i am error, using %s", "sugar")   // ERROR 级别日志，这个会打印，并附带堆栈信息
	sugaredLogger.Fatalf("i am fatal, using %s", "sugar")    // FATAL 级别日志，这个会打印，附带堆栈信息，并调用 os.Exit 退出
	fmt.Println("can i be printed?")  // 这行不会打印，呃...上面已经退出了
}

编译运行该程序，输出类似如下：

2020-12-19T17:50:24.257+0800    INFO    zap3/main.go:29 i am info, using sugar
2020-12-19T17:50:24.257+0800    WARN    zap3/main.go:30 i am warn, using sugar
2020-12-19T17:50:24.257+0800    ERROR   zap3/main.go:31 i am error, using sugar
2020-12-19T17:50:24.257+0800    FATAL   zap3/main.go:32 i am fatal, using sugar

修改日志级别

默认的级别的 INFO，我们把它改成 DEBUG， 这个也简单：

package main

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

func main() {

	// 配置 sugaredLogger
	var sugaredLogger *zap.SugaredLogger
	writer := zapcore.AddSync(os.Stdout)

	// 格式相关的配置
	encoderConfig := zap.NewProductionEncoderConfig()
	encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder  // 修改时间戳的格式
	encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder // 日志级别使用大写显示
	encoder := zapcore.NewConsoleEncoder(encoderConfig)

	core := zapcore.NewCore(encoder, writer, zapcore.DebugLevel)  // 将日志级别设置为 DEBUG
	logger := zap.New(core, zap.AddCaller())  // 增加 caller 信息
	sugaredLogger = logger.Sugar()

	// 打印日志
	sugaredLogger.Debugf("i am debug, using %s", "sugar")   // 这行现在可以打印出来了！
	sugaredLogger.Infof("i am info, using %s", "sugar")      // INFO  级别日志，这个会正常打印
	sugaredLogger.Warnf("i am warn, using %s", "sugar")    // WARN  级别日志，这个会正常打印
	sugaredLogger.Errorf("i am error, using %s", "sugar")   // ERROR 级别日志，这个会打印，并附带堆栈信息
	sugaredLogger.Fatalf("i am fatal, using %s", "sugar")    // FATAL 级别日志，这个会打印，附带堆栈信息，并调用 os.Exit 退出
	fmt.Println("can i be printed?")  // 这行不会打印，呃...上面已经退出了
}

编译运行该程序，输出类似如下：

2020-12-19T17:52:29.438+0800    DEBUG   zap3/main.go:28 i am debug, using sugar
2020-12-19T17:52:29.439+0800    INFO    zap3/main.go:29 i am info, using sugar
2020-12-19T17:52:29.439+0800    WARN    zap3/main.go:30 i am warn, using sugar
2020-12-19T17:52:29.439+0800    ERROR   zap3/main.go:31 i am error, using sugar
2020-12-19T17:52:29.439+0800    FATAL   zap3/main.go:32 i am fatal, using sugar

可以看到 DEBUG 级别的日志也打印出来了。

添加自定义字段

有时候我们需要在每行日志中都加入一些字段，用来标识这些日志，可以在调用 zap.New() 创建 logger 的时候把这些字段设置上去，如下：

package main

import (
	"fmt"
	"github.com/google/uuid"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"os"
)

func main() {

	// 配置 sugaredLogger
	var sugaredLogger *zap.SugaredLogger
	writer := zapcore.AddSync(os.Stdout)

	// 格式相关的配置
	encoderConfig := zap.NewProductionEncoderConfig()
	encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder  // 修改时间戳的格式
	encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder // 日志级别使用大写显示
	encoder := zapcore.NewConsoleEncoder(encoderConfig)

	core := zapcore.NewCore(encoder, writer, zapcore.DebugLevel)  // 将日志级别设置为 DEBUG
	logger := zap.New(core, zap.AddCaller(), zap.Fields(zapcore.Field{  // 添加 uuid 字段
		Key:       "uuid",
		Type:      zapcore.StringType,
		String:    uuid.New().String(),
	}))
	sugaredLogger = logger.Sugar()

	// 打印日志
	sugaredLogger.Debugf("i am debug, using %s", "sugar")   // 这行现在可以打印出来了！
	sugaredLogger.Infof("i am info, using %s", "sugar")      // INFO  级别日志，这个会正常打印
	sugaredLogger.Warnf("i am warn, using %s", "sugar")    // WARN  级别日志，这个会正常打印
	sugaredLogger.Errorf("i am error, using %s", "sugar")   // ERROR 级别日志，这个会打印，并附带堆栈信息
	sugaredLogger.Fatalf("i am fatal, using %s", "sugar")    // FATAL 级别日志，这个会打印，附带堆栈信息，并调用 os.Exit 退出
	fmt.Println("can i be printed?")  // 这行不会打印，呃...上面已经退出了
}

编译运行该程序，输出类似如下：

2020-12-19T18:02:15.093+0800    DEBUG   zap3/main.go:32 i am debug, using sugar {"uuid": "79432609-3ae9-4728-bbd2-f368d404018d"}
2020-12-19T18:02:15.093+0800    INFO    zap3/main.go:33 i am info, using sugar  {"uuid": "79432609-3ae9-4728-bbd2-f368d404018d"}
2020-12-19T18:02:15.093+0800    WARN    zap3/main.go:34 i am warn, using sugar  {"uuid": "79432609-3ae9-4728-bbd2-f368d404018d"}
2020-12-19T18:02:15.093+0800    ERROR   zap3/main.go:35 i am error, using sugar {"uuid": "79432609-3ae9-4728-bbd2-f368d404018d"}
2020-12-19T18:02:15.093+0800    FATAL   zap3/main.go:36 i am fatal, using sugar {"uuid": "79432609-3ae9-4728-bbd2-f368d404018d"}

可以看到每行日志都带有 uuid 信息了。

祈晴小义
关注
  • 7
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
Golang log日志框架logrus
geek99_guo的博客
03-19 122
logrus是目前Github上star数量最多的日志库。logrus功能强大，性能高效，而且具有高度灵活性，logrus是一个可插拔的、结构化的日志框架，提供了自定义插件的功能。很多开源项目，如docker，prometheus等，都是用了logrus来记录其日志。
Gin框架使用Zap接收日志
寻找09之夏的博客
06-19 2289
Gin框架使Zap编写Logger中间件和Recover中间件替换默认Logger()和Recover()中间件。
module-logging
weixin_48799254的博客
12-07 254
简介 Python的logging模块提供了通用的日志系统，这个模块提供不同的日志级别，并可以采用不同的方式记录日志，比如文件，HTTP GET/POST，SMTP，Socket等，甚至可以自己实现方式记录日志。 #导入logging模块 import logging logging模块官方文档:https://docs.python.org/3.5/library/logging.html? logging构成 logging模块包括logger，Handler，Filter，Formatter四个部分。
2024年Go最全golang日志框架之logrus，0基础学Golang
最新发布
2401_84924864的博客
05-17 654
logrus的一个很致命的问题就是没有提供文件名和行号，这在大型项目中通过日志定位问题时有诸多不便。的调用者开始，到记录日志的生成代码之间，大概有8到11层左右，所有我们在hook中循环第8到11层调用栈应该可以找到日志记录的生产代码。logrus最令人心动的功能就是其可扩展的HOOK机制了，通过在初始化时为logrus添加hook，logrus可以实现各种扩展功能。函数可以返回当前goroutine调用栈中的文件名，行号，函数信息等，参数skip表示表示返回的栈帧的层次，0表示。进行日志本地文件分割。
GO语言使用Zap日志库（小白文）
weixin_59801183的博客
05-06 1948
本文介绍了GO语言如何快速使用zap日志库进行日志打印
Go日志-Uber开源库zap使用
程序猿CKeen的专栏
06-24 2716
目录 1. zap包介绍 2. zap的使用 3. 使用Namespace构建嵌套格式 4. 构造的Logger对象的选项Option 5. 参考资料 上一篇我们讲到go日志官方标准库的log的使用方法介绍，官方log标准库虽然简单，也不依赖第三方实现，但是功能相对较弱，不支持日志级别、日志分割、日志格式等,所以在项目中很少直接使用，通用于快速调试和验证。这一篇我们来介绍一下Uber官方开源日志库zap。 1. zap包介绍 zap是uber开源的日志包，以高性能著称。zap除了具有日.
Golang zap 快速上手
Dablelv 的博客专栏。
02-17 890
它支持多种日志级别、日志格式和输出方式，包括文本格式和 JSON 格式的输出，以及在控制台输出、文件输出、发送到远程服务、发送到。需要注意的是，Zap 的性能非常高，并且使用简单，因此它是 Golang 中最受欢迎的日志库之一。在上面的示例中，我们创建了一个 JSONEncoder 和一个 Core，将日志输出到标准输出，并将 lumberjackLogger 作为 Core 的 WriteSyncer。在上面的示例中，我们创建了一个生产级别的 Logger，它将日志记录到控制台或文件中。
golang日志框架之logrus的使用
09-18
本文主要探讨的是一个流行的日志框架——`logrus`，它是Go语言社区中广泛使用的日志库，尤其在大型开源项目中，如Docker和Prometheus。 `logrus`之所以受欢迎，是因为它提供了丰富的功能，包括不同的日志级别、...
golang基于zap日志库封装.rar
01-14
以上就是关于`golang`中基于`zap`日志库封装的基本概念和实践方法，结合`gin`、`xorm`和`gorm`框架，可以帮助我们构建更健壮、易维护的系统日志管理体系。通过合理封装，可以提高代码的可复用性和可扩展性，使日志...
python-web-guide：pythongolang -web入坑指南
02-03
【描述】：“Python-Web-Guide：Python与Golang -Web入坑指南”是一个专为初学者设计的资源，旨在帮助那些对使用Python和Golang进行Web开发感兴趣的人。这个指南将引导你了解这两种语言在构建Web应用程序时的基础...
Golang logrus 日志包及日志切割的实现
09-17
主要介绍了Golang logrus 日志包及日志切割的实现,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
logbench:Golang日志记录库基准测试
05-22
在Golang编程语言中，日志记录库是开发者在构建应用程序时不可或缺的工具。日志可以帮助我们追踪程序运行状态，定位错误，以及进行性能分析。本文将深入探讨标题中的"Logbench"，这是一个用于比较Golang日志库性能的...
golang 日志库zap和日志切割实践
qq_32421489的博客
07-19 1476
golang 日志库zap和日志切割实践
一文搞懂 Golang 高性能日志库 - Zap
rubys007的博客
02-02 1830
到目前为止，我们已经展示了如何通过 Zap 提供的生产和开发预设来使用默认配置。现在让我们来看看如何使用自定义配置选项创建一个实例。使用Zap创建自定义Logger有两种主要方法。第一种方法是使用其Configimport ("os""stderr",},"stderr",},},")上面的函数返回一个新的zap.Logger，它的功能类似于Logger，但有一些不同之处。我们将 Zap 的生产配置作为我们自定义日志记录器的基础，通过调用并稍微修改它，将ts字段更改为。
Golang高性能日志库zap + lumberjack 日志切割组件详解
脑袋装水的博客
09-01 7391
Golang 高性能日志库 zap 的详细使用！！！ Gin集成zap！！！ lumberjack 日志切割组件的详细使用！！！
深度 | 从Go高性能日志库zap看如何实现高性能Go组件
weixin_45583158的博客
08-15 1379
导语：zap是uber开源的Go高性能日志库。本文作者深入分析了zap的架构设计和具体实现，揭示了zap高效的原因。并且对如何构建高性能Go语言库给出自己的建议。作者简介...
ZAP使用
YIMT的博客
06-26 2853
ZAP使用 uber开源高性能日志库 一、快速开始 1.非结构化 性能比结构化的要差（性能比较：https://github.com/uber-go/zap） （1）友好的日志打印 url := "https://www.baidu.com" logger, _ := zap.NewDevelopment() defer logger.Sync() sugar := logger.Suga...
Python的log日志功能及设置
DefaultTest的 编程试验场
07-16 3547
引入：Python中有个logging模块可以完成相关信息的记录，在debug时用它往往事半功倍   一、日志级别(从低到高)： DEBUG :详细的信息,通常只出现在诊断问题上 INFO:确认一切按预期运行 WARNING:一个迹象表明,一些意想不到的事情发生了,或表明一些问题在不久的将来(例如。磁盘空间低”)。这个软件还能按预期工作。 ERROR:更严...
golang日志框架之logrus详细说明
Salted fish in hand, I have the world.
04-28 7351
前面的话 下面示例代码中的一些import我没做校验，我只是从我的一个测试代码里抠出来的，出现一些错误自己简单处理下就可以用。 logrus简介 logrus是一个可插拔的、结构化的日志框架。 logrus拥有六种日志级别：debug、info、warn、error、fatal和panic 可扩展的Hook机制： 允许使用者通过hook的方式将日志分发到任意地方，如本地文件系统、标准输出、logs...
golang glog与zap性能对比
07-27
Golang中的日志库glog和zap都是常见的选择，它们在性能方面有一差异。 glog是由Google开的日志库，它具有很高的性能，特别适用于高吞吐量的应用程序。它使用了缓冲区来减少磁盘I/O，并支持异步写入以提高性能。此外，glog还提供了一些高级功能，如按文件大小切割日志、按日期切割日志等。 而zap是由Uber开发的日志库，它也具有出色的性能。zap使用了零内存分配的技术，减少了垃圾回收的负担，并且支持异步写入。zap还提供了结构化日志记录的能力，可以方便地添加字段和标记。 在性能方面，根据一些基准测试结果，zap通常比glog更快。具体的性能差异取决于使用场景和配置。如果你追求最高的性能，并且需要更多高级功能和结构化日志记录的支持，那么zap可能是更好的选择。但如果你已经在使用glog并且满足需求，迁移到zap可能并不是必要的。 总结而言，glog和zap都是性能出色的日志库，具体选择取决于你的需求和偏好。你可以根据自己的场景进行基准测试，并选择最适合的日志库。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值