Monitorizar collector OpenTelemetry: su telemetría interna en Dynatrace (SaaS y Managed)

Monitorizar collector OpenTelemetry: expón su telemetría interna, envíala a Dynatrace y alerta sobre rechazos, cola de envío y exportaciones fallidas.
Superviser collector OpenTelemetry : sa télémétrie interne dans Dynatrace (SaaS et Managed)

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-contrib o la distribución de Dynatrace). Este tutorial supone una versión 0.100 o superior; la sintaxis de service.telemetry ha 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.com en SaaS, o https://{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_spans y otelcol_receiver_refused_spans: lo que entra y lo que se rechaza (equivalentes _metric_points y _log_records);
  • otelcol_exporter_sent_spans y otelcol_exporter_send_failed_spans: lo que sale y lo que falla;
  • otelcol_exporter_queue_size y otelcol_exporter_queue_capacity: el llenado de la cola de envío;
  • otelcol_process_memory_rss y otelcol_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:

  1. Fallos de exportación: send_failed mayor que cero durante 10 minutos. Es una pérdida de datos real.
  2. Cola casi llena: queue_size / queue_capacity por encima del 80 % durante 10 minutos. El collector pronto rechazará datos.
  3. Rechazos en la entrada: refused_spans al alza, a menudo señal de que el memory_limiter protege 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/self dedicado evita que un error en tus métricas de negocio oculte la salud del collector.
  • Etiqueta cada instancia: añade service.instance.id y el nombre del clúster con el processor resource, para saber qué collector sufre.
  • Dimensiona la cola: ajusta sending_queue y retry_on_failure en el exporter y comprueba después la proporción de llenado bajo carga.
  • No pases a detailed en todas partes: ese nivel aumenta el volumen de series. Mantenlo donde aporte diagnóstico.
  • Duplica el control: la sonda health_check detecta 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.

Total
0
Shares
Leave a Reply

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

Previous Post
Attributs OpenTelemetry Dynatrace : service.name, enrichissement et allow-list

Atributos OpenTelemetry Dynatrace: service.name, enriquecimiento y allow-list

Next Post
Site Reliability Guardian : valider une release automatiquement sur vos SLO (Dynatrace SaaS)

Site Reliability Guardian: valida una release automáticamente con tus SLO (Dynatrace SaaS)

Related Posts