go-Go Logrus 日志库：企业级日志记录解决方案

icy 今天 11 抢沙发

默认

摘要： Go Logrus 日志库：企业级日志记录解决方案概述 Logrus 是 Go 语言中最受欢迎的结构化日志库之一，它提供了丰富的日志功能，同时保持了 Go 标准库 log 包的简...

Go Logrus 日志库：企业级日志记录解决方案

概述

Logrus 是 Go 语言中最受欢迎的结构化日志库之一，它提供了丰富的日志功能，同时保持了 Go 标准库 log 包的简单性。Logrus 的设计哲学是提供强大的日志功能，同时保持 API 的简洁和易用性。

主要特性

1. 结构化日志记录

Logrus 支持 JSON、文本等多种格式的结构化输出，便于日志分析和处理。

2. 灵活的日志级别

支持 7 种日志级别： - Panic - Fatal - Error - Warning - Info - Debug - Trace

3. 丰富的钩子（Hooks）系统

可以通过钩子将日志发送到各种目的地，如文件、数据库、消息队列等。

4. 线程安全

默认情况下是线程安全的，可以在并发环境中安全使用。

5. 字段支持

支持添加结构化字段到日志条目中，便于上下文追踪。

安装

text

go get github.com/sirupsen/logrus

基础使用示例

基本配置

text

package main

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

func main() {
    // 设置日志格式为 JSON
    log.SetFormatter(&log.JSONFormatter{})
    
    // 设置日志级别
    log.SetLevel(log.InfoLevel)
    
    // 基本日志记录
    log.Info("这是一条信息日志")
    log.Warn("这是一条警告日志")
    log.Error("这是一条错误日志")
    
    // 带字段的日志
    log.WithFields(log.Fields{
        "user_id": 12345,
        "ip": "192.168.1.1",
        "action": "login",
    }).Info("用户登录成功")
}

结构化字段使用

text

package main

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

func main() {
    // 创建带有默认字段的日志记录器
    logger := log.WithFields(log.Fields{
        "app": "myapp",
        "version": "1.0.0",
    })
    
    // 添加更多字段
    logger.WithFields(log.Fields{
        "request_id": "abc123",
        "method": "GET",
        "path": "/api/users",
    }).Info("处理请求")
    
    // 链式调用
    logger.
        WithField("user", "john_doe").
        WithField("email", "john@example.com").
        Info("用户操作")
}

自定义格式和输出

text

package main

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

func initLogger() {
    // 创建多文件输出
    logFile, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err == nil {
        // 同时输出到文件和控制台
        mw := io.MultiWriter(os.Stdout, logFile)
        log.SetOutput(mw)
    } else {
        log.Info("无法创建日志文件，使用标准输出")
    }
    
    // 自定义文本格式
    log.SetFormatter(&log.TextFormatter{
        FullTimestamp: true,
        TimestampFormat: "2006-01-02 15:04:05",
        ForceColors: true,
    })
}

func main() {
    initLogger()
    
    log.Info("应用程序启动")
    log.Warn("内存使用率较高")
    log.Error("数据库连接失败")
}

钩子（Hooks）使用示例

text

package main

import (
    "github.com/sirupsen/logrus"
    "gopkg.in/gemnasium/logrus-airbrake-hook.v2"
    "github.com/zbindenren/logrus_mail"
)

func setupHooks() {
    // 添加 Airbrake 错误追踪钩子
    hook, err := logrus_airbrake.NewHook("your-project-id", "your-api-key", "production")
    if err == nil {
        logrus.AddHook(hook)
    }
    
    // 添加邮件通知钩子（仅发送错误级别以上的日志）
    mailHook := &logrus_mail.MailAuthHook{
        AppName:  "MyApp",
        Host:     "smtp.gmail.com",
        Port:     587,
        From:     "alerts@example.com",
        To:       []string{"admin@example.com"},
        Username: "your-email@gmail.com",
        Password: "your-password",
    }
    logrus.AddHook(mailHook)
}

func main() {
    setupHooks()
    
    // 这些日志会触发钩子
    logrus.Error("发生严重错误，已发送邮件通知")
    logrus.Fatal("应用程序崩溃")
}

上下文日志记录器

text

package main

import (
    "context"
    "net/http"
    "time"
    log "github.com/sirupsen/logrus"
)

type contextKey string

const requestIDKey contextKey = "request_id"

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        // 创建请求特定的日志记录器
        requestID := generateRequestID()
        logger := log.WithFields(log.Fields{
            "request_id": requestID,
            "method":     r.Method,
            "path":       r.URL.Path,
            "ip":         r.RemoteAddr,
        })
        
        // 将日志记录器放入上下文
        ctx := context.WithValue(r.Context(), requestIDKey, logger)
        
        logger.Info("请求开始")
        
        // 调用下一个处理器
        next.ServeHTTP(w, r.WithContext(ctx))
        
        duration := time.Since(start)
        logger.WithField("duration", duration).Info("请求完成")
    })
}

func generateRequestID() string {
    return "req_" + time.Now().Format("20060102150405")
}

func main() {
    http.Handle("/api", loggingMiddleware(http.HandlerFunc(apiHandler)))
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func apiHandler(w http.ResponseWriter, r *http.Request) {
    // 从上下文中获取日志记录器
    if logger, ok := r.Context().Value(requestIDKey).(*log.Entry); ok {
        logger.Info("处理 API 请求")
        // 业务逻辑...
    }
}

性能优化配置

text

package main

import (
    "runtime"
    log "github.com/sirupsen/logrus"
)

func init() {
    // 禁用调用者信息（提高性能）
    log.SetReportCaller(false)
    
    // 在生产环境中使用 JSON 格式
    log.SetFormatter(&log.JSONFormatter{
        DisableTimestamp: false,
        DataKey: "context",
    })
    
    // 根据环境设置日志级别
    if runtime.GOOS == "production" {
        log.SetLevel(log.WarnLevel)
    } else {
        log.SetLevel(log.DebugLevel)
    }
}

func main() {
    // 性能敏感区域使用 WithFields 避免重复创建字段
    logger := log.WithFields(log.Fields{
        "component": "performance_critical",
    })
    
    for i := 0; i < 1000; i++ {
        logger.WithField("iteration", i).Debug("处理迭代")
    }
}