Monitoring & Observability cho LLM Services: Đào Sâu Metrics, Tracing, Drift Detection và Alert Hallucination Spikes

Chào anh em dev, anh Hải đây. Hôm nay ngồi cà phê, nghĩ về mấy hệ thống LLM đang chạy production. LLM không phải cái toy nữa, giờ nó serve hàng nghìn query/giây, latency phải dưới 200ms P95 nếu không user bỏ chạy hết. Nhưng vấn đề lớn nhất: mày không monitor kỹ, mày không biết nó đang chết dần thế nào. Hallucination spike lên 15% giữa đêm, model drift vì data input thay đổi, tracing request mất hút – toàn chuyện thường ngày.

Mình từng build LLM service trên vLLM 0.5.3 với Python 3.12, handle 5k RPS trên cluster GPU A100. Không observability, latency nhảy từ 150ms lên 800ms chỉ vì queue backlog. Hôm nay anh em theo style Hải “Performance”, đào số liệu cụ thể: latency, throughput, memory leak, error rates. Không màu mè, chỉ data-driven.

Tại Sao LLM Services Cần Observability Đặc Biệt?

Observability (khả năng quan sát hệ thống) khác monitoring truyền thống. Monitoring là “hệ thống down chưa?”, observability là “tại sao down, luồng dữ liệu đi đâu?”. Với LLM:

• Metrics: Đo latency/token, RPS (requests per second), GPU utilization.
• Tracing: Theo dõi end-to-end từ API call đến LLM inference.
• Drift Detection: Phát hiện input/output lệch chuẩn (data drift hoặc concept drift).
• Alerting on Hallucination: Hallucination là LLM bịa fact sai (ví dụ: bảo “Hà Nội có 100 quận” thay vì 12). Spike hallucination >10% là báo động đỏ.

Use Case kỹ thuật 1: Hệ thống chat AI handle 10k user concurrent, mỗi query 1k tokens. Không tracing, khó biết bottleneck ở tokenizer (20ms) hay sampling (150ms).

Theo OpenAI Engineering Blog, LLM inference latency scale O(n^2) với sequence length. Phải monitor P99 latency <500ms mới scale được.

Metrics Cơ Bản: Đo Latency, Throughput và Resource Usage

Bắt đầu từ metrics. Dùng Prometheus 2.52 + Grafana 10.4 stack – free, battle-tested.

Core Metrics cho LLM:
– llm_inference_latency_ms: P50=100ms, P95=250ms, P99=500ms.
– llm_rps: Target 2k-5k RPS/GPU.
– llm_error_rate: >1% là vấn đề (OOM, timeout).
– gpu_utilization: NVIDIA DCGM exporter, target 80-95%.
– memory_vram_usage_gb: Leak nếu >90% sau 1h.

Code sample: Integrate Prometheus với FastAPI + vLLM (Python 3.12).

from fastapi import FastAPI
from vllm import LLM, SamplingParams
from prometheus_client import Counter, Histogram, generate_latest
from fastapi.responses import Response
import torch

app = FastAPI()
llm = LLM(model="meta-llama/Llama-2-7b-hf", tensor_parallel_size=4)  # Cluster 4xA100

# Metrics
REQUESTS = Counter('llm_requests_total', 'Total requests', ['status'])
LATENCY = Histogram('llm_inference_latency_seconds', 'Inference latency')

@app.post("/generate")
async def generate(prompt: str):
    start = torch.cuda.Event(enable_timing=True)
    end = torch.cuda.Event(enable_timing=True)
    start.record()

    params = SamplingParams(temperature=0.7, max_tokens=512)
    outputs = llm.generate([prompt], params)

    end.record()
    torch.cuda.synchronize()
    latency_ms = start.elapsed_time(end)  # CUDA event, chính xác microsecond

    REQUESTS.labels(status="success").inc()
    LATENCY.observe(latency_ms / 1000)

    return {"response": outputs[0].outputs[0].text}

@app.get("/metrics")
async def metrics():
    return Response(generate_latest(), media_type="text/plain")

Chạy prometheus-client exporter trên port 8000. Grafana dashboard: Query histogram_quantile(0.95, sum(rate(llm_inference_latency_seconds_bucket[5m])) by (le)) – thấy P95 nhảy 300ms là check queue.

⚡ Performance Tip: vLLM 0.5.3 paginated KV cache giảm memory 40%, latency từ 450ms xuống 180ms tại 4k tokens (test trên Llama-3-8B).

Tracing: Theo Dõi End-to-End với OpenTelemetry

Tracing là distributed tracing (theo dõi luồng request qua services). Dùng OpenTelemetry (OTEL) 0.47b – standard CNCF, không vendor-lock.

Tại sao OTEL? Export sang Jaeger/Zipkin hoặc cloud (Datadog). Span cho từng bước: prompt -> embed -> inference -> post-process.

Use Case kỹ thuật 2: Pipeline RAG (Retrieval-Augmented Generation) với 50GB vector DB (Pinecone). Tracing reveal 70% latency ở embedding (BERT-base: 120ms/query).

