Go Fork Log Package

package main

import (
    "go.fork.vn/log"
    "go.fork.vn/log/handler"
)

func main() {
    // Tạo cấu hình
    config := &log.Config{
        Level: handler.InfoLevel,
        Console: log.ConsoleConfig{
            Enabled: true,
            Colored: true,
        },
        File: log.FileConfig{
            Enabled: true,
            Path:    "logs/app.log",
            MaxSize: 10 * 1024 * 1024, // 10MB
        },
    }
    
    // Khởi tạo manager
    manager := log.NewManager(config)
    defer manager.Close()
    
    // Lấy logger theo context
    userLogger := manager.GetLogger("UserService")
    orderLogger := manager.GetLogger("OrderService")
    
    // Structured logging
    userLogger.Info("User logged in", "user_id", 12345, "username", "john_doe")
    orderLogger.Warning("Low stock", "product_id", "ABC123", "stock", 2)
    userLogger.Error("Database error", "error", "connection timeout")
}

// main.go
func main() {
    app := fork.NewApplication()
    
    // Đăng ký log service provider
    logConfig := log.DefaultConfig()
    app.RegisterProvider(providers.NewLogProvider(logConfig))
    
    // Đăng ký service khác
    app.RegisterProvider(providers.NewUserServiceProvider())
    
    app.Run()
}

// services/user_service.go
type UserService struct {
    logger log.Logger
    db     *database.DB
}

func NewUserService(container *container.Container) *UserService {
    manager := container.Get("log").(log.Manager)
    
    return &UserService{
        logger: manager.GetLogger("UserService"),
        db:     container.Get("database").(*database.DB),
    }
}

func (s *UserService) CreateUser(user *User) error {
    s.logger.Info("Creating user", "username", user.Username)
    
    if err := s.db.Create(user); err != nil {
        s.logger.Error("Failed to create user", 
            "username", user.Username, 
            "error", err.Error(),
        )
        return err
    }
    
    s.logger.Info("User created successfully", 
        "user_id", user.ID,
        "username", user.Username,
    )
    
    return nil
}

type DatabaseHandler struct {
    db *sql.DB
}

func (h *DatabaseHandler) Log(level handler.Level, message string, args ...interface{}) error {
    // Custom implementation
    return nil
}

func (h *DatabaseHandler) Close() error {
    return nil
}

config := log.DefaultConfig()
// Level: InfoLevel
// Console: Enabled=true, Colored=true
// File: Enabled=false
// Stack: Enabled=false

// Development
devConfig := &log.Config{
    Level: handler.DebugLevel,
    Console: log.ConsoleConfig{Enabled: true, Colored: true},
    File:    log.FileConfig{Enabled: true, Path: "logs/dev.log"},
    Stack:   log.StackConfig{Enabled: true, Handlers: log.StackHandlers{Console: true, File: true}},
}

// Production
prodConfig := &log.Config{
    Level: handler.InfoLevel,
    Console: log.ConsoleConfig{Enabled: false},
    File:    log.FileConfig{Enabled: true, Path: "/var/log/app/app.log", MaxSize: 100*1024*1024},
    Stack:   log.StackConfig{Enabled: false},
}

func LoggingMiddleware(manager log.Manager) func(http.Handler) http.Handler {
    logger := manager.GetLogger("HTTPMiddleware")
    
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            start := time.Now()
            
            logger.Info("Request started",
                "method", r.Method,
                "path", r.URL.Path,
                "remote_addr", r.RemoteAddr,
            )
            
            next.ServeHTTP(w, r)
            
            logger.Info("Request completed",
                "method", r.Method,
                "path", r.URL.Path,
                "duration", time.Since(start).String(),
            )
        })
    }
}

type PerformanceLogger struct {
    logger log.Logger
}

func (p *PerformanceLogger) TimeOperation(operation string, fn func() error, context ...interface{}) error {
    start := time.Now()
    
    p.logger.Info("Operation started", append(context, "operation", operation)...)
    
    err := fn()
    duration := time.Since(start)
    
    logArgs := append(context, "operation", operation, "duration_ms", duration.Milliseconds())
    
    if err != nil {
        p.logger.Error("Operation failed", append(logArgs, "error", err.Error())...)
    } else {
        p.logger.Info("Operation completed", logArgs...)
    }
    
    return err
}

// Thêm custom handler
dbHandler := NewDatabaseHandler(db)
manager.AddHandler("database", dbHandler)

// Set handler cho logger cụ thể
manager.SetHandler("AuditService", "database")

// Remove handler
manager.RemoveHandler("database")

func TestUserService_CreateUser(t *testing.T) {
    // Setup mock logger
    mockLogger := &MockLogger{}
    service := &UserService{logger: mockLogger}
    
    // Execute
    user := &User{Username: "testuser"}
    err := service.CreateUser(user)
    
    // Assert
    assert.NoError(t, err)
    assert.Contains(t, mockLogger.Logs, "Creating user")
    assert.Contains(t, mockLogger.Logs, "User created successfully")
}