Agentic Observability: Giám Sát OpenTelemetry & Chi Phí LLM

📖 Bản tiếng Anh (English Edition)

Điều kiện tiên quyết: Nắm vững các chỉ số đo lường hiệu năng suy luận và hạ tầng phục vụ vLLM từ Phần 8 — Inference Optimization: vLLM & PagedAttention.

Answer-first: Hệ thống Multi-Agent hộp đen gây khó khăn cho việc truy vết lỗi lập luận, đo độ trễ gọi công cụ và kiểm soát chi phí token. Ứng dụng chuẩn OpenTelemetry GenAI Semantic Conventions giúp trực quan hóa cây span phân cấp, giám sát độ trễ TTFT và phân bổ chi phí người dùng theo thời gian thực.

Cuộc Khủng Hoảng Khả Năng Quan Sát Trong Hệ Thống AI Tự Hành

Khả năng quan sát microservices truyền thống dựa trên 3 trụ cột cơ bản:

1. Metrics: Bộ đếm, thước đo và đồ thị phân vị đo lường tải CPU, bão hòa bộ nhớ RAM và thông lượng xử lý yêu cầu.
2. Logs: Các dòng văn bản có cấu trúc ghi lại sự kiện ứng dụng và dấu vết lỗi (stack traces).
3. Traces: Truy vết phân tán lan truyền các định danh nguyên nhân qua các cuộc gọi HTTP/gRPC tất định.

Khi triển khai các cụm bầy đàn đa tác nhân (Multi-Agent Swarms) vào môi trường sản xuất, các mô hình quan sát kinh điển này hoàn toàn sụp đổ. Quy trình của AI Agent mang bản chất phi tất định, có trạng thái và mang tính đệ quy. Một câu hỏi duy nhất của người dùng không tạo ra một chuỗi gọi hàm tuyến tính đơn giản; thay vào đó, nó mở ra một hành trình duyệt đồ thị nhiều bước:

Yêu Cầu Người Dùng ---> Điều Phối Viên (Tư Duy)
                               |
                               +---> Agent Con A (Tìm Kiếm Vector) ---> Độ trễ: 18ms
                               |
                               +---> Agent Con B (Truy Vấn SQL)    ---> Độ trễ: 84ms
                               |
                               +---> Vòng Lặp Phản Tư (Gọi LLM)   ---> Phát hiện mâu thuẫn!
                               |          |
                               |          +---> Agent Con C (Cào Web) ---> Độ trễ: 320ms
                               |
                               +---> Tổng Hợp Cuối Cùng (Gọi LLM)  ---> Phát sinh phản hồi

Nếu không có hệ thống truy vết phân tán chuẩn hóa, việc tìm hiểu lý do tại sao một tác vụ của Agent mất tới 12 giây thay vì 1.5 giây, hoặc tại sao một yêu cầu tiêu tốn tới $4.80 qua 45.000 tokens đệ quy sẽ trở thành cơn ác mộng bất khả thi đối với đội ngũ vận hành.

Kiến Trúc Đường Ống Truy Vết Chuẩn OpenTelemetry

Ngành công nghiệp đã thống nhất chọn OpenTelemetry (OTel)—chuẩn mã nguồn mở trung lập của tổ chức CNCF—làm nền tảng thu thập dữ liệu viễn trắc xuyên suốt các framework agent, máy chủ phục vụ mô hình và cơ sở dữ liệu.

