문맥 기반 로깅

type Span struct {
    ServiceName string
    Scope       string
    Method      string
    RequestID   string
    StartTime   time.Time
    Payload     map[string]interface{}
}

func NewSpan(service, scope, method, requestID string) *Span {
    return &Span{
        ServiceName: service,
        Scope:       scope,
        Method:      method,
        RequestID:   requestID,
        Payload:     make(map[string]interface{}),
    }
}

// 시작 시점을 기록하고 Span 객체를 반환
func (s *Span) Start() *Span {
    s.StartTime = time.Now()
    return s
}

// 작업 완료 시 호출: 소요 시간(Duration)을 자동 계산하여 기록
func (s *Span) Complete() {
    duration := time.Since(s.StartTime)
    // Log format: {"level":"INFO", "service":"{Service}", "scope":"{Scope}", "method":"{Method}", "request_id":"{RequestID}", "status":"completed", "duration_ms":{Duration}}
}

// 작업 실패 시 호출: 에러 원인과 소요 시간을 함께 기록
func (s *Span) Fail(err error) {
    duration := time.Since(s.StartTime)
    // Log format: {"level":"ERROR", "service":"{Service}", "scope":"{Scope}", "method":"{Method}", "request_id":"{RequestID}", "status":"failed", "error":"{Error}", "duration_ms":{Duration}}
}

type StateLogger struct {
    ServiceName string
    Scope       string
    RequestID   string
}

func NewStateLogger(service, scope, requestID string) *StateLogger {
    return &StateLogger{
        ServiceName: service,
        Scope:       scope,
        RequestID:   requestID,
    }
}

// 상태 전이(Transition): 이전 상태(From)와 이후 상태(To)를 명시적으로 기록
// 버그 추적 시 "어떤 상태에서 넘어왔는가"를 파악하는 데 핵심적임
func (l *StateLogger) Transition(entity string, from, to string, reason string) {
    // Log format: {"type":"transition", "service":"{Service}", "request_id":"{RequestID}", "entity":"{Entity}", "from":"{From}", "to":"{To}", "reason":"{Reason}"}
}

// 상태 스냅샷(Snapshot): 특정 시점의 객체 상태 전체를 덤프
// 데이터 정합성 확인이나 디버깅 시점의 데이터 확인용
func (l *StateLogger) Snapshot(entity string, data interface{}) {
    // Log format: {"type":"snapshot", "service":"{Service}", "request_id":"{RequestID}", "entity":"{Entity}", "data":{JSON_Dump}}
}

type TrendCollector struct {
    // 1. Counter: 누적 값 (요청 수, 에러 수, 캐시 히트/미스 등)
    counters map[string]*atomic.Uint64
    counterMetrics map[string]struct{}
    // 2. Gauge: 현재 상태 값 (CPU/메모리 사용량, 고루틴 수, 큐 크기 등)
    gauges map[string]*atomic.Int64
    gaugeMetrics map[string]struct{}
    // 3. Histogram: 분포 (요청 레이턴시, 응답 크기 등) - 버킷별 카운팅
    histograms map[string]*Histogram
    histogramsLock sync.RWMutex
}

type Histogram struct {
    buckets []float64
    counts  []*atomic.Uint64
}

func NewTrendCollector(cm []string, gm []string) *TrendCollector {
    counterMetrics := make(map[string]struct{}, len(cm))
    counters := make(map[string]*atomic.Uint64, len(cm))
    for _, m := range cm {
        counterMetrics[m] = struct{}{}
        counters[m] = &atomic.Uint64{}
    }

    gaugeMetrics := make(map[string]struct{}, len(gm))
    gauges := make(map[string]*atomic.Int64, len(gm))
    for _, m := range gm {
        gaugeMetrics[m] = struct{}{}
        gauges[m] = &atomic.Int64{}
    }

    return &TrendCollector{
        counters:      counters,
        counterMetrics: counterMetrics,
        gauges:        gauges,
        gaugeMetrics:  gaugeMetrics,
        histograms:    make(map[string]*Histogram),
    }
}

// Counter: 단순히 1씩 증가 (예: http_requests_total, cache_hits)
func (t *TrendCollector) IncCounter(metric string) {
    if _, ok := t.counterMetrics[metric]; !ok {
        return
    }

    t.counters[metric].Add(1)
}

// Gauge: 특정 값으로 설정 (예: memory_usage_bytes, active_goroutines)
func (t *TrendCollector) SetGauge(metric string, value int64) {
    if _, ok := t.gaugeMetrics[metric]; !ok {
        return
    }

    t.gauges[metric].Store(value)
}

// Histogram: 관측된 값을 버킷에 기록 (예: request_duration_ms)
func (t *TrendCollector) ObserveHistogram(metric string, value float64) {
    t.histogramsLock.RLock()
    hist, ok := t.histograms[metric]
    t.histogramsLock.RUnlock()

    if !ok {
        t.histogramsLock.Lock()
        if hist, ok = t.histograms[metric]; !ok {
            // 예시를 위해 고정된 버킷 사용 (실제로는 설정 필요)
            hist = &Histogram{
                buckets: []float64{10, 50, 100, 500, 1000},
                counts:  make([]*atomic.Uint64, 5),
            }
            for i := range hist.counts {
                hist.counts[i] = &atomic.Uint64{}
            }
            t.histograms[metric] = hist
        }
        t.histogramsLock.Unlock()
    }

    for i, bound := range hist.buckets {
        if value <= bound {
            hist.counts[i].Add(1)
            break
        }
    }
}

// 별도의 고루틴에서 주기적으로(예: 1분) 집계된 데이터를 로그로 배출(Flush)
func (t *TrendCollector) StartFlushLoop(ctx context.Context, interval time.Duration) {
    ticker := time.NewTicker(interval)
    for {
        select {
        case <-ticker.C:
            // Histogram은 맵 교체가 필요하므로 Lock 사용
            t.histogramsLock.Lock()
            // currentHistograms := t.histograms
            // t.histograms = make(map[string]*Histogram)
            t.histogramsLock.Unlock()

            // Counter와 Gauge는 Atomic 연산이므로 Lock 없이 값만 읽고 초기화 가능
            // (단, 엄밀한 일관성이 필요하다면 Lock 사용 고려)
            
            // Log format example:
            // {
            //   "type": "trend",
            //   "service": "payment-service",
            //   "window": "1m",
            //   "counters": { "http_req_total": 1500, "cache_hit": 1450, "cache_miss": 50 },
            //   "gauges": { "goroutines": 120, "heap_alloc_bytes": 52428800 },
            //   "histograms": { "latency_ms": { "p50": 15, "p99": 120 } }
            // }
        case <-ctx.Done():
            return
        }
    }
}