ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Đánh giá & Quan sát hệ thống AI

AI Builder

Quan sát hệ thống AI — Trace, Log, Metric cho LLM app

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Đưa hệ thống LLM ra production cần quan sát được từng bước: distributed tracing đa tầng (retrieval + LLM + tool), metric p50/p95, structured logs có PII-safe redaction, và cảnh báo khi drift. Khung observability AI-native khác biệt với APM truyền thống như thế nào.

lesson120 minĐánh giá & Quan sát hệ thống AIAI Engineer

Dự đoán

Production LLM app của bạn đang chậm. Dashboard APM (DataDog) cho thấy 'POST /chat p95 = 8s'. Bạn làm gì tiếp theo?

APM truyền thống chỉ thấy lớp HTTP bên ngoài: một request = 8s. Bên trong là 5-10 span (embed, vector search, rerank, LLM, tool). Nếu chưa biết rerank chiếm 3s hay LLM decode 5s thì mọi giả thuyết về scale/cache/rollback đều là đoán mò. Bước đầu tiên luôn là cài đặt observability AI-native, không phải tối ưu mù quáng.

Khoảnh khắc aha

Một request LLM nhìn bên ngoài là POST /chat = 4.5s, nhưng bên trong là một distributed system tí hon: router, embed, vector DB, reranker, LLM, tool — mỗi thứ có latency, cost, model version, và prompt riêng. APM truyền thống chỉ thấy lớp ngoài cùng; muốn debug thật sự bạn cần AI-native observability — tracing biết về token, prompt, tool call, và TTFT, không chỉ HTTP status.

Bốn lưu ý quan trọng

Thử thách 1

Dashboard cho thấy /chat p95 = 6.5s (vượt SLO 5s) nhưng kênh support không có phàn nàn và CSAT tuần này thậm chí còn tăng. Bạn giải thích và hành động ra sao?

p95 aggregate che mất cohort. Một tính năng 'deep research' trả sau 15s nhưng user vui vẻ chấp nhận có thể kéo p95 tổng mà không ảnh hưởng UX. Observability tốt phải slice theo intent, route, user tier — không chỉ dashboard tổng. SLO chia theo cohort là practice production trưởng thành.

Thử thách 2

Wall-clock trace của một request = 4.5s, nhưng tổng duration cộng lại của 8 span = 6.2s. Vì sao không khớp — và điều này gợi ý gì?

Waterfall là công cụ trực quan cho chính điều này: nhìn ngang để thấy parallel (span chồng lên nhau) hoặc gap (khoảng trắng giữa hai span nối tiếp). Nếu sum > wall-clock → tốt, có parallel. Nếu sum < wall-clock → có thời gian không được bọc span (thường là queue trong message bus, TLS handshake, cold start) — đó là nơi cần instrument thêm.

Ba trụ cột và p95

Observability (khả năng quan sát) là khả năng suy luận về trạng thái bên trong hệ thống chỉ từ tín hiệu bên ngoài mà nó phát ra. Khác với monitoring (biết trước bạn sẽ đo gì), observability để bạn đặt câu hỏi mới sau khi hệ thống đã chạy. Với LLM app — nơi hành vi phi tất định, phụ thuộc prompt, phụ thuộc phiên bản model — observability không phải một tính năng mà là tiền đề để sống sót trong production.

Observability đứng trên ba trụ cột, mỗi cái trả lời một câu hỏi khác nhau:

  • Traces — "đường đi của MỘT request qua hệ thống". Mỗi trace là cây các span; mỗi span có start, duration, status, và attribute (key-value). Trace là tín hiệu đầu tiên cần có cho LLM app vì kiến trúc tự nhiên là nhiều bước.
  • Metrics — "hành vi TỔNG HỢP theo thời gian". Counter (requests_total), gauge (queue_depth), histogram ( latency_ms). Metric là rẻ và dùng cho dashboard + alert.
  • Logs — "event chi tiết tại một điểm". Log có structure (JSON) + correlation ID (gắn với trace_id + span_id) là log dùng được; log text tự do là log để đọc-một-lần.

