# OpenTelemetry

## Qué es

OpenTelemetry es un estándar de código abierto, con bibliotecas y herramientas correspondientes, para producir trazas, métricas y registros del software en ejecución y entregarlos al sistema que los almacene y muestre. La mayoría de los ingenieros lo llaman OTel. Es un proyecto de la Cloud Native Computing Foundation, nacido al fusionarse dos iniciativas anteriores, OpenTracing y OpenCensus.

Lo más útil que conviene saber es lo que deja fuera. OpenTelemetry no es un backend de observabilidad: no conserva datos, no dibuja paneles ni envía alertas. Esa parte la hacen Jaeger, Prometheus y las plataformas comerciales. Por tanto, «¿OpenTelemetry o Prometheus?» compara un conducto con un destino, y la respuesta habitual es ambos: OpenTelemetry donde se producen los datos y un backend elegido por el equipo donde se guardan.

El proyecto consta de varias piezas que encajan entre sí:
* una especificación que define la API, el SDK y los datos para todos los lenguajes;
* OTLP, el protocolo que transporta telemetría por gRPC o HTTP, codificada con Protocol Buffers;
* convenciones semánticas, nombres compartidos para elementos compartidos, de modo que una ruta HTTP o una sentencia de base de datos tenga la misma etiqueta en Go, Java y Python;
* una API y un SDK por lenguaje, con bibliotecas de instrumentación e instrumentación automática para marcos populares;
* el Collector, un proceso separado que recibe telemetría, la procesa y la exporta hacia el siguiente destino.

De las señales que transporta, las trazas son las que más explicación necesitan. Una traza sigue una petición por todos los servicios que toca. Cada paso es un span: un nombre, una hora de inicio, una duración, un conjunto de atributos y la identidad del span que lo provocó. Cuando la petición pasa de un servicio al siguiente, esa identidad viaja con ella en una cabecera, de forma predeterminada la que define W3C Trace Context:

```text
traceparent: 00-a0892f3577b34da6a3ce929d0e0e4736-f03067aa0ba902b7-01
```

Los cuatro campos son la versión del formato, el ID de traza compartido por todos los spans de la petición, el ID del span que hace la llamada y un conjunto de indicadores, donde un `01` final marca la traza como muestreada. Las métricas y los registros completan la imagen, y una cuarta señal, baggage, lleva pequeños datos de clave y valor junto con la petición para que un servicio situado tres saltos más allá aún pueda verlos.

## Por qué importa

El almacenamiento es el coste visible de la observabilidad. El más persistente es la instrumentación: alguien tiene que añadir llamadas a cada servicio, en cada lenguaje, y mantenerlas al día conforme cambia el código. Cuando cada proveedor distribuía su propio agente y su propia API, cambiar de proveedor significaba repetir todo ese trabajo. Con OpenTelemetry, el código llama a una API, y la elección del backend pasa a la configuración, ya sea un exportador en el SDK o una ruta en el Collector. El proyecto enuncia directamente el principio: los datos que genera un sistema pertenecen a quien lo opera.

Esa propiedad tiene efectos prácticos además de contractuales. El Collector se sitúa entre las aplicaciones y el backend, lo que lo convierte en el lugar para filtrar, muestrear, renombrar o eliminar atributos antes de que salga nada y para enviar el mismo flujo a dos backends mientras se realiza una migración. Pasar de un proveedor a otro se convierte en un cambio de configuración del Collector en vez de en cien servicios.

El volumen es el coste que hay que planificar. Cada petición puede producir decenas de spans, y con tráfico real la factura de conservarlos todos puede superar la del servicio observado. El muestreador predeterminado del SDK, `ParentBased(root=AlwaysOn)`, muestrea cada traza nueva y sigue la decisión de quien llama para el resto, por lo que, tal como viene configurado, se conserva todo. Cuánto conservar es una decisión que el equipo toma deliberadamente.

La madurez varía según la señal y el lenguaje. OTLP es estable para trazas, métricas y registros, mientras que el SDK de cada lenguaje avanza a su propio ritmo, y la página de estado del proyecto indica dónde está cada uno. Léala antes de decidirse por él para un servicio escrito en un lenguaje menos habitual.

Y no siempre compensa. Una sola aplicación con registros estructurados y unas pocas métricas gana poco con el trazado distribuido. OpenTelemetry justifica su coste cuando una petición cruza límites entre procesos, pasando por un frontend, una API, una cola y una base de datos, y responder a «¿en qué se fue el tiempo?» requiere una reunión.

## Cómo se aplica en la práctica

