package main

import "github.com/gw123/glog"

func main() {
    // 简单日志输出
    glog.Info("Application started")
    glog.Infof("Server listening on port %d", 8080)
    
    // 带字段的结构化日志
    glog.WithField("user_id", 12345).Info("User logged in")
    
    // 链式调用添加多个字段
    glog.Log().
        WithField("method", "GET").
        WithField("path", "/api/users").
        WithField("status", 200).
        Info("HTTP request processed")
    
    // 错误日志
    err := someOperation()
    glog.WithError(err).Error("Operation failed")
}

package main

import (
    "context"
    "github.com/gw123/glog"
)

func main() {
    // 1. 创建根 context 并注入 logger
    ctx := context.Background()
    ctx = glog.ToContext(ctx, glog.DefaultLogger())
    
    // 2. 添加应用全局字段
    glog.AddField(ctx, "app_name", "web-service")
    glog.AddField(ctx, "version", "1.0.0")
    
    // 3. 在中间件中添加请求级别的追踪信息
    handleRequest(ctx)
}

func handleRequest(ctx context.Context) {
    // 添加请求追踪 ID 和用户信息
    glog.AddTraceID(ctx, "trace-abc-123")
    glog.AddUserID(ctx, 12345)
    glog.AddPathname(ctx, "/api/orders")
    glog.AddField(ctx, "client_ip", "192.168.1.100")
    
    // 提取 logger，自动包含之前添加的所有字段
    logger := glog.ExtractEntry(ctx)
    logger.Info("Request received")
    
    // 在业务逻辑中继续添加字段
    processOrder(ctx)
    
    logger.Info("Request completed")
}

func processOrder(ctx context.Context) {
    // 继续添加业务相关字段
    glog.AddField(ctx, "order_id", "ORD-12345")
    glog.AddField(ctx, "amount", 299.99)
    
    // 提取的 logger 包含从 root context 到此处的所有字段
    glog.ExtractEntry(ctx).Info("Processing order")
    
    // 调用其他服务
    validatePayment(ctx)
}

func validatePayment(ctx context.Context) {
    glog.AddField(ctx, "payment_method", "credit_card")
    
    // 所有日志都包含完整的上下文链路信息
    glog.ExtractEntry(ctx).Info("Payment validated")
}

// 数据库日志器
dbLogger := glog.Log().Named("database")
dbLogger.Info("Database connection established")
dbLogger.WithField("pool_size", 10).Info("Connection pool initialized")

// 缓存日志器
cacheLogger := glog.Log().Named("cache")
cacheLogger.Info("Redis connected")

// API 日志器
apiLogger := glog.Log().Named("api")
apiLogger.WithField("port", 8080).Info("API server started")

import (
    "github.com/gw123/glog"
    "github.com/gw123/glog/common"
)

func main() {
    // 配置日志器
    err := glog.SetDefaultLoggerConfig(
        common.Options{},
        common.WithLevel(common.DebugLevel),        // 设置日志级别
        common.WithConsoleEncoding(),               // 使用 Console 格式
        common.WithOutputPath("./logs/app.log"),    // 输出到文件
        common.WithStdoutOutputPath(),              // 同时输出到标准输出
    )
    if err != nil {
        panic(err)
    }
    
    // 现在可以看到 debug 日志
    glog.Debug("This is a debug message")
    glog.Info("Application configured")
}

err := glog.SetDefaultLoggerConfig(
    common.Options{},
    common.WithLevel(common.InfoLevel),
    common.WithJsonEncoding(),                  // 使用 JSON 格式
    common.WithOutputPath("./logs/app.json"),
)

import (
    "context"
    "go.opentelemetry.io/otel"
    "github.com/gw123/glog"
)

func handleRequest(ctx context.Context) {
    // 假设已经通过 OTEL 中间件注入了 span
    // ExtractEntry 会自动提取 trace_id
    logger := glog.ExtractEntry(ctx)
    logger.Info("Processing with OTEL trace")
    
    // 或者显式使用 WithOTEL
    glog.WithOTEL(ctx).Info("Explicit OTEL integration")
}

