OpenTelemetry vs Prometheus (OTel vs Prometheus): ¿complementarios o rivales?

OpenTelemetry vs Prometheus: señales, recopilación, temporalidad y nomenclatura comparadas, y cuatro arquitecturas que combinan ambos con Dynatrace.
OpenTelemetry vs Prometheus (OTel vs Prometheus) : complémentaires ou concurrents ?

En muchos equipos, el debate vuelve en cada revisión de arquitectura: ¿hay que migrar de Prometheus a OpenTelemetry, o al revés? Planteada así, la cuestión OpenTelemetry vs Prometheus (OTel vs Prometheus) mezcla dos herramientas que no tienen el mismo papel. Prometheus recopila, almacena y consulta métricas; OpenTelemetry estandariza la producción y el transporte de la telemetría, sin almacenar nada.

Este artículo compara ambos en los puntos que importan en operación (modelo de recopilación, señales, temporalidad, nomenclatura), muestra dónde coinciden y propone cuatro arquitecturas que los combinan, con exportación a Dynatrace SaaS o Dynatrace Managed. Las diferencias entre las dos plataformas de Dynatrace se señalan a lo largo del texto.

Para la integración práctica de Prometheus en un clúster monitorizado por Dynatrace, consulta también Prometheus y Dynatrace en Kubernetes.

Dos proyectos, dos ámbitos

Prometheus es una caja de herramientas de monitorización y alertas. Hace scraping (en pull) de endpoints HTTP que exponen métricas, las almacena en su base de datos de series temporales, las consulta con PromQL y dispara alertas mediante Alertmanager. Su dominio son las métricas.

OpenTelemetry ofrece API, SDK, agentes de instrumentación, un protocolo (OTLP) y un Collector para producir y encaminar trazas, métricas y logs. Como recuerda su documentación, OpenTelemetry no es un backend de observabilidad: hace falta un almacenamiento detrás, que puede ser Prometheus, Dynatrace u otra herramienta.

Por tanto, solo se solapan en un segmento: la recopilación y el transporte de métricas.

OpenTelemetry vs Prometheus: la comparativa punto por punto

Criterio Prometheus OpenTelemetry
Señales Métricas Trazas, métricas, logs
Modelo de recopilación Pull: el servidor hace scraping de los destinos Push por OTLP desde los SDK; el Collector también sabe hacer scraping
Almacenamiento y consultas TSDB integrada, PromQL Ninguno: delegado en el backend
Temporalidad de los contadores Cumulative por defecto Delta o cumulative, a elegir
Contexto de recurso Labels del destino (job, instance) Atributos de recurso (service.name, k8s.pod.name…)
Nomenclatura Guiones bajos y sufijos de unidad Puntos, convenciones semánticas

La temporalidad es el punto más traicionero. Un contador de Prometheus solo aumenta: el valor expuesto es un total acumulado desde el arranque del proceso, y es la función rate() la que obtiene de él un caudal en el momento de la consulta.

Dynatrace, en cambio, espera métricas OTLP en delta: su documentación indica que un contador acumulativo no se ingiere, como tampoco un histograma acumulativo. El detalle está en la temporalidad de las métricas OTLP.

Dónde coinciden

Prometheus como backend de OpenTelemetry

Prometheus acepta OTLP sobre HTTP, pero el receptor está desactivado por defecto, igual que el receptor remote write, porque Prometheus puede funcionar sin autenticación. Se activa con un flag:

prometheus --web.enable-otlp-receiver

Las métricas llegan entonces a /api/v1/otlp/v1/metrics. En la aplicación:

export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://localhost:9090/api/v1/otlp
export OTEL_TRACES_EXPORTER=none
export OTEL_LOGS_EXPORTER=none

La guía de Prometheus recomienda además promover ciertos atributos de recurso a labels (promote_resource_attributes: service.name, k8s.namespace.name…); los demás acaban en la métrica especial target_info, que hay que unir en el momento de la consulta. Los deltas OTLP siguen siendo una función experimental (flag otlp-deltatocumulative).

El Collector de OpenTelemetry como scraper de Prometheus

El receiver prometheus del Collector reutiliza la sintaxis scrape_configs de Prometheus. Tus exporters existentes (node exporter, exporters de bases de datos) no tienen que cambiar. El repositorio de la distribución de Dynatrace del Collector (licencia Apache 2.0) ofrece un ejemplo completo:

Archivo prometheus.yaml del repositorio dynatrace-otel-collector: receiver prometheus con dos scrape_configs, processors metric_start_time y cumulative_to_delta, exporter otlp_http hacia Dynatrace

Las dos líneas clave: metric_start_time establece la hora de inicio de las series acumulativas y después cumulative_to_delta las convierte a delta antes de exportar a Dynatrace. En Kubernetes, el OpenTelemetry Operator añade el Target Allocator, que reparte los destinos de scraping entre varios Collectors y sabe descubrir los recursos ServiceMonitor y PodMonitor del ecosistema Prometheus.

¿Dynatrace vs Prometheus? El caso de Dynatrace: ActiveGate o Collector

