Golang错误日志记录的最佳实践与实现

在Go语言中实现高性能的错误日志记录，特别是针对高并发REST服务，确实需要考虑多个关键因素。以下是基于标准库log和缓冲机制的实现方案：

核心实现代码

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "sync"
    "time"
)

// BufferedLogger 带缓冲的日志记录器
type BufferedLogger struct {
    file   *os.File
    writer *bufio.Writer
    mutex  sync.Mutex
}

// NewBufferedLogger 创建新的缓冲日志记录器
func NewBufferedLogger(filePath string, bufferSize int) (*BufferedLogger, error) {
    file, err := os.OpenFile(filePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        return nil, fmt.Errorf("failed to open log file: %v", err)
    }

    writer := bufio.NewWriterSize(file, bufferSize)
    
    return &BufferedLogger{
        file:   file,
        writer: writer,
    }, nil
}

// LogError 记录错误信息
func (bl *BufferedLogger) LogError(err error, context string) {
    bl.mutex.Lock()
    defer bl.mutex.Unlock()
    
    timestamp := time.Now().Format("2006-01-02 15:04:05")
    logEntry := fmt.Sprintf("[%s] ERROR: %s - Context: %s\n", timestamp, err.Error(), context)
    
    _, writeErr := bl.writer.WriteString(logEntry)
    if writeErr != nil {
        log.Printf("Failed to write log entry: %v", writeErr)
    }
}

// Flush 强制刷新缓冲区到文件
func (bl *BufferedLogger) Flush() error {
    bl.mutex.Lock()
    defer bl.mutex.Unlock()
    return bl.writer.Flush()
}

// Close 关闭日志记录器
func (bl *BufferedLogger) Close() error {
    if err := bl.Flush(); err != nil {
        return err
    }
    return bl.file.Close()
}

// 全局日志记录器实例
var globalLogger *BufferedLogger

func init() {
    var err error
    globalLogger, err = NewBufferedLogger("/var/log/myservice.log", 64*1024) // 64KB缓冲区
    if err != nil {
        log.Fatalf("Failed to initialize logger: %v", err)
    }
}

// 在REST处理器中使用
func handleRequest() {
    // 模拟业务逻辑
    err := someBusinessLogic()
    if err != nil {
        globalLogger.LogError(err, "handleRequest - user processing")
    }
}

func someBusinessLogic() error {
    return fmt.Errorf("database connection failed")
}

并发安全的多goroutine使用示例

package main

import (
    "net/http"
    "sync"
)

func main() {
    // 启动定期刷新缓冲区的goroutine
    go func() {
        ticker := time.NewTicker(30 * time.Second)
        defer ticker.Stop()
        
        for range ticker.C {
            if err := globalLogger.Flush(); err != nil {
                log.Printf("Failed to flush logs: %v", err)
            }
        }
    }()

    http.HandleFunc("/api/users", usersHandler)
    http.HandleFunc("/api/orders", ordersHandler)
    
    log.Println("Server starting on :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        globalLogger.LogError(err, "HTTP server failed")
    }
}

func usersHandler(w http.ResponseWriter, r *http.Request) {
    var wg sync.WaitGroup
    
    // 模拟并发处理
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(userID int) {
            defer wg.Done()
            
            err := processUser(userID)
            if err != nil {
                globalLogger.LogError(err, fmt.Sprintf("usersHandler - userID: %d", userID))
            }
        }(i)
    }
    
    wg.Wait()
    w.WriteHeader(http.StatusOK)
}

func ordersHandler(w http.ResponseWriter, r *http.Request) {
    err := validateOrder(r)
    if err != nil {
        globalLogger.LogError(err, "ordersHandler - validation")
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    
    w.WriteHeader(http.StatusOK)
}

func processUser(userID int) error {
    if userID%7 == 0 { // 模拟错误条件
        return fmt.Errorf("user processing failed for ID: %d", userID)
    }
    return nil
}

func validateOrder(r *http.Request) error {
    return fmt.Errorf("invalid order data")
}

关键设计要点

1. 单文件句柄共享：使用单个BufferedLogger实例，通过sync.Mutex确保线程安全
2. 缓冲写入：bufio.Writer提供64KB缓冲区，减少磁盘I/O操作
3. 定期刷新：后台goroutine每30秒强制刷新缓冲区，防止日志丢失
4. 时间戳格式：包含精确时间戳便于问题排查
5. 上下文信息：记录错误发生的具体上下文

这种实现方式能够有效处理每分钟数千请求的场景，通过缓冲机制显著降低文件系统调用频率，同时保持线程安全性。