Golang统一日志接口与最佳实践：logur使用指南

统一日志接口的重要性

在Go项目中，统一的日志接口可以带来以下好处：

1. 解耦业务代码与具体日志实现
2. 方便切换不同的日志库
3. 统一日志格式和输出方式
4. 便于集中管理日志级别和过滤

logur简介

logur是一个轻量级的日志接口库，它提供了统一的日志接口，同时支持多种流行的日志库作为后端实现，如：

• logrus
• zap
• zerolog
• go-kit/log
• stdlib log

安装logur

go get github.com/logur/logur
go get github.com/logur/logur/adapter/logrus // 如果需要logrus适配器

基本使用示例

1. 创建统一日志接口

package main

import (
	"github.com/logur/logur"
	"github.com/logur/logur/adapter/logrus"
	"github.com/sirupsen/logrus"
)

func main() {
	// 创建logrus实例
	logrusLogger := logrus.New()
	
	// 包装为logur接口
	logger := logrus.New(logrusLogger)
	
	// 使用统一接口记录日志
	logger.Debug("This is a debug message")
	logger.Info("This is an info message")
	logger.Warn("This is a warning message")
	logger.Error("This is an error message")
	
	// 带上下文的日志
	logger.Info("User logged in", map[string]interface{}{
		"user_id": 123,
		"ip":      "192.168.1.1",
	})
}

2. 使用适配器模式切换日志实现

func createLogger(backend string) logur.Logger {
	switch backend {
	case "logrus":
		l := logrus.New()
		return logrus.New(l)
	case "zap":
		l, _ := zap.NewProduction()
		return zap.New(l)
	case "zerolog":
		l := zerolog.New(os.Stdout)
		return zerolog.New(l)
	default:
		return logur.NoopLogger{} // 无操作日志，用于测试
	}
}

最佳实践

1. 在项目中传递logger

type Service struct {
	logger logur.Logger
}

func NewService(logger logur.Logger) *Service {
	return &Service{
		logger: logger,
	}
}

func (s *Service) Process(data string) {
	s.logger.Info("Processing data", map[string]interface{}{
		"data": data,
	})
	// 业务逻辑...
}

2. 日志级别控制

func setupLogger(level logur.Level) logur.Logger {
	logrusLogger := logrus.New()
	
	// 设置logrus级别
	switch level {
	case logur.Debug:
		logrusLogger.SetLevel(logrus.DebugLevel)
	case logur.Info:
		logrusLogger.SetLevel(logrus.InfoLevel)
	case logur.Warn:
		logrusLogger.SetLevel(logrus.WarnLevel)
	case logur.Error:
		logrusLogger.SetLevel(logrus.ErrorLevel)
	}
	
	return logrus.New(logrusLogger)
}

3. 结构化日志

func logUserActivity(logger logur.Logger, userID int, action string) {
	logger.Info("User activity", map[string]interface{}{
		"user_id": userID,
		"action":  action,
		"time":    time.Now().Format(time.RFC3339),
	})
}

4. 错误处理与日志

func processFile(logger logur.Logger, path string) error {
	file, err := os.Open(path)
	if err != nil {
		logger.Error("Failed to open file", map[string]interface{}{
			"path":  path,
			"error": err,
		})
		return fmt.Errorf("open file: %w", err)
	}
	defer file.Close()
	
	// 处理文件...
	return nil
}

高级用法

1. 创建子日志器

func main() {
	logrusLogger := logrus.New()
	logger := logrus.New(logrusLogger)
	
	// 创建带固定字段的子日志器
	serviceLogger := logur.WithFields(logger, map[string]interface{}{
		"service": "user-service",
		"version": "1.0.0",
	})
	
	serviceLogger.Info("Service started")
}

2. 日志采样（避免日志洪泛）

func createSampledLogger(logger logur.Logger, interval time.Duration) logur.Logger {
	return logur.NewSampledLogger(logger, interval)
}

func main() {
	baseLogger := logrus.New(logrus.New())
	sampledLogger := createSampledLogger(baseLogger, time.Second)
	
	// 快速连续调用多次，但每秒只会记录一条
	for i := 0; i < 100; i++ {
		sampledLogger.Info("High frequency log message")
	}
}

3. 测试中使用日志

func TestService(t *testing.T) {
	// 使用测试日志器，可以验证日志是否被正确调用
	testLogger := logur.NewTestLogger()
	
	service := NewService(testLogger)
	service.Process("test data")
	
	// 验证是否记录了预期的日志
	if !testLogger.Has(logur.InfoLevel, "Processing data") {
		t.Error("Expected info log not found")
	}
}

总结

logur为Go项目提供了以下优势：

1. 统一的日志接口，便于维护和切换实现
2. 支持多种流行日志库作为后端
3. 提供丰富的日志功能（结构化日志、采样、测试支持等）
4. 促进更好的日志实践（上下文传递、错误处理等）

通过采用logur作为项目的日志接口，可以大大提高代码的可维护性和灵活性，同时保持与各种日志实现的兼容性。