14. Логирование. structured logging

type Handler interface {
    Enabled(ctx context.Context, level Level) bool
    Handle(ctx context.Context, r Record) error
    WithAttrs(attrs []Attr) Handler
    WithGroup(name string) Handler
}

package main

import (
    "io"
    "log/slog"
    "os"
)

func setupLogger() *slog.Logger {
    opts := &slog.HandlerOptions{
        Level:     slog.LevelInfo,
        AddSource: true, // Добавляет файл и строку вызова
        ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
            // Кастомизация атрибутов (например, переименование time -> ts)
            if a.Key == slog.TimeKey {
                a.Key = "ts"
            }
            return a
        },
    }

    // JSON-формат предпочтителен для production
    handler := slog.NewJSONHandler(os.Stdout, opts)
    return slog.New(handler)
}

// Production-ready инициализация с буферизацией
func setupBufferedLogger() *slog.Logger {
    w := bufio.NewWriter(os.Stdout)
    // Важно: bufio.Writer НЕ потоко-безопасен по умолчанию.
    // slog.Handler гарантирует синхронизацию на уровне Handler,
    // но для максимальной производительности лучше использовать 
    // slog.NewJSONHandler с кастомным io.Writer, который сам управляет lock.
    // Стандартный JSONHandler уже имеет встроенную синхронизацию через sync.Mutex.

    handler := slog.NewJSONHandler(w, &slog.HandlerOptions{Level: slog.LevelInfo})
    logger := slog.New(handler)

    // Запуск фоновой горутин для периодического сброса буфера
    go func() {
        ticker := time.NewTicker(500 * time.Millisecond)
        defer ticker.Stop()
        for range ticker.C {
            w.Flush() // Принудительный сброс, чтобы логи не терялись при панике
        }
    }()
    return logger
}

// Middleware для добавления request_id
func logContextMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        reqID := uuid.New().String()

        // Обогащаем контекст атрибутами логгера
        logger := slog.Default().With("request_id", reqID, "user_agent", r.UserAgent())
        ctx := slog.WithContext(r.Context(), logger)

        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// Использование в обработчике
func handleRequest(w http.ResponseWriter, r *http.Request) {
    // Извлекаем обогащенный логгер
    log := slog.Default()
    if ctxLog := slog.FromContext(r.Context()); ctxLog != nil {
        log = ctxLog
    }

    log.Info("processing request", "method", r.Method, "path", r.URL.Path)
    // ... бизнес-логика
    log.Info("request completed", "duration_ms", 42)
}

type AsyncHandler struct {
    handler slog.Handler
    ch      chan slog.Record
    done    chan struct{}
}

func NewAsyncHandler(base slog.Handler, queueSize int) *AsyncHandler {
    h := &AsyncHandler{
        handler: base,
        ch:      make(chan slog.Record, queueSize),
        done:    make(chan struct{}),
    }
    go h.run()
    return h
}

func (h *AsyncHandler) run() {
    for r := range h.ch {
        _ = h.handler.Handle(context.Background(), r)
    }
    if c, ok := h.handler.(io.Closer); ok {
        _ = c.Close()
    }
    close(h.done)
}

func (h *AsyncHandler) Handle(ctx context.Context, r slog.Record) error {
    // Контракт slog.Handler требует вызова r.Clone() при асинхронной обработке,
    // чтобы предотвратить гонки данных за слайсы атрибутов при возврате из Handle
    cloned := r.Clone()

    select {
    case h.ch <- cloned:
        return nil
    default:
        // Очередь полна. Либо дропаем, либо пишем в stderr.
        // В production надежнее дропнуть, чем заблокировать рабочую горутину.
        _, _ = os.Stderr.WriteString("log queue full, dropping record\n")
        return nil
    }
}

// Остальные методы Enabled, WithAttrs, WithGroup делегируются base handler