Code sample: OTEL instrumentation cho FastAPI + vLLM.

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
from opentelemetry.instrumentation.vllm import VLLMInstrumentor  # Custom nếu cần

trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
    BatchSpanProcessor(OTLPSpanExporter(endpoint="http://jaeger:4317"))
)

app = FastAPI()
FastAPIInstrumentor.instrument_app(app)
# VLLMInstrumentor().instrument(engine=llm.engine)  # Wrap nếu vLLM support

@app.post("/generate")
async def generate(prompt: str):
    with trace.get_tracer(__name__).start_as_current_span("llm-inference"):
        # ... inference code ...
        span.set_attribute("prompt.length", len(prompt))
        span.set_attribute("tokens.generated", 512)
    return response

Jaeger UI: Flame graph show inference span chiếm 85% total time. Theo Uber Engineering Blog on OTEL, giảm MTTR (mean time to resolution) từ 2h xuống 15p.

Drift Detection: Phát Hiện Model/Data Drift

Drift là khi input distribution thay đổi (data drift) hoặc semantic shift (concept drift). Với LLM, input prompt drift -> output quality drop.

Phương pháp:
– Statistical Drift: KS-test (Kolmogorov-Smirnov) trên embedding vectors.
– Embedding Drift: Monitor cosine similarity giữa input embeddings và baseline.

Dùng Evidently 0.4.15 – open-source ML observability.

Code sample: Drift detector với SentenceTransformers.

import numpy as np
from evidently.report import Report
from evidently.metric_preset import DataDriftPreset
from sentence_transformers import SentenceTransformer
import joblib

model = SentenceTransformer('all-MiniLM-L6-v2')
reference_data = joblib.load('baseline_embeddings.pkl')  # 10k samples

def detect_drift(current_prompts: list):
    current_emb = model.encode(current_prompts)
    report = Report(metrics=[DataDriftPreset()])
    report.run(reference_data=reference_data, current_data=current_emb)

    drift_score = report.as_dict()['metrics'][0]['result']['dataset_drift']  # 0-1 score
    if drift_score > 0.2:  # Threshold empirical
        print(f"🚨 Drift detected: {drift_score:.2f}")
    return drift_score

Use Case kỹ thuật 3: Big Data 50GB logs, prompt drift sau update app (user query dài hơn 20%). Drift score nhảy 0.35 -> latency +25% vì context overflow.

GitHub Stars: Evidently 4.2k, battle-tested bởi Meta (xem Meta AI Blog on Model Monitoring).

Alerting on Hallucination Spikes: Detect và Notify

Hallucination khó detect tự động. Proxy:
– ROUGE Score vs ground truth (nếu có).
– Semantic Similarity với fact-checked output.
– Confidence Score từ LLM (logprobs).

Spike >10% trong 5p -> alert Slack/PagerDuty.

Code sample: Prometheus AlertRule + custom hallucination metric.

# prometheus.yml
groups:
- name: llm_hallucination
  rules:
  - alert: HallucinationSpike
    expr: rate(llm_hallucination_rate[5m]) > 0.1
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "Hallucination >10% on {{ $labels.instance }}"

Python metric cho hallucination (giả sử dùng RAG với fact check):

from rouge_score import rouge_scorer
scorer = rouge_scorer.RougeScorer(['rougeL'], use_stemmer=True)

def compute_hallucination(response: str, facts: str):
    score = scorer.score(facts, response)['rougeL'].fmeasure
    return 1 - score  # 0=good, 1=hallucinate

# Trong endpoint
hallucination_rate = Counter('llm_hallucination_rate')
hallucination_rate.inc(compute_hallucination(output, ground_truth))

⚠️ Warning: Threshold 10% dựa trên StackOverflow Survey 2024 – 62% dev report hallucination là top pain LLM production.

Bảng So Sánh: Monitoring Stacks cho LLM Services

Prometheus thắng free tier, 10k RPS không lag. Datadog nếu budget >$1k/tháng (theo Netflix blog, họ mix cả hai).

Triển Khai Production: Scale & Best Practices

Use Case kỹ thuật 4: 100k queries/giờ, multi-region. Dùng Thanos cho Prometheus HA, query federated latency <100ms.

Best Practice: Log structured JSON với structlog Python. Trace sample rate 10% production (tránh overhead 5%).

Overhead OTEL <2% CPU (Uber benchmark). Alert fatigue? Dùng anomaly detection với Grafana Mimir.

Key Takeaways

1. Metrics first: P95 latency <250ms, RPS/GPU >2k – baseline cho LLM scale.
2. Tracing + Drift: OTEL + Evidently giảm blind spot 80%.
3. Alert hallucination: Proxy metrics như ROUGE, threshold 10% – proactive fix.

Anh em đã từng spike hallucination production chưa? Drift detect kiểu gì? Comment share kinh nghiệm đi.

Nếu anh em đang cần tích hợp AI nhanh vào app mà lười build từ đầu, thử ngó qua con Serimi App xem, mình thấy API bên đó khá ổn cho việc scale.