Phần lớn sự cố production không giải được bằng một trụ cột đơn lẻ: metric báo p95 cao → mở trace tiêu biểu để xem span nào chậm → mở log của span đó để thấy prompt/tham số cụ thể. Ba trụ cột bổ sung, không thay thế.

Vì sao p95 quan trọng hơn mean? Phân phối latency LLM lệch phải nặng do throttling, context dài, và cold start. Mean bị che bởi đuôi. p95 (percentile thứ 95) là ngưỡng mà 5% request tệ nhất vượt qua — tức là "ngưỡng tệ nhất của trải nghiệm người dùng thông thường":

p95=inf⁡{t∣FL(t)≥0.95},FL(t)=P(L≤t)p_{95} = \inf\{t \mid F_L(t) \geq 0.95\}, \quad F_L(t) = P(L \leq t)

Với L là biến ngẫu nhiên latency. SLO chuẩn của LLM app đối diện người dùng thường viết dạng "p95 < 5s trong cửa sổ 30 ngày, đo theo intent". Không viết theo mean. Không viết không có cửa sổ.

OpenTelemetry cho GenAI

OpenTelemetry semantic conventions cho GenAI. OTel đã chuẩn hóa attribute cho LLM dưới namespace gen_ai.*. Dùng đúng semantic conventions là cách rẻ nhất để khóa chặt code instrumentation với backend — bạn có thể đổi Langfuse → Phoenix → Helicone mà không phải viết lại SDK. Các attribute cốt lõi cần biết:

  • gen_ai.system — nhà cung cấp (openai, anthropic, azure.openai...)
  • gen_ai.request.model — tên model được hỏi (claude-sonnet-4.7)
  • gen_ai.request.temperature, gen_ai.request.top_p, gen_ai.request.max_tokens
  • gen_ai.usage.input_tokens, gen_ai.usage.output_tokens — cho metric chi phí
  • gen_ai.response.finish_reason — stop / length / tool_calls
  • gen_ai.operation.name — chat / embeddings / completion

Ví dụ instrument một pipeline RAG bằng OpenTelemetry Python. Mọi span được bọc bằng tracer, context tự động truyền qua with block:

rag_pipeline.py — OTel instrumentation cho RAG

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
    BatchSpanProcessor(OTLPSpanExporter(endpoint="http://otel-collector:4318/v1/traces"))
)
tracer = trace.get_tracer("rag.pipeline")

GENAI_SYSTEM = "anthropic"
MODEL = "claude-sonnet-4.7"

def redact_pii(text: str) -> str:
    # tối giản — production dùng presidio hoặc rule engine đầy đủ
    import re
    text = re.sub(r"\b\d{9,12}\b", "<ID>", text)
    text = re.sub(r"[\w.+-]+@[\w-]+\.[\w.-]+", "<EMAIL>", text)
    return text[:2000]

def answer(query: str, tenant_id: str) -> str:
    with tracer.start_as_current_span("chat.request") as root:
        root.set_attribute("tenant.id", tenant_id)
        root.set_attribute("gen_ai.operation.name", "chat")
        root.set_attribute("user.query_preview", redact_pii(query))

        with tracer.start_as_current_span("retrieve.embed") as sp:
            sp.set_attribute("gen_ai.request.model", "text-embedding-3-small")
            vec = embed(query)
            sp.set_attribute("vector.dim", len(vec))

        with tracer.start_as_current_span("retrieve.vector_search") as sp:
            sp.set_attribute("db.system", "pgvector")
            sp.set_attribute("retrieval.top_k", 20)
            chunks = vector_search(vec, tenant_id, top_k=20)
            sp.set_attribute("retrieval.hits", len(chunks))

        with tracer.start_as_current_span("retrieve.rerank") as sp:
            sp.set_attribute("gen_ai.request.model", "cohere-rerank-v3")
            top = rerank(query, chunks, keep=5)

        with tracer.start_as_current_span("llm.generate") as sp:
            sp.set_attribute("gen_ai.system", GENAI_SYSTEM)
            sp.set_attribute("gen_ai.request.model", MODEL)
            sp.set_attribute("gen_ai.request.temperature", 0.2)
            out = llm_chat(query, context=top, model=MODEL)
            sp.set_attribute("gen_ai.usage.input_tokens", out.usage.input)
            sp.set_attribute("gen_ai.usage.output_tokens", out.usage.output)
            sp.set_attribute("gen_ai.response.finish_reason", out.finish_reason)
            sp.set_attribute("gen_ai.response.output_preview",
                             redact_pii(out.text))

        root.set_attribute("chat.status", "ok")
        return out.text

