Go语言中实现级别日志的策略与实践

package main

import (
    "flag"
    "fmt"
    "io"
    "os"
    "strings"

    "github.com/sirupsen/logrus"
)

// 定义一个全局的logrus实例
var log = logrus.New()

func init() {
    // 设置日志输出格式为文本，也可以设置为logrus.JSONFormatter{}
    log.SetFormatter(&logrus.TextFormatter{
        FullTimestamp: true,
    })

    // 默认日志级别
    log.SetLevel(logrus.InfoLevel)
}

func main() {
    // 命令行参数解析
    logLevelStr := flag.String("log-level", "info", "Set the logging level (debug, info, warn, error, fatal, panic)")
    logFile := flag.String("log-file", "", "Path to the log file. If empty, logs only to stdout.")
    flag.Parse()

    // 根据命令行参数设置日志级别
    parsedLevel, err := logrus.ParseLevel(strings.ToLower(*logLevelStr))
    if err != nil {
        fmt.Printf("Invalid log level: %s. Using default info level.\n", *logLevelStr)
        log.SetLevel(logrus.InfoLevel)
    } else {
        log.SetLevel(parsedLevel)
    }

    // 配置日志输出目的地
    var writers []io.Writer
    writers = append(writers, os.Stdout) // 总是输出到标准输出

    if *logFile != "" {
        file, err := os.OpenFile(*logFile, os.O_CREATE|os.O_WRITER|os.O_APPEND, 0666)
        if err == nil {
            writers = append(writers, file)
        } else {
            log.Errorf("Failed to open log file %s: %v. Logging only to stdout.", *logFile, err)
        }
    }

    // 将多个writer组合起来
    mw := io.MultiWriter(writers...)
    log.SetOutput(mw)

    // 示例日志输出
    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.")
    log.WithFields(logrus.Fields{
        "transaction_id": "abc-123",
        "user_id":        "user-456",
    }).Info("User transaction processed.")

    // log.Fatal("This is a fatal message, will exit the program.")
}

package main

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

// LogLevel 定义日志级别
type LogLevel int

const (
    DEBUG LogLevel = iota
    INFO
    WARN
    ERROR
    FATAL
)

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

func (l LogLevel) String() string {
    if l >= 0 && int(l) < len(logLevelNames) {
        return logLevelNames[l]
    }
    return fmt.Sprintf("UNKNOWN(%d)", l)
}

// CustomLogger 自定义日志器
type CustomLogger struct {
    minLevel LogLevel
    writers  []io.Writer
    mu       sync.Mutex // 保护写入操作
}

// NewCustomLogger 创建并初始化一个自定义日志器
func NewCustomLogger(minLevel LogLevel, writers ...io.Writer) *CustomLogger {
    if len(writers) == 0 {
        writers = []io.Writer{os.Stderr} // 默认输出到标准错误
    }
    return &CustomLogger{
        minLevel: minLevel,
        writers:  writers,
    }
}

// SetMinLevel 设置最小日志级别
func (l *CustomLogger) SetMinLevel(level LogLevel) {
    l.mu.Lock()
    defer l.mu.Unlock()
    l.minLevel = level
}

// log 核心日志写入方法
func (l *CustomLogger) log(level LogLevel, format string, args ...interface{}) {
    if level < l.minLevel {
        return // 级别不够，不记录
    }

    l.mu.Lock()
    defer l.mu.Unlock()

    prefix := fmt.Sprintf("[%s] %s ", level.String(), time.Now().Format("2006-01-02 15:04:05"))
    message := fmt.Sprintf(format, args...)
    fullMessage := prefix + message + "\n"

    for _, w := range l.writers {
        _, err := w.Write([]byte(fullMessage))
        if err != nil {
            // 如果写入失败，可以考虑打印到标准错误或采取其他措施
            fmt.Fprintf(os.Stderr, "Failed to write log: %v\n", err)
        }
    }

    if level == FATAL {
        os.Exit(1) // FATAL级别通常会导致程序退出
    }
}

// Debug 记录调试信息
func (l *CustomLogger) Debug(format string, args ...interface{}) {
    l.log(DEBUG, format, args...)
}

// Info 记录一般信息
func (l *CustomLogger) Info(format string, args ...interface{}) {
    l.log(INFO, format, args...)
}

// Warn 记录警告信息
func (l *CustomLogger) Warn(format string, args ...interface{}) {
    l.log(WARN, format, args...)
}

// Error 记录错误信息
func (l *CustomLogger) Error(format string, args ...interface{}) {
    l.log(ERROR, format, args...)
}

// Fatal 记录致命错误并退出程序
func (l *CustomLogger) Fatal(format string, args ...interface{}) {
    l.log(FATAL, format, args...)
}

func main() {
    // 示例：配置日志输出到 stdout 和文件
    logFile, err := os.OpenFile("custom_app.log", os.O_CREATE|os.O_WRITER|os.O_APPEND, 0666)
    if err != nil {
        log.Fatalf("Failed to open log file: %v", err)
    }
    defer logFile.Close()

    // 初始化自定义日志器，默认级别为INFO，输出到 stdout 和文件
    myLogger := NewCustomLogger(INFO, os.Stdout, logFile)

    // 可以通过命令行参数或其他配置方式动态设置级别
    // 假设这里通过变量模拟命令行参数
    configuredLevelStr := os.Getenv("APP_LOG_LEVEL") // 例如通过环境变量设置
    configuredLevel := INFO
    switch strings.ToUpper(configuredLevelStr) {
    case "DEBUG":
        configuredLevel = DEBUG
    case "INFO":
        configuredLevel = INFO
    case "WARN":
        configuredLevel = WARN
    case "ERROR":
        configuredLevel = ERROR
    case "FATAL":
        configuredLevel = FATAL
    }
    myLogger.SetMinLevel(configuredLevel)

    myLogger.Debug("这是一个调试信息，仅在DEBUG级别时显示。")
    myLogger.Info("程序启动成功，当前日志级别为 %s。", configuredLevel.String())
    myLogger.Warn("配置项 'database_url' 未设置，使用默认值。")
    myLogger.Error("处理请求时发生错误：%v", fmt.Errorf("网络连接超时"))
    // myLogger.Fatal("系统初始化失败，无法继续运行。")
}