Dynatrace ofrece una integración histórica con Prometheus: el ActiveGate, dentro del clúster, hace scraping de los pods anotados con metrics.dynatrace.com/scrape. Está documentada en Dynatrace Classic, con límites estrictos: 1000 pods exporters, 1000 métricas por pod y 500 000 puntos de datos por pod. Para los despliegues nuevos, y para cualquier instalación cercana a esos límites, la documentación de Dynatrace recomienda ahora hacer el scraping con el OpenTelemetry Collector, desplegado con un Target Allocator, que puede reutilizar tus anotaciones existentes.

En esta integración, un contador de Prometheus se convierte en una métrica de tipo COUNT en delta en Dynatrace, y un gauge sigue siendo un GAUGE. Las métricas info, stateset, gaugehistogram y los exemplars no los ingiere la integración del ActiveGate.

Cuatro arquitecturas que combinan ambos

  1. Prometheus conserva las métricas, OpenTelemetry aporta las trazas. Lo más habitual: Grafana y PromQL se quedan, y los SDK de OpenTelemetry envían las trazas a un backend de trazas. Único defecto: dos fuentes de verdad que correlacionar.
  2. Prometheus como almacenamiento de las métricas de OpenTelemetry. Las aplicaciones envían por OTLP a Prometheus. Piensa en la promoción de los atributos de recurso; si no, las consultas se convierten en joins sobre target_info.
  3. El Collector hace scraping de los exporters y lo envía todo a Dynatrace. Una sola plataforma para trazas, métricas y logs, conservando los exporters existentes. Es la opción que recomienda Dynatrace para Prometheus a gran escala.
  4. Doble exportación durante una migración. El Collector envía las mismas métricas a Prometheus y a Dynatrace mientras comparas dashboards y alertas. La comparativa de SLO entre ambos mundos está en SLO con Dynatrace, Grafana y Prometheus.

Cómo comprobar que funciona

  1. En el Collector, comprueba que el scraping tiene éxito:
    kubectl -n observability logs deploy/otel-gateway | grep -iE "scrape|error|refused"
  2. En Prometheus (arquitectura 2), consulta la API para verificar que ha llegado una métrica OTLP:
    curl -s 'http://localhost:9090/api/v1/query?query=target_info' | head -c 400
  3. En Dynatrace SaaS, abre un Notebook y representa la métrica esperada:
    timeseries avg(<nom-de-la-metrique>), by: {k8s.namespace.name}

    ¿Falta un contador aunque el gauge vecino llega? Falta el processor cumulative_to_delta en el pipeline.

  4. En Managed, busca la métrica en Data Explorer y comprueba sus dimensiones.

Buenas prácticas

  • No migres los exporters: un exporter de Prometheus funciona igual de bien detrás de un Collector.
  • Fija service.name y service.instance.id en todas partes: es lo que permite relacionar una métrica de Prometheus con una traza.
  • Elige la temporalidad según el backend: cumulative para Prometheus, delta para Dynatrace, y convierte en el Collector en lugar de en cada aplicación.
  • Vigila la cardinalidad: cada atributo promovido a label multiplica las series, tanto en Prometheus como en Dynatrace.
  • Documenta quién alerta: Alertmanager o Dynatrace, no ambos sobre la misma condición, para evitar dobles avisos de guardia.

Preguntas frecuentes

OpenMetrics vs OpenTelemetry: ¿qué diferencia hay?

OpenMetrics es una especificación que retoma y amplía el formato de exposición de Prometheus de forma casi totalmente retrocompatible; el proyecto está ahora alojado en Prometheus. Describe cómo un destino expone sus métricas para el scraping. OpenTelemetry cubre trazas, métricas y logs, con su propio protocolo, OTLP. El receiver prometheus del Collector tiende el puente entre ambos.

¿Va a sustituir OpenTelemetry a Prometheus?

No: OpenTelemetry no almacena ni consulta datos. Puede sustituir las bibliotecas cliente y el transporte, pero sigue haciendo falta un backend, que puede seguir siendo Prometheus.

¿Hay que reinstrumentar una aplicación que ya expone /metrics?

No para las métricas: el receiver prometheus del Collector las recoge tal cual. La instrumentación de OpenTelemetry resulta útil cuando quieres también trazas, como en OpenTelemetry de extremo a extremo con Dynatrace.

¿Por qué no aparecen mis contadores de Prometheus en Dynatrace mediante OTLP?

Llegan con temporalidad cumulative, que la API OTLP de Dynatrace no ingiere. Añade cumulative_to_delta (y metric_start_time) en el pipeline del Collector.

Conclusión

El duelo OpenTelemetry vs Prometheus es en realidad un reparto de papeles: OpenTelemetry estandariza la producción y el transporte de las tres señales, y Prometheus sigue siendo un excelente motor de métricas. Conserva tus exporters, coloca un Collector en el medio y elige el backend según tus necesidades de correlación. Así reduces el número de agentes que mantener y el tiempo dedicado a cruzar señales durante un incidente.

span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC. Dynatrace es una marca de Dynatrace LLC. Comprueba siempre los valores (puertos, versiones, tamaños) en la documentación oficial correspondiente a tu versión.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
OpenTelemetry Collector Contrib : quels composants choisir pour la production

OpenTelemetry Collector Contrib: qué componentes elegir para producción

Next Post
OpenTelemetry Operator Kubernetes : Collector et auto-instrumentation pas à pas

OpenTelemetry Operator Kubernetes: Collector y autoinstrumentación paso a paso

Related Posts