sequenceDiagram
    autonumber
    actor Client as "Ứng Dụng Doanh Nghiệp"
    participant Gateway as "Cổng API Gateway (Envoy / Kong)"
    participant Orchestrator as "Runtime Điều Phối Supervisor"
    participant Worker as "Agent Con Chuyên Trách"
    participant VectorDB as "Cụm Vector Qdrant"
    participant LLM as "Cụm Phục Vụ vLLM"
    participant OTel as "OpenTelemetry Collector"
    participant Jaeger as "Jaeger / Grafana Tempo"

    Client->>Gateway: POST /v1/chat/completions (Đính kèm W3C traceparent)
    Gateway->>Orchestrator: Chuyển tiếp HTTP với Ngữ Cảnh Trace
    activate Orchestrator
    Note over Orchestrator: Bắt đầu Span Gốc: `agent.workflow`
    
    Orchestrator->>Worker: Giao tác vụ con bất đồng bộ qua Kafka / gRPC
    activate Worker
    Note over Worker: Span Con: `subagent.execution`
    
    Worker->>VectorDB: Truy vấn vector embedding (Span: `db.vector.search`)
    VectorDB-->>Worker: Trả về top-5 đoạn văn bản liên quan (12ms)
    
    Worker->>LLM: Gửi yêu cầu sinh suy luận (Span: `gen_ai.client.completion`)
    LLM-->>Worker: Trả về luồng token (TTFT: 95ms)
    Worker-->>Orchestrator: Gửi lại dữ liệu quan sát tác vụ con
    deactivate Worker

    Orchestrator-->>Gateway: Trả về kết quả tổng hợp cuối cùng
    Gateway-->>Client: Stream phản hồi đã xác thực (Tổng: 480ms)
    deactivate Orchestrator

    par Xuất Viễn Trắc Bất Đồng Bộ Không Gây Chặn
        Gateway-->>OTel: Xuất Span Gateway Cổng Vào
        Orchestrator-->>OTel: Xuất Span Tư Duy Agent
        Worker-->>OTel: Xuất Span Thực Thi Công Cụ
        LLM-->>OTel: Xuất Span Lượng Token & Chi Phí
        OTel->>Jaeger: Nạp đồ thị vết & đánh giá ngưỡng SLA
    end

Cơ Chế Xuất Dữ Liệu Viễn Trắc Không Gây Nghẽn (Non-Blocking Export)

Việc ghi nhận vết truy vết tuyệt đối không được làm ảnh hưởng đến độ trễ trả lời người dùng. SDK OpenTelemetry sử dụng bộ đệm vòng không khóa (Lock-free Ring Buffer) để tách rời việc tạo span khỏi quá trình truyền tải qua mạng. Các span được xếp hàng trong bộ nhớ và đẩy theo từng đợt (batch) qua kết nối gRPC HTTP/2 tới tiến trình nền OpenTelemetry Collector độc lập sau mỗi 500ms.

Cấu Trúc Cây Phân Cấp Spans Theo Chuẩn GenAI

Trong một cụm bầy đàn đa tác nhân, dữ liệu viễn trắc được tổ chức dưới dạng một cây phân cấp các mối quan hệ cha-con. Span gốc bao quát toàn bộ phiên giao dịch của người dùng, các span trung gian theo dõi từng vòng lặp tư duy nhận thức, và các span lá giám sát các thao tác gọi cơ sở dữ liệu vật lý và các lượt lan truyền qua nhân GPU.

graph TD
    RootSpan["Span Gốc: Cổng HTTP Ingress /agent/chat (480ms)"] --> AgentLoop["Span: Vòng Lặp ReAct Agent (440ms)"]
    
    AgentLoop --> SearchSpan["Span: db.vector.search - Qdrant (18ms)"]
    AgentLoop --> ToolSpan["Span: tool.execution - CodeSandbox (85ms)"]
    AgentLoop --> LLMSpan1["Span: gen_ai.client.completion - vLLM Draft (42ms)"]
    AgentLoop --> LLMSpan2["Span: gen_ai.client.completion - Target Model (280ms)"]

    SearchSpan -.-> OTelCollector["OTel Collector (Bộ Xử Lý GenAI Semantic)"]
    ToolSpan -.-> OTelCollector
    LLMSpan1 -.-> OTelCollector
    LLMSpan2 -.-> OTelCollector

    OTelCollector --> CostCalc["Phân Bổ Chi Phí & Cảnh Báo Ngân Sách"]
    OTelCollector --> TraceStore["Hệ Thống Lưu Trữ Jaeger / Tempo"]

Mỗi span trong cấu trúc này mang theo các định danh mật mã học và mã trạng thái chuẩn OpenTelemetry:

• Trace ID: Mã định danh 128-bit duy nhất toàn cầu được truyền xuyên suốt mọi biên giới dịch vụ.
• Span ID: Mã định danh 64-bit phân biệt đơn vị thực thi hiện tại.
• Parent Span ID: Liên kết thao tác con (như thực thi tool) trực tiếp với bước tư duy của agent đã khởi sinh ra nó.

Quy Chuẩn Ngữ Nghĩa GenAI Semantic Conventions

Nhằm ngăn chặn hiện tượng phụ thuộc vào nền tảng độc quyền, nhóm nghiên cứu OpenTelemetry đã ban hành bộ quy chuẩn GenAI Semantic Conventions. Mọi dịch vụ doanh nghiệp tương tác với LLM hay Agent đều phải tuân thủ các thuộc tính sau:

Triển Khai Go 1.25+ OpenTelemetry Instrumentor Hỗ Trợ Lan Truyền W3C

Đoạn mã Go 1.25+ chuẩn sản xuất dưới đây triển khai middleware quan sát sử dụng các thư viện chính thức của OpenTelemetry, xử lý việc trích xuất header W3C traceparent, tạo span phân cấp, đính kèm thuộc tính GenAI và tự động tính toán chi phí tài chính thời gian thực:

package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"strings"
	"sync/atomic"
	"time"

	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/codes"
	"go.opentelemetry.io/otel/propagation"
	"go.opentelemetry.io/otel/trace"
)

// LLMRequest đóng gói thông tin yêu cầu gửi tới cụm suy luận.
type LLMRequest struct {
	Model       string  `json:"model"`
	Prompt      string  `json:"prompt"`
	MaxTokens   int     `json:"max_tokens"`
	Temperature float64 `json:"temperature"`
	TenantID    string  `json:"tenant_id"`
}

// LLMResponse chứa thông tin phản hồi và số liệu viễn trắc.
type LLMResponse struct {
	Text             string  `json:"text"`
	PromptTokens     int     `json:"prompt_tokens"`
	CompletionTokens int     `json:"completion_tokens"`
	TTFTMs           float64 `json:"ttft_ms"`
}

// OTelAgentInstrumentor quản lý truy vết phân tán và hạch toán chi phí token.
type OTelAgentInstrumentor struct {
	tracer             trace.Tracer
	propagator         propagation.TextMapPropagator
	cumulativeSpendUSD uint64 // Theo dõi chi phí nguyên tử theo đơn vị micro-cent
}

func NewOTelAgentInstrumentor() *OTelAgentInstrumentor {
	return &OTelAgentInstrumentor{
		tracer:     otel.Tracer("enterprise.genai.agent"),
		propagator: propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}),
	}
}

// ExecuteAgentStep đo lường một bước lặp ReAct và gán các thuộc tính GenAI Semantic.
func (inst *OTelAgentInstrumentor) ExecuteAgentStep(
	ctx context.Context,
	stepIdx int,
	req LLMRequest,
	carrier http.Header,
) (*LLMResponse, error) {
	// Trích xuất ngữ cảnh W3C traceparent từ header HTTP/tin nhắn
	extractedCtx := inst.propagator.Extract(ctx, propagation.HeaderCarrier(carrier))

	spanName := fmt.Sprintf("gen_ai.agent.step.%d", stepIdx)
	ctx, span := inst.tracer.Start(extractedCtx, spanName,
		trace.WithSpanKind(trace.SpanKindInternal),
		trace.WithAttributes(
			attribute.String("gen_ai.system", "vllm-cluster"),
			attribute.String("gen_ai.request.model", req.Model),
			attribute.Int("gen_ai.request.max_tokens", req.MaxTokens),
			attribute.Float64("gen_ai.request.temperature", req.Temperature),
			attribute.String("app.tenant_id", req.TenantID),
			attribute.Int("gen_ai.agent.step_index", stepIdx),
		),
	)
	defer span.End()

	startTime := time.Now()

	// Thực thi gọi suy luận mô hình
	resp, err := inst.dispatchInference(ctx, req)
	if err != nil {
		span.RecordError(err)
		span.SetStatus(codes.Error, fmt.Sprintf("Gọi mô hình thất bại: %v", err))
		return nil, err
	}

	totalDurationMs := float64(time.Since(startTime).Milliseconds())

	// Hạch toán chi phí: biểu giá Llama-3-70B ($0.90/1M prompt, $2.50/1M completion)
	promptCostUSD := (float64(resp.PromptTokens) / 1_000_000.0) * 0.90
	completionCostUSD := (float64(resp.CompletionTokens) / 1_000_000.0) * 2.50
	totalStepCostUSD := promptCostUSD + completionCostUSD

	// Cập nhật tổng chi tiêu toàn cục an toàn luồng
	costMicroCents := uint64(totalStepCostUSD * 100_000_000)
	atomic.AddUint64(&inst.cumulativeSpendUSD, costMicroCents)

	// Ghi nhận các thuộc tính GenAI chuẩn OpenTelemetry lên Span
	span.SetAttributes(
		attribute.Int("gen_ai.usage.input_tokens", resp.PromptTokens),
		attribute.Int("gen_ai.usage.output_tokens", resp.CompletionTokens),
		attribute.Float64("gen_ai.response.ttft_ms", resp.TTFTMs),
		attribute.Float64("gen_ai.cost.estimated_usd", totalStepCostUSD),
		attribute.Float64("gen_ai.latency.total_ms", totalDurationMs),
	)

	span.SetStatus(codes.Ok, "Bước thực thi hoàn tất thành công")
	return resp, nil
}

