Go 应用日志记录的最佳实践：并发、传递与粒度控制

package main

import (
    "log"
    "os"
    "sync"
)

func worker(id int, logger *log.Logger, wg *sync.WaitGroup) {
    defer wg.Done()
    logger.Printf("Worker %d: Starting task...", id)
    // Simulate some work
    logger.Printf("Worker %d: Task completed.", id)
}

func main() {
    // 创建一个指向标准输出的日志器
    myLogger := log.New(os.Stdout, "APP: ", log.Ldate|log.Ltime|log.Lshortfile)

    var wg sync.WaitGroup
    numWorkers := 5

    for i := 1; i <= numWorkers; i++ {
        wg.Add(1)
        go worker(i, myLogger, &wg) // 多个 goroutine 共享同一个日志器实例
    }

    wg.Wait()
    myLogger.Println("All workers finished.")
}

package main

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

// MailService 模拟邮件发送服务
type MailService struct {
    logger *log.Logger
}

func NewMailService(output io.Writer) *MailService {
    return &MailService{
        logger: log.New(output, "[MAIL_SERVICE]: ", log.Ldate|log.Ltime|log.Lshortfile),
    }
}

func (ms *MailService) SendEmail(to, subject, body string) error {
    ms.logger.Printf("Attempting to send email to %s with subject '%s'", to, subject)
    // Simulate email sending logic
    time.Sleep(50 * time.Millisecond) // Simulate network delay
    ms.logger.Printf("Email sent successfully to %s", to)
    return nil
}

// DBService 模拟数据库服务
type DBService struct {
    logger *log.Logger
}

func NewDBService(output io.Writer) *DBService {
    return &DBService{
        logger: log.New(output, "[DB_SERVICE]: ", log.Ldate|log.Ltime|log.Lshortfile),
    }
}

func (ds *DBService) QueryUser(userID int) (string, error) {
    ds.logger.Printf("Querying user with ID: %d", userID)
    // Simulate database query
    time.Sleep(30 * time.Millisecond)
    ds.logger.Printf("User %d found.", userID)
    return "User-" + string(userID), nil
}

func main() {
    // 创建一个文件用于邮件服务日志
    mailLogFile, err := os.OpenFile("mail_service.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        log.Fatalf("Failed to open mail log file: %v", err)
    }
    defer mailLogFile.Close()

    // 创建一个文件用于数据库服务日志
    dbLogFile, err := os.OpenFile("db_service.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        log.Fatalf("Failed to open db log file: %v", err)
    }
    defer dbLogFile.Close()

    mailService := NewMailService(mailLogFile) // 邮件服务有自己的日志器
    dbService := NewDBService(dbLogFile)       // 数据库服务有自己的日志器

    mailService.SendEmail("test@example.com", "Hello", "This is a test email.")
    dbService.QueryUser(123)
    dbService.QueryUser(456)
    mailService.SendEmail("another@example.com", "Reminder", "Don't forget.")
}

package main

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

// SMTPServerConfig 定义SMTP服务器配置
type SMTPServerConfig struct {
    Name string
    Host string
    Port int
    // ... 其他配置
}

// SMTPServer 模拟SMTP服务实例
type SMTPServer struct {
    config *SMTPServerConfig
    logger *log.Logger
}

func NewSMTPServer(cfg *SMTPServerConfig, output io.Writer) *SMTPServer {
    prefix := fmt.Sprintf("[%s_SMTP]: ", cfg.Name)
    return &SMTPServer{
        config: cfg,
        logger: log.New(output, prefix, log.Ldate|log.Ltime|log.Lshortfile),
    }
}

func (s *SMTPServer) Connect() error {
    s.logger.Printf("Attempting to connect to %s (%s:%d)...", s.config.Name, s.config.Host, s.config.Port)
    // Simulate connection logic
    s.logger.Printf("Successfully connected to %s.", s.config.Name)
    return nil
}

func main() {
    // 配置本地MTA服务
    localMTAConfig := &SMTPServerConfig{
        Name: "LocalMTA",
        Host: "localhost",
        Port: 25,
    }
    // 配置Gmail服务
    gmailConfig := &SMTPServerConfig{
        Name: "Gmail",
        Host: "smtp.gmail.com",
        Port: 587,
    }

    // 为本地MTA服务创建独立的日志器，输出到stdout
    localMTA := NewSMTPServer(localMTAConfig, os.Stdout)
    // 为Gmail服务创建独立的日志器，输出到stderr
    gmail := NewSMTPServer(gmailConfig, os.Stderr)

    localMTA.Connect()
    gmail.Connect()
}