Limpia las trazas de tu LLM

Marina Camacho16 de noviembre de 2026

Qué nos enseñan los incidentes de Cursor, NEAR AI y Phala sobre la observabilidad de productos con LLM, y cómo diseñarla para que tus trazas no sean el botín.

Cualquier equipo que lleva un producto con LLM a producción acaba instrumentándolo: sin trazas no sabes por qué el agente tomó una decisión, cuánto cuesta cada usuario ni qué cambió cuando subiste de versión el prompt. Herramientas como Langfuse, LangSmith, Phoenix o cualquier backend de OpenTelemetry lo ponen muy fácil. Tan fácil que lo habitual es activar "capturar todo" el primer día y no volver a pensarlo.

El problema es lo que hay dentro de ese "todo". Un prompt contiene lo que el usuario escribió (incluida la API key que pegó para que el agente "la configure"), lo que devolvieron las herramientas (incluido el .env que el agente leyó para entender el proyecto) y lo que el modelo respondió. Las últimas semanas han dado varios ejemplos de lo que pasa cuando eso se guarda tal cual:

  • Cursor explicó el 13 de noviembre que un atacante usó una clave que había entregado a Fireworks AI, y que Fireworks expuso, para copiar un bucket con trazas de su agente de programación, la mayoría de 2025. Algunas trazas contenían credenciales sin redactar; con ellas el atacante llegó a herramientas SaaS internas y, desde ahí, a una credencial con la que publicó una copia maliciosa de la extensión de Claude Code en su marketplace [1][2].
  • NEAR AI publicó el 9 de noviembre que un atacante explotó una ejecución remota de código en SGLang, su motor de inferencia, y se llevó el historial de chat, la configuración y los logs de 18 agentes. Las API keys de dos clientes estaban en esos logs [3].
  • Phala pidió el 10 de noviembre a los usuarios cuyas peticiones a un modelo pasaron por su despliegue entre el 21 de octubre y el 8 de noviembre que rotasen cualquier secreto incluido en el contenido de esas peticiones, porque se vieron en claro durante el procesamiento [4].
  • Y en la ola de ataques a plataformas de desarrollo de IA que Wiz bautizó como "Black October", Warp informó de que el ataque a un proveedor alcanzó trazas de agentes y telemetría de en torno al 1% de sus usuarios [5][6].

Ninguno de estos incidentes empezó por las trazas. Pero en varios, las trazas fueron lo que convirtió un acceso parcial en un incidente grave. Este post va de cómo diseñar la observabilidad de un producto con LLM para que eso no ocurra.

Este es el quinto post de nuestra serie sobre buenas prácticas en productos de IA. El anterior cubría el endurecimiento del servidor de inferencia; hoy bajamos a las trazas y los logs.

1. Tres ideas que conviene tener claras

Tus trazas son una base de datos de producción. Y probablemente la más sensible que tienes: concentran, en un solo sitio y con buen índice de búsqueda, lo que tus usuarios escriben, lo que tus herramientas leen y lo que tu modelo contesta. Si tu base de datos principal tiene cifrado, control de acceso, retención y auditoría, tu backend de trazas necesita lo mismo.

Los secretos llegan por el prompt, no solo por la configuración. El equipo de seguridad suele vigilar dónde se guardan las API keys de la aplicación. Pero en un producto con LLM los secretos entran por la puerta principal: el usuario pega un token, el agente hace cat .env, una herramienta devuelve una cabecera Authorization, un error del proveedor cita la clave que recibió. El investigador que detectó el incidente de Phala lo hizo precisamente así: metiendo credenciales trampa en sus peticiones y vigilando si alguien las usaba [4].

Cada copia de una traza es una superficie de ataque nueva. La traza del incidente de Cursor no se robó del sistema principal, sino de un bucket compartido con un proveedor para entrenamiento [1]. Exportar a un SaaS de observabilidad, copiar a un dataset de evals, compartir con un proveedor de fine-tuning: cada copia hereda el riesgo y casi nunca hereda los controles.

