Golang 分级日志记录封装库使用指南

在Go语言中实现分级日志记录可以帮助我们更好地管理和调试应用程序。下面我将介绍一个简单的分级日志记录封装库的实现和使用方法。

基础日志封装实现

首先，我们创建一个简单的日志封装库，支持不同级别的日志记录：

package log

import (
	"fmt"
	"io"
	"os"
	"sync"
	"time"
)

// 日志级别类型
type Level int

const (
	LevelDebug Level = iota
	LevelInfo
	LevelWarn
	LevelError
	LevelFatal
)

var levelNames = []string{
	"DEBUG",
	"INFO",
	"WARN",
	"ERROR",
	"FATAL",
}

// Logger 日志记录器
type Logger struct {
	mu     sync.Mutex
	output io.Writer
	level  Level
}

// NewLogger 创建新的日志记录器
func NewLogger(output io.Writer, level Level) *Logger {
	return &Logger{
		output: output,
		level:  level,
	}
}

// 默认日志记录器
var defaultLogger = NewLogger(os.Stderr, LevelInfo)

// SetOutput 设置日志输出
func SetOutput(w io.Writer) {
	defaultLogger.mu.Lock()
	defer defaultLogger.mu.Unlock()
	defaultLogger.output = w
}

// SetLevel 设置日志级别
func SetLevel(level Level) {
	defaultLogger.mu.Lock()
	defer defaultLogger.mu.Unlock()
	defaultLogger.level = level
}

// log 内部日志记录方法
func (l *Logger) log(level Level, format string, args ...interface{}) {
	if level < l.level {
		return
	}

	now := time.Now().Format("2006-01-02 15:04:05")
	msg := fmt.Sprintf(format, args...)
	logEntry := fmt.Sprintf("[%s] %s %s\n", now, levelNames[level], msg)

	l.mu.Lock()
	defer l.mu.Unlock()
	_, _ = fmt.Fprint(l.output, logEntry)
}

// 导出各级别日志方法
func Debug(format string, args ...interface{}) {
	defaultLogger.log(LevelDebug, format, args...)
}

func Info(format string, args ...interface{}) {
	defaultLogger.log(LevelInfo, format, args...)
}

func Warn(format string, args ...interface{}) {
	defaultLogger.log(LevelWarn, format, args...)
}

func Error(format string, args ...interface{}) {
	defaultLogger.log(LevelError, format, args...)
}

func Fatal(format string, args ...interface{}) {
	defaultLogger.log(LevelFatal, format, args...)
	os.Exit(1)
}

使用示例

下面是如何使用这个日志库的示例：

package main

import (
	"os"
	
	"./log" // 替换为你的实际包路径
)

func main() {
	// 设置日志级别为Debug
	log.SetLevel(log.LevelDebug)
	
	// 设置日志输出到文件
	file, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
	if err != nil {
		log.Fatal("无法打开日志文件: %v", err)
	}
	defer file.Close()
	log.SetOutput(file)
	
	// 记录不同级别的日志
	log.Debug("这是一条调试信息")
	log.Info("应用程序启动")
	log.Warn("警告: 配置项缺失, 使用默认值")
	log.Error("处理请求时出错: %v", "连接超时")
	
	// 业务逻辑
	processData()
}

func processData() {
	log.Debug("开始处理数据")
	// 模拟处理过程
	log.Info("数据处理完成")
}

高级功能扩展

如果需要更高级的功能，可以扩展上述基础实现：

1. JSON格式日志：

func (l *Logger) jsonLog(level Level, format string, args ...interface{}) {
	if level < l.level {
		return
	}

	entry := map[string]interface{}{
		"timestamp": time.Now().Format(time.RFC3339),
		"level":     levelNames[level],
		"message":   fmt.Sprintf(format, args...),
	}

	jsonData, _ := json.Marshal(entry)
	
	l.mu.Lock()
	defer l.mu.Unlock()
	_, _ = fmt.Fprintln(l.output, string(jsonData))
}

1. 日志轮转： 可以使用第三方库如lumberjack实现日志文件轮转：

import "gopkg.in/natefinch/lumberjack.v2"

func setupLogRotation() {
	log.SetOutput(&lumberjack.Logger{
		Filename:   "app.log",
		MaxSize:    100, // MB
		MaxBackups: 3,
		MaxAge:     28, // days
		Compress:   true,
	})
}

1. 上下文日志：

func WithFields(fields map[string]interface{}) *Entry {
	return &Entry{
		logger: defaultLogger,
		fields: fields,
	}
}

type Entry struct {
	logger *Logger
	fields map[string]interface{}
}

func (e *Entry) Info(format string, args ...interface{}) {
	// 将fields和消息一起记录
}

最佳实践

1. 在应用程序启动时配置日志级别和输出
2. 生产环境使用LevelInfo或更高级别
3. 开发环境可以使用LevelDebug以便调试
4. 错误日志应该包含足够的上下文信息
5. 避免在热路径上记录过多调试日志

这个简单的日志库已经能满足大多数基本需求，如果需要更复杂的功能，可以考虑使用成熟的日志库如zap、logrus或zerolog。