Golang日志库logrus的介绍与使用示例代码

go get github.com/sirupsen/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

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.")
}

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)

textLogger := logrus.New()
	// 创建一个 TEXT 格式的日志记录器
	textLogger.SetFormatter(&logrus.TextFormatter{
		DisableColors: false,
		FullTimestamp: true,
	})
	// 创建一个 JSON 格式的日志记录器
	jsonLogger := logrus.New()
	jsonLogger.SetFormatter(&logrus.JSONFormatter{})

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
}

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

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")
}

[2024-10-20T17:14:22+08:00] [info] A group of walrus emerges from the ocean size=10 animal=walrus 

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")
}