2. Qué ha pasado, con un poco más de detalle

Cursor: de un bucket de trazas a un marketplace

Según el informe de Cursor, el bucket compartido con Fireworks contenía trazas de sesiones sin el modo de privacidad activado, que la empresa tenía permiso para usar en entrenamiento. Menos del 0,01% de los clientes tenía credenciales de API expuestas en ellas. Con esas credenciales el atacante accedió a herramientas SaaS de Cursor, de las que sacó, entre otras cosas, datos de soporte, resúmenes de conversaciones del agente y credenciales que los propios usuarios habían enviado al equipo de soporte. Con una credencial obtenida ahí publicó las versiones 2.1.312 y 2.1.313 maliciosas de la extensión de Claude Code, disponibles unas 11 horas, que pudieron llegar a hasta 5.000 usuarios [1][2].

La lección para cualquier equipo no es "no uséis proveedores", sino que una traza con un secreto dentro es un secreto almacenado, con todas sus consecuencias, aunque nadie lo haya decidido así.

NEAR AI: los logs de los agentes como botín

En NEAR AI el punto de entrada fue el servidor de inferencia (el mismo tipo de pieza que tratamos la semana pasada). Pero lo que el atacante se llevó de los 18 agentes afectados fue historial de chat, configuración y logs, y en esos logs había API keys de clientes, que la empresa revocó [3]. Si los logs hubieran registrado metadatos en lugar de contenido, o hubieran redactado las claves, el impacto habría sido menor.

Phala: lo que viaja en el prompt también es tuyo

Phala ofrece inferencia confidencial, y aun así su recomendación a los usuarios afectados fue tratar como expuesto el contenido de sus peticiones y rotar los secretos que contuvieran [4]. NEAR AI llegó a una conclusión parecida: la computación confidencial protege frente al operador y al host, no frente a un fallo en el software que corre dentro [3]. Para quien construye producto, la consecuencia es simple: si un secreto o un dato personal entra en el prompt, lo estás enviando a tu proveedor de modelo, a tu backend de trazas y a cualquiera que comprometa cualquiera de los dos.

Un patrón que se repite: los errores también son logs

No hace falta un ataque sofisticado. El 10 de noviembre se publicó un fallo en pgEdge RAG Server, corregido en la 2.0.0, por el que la API devolvía al cliente el texto de error del proveedor de LLM, que podía citar parcialmente la API key del operador [7]. Lo mismo pasa cuando se registra la excepción completa de un SDK, con la petición y sus cabeceras dentro.

3. Cómo lo montaríamos

La idea de fondo es la que OpenTelemetry resume en su guía de datos sensibles: la mejor forma de no filtrar datos sensibles es no recogerlos [8]. Todo lo demás (redacción, retención, control de acceso) son capas por si la primera falla. OWASP incluye las credenciales y los datos personales entre los ejemplos de su riesgo LLM02 (divulgación de información sensible) y recomienda limitar el acceso y redactar antes de procesar [16].

3.1 Decide qué registras: metadatos siempre, contenido por excepción

Para operar un producto con LLM, la mayor parte de las preguntas se responden sin el texto: qué modelo, qué versión del prompt, cuántos tokens, cuánto tardó, cuánto costó, por qué terminó, qué herramientas se llamaron y si fallaron. Ese es el nivel que registraríamos siempre.

Las convenciones semánticas de OpenTelemetry para IA generativa van en esa línea: atributos como gen_ai.input.messages son opt-in y la especificación avisa de que probablemente contengan información sensible y datos personales [9][10]. La instrumentación oficial de Python no captura contenido salvo que lo actives explícitamente [11]:

# Producción: solo metadatos (modelo, tokens, latencia, finish_reason...)
OTEL_SEMCONV_STABILITY_OPT_IN=gen_ai_latest_experimental
OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=NO_CONTENT

