Tu collector de OpenTelemetry transporta todas tus trazas, métricas y logs. Si se satura, rechaza datos o deja de poder exportar, pierdes visibilidad sin el menor mensaje de error en las aplicaciones. Monitorizar collector OpenTelemetry es, por tanto, proteger el pipeline que alimenta tus SLO, tus alertas y tus análisis de incidentes.
Objetivo de este tutorial: activar la telemetría interna del collector, enviarla a Dynatrace y poner tres controles sencillos sobre los rechazos, los fallos de exportación y la cola de envío. El contenido sirve para Dynatrace SaaS (métricas en Grail, consultas DQL) y para Dynatrace Managed (ingesta OTLP mediante ActiveGate, explorador de datos y eventos de métrica clásicos). Las diferencias se señalan en cada paso.
Si tu collector aún no envía datos a Dynatrace, empieza por la guía de configuración del collector de OpenTelemetry para Dynatrace.
El problema: un pipeline ciego consigo mismo
Un collector que falla al exportar no genera un incidente visible. Los spans desaparecen, las gráficas muestran un valle y el equipo de guardia busca una avería de aplicación que no existe. Resultado: un MTTR que se alarga y unos SLO calculados con datos incompletos. La buena noticia: el collector ya expone sus propias métricas. Basta con recopilarlas.
Requisitos previos
- Un collector de OpenTelemetry reciente (distribución
otelcol-contribo la distribución de Dynatrace). Este tutorial supone una versión 0.100 o superior; la sintaxis deservice.telemetryha evolucionado, revisa el changelog de tu versión. - Un token de API de Dynatrace con el scope
metrics.ingest(ingesta de métricas OTLP). - La URL de tu entorno:
https://{environment-id}.live.dynatrace.comen SaaS, ohttps://{activegate}:9999/e/{environment-id}en Managed.
Paso 1: exponer la telemetría interna del collector
El bloque service.telemetry controla la telemetría del propio collector. Lo más robusto es exponer las métricas en formato Prometheus en local y leerlas de nuevo con el receiver de Prometheus. Así siguen el mismo pipeline que tus demás métricas.
service:
telemetry:
logs:
level: info
metrics:
level: detailed # basic, normal ou detailed
readers:
- pull:
exporter:
prometheus:
host: 0.0.0.0
port: 8888
Líneas críticas: level: detailed añade métricas útiles sobre las colas y los lotes; el reader pull publica las métricas en :8888/metrics. En versiones más antiguas, el equivalente era address: 0.0.0.0:8888 bajo metrics.
Paso 2: leer esas métricas y enviarlas a Dynatrace
Añade un receiver de Prometheus que consulte el puerto 8888 y un pipeline dedicado. Dynatrace espera métricas OTLP con temporalidad delta: el processor cumulativetodelta convierte los contadores de Prometheus, que son acumulativos. Este punto se detalla en el artículo sobre la temporalidad de las métricas OTLP.
receivers:
prometheus/self:
config:
scrape_configs:
- job_name: otelcol-self
scrape_interval: 30s
static_configs:
- targets: ["127.0.0.1:8888"]
processors:
cumulativetodelta: {}
batch: {}
exporters:
otlphttp/dynatrace:
endpoint: https://{environment-id}.live.dynatrace.com/api/v2/otlp
headers:
Authorization: "Api-Token ${env:DT_API_TOKEN}"
service:
pipelines:
metrics/self:
receivers: [prometheus/self]
processors: [cumulativetodelta, batch]
exporters: [otlphttp/dynatrace]
En Managed, sustituye el endpoint por https://{activegate}:9999/e/{environment-id}/api/v2/otlp. El token se queda en una variable de entorno, nunca en el archivo.
Una trampa clásica: si el exporter hacia Dynatrace cae, las métricas internas caen con él. Mantén además un control externo, por ejemplo la extensión health_check sondeada por Kubernetes.
extensions:
health_check:
endpoint: 0.0.0.0:13133
service:
extensions: [health_check]
Paso 3: identificar las métricas que importan
El collector publica decenas de series. Para el equipo de guardia bastan cuatro familias:
otelcol_receiver_accepted_spansyotelcol_receiver_refused_spans: lo que entra y lo que se rechaza (equivalentes_metric_pointsy_log_records);otelcol_exporter_sent_spansyotelcol_exporter_send_failed_spans: lo que sale y lo que falla;otelcol_exporter_queue_sizeyotelcol_exporter_queue_capacity: el llenado de la cola de envío;otelcol_process_memory_rssyotelcol_process_cpu_seconds: la salud del proceso.
Cuidado con los nombres: según la versión y el paso por Prometheus, los contadores suelen llevar el sufijo _total (por ejemplo otelcol_exporter_send_failed_spans_total). Comprueba los nombres exactos en /metrics antes de escribir tus consultas.
Cómo comprobar que funciona
Empieza en local, en la máquina o el pod del collector:
curl -s http://127.0.0.1:8888/metrics | grep -E "otelcol_exporter_(sent|send_failed)_spans"
curl -s http://127.0.0.1:13133/
Debes ver contadores distintos de cero y una respuesta de salud. Después, en Dynatrace SaaS, abre un Notebook y ejecuta:
timeseries failed = sum(otelcol_exporter_send_failed_spans_total),
sent = sum(otelcol_exporter_sent_spans_total),
by: { exporter },
interval: 5m
Si la consulta no devuelve nada, busca el nombre real de la métrica con fetch dt.metrics | filter contains(metric.key, "otelcol"); la disponibilidad de este comando depende de tu entorno, consulta la documentación de DQL. En Managed, abre el explorador de datos y escribe otelcol en el selector de métricas.
Paso 4: alertar sobre las señales adecuadas
Tres alertas cubren lo esencial, sin ruido:
- Fallos de exportación:
send_failedmayor que cero durante 10 minutos. Es una pérdida de datos real. - Cola casi llena:
queue_size / queue_capacitypor encima del 80 % durante 10 minutos. El collector pronto rechazará datos. - Rechazos en la entrada:
refused_spansal alza, a menudo señal de que elmemory_limiterprotege el proceso.
En SaaS, crea estas alertas con Davis Anomaly Detection a partir de una consulta DQL, por ejemplo:
timeseries q = max(otelcol_exporter_queue_size), cap = max(otelcol_exporter_queue_capacity),
by: { exporter }, interval: 1m
| fieldsAdd ratio = q[] / cap[] * 100
En Managed, crea un evento de métrica (Settings, Anomaly detection, Metric events) sobre la métrica ingerida, con un umbral estático. Enruta después estas alertas como las demás, mediante un perfil de alertas o un Workflow, según el método descrito para las alertas de burn rate.
Buenas prácticas para monitorizar collector OpenTelemetry
- Aísla el pipeline interno: un pipeline
metrics/selfdedicado evita que un error en tus métricas de negocio oculte la salud del collector. - Etiqueta cada instancia: añade
service.instance.idy el nombre del clúster con el processorresource, para saber qué collector sufre. - Dimensiona la cola: ajusta
sending_queueyretry_on_failureen el exporter y comprueba después la proporción de llenado bajo carga. - No pases a
detaileden todas partes: ese nivel aumenta el volumen de series. Mantenlo donde aporte diagnóstico. - Duplica el control: la sonda
health_checkdetecta un collector caído, algo que sus propias métricas no pueden hacer.
En Kubernetes, los mismos ajustes se aplican mediante los valores de Helm: consulta el despliegue del collector de OpenTelemetry en Kubernetes. Y si faltan trazas aunque el collector esté sano, sigue la checklist de trazas de OpenTelemetry ausentes.
Preguntas frecuentes
¿Puede el collector enviar su telemetría interna directamente por OTLP?
Sí, las versiones recientes aceptan un reader periodic con un exporter OTLP en service.telemetry.metrics. La sintaxis sigue cambiando de una versión a otra; el método Prometheus descrito aquí es más estable. Revisa la documentación de tu versión en opentelemetry.io.
¿Se facturan estas métricas?
Sí, son métricas personalizadas ingeridas como las demás. El volumen sigue siendo bajo si mantienes un intervalo de 30 segundos y el nivel normal fuera de los diagnósticos.
¿Cambia algo la distribución de Dynatrace del collector?
El principio es el mismo: service.telemetry forma parte del núcleo del collector. Solo comprueba que los componentes usados aquí (receiver de Prometheus, processor cumulativetodelta) están incluidos en la distribución elegida.
Conclusión
Un collector sin monitorizar es un punto de fallo silencioso. Con un pipeline interno dedicado, cuatro familias de métricas y tres alertas, sabes en pocos minutos si una pérdida de datos viene del collector o de la aplicación. Son menos falsas pistas durante un incidente y unos SLO calculados con datos fiables.
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.