Backend observability cần một điểm thu nhận chung — thường là OTel Collector đứng giữa ứng dụng và các backend cụ thể. Cấu hình tối giản cho Langfuse + sampling:

otel-collector.yaml — sampling + Langfuse

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318
      grpc:
        endpoint: 0.0.0.0:4317

processors:
  # Tail sampling — quyết định sau khi trace xong
  tail_sampling:
    decision_wait: 10s
    num_traces: 50000
    policies:
      - name: keep-errors
        type: status_code
        status_code: { status_codes: [ERROR] }
      - name: keep-slow
        type: latency
        latency: { threshold_ms: 5000 }
      - name: sample-nominal
        type: probabilistic
        probabilistic: { sampling_percentage: 5 }

  # Chặn PII ở cạnh collector — tầng phòng thủ thứ hai
  attributes/redact:
    actions:
      - key: user.query_preview
        action: hash
      - key: gen_ai.response.output_preview
        action: hash

  batch: {}

exporters:
  otlphttp/langfuse:
    endpoint: https://cloud.langfuse.com/api/public/otel
    headers:
      Authorization: Basic ${LANGFUSE_AUTH}

  prometheus:
    endpoint: 0.0.0.0:9464

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [tail_sampling, attributes/redact, batch]
      exporters: [otlphttp/langfuse]
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [prometheus]

Sampling: head vs tail

Ở scale production, lưu 100% trace là không thực tế (chi phí storage + egress). Hai chiến lược chính:

  • Head sampling: quyết định giữ/bỏ ngay khi span đầu bắt đầu (TraceIdRatioBased sampler). Rẻ, dễ triển khai, nhưng dễ bỏ sót trace lỗi vì lỗi thường hiếm (<1%). Phù hợp cho dev và môi trường đồng nhất.
  • Tail sampling: gom toàn bộ span của trace lại, đợi một khoảng (5-30s), rồi quyết định dựa trên policy (status = ERROR, duration > p95, tenant quan trọng). Đắt về CPU/RAM nhưng luôn giữ trace lỗi và trace chậm — đúng cái cần để debug.
  • Hybrid: head sampling 1-5% trên nominal + tail sampling giữ 100% lỗi + replay golden trace. Đây là pattern phổ biến ở 1M+ req/ngày.

Công cụ: OpenTelemetry Collector có processor tail_sampling built-in; nếu tự triển khai thì cần shard theo trace_id để mọi span của cùng trace đến cùng một collector node.

Drift detection

LLM app không đứng im. Phân phối câu hỏi, ngữ cảnh, thậm chí phiên bản model — đều trôi. Hai loại drift:

  • Data drift: phân phối input thay đổi. Đo bằng PSI trên embedding của query tuần này vs baseline, alert nếu PSI > 0.25.
  • Concept drift: quan hệ input → output thay đổi. Khó hơn vì cần ground-truth; proxy khả thi là độ tương đồng output với golden trace, hoặc CSAT giảm không giải thích được.
  • Model vendor drift: provider âm thầm cập nhật snapshot model. Baseline gen_ai.response_id hoặc fingerprint đầu ra, alert khi hash shift bất thường.

