Golang日志库logrus的介绍与使用

最新推荐文章于 2025-03-30 15:42:16 发布
最新推荐文章于 2025-03-30 15:42:16 发布
阅读量1.2k 收藏 13
点赞数 27
文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_70982551/article/details/143095729
版权

logrus概述

简介

  • Logrus 是一个流行的 Go 语言日志库，它提供了结构化日志和多种日志级别的功能。Logrus 非常灵活，支持自定义日志格式和输出，被许多 Go 语言项目广泛使用

特点

  1. 完全兼容log标准库：Logrus 可以很容易地替换掉log标准库，因为它实现了相同的接口

  2. 结构化日志记录：可以很容易地记录字段数据，这些数据随后可以被其他日志处理系统解析

  3. 多个日志级别：Logrus 支持多种日志级别，包括：Panic、Fatal、Error、Warn、Info、Debug和Trace

  4. 易于集成：Logrus 可以与其他系统如syslog、Hook等集成，便于日志的集中管理和分析

  5. 高度可定制：可以通过 Hooks 和格式化器来自定义日志的输出格式和内容

下载

go get github.com/sirupsen/logrus

logrus常用方法

logrus.Debugln("Debugln")
logrus.Infoln("Infoln")
logrus.Warnln("Warnln")
logrus.Errorln("Errorln")
logrus.Println("Println")

// 输出如下
time="2024-10-20T16:08:01+08:00" level=info msg=Infoln   
time="2024-10-20T16:08:01+08:00" level=warning msg=Warnln
time="2024-10-20T16:08:01+08:00" level=error msg=Errorln 
time="2024-10-20T16:08:01+08:00" level=info msg=Println
  • debug的没有输出，是因为logrus默认的日志输出等级是 info

日志级别

  • logrus.PanicLevel: 记录日志，然后调用 panic()
  • logrus.FatalLevel: 记录日志，然后调用 os.Exit(1)
  • logrus.ErrorLevel: 记录错误级别的日志
  • logrus.WarnLevel: 记录警告级别的日志
  • logrus.InfoLevel: 记录信息级别的日志
  • logrus.DebugLevel: 记录调试级别的日志
  • logrus.TraceLevel: 记录跟踪级别的日志
package main

import (
	"os"
	"github.com/sirupsen/logrus"
)

func main() {
	// 设置日志输出到 os.Stdout
	logrus.SetOutput(os.Stdout)

	// 设置日志级别为 InfoLevel，这意味着 InfoLevel 及以上级别的日志会被记录
	logrus.SetLevel(logrus.InfoLevel)

	// 记录不同级别的日志
	logrus.Trace("This is a trace message and will not be printed.")
	logrus.Debug("This is a debug message and will not be printed.")
	logrus.Info("This is an info message and will be printed.")
	logrus.Warn("This is a warning message and will be printed.")
	logrus.Error("This is an error message and will be printed.")
	// 注意：通常不推荐在生产环境中使用 PanicLevel 和 FatalLevel，因为它们会导致程序退出。
	// logrus.Panic("This is a panic message and will cause the program to panic.")
	// logrus.Fatal("This is a fatal message and will cause the program to exit.")
}

字段

  • WithField(key string, value interface{}) *Entry：添加一个字段到日志条目
  • WithFields(fields log.Fields) *Entry：添加多个字段到日志条目
  • WithError(err error) *Entry：添加错误字段到日志条目
package main

import (
	"os"
	"github.com/sirupsen/logrus"
)

func main() {
	// 设置日志输出到 os.Stdout
	logrus.SetOutput(os.Stdout)

	// 设置日志格式为 JSON，这对于结构化日志记录很有用
	logrus.SetFormatter(&logrus.JSONFormatter{})

	// 使用 WithField 方法添加一个字段
	logEntry := logrus.WithField("user", "Alice")

	// 使用 WithFields 方法添加多个字段
	logEntry = logEntry.WithFields(logrus.Fields{
		"operation": "login",
		"result":    "success",
	})

	// 记录一条包含字段的日志
	logEntry.Info("User logged in successfully")

	// 使用 WithError 方法添加一个错误字段
	err := fmt.Errorf("something went wrong")
	logEntry.WithError(err).Error("An error occurred")
}