# Entorno de depuración aislado, con datos sintéticos o consentidos:
# OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=SPAN_ONLY

Cuando sí necesitas contenido (para depurar un caso, para construir evals o para revisar calidad), trátalo como una excepción con nombre y apellidos:

  • Muestreo y alcance. Un porcentaje pequeño, o solo para tenants que lo han aceptado, o solo durante una investigación concreta con fecha de fin.
  • Almacén separado. Metadatos en tu backend de trazas habitual; contenido en un almacén aparte con su propio control de acceso y retención corta. La instrumentación de OpenTelemetry para Python permite subir prompts y respuestas a un almacenamiento propio y dejar en la traza solo una referencia [11].
  • Herramientas sensibles, sin salida. Si una herramienta del agente lee ficheros, variables de entorno o respuestas de APIs internas, registra que se llamó, con qué resultado y cuántos bytes devolvió; no el contenido.

Un ejemplo de qué guardaríamos por defecto en cada llamada:

{
  "trace_id": "4bf92f3577b34da6a3ce929d0e0e4736",
  "tenant_id_hash": "t_9f2c...",
  "gen_ai.request.model": "modelo-x-2026-10",
  "prompt.version": "soporte-v14@3a7e1c2",
  "gen_ai.usage.input_tokens": 1834,
  "gen_ai.usage.output_tokens": 212,
  "latency_ms": 2140,
  "gen_ai.response.finish_reasons": ["stop"],
  "tools": [{"name": "buscar_pedido", "status": "ok", "output_bytes": 812}],
  "redaction": {"secrets": 1, "pii": 2}
}

Fíjate en el último campo: contar cuántos secretos y datos personales se han redactado es una métrica valiosa. Si un día se dispara, alguien está pegando credenciales en tu producto o una herramienta está devolviendo más de la cuenta.

3.2 Redacta antes de que salga del proceso

Si capturas contenido, redáctalo en la aplicación, antes de exportarlo. Redactar en el backend de observabilidad significa que el dato ya ha viajado y se ha guardado, aunque sea un instante.

Un redactor mínimo para secretos y algunos datos personales habituales en España:

import re

# Formatos conocidos de credenciales. Amplía con los de tus proveedores.
SECRET_PATTERNS = [
    ("openai_key",     re.compile(r"\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}")),
    ("anthropic_key",  re.compile(r"\bsk-ant-[A-Za-z0-9_-]{20,}")),
    ("aws_access_key", re.compile(r"\b(?:AKIA|ASIA)[0-9A-Z]{16}\b")),
    ("github_token",   re.compile(r"\bgh[pousr]_[A-Za-z0-9]{36,}\b")),
    ("jwt",            re.compile(r"\beyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+")),
    ("bearer",         re.compile(r"(?i)\bbearer\s+[A-Za-z0-9._~+/=-]{16,}")),
    ("private_key",    re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]+?-----END [A-Z ]*PRIVATE KEY-----")),
    ("assignment",     re.compile(r"(?i)\b(api[_-]?key|secret|token|password|passwd)\b\s*[:=]\s*['\"]?[^\s'\"]{8,}")),
]

PII_PATTERNS = [
    ("email",  re.compile(r"\b[\w.+-]+@[\w-]+\.[\w.-]+\b")),
    ("dni",    re.compile(r"\b\d{8}[A-HJ-NP-TV-Z]\b")),
    ("nie",    re.compile(r"\b[XYZ]\d{7}[A-HJ-NP-TV-Z]\b")),
    ("iban",   re.compile(r"\b[A-Z]{2}\d{2}(?:[ ]?[A-Z0-9]{4}){4,7}\b")),
    ("phone",  re.compile(r"(?<!\d)(?:\+34[ ]?)?[6789]\d{2}[ ]?\d{3}[ ]?\d{3}(?!\d)")),
]