Xem thêm monitoring cho các công thức PSI và KL divergence cụ thể. So sánh với mlops để hiểu vị trí của observability trong vòng lặp build-deploy-observe-retrain.

Case study minh hoạ: chatbot tư vấn sức khỏe

Case study minh hoạ: các sự kiện và con số dưới đây không phải dữ liệu thật của startup hay VNG Cloud được nêu trong bài.

Bối cảnh. Một startup y tế Việt Nam triển khai chatbot tư vấn sức khỏe trên hạ tầng VNG Cloud, tích hợp RAG với tài liệu hướng dẫn của Bộ Y tế. Sau launch, dashboard APM hiển thị p95 = 12s. SLO ban đầu viết là < 6s. User complain tăng; CSAT tụt từ 4.6 xuống 3.9 trong 2 tuần.

Đoán mò (thất bại). Team thử scale replica × 3 (không đổi), bật Redis cache trên prompt hash (hit rate 2% — prompt y tế đa dạng), đổi model từ claude-sonnet-4.7 sang haiku (CSAT tụt thêm). Ba ngày, không fix được.

Bật observability. Team cài Langfuse self-hosted (yêu cầu tuân thủ dữ liệu y tế, không ra khỏi mạng nội bộ) + OTel Collector với PII redaction trước khi lưu. Một trace waterfall cho câu hỏi "triệu chứng sốt kéo dài 3 ngày" lộ ra:

  • retrieve.vector_search = 0.4s (ổn).
  • retrieve.rerank = 4.1s (bất thường — model rerank chạy trên CPU, batch size 1).
  • llm.generate = 6.8s — và điều đáng lẽ phải bắt đầu ngay sau vector_search lại chờ xong rerank. Rerank và LLM đang chạy tuần tự.

Sửa. Hai thay đổi: (1) chuyển rerank sang GPU batch + cho chạy song song với việc gửi prompt đầu tiên tới LLM (speculative — LLM bắt đầu với top-20 chưa rerank, cập nhật khi rerank xong); (2) cache rerank theo intent. Kết quả: p95 từ 12s xuống 5.2s. CSAT hồi phục sau 10 ngày.

Bài học. Không có trace, debug latency là đoán mò — scale, cache, đổi model đều là giả thuyết không bằng chứng. Một trace tốt biến câu hỏi "vì sao chậm?" thành một đồ thị trực quan với đáp án nhìn thấy được bằng mắt thường. Với domain nhạy cảm (y tế, tài chính), self-hosted Langfuse + PII redaction là điều kiện bắt buộc, không phải tùy chọn.

Tóm tắt

  • LLM app là distributed system tí hon — một request = 5-10 span. APM HTTP truyền thống không đủ; cần AI-native observability hiểu prompt, token, model, tool.
  • Ba trụ cột: Traces (đường đi của MỘT request), Metrics (hành vi tổng hợp), Logs (event chi tiết) — mỗi cái trả lời một câu hỏi, bổ sung không thay thế.
  • p95 > mean cho LLM vì phân phối latency lệch phải; SLO production luôn viết theo p95 hoặc p99 kèm cửa sổ thời gian, thường chia theo cohort/intent.
  • OpenTelemetry semantic conventions cho GenAI (gen_ai.*) là ngôn ngữ chung — dùng đúng để swap backend (Langfuse ↔ Phoenix ↔ Helicone) không phải viết lại SDK.
  • Prompt và output chứa PII — redact ở SDK (regex, presidio) + tầng hai ở OTel Collector, kết hợp sampling và retention ngắn cho vùng chứa bản gốc.
  • Golden trace + tail sampling là cặp đôi vận hành: golden replay mỗi giờ để bắt drift sớm, tail sampling giữ 100% trace lỗi/chậm để debug khi bị pager.

Continue the module

Lesson 4 of 7