┌─────────────────────────────────────┐
            │          Observability               │
            │                                      │
            │   ┌─────────┐  ┌──────┐  ┌───────┐  │
            │   │ Metrics │  │ Logs │  │Traces │  │
            │   │ (숫자)  │  │(이벤트)│ │(경로) │  │
            │   └─────────┘  └──────┘  └───────┘  │
            │        ↕          ↕         ↕        │
            │        상관관계 (Correlation)         │
            └─────────────────────────────────────┘

# 형식: {네임스페이스}_{서브시스템}_{이름}_{단위}
# 예시:
http_requests_total              # Counter — 총 HTTP 요청 수
http_request_duration_seconds    # Histogram — 요청 지연시간(초)
gpu_memory_usage_bytes           # Gauge — GPU 메모리 사용량(바이트)
model_inference_tokens_total     # Counter — 처리한 총 토큰 수

# API 성공률 (%) — 최근 5분
(
  sum(rate(http_requests_total{status=~"2.."}[5m]))
  /
  sum(rate(http_requests_total[5m]))
) * 100

# GPU 사용률 상위 3 인스턴스
topk(3, avg by (instance) (gpu_utilization_percent))

# p99 응답 시간
histogram_quantile(0.99, sum by (le) (rate(http_request_duration_seconds_bucket[5m])))

# 비구조화 로그 — 사람은 읽기 쉬우나, 기계 파싱 어려움
2024-03-15 14:23:01 ERROR Failed to load model checkpoint from /models/v2.1
Connection timeout after 30s to model registry

# 구조화 로그 (JSON) — 기계 파싱 용이, 검색/필터링 최적
{"timestamp":"2024-03-15T14:23:01Z","level":"ERROR","service":"model-server",
 "message":"Failed to load model checkpoint","model_path":"/models/v2.1",
 "error_type":"ConnectionTimeout","timeout_seconds":30,
 "trace_id":"abc123","span_id":"def456"}

┌──────────┐    ┌──────────────┐    ┌───────────────┐    ┌──────────┐
│ App      │ →  │ Fluent Bit   │ →  │ OpenSearch    │ →  │ Kibana/  │
│ (stdout) │    │ (수집/필터)  │    │ 또는 Loki     │    │ Grafana  │
└──────────┘    └──────────────┘    └───────────────┘    └──────────┘

Trace (trace_id: abc-123)
├── Span A: API Gateway (10ms)
│   ├── Span B: Auth Service (3ms)
│   └── Span C: Model Server (150ms)
│       ├── Span D: Tokenizer (5ms)
│       ├── Span E: GPU Inference (120ms)
│       └── Span F: Post-processing (8ms)

┌──────────────────────────────────────────────────┐
│                  Application                      │
│  ┌──────────┐  ┌──────────┐  ┌──────────────┐   │
│  │ Tracer   │  │  Meter   │  │   Logger     │   │
│  │ (traces) │  │ (metrics)│  │   (logs)     │   │
│  └──────────┘  └──────────┘  └──────────────┘   │
│           OTEL SDK (자동/수동 계측)                │
└──────────┬───────────────────────────────────────┘
           │ OTLP (OpenTelemetry Protocol)
           ▼
┌──────────────────────┐
│   OTEL Collector     │
│  ┌────────────────┐  │
│  │   Receivers    │  │  ← OTLP, Prometheus, Jaeger 등
│  │   Processors   │  │  ← 필터, 배치, 속성 추가
│  │   Exporters    │  │  ← Prometheus, Jaeger, Loki 등
│  └────────────────┘  │
└──────────────────────┘
           │
     ┌─────┼──────┐
     ▼     ▼      ▼
 Prometheus Jaeger  Loki

from opentelemetry import trace, metrics
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter

# Tracer 설정
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer("model-server")

# Meter 설정
metrics.set_meter_provider(MeterProvider())
meter = metrics.get_meter("model-server")

# 커스텀 메트릭 정의
inference_counter = meter.create_counter(
    "model_inference_total",
    description="Total inference requests"
)
inference_duration = meter.create_histogram(
    "model_inference_duration_seconds",
    description="Inference latency"
)

# 트레이싱 + 메트릭 사용
@tracer.start_as_current_span("inference")
def run_inference(prompt: str):
    span = trace.get_current_span()
    span.set_attribute("prompt.length", len(prompt))
    span.set_attribute("model.name", "llama-3-8b")

    start = time.time()
    result = model.generate(prompt)
    duration = time.time() - start

    inference_counter.add(1, {"model": "llama-3-8b", "status": "success"})
    inference_duration.record(duration, {"model": "llama-3-8b"})

    span.set_attribute("output.tokens", result.token_count)
    return result

Level 1 (INFO):     Slack 채널 알림       ← 참고용, 즉시 대응 불필요
Level 2 (WARNING):  Telegram + Slack      ← 30분 내 확인 필요
Level 3 (CRITICAL): PagerDuty + 전화      ← 즉시 대응 필요
Level 4 (FATAL):    전 팀 호출 + 인시던트  ← 서비스 다운, 전원 동원

# LLM 메트릭 계측 예시
from prometheus_client import Histogram, Counter, Gauge

ttft_histogram = Histogram(
    'llm_time_to_first_token_seconds',
    'Time to first token',
    buckets=[0.1, 0.25, 0.5, 1.0, 2.0, 5.0, 10.0]
)

tokens_per_second = Histogram(
    'llm_tokens_per_second',
    'Output tokens per second',
    buckets=[5, 10, 20, 50, 100, 200]
)

token_cost_counter = Counter(
    'llm_token_cost_dollars_total',
    'Cumulative token cost in dollars',
    ['model', 'direction']  # direction: input/output
)

kv_cache_usage = Gauge(
    'llm_kv_cache_usage_percent',
    'KV cache memory utilization'
)