Configurar el colector OpenTelemetry Dynatrace: trazas, métricas y logs con OTLP/HTTP

Colector OpenTelemetry Dynatrace: configuración YAML completa, token y scopes, OTLP/HTTP, delta, Docker y verificación con DQL, para SaaS y Managed.
Configurer le collector OpenTelemetry Dynatrace : traces, métriques et logs en OTLP/HTTP

Tus servicios ya emiten trazas, métricas y logs de OpenTelemetry, pero cada uno los envía a su manera. El colector OpenTelemetry Dynatrace pone orden: un único punto de salida, un único token y una única configuración que revisar cuando haya un incidente.

Para un SRE, lo que está en juego es concreto. Una exportación mal configurada significa spans perdidos, SLI falsos y un MTTR más largo el día que hay que entender una caída. Centralizar la exportación en un Collector reduce el toil: se cambia un endpoint o un token en un solo lugar.

Este tutorial sirve para Dynatrace SaaS y Dynatrace Managed. Las diferencias (endpoint, ActiveGate, consultas) se señalan en cada paso.

Objetivo y requisitos previos

Al terminar, tendrás un Collector funcionando en Docker, que recibe OTLP de tus aplicaciones y envía trazas, métricas y logs a Dynatrace por OTLP/HTTP. También sabrás comprobar que los datos llegan.

  • Un entorno de Dynatrace SaaS, o un clúster Managed con un ActiveGate de entorno;
  • Docker instalado en la máquina que alojará el Collector;
  • una aplicación ya instrumentada con un SDK de OpenTelemetry (consulta OpenTelemetry de extremo a extremo con Dynatrace);
  • un token de API con los scopes de ingesta descritos en el paso 2.

Configurar el colector OpenTelemetry Dynatrace, paso a paso

Paso 1: elegir una distribución

Hay dos opciones razonables:

  • Collector contrib (otel/opentelemetry-collector-contrib): la distribución comunitaria, muy completa, con todos los componentes;
  • Dynatrace distribution (ghcr.io/dynatrace/dynatrace-otel-collector/dynatrace-otel-collector): una selección de componentes probados y con soporte de Dynatrace, entre ellos los que se usan aquí.

Si quieres soporte del fabricante, elige la distribución de Dynatrace. Si necesitas un componente poco habitual, elige contrib. En ambos casos, fija una versión concreta de la imagen: un Collector que cambia de versión por sí solo es una fuente de incidentes.

Paso 2: crear el token de API

En Dynatrace, abre Access tokens y crea un token dedicado al Collector con estos scopes:

  • openTelemetryTrace.ingest para las trazas;
  • metrics.ingest para las métricas;
  • logs.ingest para los logs.

Un token por Collector y nada más que esos scopes. Si hay una fuga, revocas un solo token sin cortar los demás flujos.

Paso 3: localizar el endpoint OTLP

La API OTLP de Dynatrace solo acepta OTLP/HTTP (protobuf). El Collector añade por sí mismo /v1/traces, /v1/metrics y /v1/logs a la base:

# Dynatrace SaaS
https://{env-id}.live.dynatrace.com/api/v2/otlp

# Dynatrace Managed (via ActiveGate d'environnement)
https://{activegate-host}:9999/e/{env-id}/api/v2/otlp

En Managed, la ruta /e/{env-id}/ designa el entorno. Comprueba el puerto y el dominio exactos de tu ActiveGate en la documentación de la API OTLP de Dynatrace.

Paso 4: escribir otel-collector-config.yaml

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

processors:
  memory_limiter:
    check_interval: 1s
    limit_percentage: 75
    spike_limit_percentage: 15
  resource:
    attributes:
      - key: deployment.environment
        value: production
        action: upsert
  cumulativetodelta: {}
  batch:
    send_batch_size: 1000
    timeout: 5s

exporters:
  otlphttp:
    endpoint: ${env:DT_ENDPOINT}
    headers:
      Authorization: "Api-Token ${env:DT_API_TOKEN}"
  debug:
    verbosity: basic

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [memory_limiter, resource, batch]
      exporters: [otlphttp]
    metrics:
      receivers: [otlp]
      processors: [memory_limiter, resource, cumulativetodelta, batch]
      exporters: [otlphttp]
    logs:
      receivers: [otlp]
      processors: [memory_limiter, resource, batch]
      exporters: [otlphttp]

Las líneas críticas:

  • receiver otlp: tus aplicaciones pueden hablar con el Collector por gRPC (4317) o HTTP (4318). Solo la salida hacia Dynatrace tiene que ser HTTP;
  • memory_limiter el primero: rechaza datos antes de que el Collector sea eliminado por falta de memoria;
  • resource: añade un atributo común, útil para filtrar por entorno en tus consultas;
  • batch el último: agrupa los envíos y limita el número de peticiones;
  • Authorization: el valor empieza por Api-Token seguido de un espacio y después el token. El token procede de una variable de entorno, nunca del archivo.

Paso 5: gestionar la temporalidad de las métricas