输出

日志样式

显示行号

logrus.SetReportCaller(true)

样式设置

  • 默认的是以text的形式展示，也可以设置为jsong样式
textLogger := logrus.New()
	// 创建一个 TEXT 格式的日志记录器
	textLogger.SetFormatter(&logrus.TextFormatter{
		DisableColors: false,
		FullTimestamp: true,
	})

	// 创建一个 JSON 格式的日志记录器
	jsonLogger := logrus.New()
	jsonLogger.SetFormatter(&logrus.JSONFormatter{})

输出地址

  • SetOutput(io.Writer)：设置日志的输出目的地

  • SetFormatter(formatter Formatter)：设置日志的格式化器

package main

import (
	"os"
	"github.com/sirupsen/logrus"
)

func main() {
	// 创建一个新的 Logrus 实例
	log := logrus.New()

	// 输出到 os.Stdout
	log.SetOutput(os.Stdout)

	// 输出到文件
	file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
	if err == nil {
		log.SetOutput(file)
	} else {
		log.Fatalf("Failed to log to file, using default stderr: %v", err)
	}

	// 输出到自定义 io.Writer，例如 bytes.Buffer
	var buffer bytes.Buffer
	log.SetOutput(&buffer)

	// 记录一些日志
	log.Info("This is an info message")
	log.Warn("This is a warning message")
	log.Error("This is an error message")

	// 如果输出到 bytes.Buffer，你可以获取日志内容
	logBytes := buffer.Bytes()
	os.Stdout.Write(logBytes) // 将 buffer 中的内容输出到 os.Stdout
}

日志颜色

默认颜色

  • DebugLevel: 蓝色

  • InfoLevel: 绿色

  • WarningLevel: 黄色

  • ErrorLevel: 红色

  • FatalLevel: 红色（通常伴随有其他指示，比如退出程序）

  • PanicLevel: 红色（通常伴随有 panic）

禁用颜色

log.SetFormatter(&logrus.TextFormatter{
	DisableColors: true,
})

自定义颜色

  1. 创建一个新的 TextFormatter 结构体
  2. 重写 Format 方法，在格式化日志时添加自定义颜色代码
  3. 将自定义的 Formatter 设置给 Logrus 实例
package main
import (
	"bytes"
	"fmt"
	"github.com/sirupsen/logrus"
	"os"
)
// CustomFormatter 自定义格式化器
type CustomFormatter struct {
	logrus.TextFormatter
}
// Format 实现 logrus.Formatter 接口
func (f *CustomFormatter) Format(entry *logrus.Entry) ([]byte, error) {
	var b *bytes.Buffer
	if entry.Buffer != nil {
		b = entry.Buffer
	} else {
		b = &bytes.Buffer{}
	}
	// 添加自定义颜色代码
	color := ""
	switch entry.Level {
	case logrus.DebugLevel:
		color = "\x1b[34m" // 蓝色
	case logrus.InfoLevel:
		color = "\x1b[32m" // 绿色
	case logrus.WarnLevel:
		color = "\x1b[33m" // 黄色
	case logrus.ErrorLevel, logrus.FatalLevel, logrus.PanicLevel:
		color = "\x1b[31m" // 红色
	}
	// 写入颜色代码和日志内容
	fmt.Fprintf(b, "%s%s\x1b[0m\n", color, entry.Message)
	return b.Bytes(), nil
}
func main() {
	log := logrus.New()
	log.SetFormatter(&CustomFormatter{
		TextFormatter: logrus.TextFormatter{
			DisableColors: false,
			FullTimestamp: true,
		},
	})
	log.Debug("This is a debug message")
	log.Info("This is an info message")
	log.Warn("This is a warning message")
	log.Error("This is an error message")
}

