DEV Community

LeoJulieta
LeoJulieta

Posted on

Monitorea LLMs en producción con OpenObserve: guía paso a paso

#observabilidad #ia #llm #espanol

Observabilidad de LLMs en producción con OpenObserve: guía práctica y scripts listos para usar (2026)

Introducción

Los modelos de lenguaje grande (LLM) ya no son un experimento de laboratorio; están detrás de los chats de atención al cliente, los asistentes de código y los sistemas de recomendación de miles de empresas. ¿El problema? Cuando un LLM se comporta mal – sesgo inesperado, latencia excesiva o costes descontrolados – el daño se siente al instante.

En esta guía verás paso a paso cómo instrumentar cualquier endpoint de LLM con OpenTelemetry y OpenObserve, exportar métricas a Grafana/Prometheus y depurar en tiempo real sin tocar la lógica de negocio. Todo con ejemplos de código, comandos listos para copiar y una checklist de compliance.

1. Observabilidad vs. monitorización: la diferencia clave

Concepto Qué mide Qué permite inferir
Monitorización Métricas estáticas (CPU, RAM, latencia, error rate). Si el número supera el umbral, el servicio está “roto”.
Observabilidad Traces, logs estructurados y métricas personalizadas generadas por el propio modelo. Permite reconstruir el estado interno del LLM (prompt, tokens, decisiones) y descubrir la causa raíz sin reproducir el error.

2. Comparativa rápida de plataformas (2026)

Plataforma Integración OpenTelemetry Soporte LLMs UI de traces Export a Grafana/Prometheus Precio (USD/mes)
OpenObserve ✔️ (SDK oficial) ✅ (ChatGPT, Claude, Llama 2, custom) UI web + API ✔️ (exporter nativo) $0 – $199 (según retención)
LangChain‑Trace ✔️ (middleware) ✅ (solo LangChain) Minimalista ❌ (requiere Prometheus) $49
Arize AI ✔️ (auto‑instrumentación) ✅ (todos) Dashboard avanzado ✔️ (via webhook) $299
Evidently AI ✔️ (SDK) ❌ (solo modelos tabulares) Simple ✔️ (Prometheus) $0 – $99

Conclusión: OpenObserve ofrece la mejor relación costo‑beneficio para equipos que usan varios frameworks y quieren una solución “out‑of‑the‑box”.

3. Preparando el entorno 

# 1. Instala OpenTelemetry SDK y el exporter de OpenObserve
pip install opentelemetry-sdk opentelemetry-instrumentation \
            opentelemetry-exporter-openobserve

# 2. Inicia OpenObserve (Docker) – versión 2.5.1
docker run -d --name openobserve \
  -p 5080:5080 -p 4317:4317 \
  -e OPENOBSERVE_API_KEY=YOUR_API_KEY \
  -e OPENOBSERVE_RETENTION_DAYS=30 \
  otel/openobserve:2.5.1
Enter fullscreen mode Exit fullscreen mode

Tip: Usa la variable OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317 para que cualquier aplicación instrumentada envíe datos directamente a OpenObserve.

4. Instrumentando un endpoint de LLM (FastAPI + OpenAI) 

# app.py
from fastapi import FastAPI, Request
from opentelemetry import trace
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
from opentelemetry.instrumentation.openai import OpenAIInstrumentor
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter

app = FastAPI()

# 1️⃣ Configuración del tracer
resource = Resource(attributes={"service.name": "llm‑api"})
provider = TracerProvider(resource=resource)
processor = BatchSpanProcessor(OTLPSpanExporter())
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

# 2️⃣ Instrumentación automática
FastAPIInstrumentor().instrument_app(app)
OpenAIInstrumentor().instrument()

@app.post("/chat")
async def chat(request: Request):
    body = await request.json()
    prompt = body.get("prompt", "")
    # Llamada a OpenAI (o cualquier otro proveedor)
    response = await openai.ChatCompletion.acreate(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.7,
    )
    return {"answer": response.choices[0].message.content}