func (inst *OTelAgentInstrumentor) dispatchInference(ctx context.Context, req LLMRequest) (*LLMResponse, error) {
	t0 := time.Now()
	time.Sleep(35 * time.Millisecond) // Giả lập Time-To-First-Token
	ttft := float64(time.Since(t0).Microseconds()) / 1000.0

	time.Sleep(45 * time.Millisecond) // Giả lập thời gian decode token

	words := strings.Fields(req.Prompt)
	pTokens := len(words) * 2
	if pTokens < 16 {
		pTokens = 16
	}
	cTokens := 64

	return &LLMResponse{
		Text:             "Kế hoạch có cấu trúc: 1. Nạp nguồn CDC. 2. Kiểm tra schema. 3. Cập nhật chỉ mục Iceberg.",
		PromptTokens:     pTokens,
		CompletionTokens: cTokens,
		TTFTMs:           ttft,
	}, nil
}

func main() {
	instrumentor := NewOTelAgentInstrumentor()
	carrier := make(http.Header)
	// Giả lập tiếp nhận W3C Trace Context từ API Gateway phía trước
	carrier.Set("traceparent", "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01")

	req := LLMRequest{
		Model:       "meta-llama/Meta-Llama-3.1-70B-Instruct",
		Prompt:      "Lên kế hoạch kiểm thử luồng streaming ingestion trên Apache Flink và Iceberg.",
		MaxTokens:   512,
		Temperature: 0.1,
		TenantID:    "doanh-nghiep-alpha",
	}

	ctx := context.Background()
	resp, err := instrumentor.ExecuteAgentStep(ctx, 1, req, carrier)
	if err != nil {
		log.Fatalf("Thực thi bước agent thất bại: %v", err)
	}

	totalSpend := float64(atomic.LoadUint64(&instrumentor.cumulativeSpendUSD)) / 100_000_000.0
	fmt.Printf("[Đo Lường OTel Hoàn Tất]\nKết Quả: %s\nInput Tokens: %d | Output Tokens: %d | TTFT: %.2fms\nTổng Chi Phí: $%.6f\n",
		resp.Text, resp.PromptTokens, resp.CompletionTokens, resp.TTFTMs, totalSpend)
}

Triển Khai Python 3.12+ OpenTelemetry Middleware Che Giấu PII

Module Python 3.12+ dưới đây minh họa việc tích hợp OpenTelemetry SDK với cơ chế tự động che giấu dữ liệu nhạy cảm (PII Redaction) trước khi đẩy lên bộ lưu trữ tập trung:

"""
Middleware OpenTelemetry GenAI Cho Python Với Cơ Chế Che Giấu PII Tự Động.
Yêu cầu: Python 3.12+, opentelemetry-api >= 1.25.0, opentelemetry-sdk >= 1.25.0
"""