// 简单日志
glog.Debug(args ...interface{})
glog.Info(args ...interface{})
glog.Warn(args ...interface{})
glog.Error(args ...interface{})

// 格式化日志
glog.Debugf(format string, args ...interface{})
glog.Infof(format string, args ...interface{})
glog.Warnf(format string, args ...interface{})
glog.Errorf(format string, args ...interface{})

// 获取 logger 实例
logger := glog.Log()
defaultLogger := glog.DefaultLogger()

// 添加单个字段
glog.WithField(key string, value interface{})

// 添加错误字段
glog.WithError(err error)

// 创建命名 logger
logger := glog.Log().Named("component-name")

// 注入 logger 到 context
ctx = glog.ToContext(ctx, logger)

// 添加字段到 context
glog.AddField(ctx, key string, value interface{})
glog.AddFields(ctx, fields map[string]interface{})

// 添加顶级字段（优先级更高）
glog.AddTopField(ctx, key string, value interface{})

// 添加预定义字段
glog.AddTraceID(ctx, traceID string)
glog.AddUserID(ctx, userID int64)
glog.AddPathname(ctx, pathname string)
glog.AddClientIP(ctx, clientIP string)

// 从 context 提取 logger（自动包含所有字段和 OTEL trace_id）
logger := glog.ExtractEntry(ctx)

// 从 context 提取字段值
traceID := glog.ExtractTraceID(ctx)
userID := glog.ExtractUserID(ctx)

// 显式 OTEL 集成
logger := glog.WithOTEL(ctx)

// 在应用启动时配置 logger
func init() {
    glog.SetDefaultLoggerConfig(
        common.Options{},
        common.WithLevel(common.InfoLevel),
        common.WithJsonEncoding(),
        common.WithOutputPath("./logs/app.log"),
        common.WithStdoutOutputPath(),
    )
}

// 在 HTTP 中间件中初始化请求上下文
func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 创建请求 context
        ctx := glog.ToContext(r.Context(), glog.Log().Named("http"))
        
        // 添加请求追踪信息
        requestID := generateRequestID()
        glog.AddTraceID(ctx, requestID)
        glog.AddPathname(ctx, r.URL.Path)
        glog.AddClientIP(ctx, r.RemoteAddr)
        glog.AddField(ctx, "method", r.Method)
        
        // 记录请求开始
        glog.ExtractEntry(ctx).Info("Request started")
        
        // 处理请求
        next.ServeHTTP(w, r.WithContext(ctx))
        
        // 记录请求结束
        glog.ExtractEntry(ctx).Info("Request completed")
    })
}

// 在业务逻辑中使用
func CreateOrder(ctx context.Context, order Order) error {
    glog.AddField(ctx, "order_id", order.ID)
    glog.AddField(ctx, "amount", order.Amount)
    
    logger := glog.ExtractEntry(ctx)
    logger.Info("Creating order")
    
    // 业务逻辑...
    
    logger.Info("Order created successfully")
    return nil
}

import (
    "go.opentelemetry.io/otel"
    "github.com/gw123/glog"
)

func ServiceA(ctx context.Context) {
    // OTEL 会自动注入 span 到 context
    tracer := otel.Tracer("service-a")
    ctx, span := tracer.Start(ctx, "ServiceA.Process")
    defer span.End()
    
    // ExtractEntry 会自动提取 OTEL trace_id
    logger := glog.ExtractEntry(ctx)
    logger.Info("Service A processing")
    
    // 调用其他服务，trace_id 会自动传递
    ServiceB(ctx)
}

func ProcessData(ctx context.Context, data []byte) error {
    logger := glog.ExtractEntry(ctx)
    
    result, err := parseData(data)
    if err != nil {
        logger.WithError(err).
            WithField("data_size", len(data)).
            Error("Failed to parse data")
        return err
    }
    
    logger.WithField("records_count", len(result)).
        Info("Data processed successfully")
    return nil
}