def redact(text: str) -> tuple[str, dict[str, int]]:
    counts: dict[str, int] = {}
    for kind, pattern in SECRET_PATTERNS + PII_PATTERNS:
        text, n = pattern.subn(f"[REDACTED:{kind}]", text)
        if n:
            counts[kind] = counts.get(kind, 0) + n
    return text, counts

Y cómo engancharlo en el exportador. Con Langfuse, por ejemplo, el SDK de Python permite modificar los atributos de cada span justo antes de exportarlo con mask_otel_spans [12]:

from langfuse import Langfuse
from langfuse.types import MaskOtelSpansParams, MaskOtelSpansResult, OtelSpanPatch

def mask_otel_spans(*, params: MaskOtelSpansParams) -> MaskOtelSpansResult | None:
    patches = {}
    for span_id, span in params.spans.items():
        changes, total = {}, 0
        for key, value in span.attributes.items():
            if isinstance(value, str):
                clean, counts = redact(value)
                if clean != value:
                    changes[key] = clean
                    total += sum(counts.values())
        if changes:
            changes["redaction.count"] = total
            patches[span_id] = OtelSpanPatch(set_attributes=changes)
    return MaskOtelSpansResult(span_patches=patches) if patches else None

langfuse = Langfuse(mask_otel_spans=mask_otel_spans)

Dos detalles que la documentación de Langfuse deja claros y que conviene no pasar por alto: si la función lanza una excepción, se descarta el lote entero (falla cerrado, que es lo que quieres), y el hook solo afecta a lo que exporta ese cliente; si mandas las mismas trazas a otro backend, ese recibe su copia sin redactar [12].

Como segunda capa, centralizada para todos los servicios, el procesador redaction del OpenTelemetry Collector funciona con lista blanca: los atributos que no estén en allowed_keys se eliminan antes de mirar sus valores [13]:

processors:
  redaction/genai:
    allow_all_keys: false          # falla cerrado: lo que no está aquí, se borra
    allowed_keys:
      - gen_ai.operation.name
      - gen_ai.provider.name
      - gen_ai.request.model
      - gen_ai.response.model
      - gen_ai.response.finish_reasons
      - gen_ai.usage.input_tokens
      - gen_ai.usage.output_tokens
      - prompt.version
      - tenant_id_hash
      - redaction.count
    blocked_key_patterns:
      - ".*(token|secret|password|api_key|authorization).*"
    blocked_values:
      - "sk-[A-Za-z0-9_-]{20,}"
      - "(AKIA|ASIA)[0-9A-Z]{16}"
      - "eyJ[A-Za-z0-9_-]+\\.eyJ[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+"
    summary: info                   # no listar qué claves se borraron

Tres advertencias honestas sobre la redacción:

  1. Las expresiones regulares no lo detectan todo. Un secreto sin formato conocido, una dirección postal o un diagnóstico médico en texto libre pasan sin problema. Para datos personales en texto libre hay herramientas como Microsoft Presidio, que combinan patrones y modelos de NLP [14], pero tampoco son perfectas. La redacción es una capa, no la defensa.
  2. Hashear no es anonimizar. OpenTelemetry lo advierte: el hash de un identificador se puede revertir si el espacio de valores es pequeño y predecible [8]. Para identificadores de usuario, usa un HMAC con una clave que no esté en el backend de trazas.
  3. Prueba el redactor como cualquier otro código. Un test con un corpus de secretos y datos personales falsos que debe salir limpio, ejecutado en CI. Si alguien cambia la instrumentación y empieza a exportar un atributo nuevo, el test debería romper.

3.3 Los errores, sin contenido