自定义格式

  • 通过实现 logrus.Formatter 接口来自定义日志格式
package main
import (
	"bytes"
	"fmt"
	"time"
	"github.com/sirupsen/logrus"
)
// MyFormatter 自定义格式化器
type MyFormatter struct {
}
// Format 实现了 logrus.Formatter 接口
func (f *MyFormatter) Format(entry *logrus.Entry) ([]byte, error) {
	b := &bytes.Buffer{}
	// 自定义时间格式
	timestamp := time.Now().Format(time.RFC3339)
	fmt.Fprintf(b, "[%s] ", timestamp)
	// 自定义日志级别
	level := entry.Level.String()
	fmt.Fprintf(b, "[%s] ", level)
	// 自定义消息格式
	message := entry.Message
	fmt.Fprintf(b, "%s ", message)
	// 添加字段
	for key, value := range entry.Data {
		fmt.Fprintf(b, "%s=%v ", key, value)
	}
	// 添加换行符
	b.WriteByte('\n')
	return b.Bytes(), nil
}
func main() {
	log := logrus.New()
	// 设置自定义格式化器
	log.SetFormatter(&MyFormatter{})
	log.WithFields(logrus.Fields{
		"animal": "walrus",
		"size":   10,
	}).Info("A group of walrus emerges from the ocean")
}
  • MyFormatter 结构体实现了 Format 方法，该方法接收一个 logrus.Entry 对象，该对象包含了日志条目的所有信息，包括时间戳、日志级别、消息和字段。Format 方法将这些信息格式化为一个字符串，并返回字节数组。
[2024-10-20T17:14:22+08:00] [info] A group of walrus emerges from the ocean size=10 animal=walrus

Hook

  • 在 Logrus 中，Hook 是一个接口，允许你添加自定义的逻辑，这些逻辑会在日志记录之前或之后执行。通过实现 logrus.Hook 接口，你可以创建自己的钩子来执行额外的操作，比如发送日志到远程系统、写入数据库、执行特定的监控检查等。

  • 在 Logrus 中，Hook 的基本用法涉及以下步骤：

  1. 定义一个 Hook 结构体：这个结构体需要实现 Levels() 和 Fire(entry *logrus.Entry) error 方法。
  2. 实现 Levels() 方法：这个方法返回一个 logrus.Level 切片，表示该 Hook 将被哪些日志级别触发。
  3. 实现 Fire(entry \*logrus.Entry) error 方法：这个方法定义了当日志被记录时应该执行的逻辑。
  4. 将 Hook 添加到 Logrus 实例：使用 log.AddHook(hook) 方法。
  • 自定义 Hook 示例，它会在每次记录日志时打印出当前的函数名和文件名：
package main
import (
	"fmt"
	"runtime"
	"github.com/sirupsen/logrus"
)
// MyHook 是一个自定义的 Logrus 钩子
type MyHook struct {
}
// Levels 定义了这个钩子会被哪些日志级别触发
func (hook *MyHook) Levels() []logrus.Level {
	return logrus.AllLevels
}
// Fire 是每次日志记录时都会调用的方法
func (hook *MyHook) Fire(entry *logrus.Entry) error {
	// 获取调用者的函数名和文件名
	pc, file, line, ok := runtime.Caller(8) // 8 是调用栈的深度，可能需要根据你的代码结构进行调整
	if !ok {
		fmt.Println("Could not get caller info")
		return nil
	}
	function := runtime.FuncForPC(pc).Name()
	fmt.Printf("Caller: %s:%d %s\n", file, line, function)
	return nil
}
func main() {
	log := logrus.New()
	// 添加自定义钩子
	log.AddHook(&MyHook{})
	log.Info("This is an informational message")
	log.Warn("This is a warning message")
}

  • 在上面的代码中，MyHook 结构体实现了 Levels 和 Fire 方法。Levels 方法返回一个日志级别切片，表示这个钩子会对哪些级别的日志进行响应。在这个例子中，我们使用 logrus.AllLevels，这意味着它会对所有级别的日志做出响应。
    Fire 方法会在每次记录日志时被调用。在这个方法中，我们使用 runtime.Caller 来获取调用日志记录函数的函数名和文件名，并打印出来。
    在 main 函数中，我们创建了一个 Logrus 实例，并使用 AddHook 方法将自定义的 MyHook 添加到 Logrus 中。之后，当我们记录日志时，MyHook 的 Fire 方法会被调用，并打印出调用日志的函数名和文件名。

  • 代码输出：