Dynatrace espera métricas OTLP con temporalidad delta. Muchos SDK y receivers producen por defecto temporalidad acumulativa. Hay dos soluciones: configurar el SDK en delta, o dejar que el procesador cumulativetodelta convierta dentro del Collector, como en el pipeline metrics de arriba. Este procesador guarda un estado en memoria: con varias réplicas, procura que una misma serie llegue siempre al mismo Collector. Para los histogramas, consulta también métricas e histogramas con OpenPipeline.

Paso 6: desplegar con Docker

export DT_ENDPOINT="https://{env-id}.live.dynatrace.com/api/v2/otlp"
export DT_API_TOKEN="dt0c01.XXXX"   # ne pas committer

docker run -d --name otel-collector \
  -p 4317:4317 -p 4318:4318 \
  -e DT_ENDPOINT -e DT_API_TOKEN \
  -v "$(pwd)/otel-collector-config.yaml:/etc/otelcol/config.yaml" \
  ghcr.io/dynatrace/dynatrace-otel-collector/dynatrace-otel-collector:<version> \
  --config=/etc/otelcol/config.yaml

Después, apunta tus aplicaciones al Collector, por ejemplo con OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4318.

Kubernetes: el mismo archivo se convierte en un ConfigMap y el token en un Secret inyectado como variable de entorno. El chart de Helm del proyecto OpenTelemetry o el Dynatrace Operator permiten desplegar el Collector; elige un Deployment para la pasarela central y un DaemonSet para una recogida por nodo. Recuerda la restricción de cumulativetodelta si tienes varias réplicas.

Cómo comprobar que funciona

  1. Logs del Collector: docker logs -f otel-collector. Al arrancar, debes ver «Everything is ready». Un error de exportación muestra el código HTTP devuelto por Dynatrace.
  2. Exporter debug: añade temporalmente debug a los exporters de un pipeline. El Collector escribirá entonces en sus logs lo que recibe. Si no aparece nada, el problema está en la aplicación, no en Dynatrace.
  3. DQL en un Notebook (SaaS):
fetch spans, from: now() - 15m
| filter deployment.environment == "production"
| summarize spans = count(), by: {service.name}
| sort spans desc

El principio es el mismo para los logs con fetch logs. En Managed, sin Grail, abre mejor la vista de trazas distribuidas y filtra por el nombre del servicio. Para profundizar en DQL y en los datos OTLP en SaaS, consulta el módulo 8 de la ruta de SaaS.

Managed y SaaS: qué cambia

Punto Dynatrace SaaS Dynatrace Managed
Endpoint {env-id}.live.dynatrace.com/api/v2/otlp ActiveGate o dominio del clúster + /e/{env-id}/api/v2/otlp
Certificado público a menudo interno: añade la CA al Collector
Análisis Grail, DQL, Notebooks vistas clásicas (trazas distribuidas, explorador de datos)

Resolución de problemas

Síntoma Causa probable Solución
401 Unauthorized token ausente, mal formado o revocado comprobar el prefijo Api-Token y la variable de entorno
403 Forbidden falta un scope añadir al token el scope de la señal afectada
404 Not Found ruta incorrecta base /api/v2/otlp sin /v1/...; /e/{env-id} en Managed
Fallo con el exporter otlp Dynatrace no admite gRPC usar otlphttp
Métricas ausentes o rechazadas temporalidad acumulativa añadir cumulativetodelta o pasar el SDK a delta

Buenas prácticas

  • Un token por Collector, solo con scopes de ingesta, guardado en un secreto.
  • Siempre memory_limiter al principio y batch al final del pipeline.
  • Fijar la versión de la imagen y actualizarla de forma deliberada.
  • Monitorizar el propio Collector: una exportación que falla en silencio falsea tus SLO.
  • Quitar el exporter debug cuando termine la verificación.

Preguntas frecuentes

¿Hace falta un Collector si OneAgent ya está instalado?

No necesariamente. OneAgent puede capturar datos de OpenTelemetry en los hosts que monitoriza. El Collector resulta útil sin OneAgent, para centralizar varias fuentes o para filtrar y enriquecer antes del envío.

¿Puedo enviar por gRPC a Dynatrace?

No, la API OTLP de Dynatrace espera OTLP/HTTP. Tus aplicaciones pueden hablar gRPC con el Collector; es él quien exporta por HTTP.

¿Contrib o la distribución de Dynatrace?

La distribución de Dynatrace cubre los casos habituales con soporte del fabricante. Contrib ofrece más componentes, sin ese soporte. La configuración que se presenta aquí funciona con ambas.

Conclusión

Un Collector bien configurado es una cadena de exportación legible: un endpoint, un token, tres pipelines. Ganas un único punto de control para la telemetría y, con él, diagnósticos más rápidos cuando un SLO se degrada. Empieza por las trazas, verifica en un Notebook y después añade métricas y logs.

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
Module 8 : OpenTelemetry/IA, des traces OTLP aux agents MCP

Módulo 8: OpenTelemetry e IA, de las trazas OTLP a los agentes MCP

Next Post
Alertes burn rate SLO dans Dynatrace : le tutoriel multi-fenêtres (SaaS et Managed)

Alertas burn rate SLO en Dynatrace: el tutorial multiventana (SaaS y Managed)

Related Posts