import re
import time
from typing import Optional
from opentelemetry import trace
from opentelemetry.trace import Status, StatusCode


class OpenTelemetryAgentTracer:
    """
    Trình truy vết GenAI chuẩn hóa với chức năng làm sạch PII và tính toán chi phí token.
    """

    EMAIL_PATTERN = re.compile(r"[\w\.-]+@[\w\.-]+\.\w+")
    CREDIT_CARD_PATTERN = re.compile(r"\b(?:\d{4}[-\s]?){3}\d{4}\b")

    def __init__(self, service_name: str = "enterprise.agent.orchestrator"):
        self.tracer = trace.get_tracer(service_name)
        self.rate_per_1m_input = 0.90   # $0.90 cho mỗi 1 triệu input tokens
        self.rate_per_1m_output = 2.50  # $2.50 cho mỗi 1 triệu output tokens

    def sanitize_text(self, text: str) -> str:
        """Che giấu thông tin định danh cá nhân (PII) trước khi xuất telemetry."""
        text = self.EMAIL_PATTERN.sub("[REDACTED_EMAIL]", text)
        text = self.CREDIT_CARD_PATTERN.sub("[REDACTED_CARD]", text)
        return text

    def calculate_cost(self, input_tokens: int, output_tokens: int) -> float:
        input_cost = (input_tokens / 1_000_000.0) * self.rate_per_1m_input
        output_cost = (output_tokens / 1_000_000.0) * self.rate_per_1m_output
        return input_cost + output_cost

    def trace_agent_execution(
        self,
        parent_context: Optional[trace.Context],
        agent_name: str,
        goal: str,
        tenant_id: str,
    ):
        """
        Khởi tạo span gốc cho tiến trình Agent tuân thủ chuẩn GenAI Semantic Conventions.
        """
        clean_goal = self.sanitize_text(goal)
        span = self.tracer.start_span(
            name=f"agent.execution.{agent_name}",
            context=parent_context,
            attributes={
                "gen_ai.system": "multi-agent-orchestrator",
                "gen_ai.agent.name": agent_name,
                "app.tenant_id": tenant_id,
                "gen_ai.prompt.sanitized": clean_goal,
            },
        )
        return span

    def trace_tool_invocation(self, tool_name: str, args_payload: str):
        """
        Tạo span con ghi nhận độ trễ thực thi công cụ và tham số đã làm sạch.
        """
        clean_args = self.sanitize_text(args_payload)
        return self.tracer.start_span(
            name=f"tool.execution.{tool_name}",
            attributes={
                "gen_ai.agent.tool_name": tool_name,
                "tool.arguments.sanitized": clean_args,
            },
        )


def main():
    tracer = OpenTelemetryAgentTracer()
    tenant = "tenant_enterprise_99"
    sensitive_goal = "Xử lý thanh toán thẻ cho khách hàng john.doe@corp.com với số thẻ 4532-1100-2299-8812."

    # 1. Khởi động Span Gốc cho Agent
    root_span = tracer.trace_agent_execution(None, "FinancialAuditor", sensitive_goal, tenant)
    with trace.use_span(root_span, end_on_exit=True):
        print("[Tracer Hoạt Động] Span gốc đã khởi tạo với các thuộc tính đã làm sạch PII.")

        # 2. Khởi động Span Con cho Thao Tác Gọi Tool
        tool_span = tracer.trace_tool_invocation("validate_sap_ledger", "{'user': 'john.doe@corp.com'}")
        with trace.use_span(tool_span, end_on_exit=True):
            time.sleep(0.04)  # Giả lập I/O gọi công cụ
            tool_span.set_attribute("tool.status", "SUCCESS")
            tool_span.set_status(Status(StatusCode.OK))

        # 3. Ghi nhận số lượng Token và Chi phí lên Span Gốc
        cost = tracer.calculate_cost(input_tokens=1850, output_tokens=320)
        root_span.set_attributes({
            "gen_ai.usage.input_tokens": 1850,
            "gen_ai.usage.output_tokens": 320,
            "gen_ai.cost.estimated_usd": cost,
            "gen_ai.response.ttft_ms": 115.4,
        })
        root_span.set_status(Status(StatusCode.OK))

    print(f"[Trace Hoàn Tất] Chi phí bước thực thi: ${cost:.6f}")