Enter fullscreen mode Exit fullscreen mode

Qué se está registrando automáticamente

Dato Uso práctico
trace_id / span_id Correlacionar una petición con sus logs y métricas.
prompt (scrubbed) Analizar sesgos o palabras prohibidas.
tokens_in, tokens_out Calcular coste por request.
latency_ms Detectar cuellos de botella en tiempo real.

5. Exportando métricas a Grafana/Prometheus 

# prometheus.yml (añade el job openobserve)
scrape_configs:
  - job_name: 'openobserve'
    static_configs:
      - targets: ['localhost:5080']
    metrics_path: '/metrics'
    scheme: 'http'
Enter fullscreen mode Exit fullscreen mode 
# Reinicia Prometheus
docker exec prometheus kill -HUP 1
Enter fullscreen mode Exit fullscreen mode

En Grafana crea un dashboard con estas queries básicas:

# Latencia media de los endpoints LLM
avg_over_time(http_server_duration_seconds_sum{service="llm-api"}[5m])
/
avg_over_time(http_server_duration_seconds_count{service="llm-api"}[5m])

# Tokens procesados por minuto
rate(openobserve_tokens_total[1m])
Enter fullscreen mode Exit fullscreen mode

6. Depuración en vivo (debugging)

  1. Busca el trace problemático en la UI de OpenObserve → Traces → filtra por status_code = 500 o error = true.
  2. Abre el span y revisa los atributos prompt, response_time_ms y error_message.
  3. Reproduce la petición usando el trace_id como header X-Trace-Id para que el nuevo request se agregue al mismo trace. 
curl -X POST http://localhost:8000/chat \
  -H "Content-Type: application/json" \
  -H "X-Trace-Id: 0a1b2c3d4e5f" \
  -d '{"prompt":"¿Cuál es el precio del oro hoy?"}'
Enter fullscreen mode Exit fullscreen mode

7. Checklist de compliance y seguridad

  • [ ] Anonimización: activa scrubbing en OpenObserve (scrub_fields = ["prompt", "user_id"]).
  • [ ] Retención: configura OPENOBSERVE_RETENTION_DAYS (máximo 90 días para GDPR).
  • [ ] Cifrado en reposo: usa bucket S3 con SSE‑KMS y habilita encryption_at_rest = true.
  • [ ] Control de accesos: define roles viewer, operator, admin en OpenObserve IAM.
  • [ ] Auditoría: exporta logs a CloudTrail / Azure Monitor cada 24 h.

8. Mini‑infografía del flujo de datos 

Cliente → API FastAPI → OpenTelemetry SDK → OTLP (gRPC) → OpenObserve
          │                                   │
          └─> OpenAI/Claude/Llama2 ←─────────┘
          │
          └─> Métricas (latencia, tokens) → Prometheus → Grafana
Enter fullscreen mode Exit fullscreen mode

(Puedes descargar la versión PNG en el repositorio del artículo.)

9. Preguntas frecuentes

Pregunta Respuesta
¿Necesito cambiar mi código de inferencia para usar OpenObserve? No. Sólo añades el wrapper de OpenTelemetry (como en el ejemplo) y el resto del código sigue igual.
¿Cómo garantizo que los datos cumplen GDPR? Usa la capa de scrubbing de OpenObserve, establece una retención corta y almacena los logs en un bucket cifrado con KMS.
¿Puedo combinar OpenObserve con herramientas de A/B testing? Sí. Añade un atributo experiment_id a cada span y filtra en la UI para comparar versiones.
¿Qué pasa si mi endpoint recibe 10 000 RPS? OpenObserve escala horizontalmente; basta con añadir más réplicas del contenedor (docker compose scale openobserve=3).
¿Hay límite de métricas personalizadas? No, pero se recomienda no crear más de 50 métricas por servicio para evitar sobrecarga de almacenamiento.

10. Recursos

Herramienta mencionada: Groq Cloud

Top comments (0)