El caso de pgEdge es un recordatorio útil [7]. Tres reglas sencillas:

  • Al cliente, un error genérico y un identificador. Nunca el texto del error del proveedor de LLM: puede citar la clave, el prompt o detalles de la configuración. El detalle va al log interno, redactado.
  • Nada de cabeceras ni cuerpos completos en los logs de excepciones. Muchos SDK incluyen la petición en la excepción; captura el tipo de error, el código de estado y el identificador de petición del proveedor, y descarta el resto.
  • Cuidado con los "modos debug". Los logs de nivel DEBUG de SDK y gateways suelen volcar peticiones enteras. Que estén desactivados en producción debería comprobarse en el despliegue, no confiarse a la memoria de nadie.

3.4 Guarda poco tiempo y deja ver a pocos

Con lo que decidas guardar:

  • Retención por niveles. Nuestra referencia de partida: metadatos durante el tiempo que necesites para operar y facturar; contenido, días o pocas semanas, salvo los casos que pasen a un dataset curado. Herramientas como Langfuse permiten configurar la retención para que el borrado sea automático y no dependa de que alguien se acuerde [12]. El plazo exacto depende de tu caso y de tu análisis legal, pero "para siempre por si acaso" no es un plazo.
  • Acceso mínimo y auditado. Ver el contenido de las trazas debería ser un permiso distinto de ver métricas, con registro de quién consultó qué. La mayoría del equipo necesita dashboards, no conversaciones.
  • Datasets de evals y entrenamiento, por un circuito aparte. Si quieres usar trazas reales para evaluar o entrenar, que pasen por un pipeline explícito: selección, redacción, revisión y un almacén con su propio control de acceso. Nunca una copia en bruto del backend de trazas.
  • Lo que compartes con proveedores, con fecha de caducidad. El incidente de Cursor empezó por una clave de larga duración entregada a un tercero para acceder a un bucket [1]. Credenciales temporales, acceso al mínimo de datos necesario y revocación al terminar.

3.5 Conoce a quién le llegan los prompts

Haz el inventario: proveedor de modelo, gateway, backend de observabilidad, herramienta de evals, proveedor de fine-tuning. Para cada uno, qué ve (metadatos o contenido), cuánto lo guarda, si lo usa para entrenar y en qué región está. A efectos de protección de datos, muchos serán encargados del tratamiento, y deberían figurar como tales.

Y hacia el usuario, el mismo mensaje que da Phala tras su incidente: lo que se envía en una petición puede quedar expuesto [4]. Si tu producto anima a pegar credenciales o datos sensibles en el chat, dale alternativas mejores (un gestor de secretos integrado, un formulario que no pasa por el modelo) y avisa en la interfaz.

3.6 Prepárate para la pregunta incómoda

Cuando alguien te avise de un incidente en uno de esos proveedores, la pregunta será: ¿qué secretos y qué datos personales había en lo que tenían? Si no puedes responderla, tendrás que rotarlo todo y notificar a ciegas. Para poder responder:

  • Inventario de qué se exporta y adónde, con versión, igual que las dependencias.
  • El contador de redacciones del apartado 3.1, por servicio y por destino, para saber al menos si había secretos y cuándo.
  • Credenciales trampa (canary tokens). Es la técnica que destapó el incidente de Phala [4]: incluye en peticiones de prueba periódicas credenciales falsas pero únicas, y vigila si alguien intenta usarlas. Si una aparece, sabes qué ruta se ha filtrado y desde cuándo.
  • Un procedimiento de rotación probado. La guía de la Cloud Security Alliance sobre Black October insiste en algo que se olvida a menudo: borrar una clave de la plataforma comprometida no la revoca; hay que revocarla en el proveedor que la emitió [6].

4. Y el RGPD, ¿qué dice de todo esto?