if __name__ == "__main__":
    main()

Ma Trận So Sánh Các Chiến Lược Giám Sát Observability

Lan Truyền Ngữ Cảnh Qua Hàng Đợi Tin Nhắn Bất Đồng Bộ (W3C Traceparent)

Trong các hệ thống phân tán, các agent con thường trao đổi thông tin qua hàng đợi sự kiện (Apache Kafka, RabbitMQ hoặc Redis Streams). Ngữ cảnh truy vết không được phép đứt đoạn khi bản tin được đẩy vào topic:

+-------------------------------------------------------------------------------+
|               LAN TRUYỀN W3C TRACEPARENT QUA MESSAGE BROKER KAFKA             |
+-------------------------------------------------------------------------------+
| [ Agent Điều Phối Chính ]                                                     |
|   |--- Bắt đầu Span: `agent.plan_step`                                        |
|   |--- Tiêm Ngữ Cảnh vào Header Bản Tin Kafka:                                |
|          Key: "traceparent"                                                   |
|          Val: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"       |
|                               |                                               |
|                               v                                               |
|                    [ Kafka Topic: agent.subtasks ]                            |
|                               |                                               |
|                               v                                               |
| [ Worker Agent Con Bất Đồng Bộ ]                                              |
|   |--- Đọc Header `traceparent` từ bản tin Kafka                              |
|   |--- Trích xuất ngữ cảnh qua OpenTelemetry Propagator                       |
|   |--- Bắt đầu Span Con: `subagent.execute_tool` (Parent = 00f067aa0ba902b7)  |
|   |--- Đồ thị vết được liên kết hoàn chỉnh 100% xuyên suốt các ranh giới!     |
+-------------------------------------------------------------------------------+

Định dạng W3C tiêu chuẩn gồm 4 thành phần (version-trace_id-parent_id-trace_flags) bảo đảm các giao diện hiển thị như Jaeger hay Tempo tái cấu trúc chính xác cây phả hệ tác vụ bất kể độ trễ xếp hàng tin nhắn.

Các Bất Biến Vận Hành Trong Môi Trường Sản Xuất

+-------------------------------------------------------------------------------+
|                  DANH MỤC BẤT BIẾN VẬN HÀNH KHẢ NĂNG QUAN SÁT                 |
+-------------------------------------------------------------------------------+
| [1] Lan Truyền W3C Bắt Buộc: Tiêm header qua mọi điểm chạm HTTP/gRPC/Kafka.   |
| [2] Xuất Dữ Liệu Bất Đồng Bộ: Xếp hàng qua bộ đệm vòng không khóa (< 0.5ms).  |
| [3] Làm Sạch PII Tại Cổng Vào: Xóa email, thẻ tín dụng trước khi lưu vết.     |
| [4] Phân Bổ Chi Phí Tức Thời: Tính toán chi phí USD trực tiếp theo số token.  |
| [5] Rào Chắn Ngân Sách Tenant: Kích hoạt cảnh báo khi tốc độ chi tiêu vượt quota.|
| [6] Nghiêm Ngặt Quy Chuẩn: Tuân thủ 100% định dạng GenAI OTel Conventions.    |
+-------------------------------------------------------------------------------+

Câu Hỏi Thường Gặp (FAQ)

Các Bước Tiếp Theo Trong Chuỗi Bài Viết

• Hoàn tất chuỗi bài viết với Phần 10 — Production Evals & CI/CD Guardrails: LLM-as-a-Judge Trong Quy Trình CI/CD.
• Xem lại Phần 8 — Tối Ưu Hóa Suy Luận: vLLM & PagedAttention về hạ tầng phục vụ GPU.
• Xem lại Tóm Tắt Điều Hành: Khai Tử RAG Thô Sơ để nắm bắt bức tranh toàn cảnh kiến trúc.