Caller: D:/goproject/pkg/mod/golang.org/toolchain@v0.0.1-go1.23.2.windows-amd64/src/runtime/proc.go:272 runtime.main
time="2024-10-20T17:19:37+08:00" level=info msg="This is an informational message"
time="2024-10-20T17:19:37+08:00" level=warning msg="This is a warning message"
Caller: D:/goproject/pkg/mod/golang.org/toolchain@v0.0.1-go1.23.2.windows-amd64/src/runtime/proc.go:272 runtime.main
千年死缓
关注
golang日志 logrus的使用
记录
07-25 1967
一、安装方法： go get github.com/sirupsen/logrus 二、遇到问题： 如果没有翻墙无法下载golang.org/x/sys/unix包， 请参考：https://blog.youkuaiyun.com/wsliangjian/article/details/97253595，其他无法下载的golang.org的包均可参照此方法尝试 ...
go zap日志库的使用
qq_42665165的博客
10-22 1157
Zap是非常快的、结构化的，分日志级别的Go日志库。 1.安装 go get -u go.uber.org/zap 2.配置 Zap提供了两种类型的日志记录器—Sugared Logger和Logger。 在性能很好但不是很关键的上下文中，使用SugaredLogger。它比其他结构化日志记录包快4-10倍，并且支持结构化和printf风格的日志记录。 在每一微秒和每一次内存分配都很重要的上下文中，使用Logger。它甚至比SugaredLogger更快，内存分配次数也更少，但它只支持强类型的结构化日志记录
Go 语言中 slog 日志库的全面使用指南
m0_57836225的博客
02-18 941
slog库允许开发者以结构化的方式记录日志，结构化日志是将日志信息以键值对的形式组织，这样便于后续的日志分析和处理。它支持不同的日志级别（如DebugInfoWarnError），可以轻松地配置日志输出格式（如文本格式、JSON 格式），并且支持自定义日志处理程序。slog允许我们自定义日志处理程序，以满足特定的需求。import ("log/slog""os""strings"// PrefixHandler 是一个自定义的日志处理程序，用于在每条日志前添加前缀。
golang日志处理库go-logger.zip
07-17
go-logger 是golang 的日志库 ，基于对golang内置log的封装。用法类似java日志工具包log4j 打印日志有5个方法 Debug，Info，Warn, Error ,Fatal  日志级别由低到高设置日志级别的方法为：logger.SetLevel() 如：logger.SetLevel(logger.WARN)则：logger.Debug(....),logger.Info(...) 日志不会打出，而  logger.Warn(...),logger.Error(...),logger.Fatal(...)日志会打出。设置日志级别的参数有7个，分别为：ALL，DEB
golang 日志log与logrus
最新发布
aw2371的博客
03-30 976
log特性loglogrus日志级别有限（Fatal、Error）多级别（Debug~Panic）格式化输出支持支持（Text/JSON）日志轮转不支持支持（需配合 lumberjack）钩子机制不支持支持输出目标标准输出/文件多种（文件、网络等）社区和扩展性内置库第三方库，社区丰富。
golang日志框架之logrus
热门推荐
jacklife的博客
08-14 8万+
本文转载自姜总 golang日志库 golang标准库的日志框架非常简单，仅仅提供了print，panic和fatal三个函数对于更精细的日志级别、日志文件分割以及日志分发等方面并没有提供支持。所以催生了很多第三方的日志库，但是在golang的世界里，没有一个日志库像slf4j那样在Java中具有绝对统治地位。golang中，流行的日志框架包括logrus、zap、zerolog、seelog...
golang-日志库
flowerxxxxx的博客
08-22 435
需求分析
golang日志库
dosecin的博客
08-16 405
golang日志库
一文搞懂 Golang 高性能日志库 Zerolog
rubys007的博客
01-30 3747
Zerolog是一个高性能、零内存分配的 Go 日志库。它为不需要垃圾回收的延迟敏感型应用程序提供结构化日志记录功能。您可以以完全零分配的方式使用，这样在初始化记录器对象后，堆上不会再分配其他对象，从而防止触发垃圾回收。本教程将解释如何在 Go 应用程序中安装、设置和使用 Zerolog 记录器。我们将首先介绍它的 API 和它提供的所有选项，并展示如何以各种方式自定义它们。最后，我们将描述如何在典型的 Web 应用程序中使用它，以便您可以很好地了解如何在您的项目中采用它。
Golang logrus 日志包及日志切割的实现
01-20
本文主要介绍 Golang 中最佳日志解决方案，包括常用日志包logrus 的基本使用，如何结合file-rotatelogs 包实现日志文件的轮转切割两大话题。 Golang 关于日志处理有很多包可以使用，标准库提供的 log 包功能比较少，...
Golang日志框架Logrus详解与特性
"本文将详细介绍如何使用golang日志框架logrus，包括其主要特性和使用方法。" 在Golang中，标准库的日志功能相对基础，仅提供基本的打印、 panic 和 fatal 函数，这促使开发者寻找更加强大且功能丰富的第三方日志库...
2024年Go最全Go日志库——logrus，Golang原生开发如何深入进阶
2401_84920041的博客
05-11 473
【代码】2024年Go最全Go日志库——logrus，Golang原生开发如何深入进阶。
golang入门笔记—日志库
qq_43716830的博客
04-04 467
//time包 //time.Time类型表示时间。time.Now()函数获取当前的时间对象，然后获取时间对象的年月日时分秒等信息 func main() { now := time.Now() fmt.Println(now) fmt.Println(now.Year()) fmt.Println(now.Month()) fmt.Println(now.Date()) fmt.Println(now.Hour()) fmt.Println(now.Minute()) fmt.Prin
Golang logrus 快速上手
Dablelv 的博客专栏。
02-16 3821
这个包有几个函数：Print、Printf、Println、Fatal、Fatalf、Fatalln、Panic、Panicf、Panicln，可以满足大部分日志的打印和处理需求。zap是Uber开源的一款高性能日志库，它支持多种日志级别和输出方式，包括console、json、file等等。在实际开发过程中，为了节省磁盘和方便查看，日志需要按照时间或者大小维度进行切割分成多分归档过期的日志，删除久远的日志.这个就是在日常开发中经常遇见的日志滚动(log rotation)。
Go语言日志库log
YIYIYI
06-28 965
Go语言日志库log
盘点 Go 语言的那些日志库：你用了哪个？
EDDYCJY的博客
10-08 1243
阅读本文大概需要 6 分钟。大家好，我是站长 polarisxu。Go语言是一种高性能、简洁、并发友好的编程语言，广泛用于开发各种应用程序，如网络服务、微服务、云计算、区块链等。Go语言的标准库提供了一个基本的日志包（log），可以用于记录简单的日志信息，如时间、级别、消息等。但是，如果你需要更多的功能和灵活性，例如结构化日志、日志旋转、日志钩子、日志格式化等，那么你可能需要使用第三方的日志库。在...
不到130行代码打造一个简易的golang日志库
u013131603的博客
10-18 619
最近去一家大公司面试，一道有趣的面试题让我卡壳了。回去后，我思来想去，最后用不到130行代码，打造出了一个简易的golang日志库，完成了那个“缺憾”的梦。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值