Si tus trazas contienen datos personales, y si guardan conversaciones casi seguro que sí, son un tratamiento de datos personales como cualquier otro. Varios principios del RGPD se traducen casi literalmente en decisiones de ingeniería [15]:

  • Minimización (art. 5.1.c): registrar solo lo necesario para la finalidad. "Capturar todo por si acaso" es difícil de justificar.
  • Limitación del plazo de conservación (art. 5.1.e): la retención por niveles del apartado 3.4.
  • Protección de datos desde el diseño y por defecto (art. 25): que el valor por defecto de la instrumentación sea no capturar contenido.
  • Seguridad del tratamiento (art. 32): cifrado, control de acceso y capacidad de restaurar y verificar.
  • Notificación de brechas (art. 33): si hay una violación de seguridad de datos personales, el responsable debe notificarla a la autoridad de control sin dilación indebida y, si es posible, en 72 horas. Difícil de cumplir si no sabes qué había en las trazas.

Esto no sustituye un análisis legal de tu caso, pero sí deja claro que una buena higiene de observabilidad y el cumplimiento van en la misma dirección.

Checklist: trazas y logs de LLM en producción

Qué registramos

  • [ ] Por defecto solo registramos metadatos: modelo, versión de prompt, tokens, latencia, coste, finish_reason y estado de herramientas.
  • [ ] La captura de contenido está desactivada en producción (OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=NO_CONTENT o equivalente).
  • [ ] Cuando capturamos contenido, es muestreado, acotado en el tiempo y va a un almacén separado.
  • [ ] Las herramientas que leen ficheros, variables de entorno o APIs internas no registran su salida.

Redacción

  • [ ] Redactamos secretos y datos personales en la aplicación, antes de exportar.
  • [ ] El Collector aplica una segunda capa con lista blanca de atributos.
  • [ ] Todos los exportadores pasan por la redacción, no solo el principal.
  • [ ] Un test en CI comprueba que un corpus de secretos y datos personales falsos sale limpio.
  • [ ] Medimos cuántas redacciones se hacen y alertamos si se disparan.
  • [ ] Los identificadores de usuario se pseudonimizan con HMAC, no con un hash simple.

Errores

  • [ ] El cliente recibe errores genéricos con un identificador, nunca el texto del proveedor.
  • [ ] Los logs de excepciones no incluyen cabeceras ni cuerpos de petición.
  • [ ] Los niveles DEBUG de SDK y gateways están desactivados en producción, y se comprueba en el despliegue.

Retención y acceso

  • [ ] Hay retención automática, más corta para el contenido que para los metadatos.
  • [ ] Ver contenido de trazas es un permiso separado y auditado.
  • [ ] Los datasets de evals y entrenamiento salen de un pipeline curado y redactado, no de copias en bruto.
  • [ ] Las credenciales que compartimos con proveedores son temporales y de alcance mínimo.

Terceros e incidentes

  • [ ] Tenemos inventario de quién recibe prompts y trazas, qué guarda, cuánto tiempo y dónde.
  • [ ] Hay credenciales trampa en peticiones de prueba para detectar filtraciones.
  • [ ] Sabemos revocar en origen y rotar cualquier clave en horas, y lo hemos ensayado.
  • [ ] Sabemos qué responder en 72 horas si un proveedor de observabilidad o de inferencia sufre una brecha.

Conclusión

La observabilidad es imprescindible para llevar un producto con LLM a producción con criterio: sin trazas no hay evals, ni control de costes, ni forma de entender a un agente. Pero los incidentes de este último mes muestran que, mal planteada, también es el sitio donde se acumulan las credenciales de tus usuarios y sus conversaciones, listas para quien llegue primero.

Ninguna de las medidas de este post es exótica. Registrar metadatos por defecto, redactar antes de exportar, guardar poco tiempo y saber quién ve qué son prácticas que cualquier equipo aplicaría a una base de datos de clientes. Lo que cambia con los LLM es que esa base de datos se crea sola, en cada petición, y que nadie decidió conscientemente guardar en ella una API key.

Si queréis revisar la observabilidad de vuestro producto con otra mirada (qué se está capturando, adónde va, quién puede verlo y qué pasaría si uno de vuestros proveedores sale en la próxima lista de incidentes), estaremos encantados de tener esa conversación. Sin pitch: una llamada de 30 minutos con uno de nuestros ingenieros.