En una plataforma, la monitorización se construyó en lugar de comprarse, y OpenTelemetry es su mitad de trazado. El trazado utiliza OTLP para seguir una petición lenta por el frontend, la API y la base de datos en lugar de hacer conjeturas. Junto a él funciona un flujo de procesamiento de errores propio, compuesto por un servicio errmon y otro de ingestión, que sanea las cargas útiles antes de almacenarlas, agrupa errores en problemas recurrentes, detecta picos y regresiones con un período de espera para que un despliegue defectuoso no envíe cuarenta avisos a la persona de guardia, resuelve los símbolos de las trazas de pila minificadas del frontend y ejecuta un latido sintético para demostrar que el propio flujo de procesamiento sigue vivo.

Los resultados llegan a la propia base de datos de la plataforma como eventos de error, grupos de errores, una bandeja de entrada, latencia de API y muestras de pilas. Los operadores trabajan con 11 vistas sobre esos datos, una de ellas dedicada a objetivos de nivel de servicio. La página es clara sobre el precio: construirlo requirió una inversión real de tiempo y añadió otro elemento que mantener, mientras que una herramienta comprada de seguimiento de errores habría estado funcionando aquella misma tarde. A cambio, los datos sensibles permanecen en la plataforma. También las reglas de alerta se escribieron para esta plataforma en vez de para una genérica.

## Dónde surgen los problemas

La traza se detiene en un límite. El contexto cruza fácilmente las llamadas HTTP porque las bibliotecas de instrumentación escriben y leen la cabecera en ambos extremos. Una cola de mensajes, una tarea programada o un proxy que elimine cabeceras desconocidas rompe la cadena salvo que alguien transporte el contexto a mano. La traza se divide en dos, y la mitad lenta parece no guardar relación con la petición que la causó. Incluya el contexto en los metadatos del mensaje y compruebe que todos los servicios ejecuten el mismo propagador.

Los atributos filtran información o se multiplican sin control. Es fácil añadir un atributo de span, y los valores más fáciles de añadir son los equivocados: correos electrónicos, URL completas con tokens en la cadena de consulta o SQL que aún contiene valores literales. En las métricas, el peligro es la cardinalidad. Un atributo con millones de valores distintos, como un ID de usuario, multiplica el número de series temporales y, con él, la factura. Siga las convenciones semánticas, mantenga los identificadores fuera de las métricas y oculte los datos sensibles en el Collector como segunda línea de defensa.

El muestreo ocurre por accidente. El muestreo al inicio decide al comienzo de una petición, antes de saber si será lenta o fallará, por lo que conservar el
1 % de las trazas también conserva aproximadamente el 1 % de las escasas trazas lentas. El muestreo al final decide después de ver juntos los spans de una traza y puede conservar todos los errores y todas las peticiones lentas, pero el componente que lo realiza debe mantener todos esos datos mientras espera. Es un servicio con estado cuya propia capacidad hay que planificar y vigilar.

Se confía ciegamente en el flujo de procesamiento. OTLP confirma la entrega salto a salto; la entrega de extremo a extremo queda fuera de su alcance. Un Collector que no dispone de memoria suficiente o se retrasa en su cola de exportación descarta telemetría, y las aplicaciones que se la envían continúan como si todo fuera bien. Vigile las propias métricas del Collector, ejecute más de uno y trate un hueco en las trazas como un fallo que explicar en lugar de como una hora tranquila.

## Lecturas adicionales
* ¿Qué es OpenTelemetry? — definición del propio proyecto, sus componentes y lo que deliberadamente no es.
* Especificación OTLP — protocolo de transmisión: transportes, codificación, compresión y confirmación de recepción.
* Trace Context — recomendación del W3C en la que se basa la cabecera `traceparent`.
* Propagación de contexto — cómo sigue una traza una petición a través de límites entre procesos.
* Convenciones semánticas — nombres compartidos para atributos, métricas y recursos.
* Muestreo — muestreo al inicio y al final, y el coste de ejecutar cada uno.

=> /es/portfolio/built-first-party-error-monitoring-and-tracing/ El trazado utiliza OTLP para seguir una petición lenta por el frontend, la API y la base de datos
=> https://opentelemetry.io/docs/what-is-opentelemetry/ ¿Qué es OpenTelemetry?
=> https://opentelemetry.io/docs/specs/otlp/ Especificación OTLP
=> https://www.w3.org/TR/trace-context/ Trace Context
=> https://opentelemetry.io/docs/concepts/context-propagation/ Propagación de contexto
=> https://opentelemetry.io/docs/concepts/semantic-conventions/ Convenciones semánticas
=> https://opentelemetry.io/docs/concepts/sampling/ Muestreo

=> https://engineer.company/es/glossary/opentelemetry/ Esta página en la web
