Configurar el OpenTelemetry Collector

Información general

El OpenTelemetry Collector te permite recopilar, procesar y exportar datos de telemetría de tus aplicaciones de una manera independiente del proveedor. Cuando se configura con el Datadog Exporter y el Datadog Connector, puedes enviar tus trazas, logs y métricas a Datadog sin necesidad del Datadog Agent.

  • Datadog Exporter: Reenvía datos de trazas, métricas y logs de los SDK de OpenTelemetry a Datadog (sin necesidad del Datadog Agent)
  • Datadog Connector: Calcula métricas de rastreo a partir de los datos de tramos recopilados
Diagrama: El SDK de OpenTelemetry en código envía datos a través de OTLP al host que ejecuta el OpenTelemetry Collector con el Datadog Exporter, que los reenvía a la plataforma de observabilidad de Datadog.
Para ver qué funciones de Datadog son compatibles con esta configuración, consulta la tabla de compatibilidad de funciones en OTel completo.

Instalar y configurar

1 - Descargar el OpenTelemetry Collector

Descarga la última versión de la distribución OpenTelemetry Collector Contrib, desde el repositorio del proyecto.

2 - Configurar el Datadog Exporter y el Datadog Connector

Para utilizar el Datadog Exporter y el Datadog Connector, defínelos en tu [configuración del [OpenTelemetry Collector4:

  1. Crea un archivo de configuración llamado collector.yaml.
  2. Utiliza el siguiente archivo de ejemplo para empezar.
  3. Configura tu clave de API Datadog como la variable de entorno DD_API_KEY.
The following examples use 0.0.0.0 as the endpoint address for convenience. This allows connections from any network interface. For enhanced security, especially in local deployments, consider using localhost instead. For more information on secure endpoint configuration, see the OpenTelemetry security documentation.
receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318
      grpc:
        endpoint: 0.0.0.0:4317
  # The hostmetrics receiver is required to get correct infrastructure metrics in Datadog.
  hostmetrics:
    collection_interval: 10s
    scrapers:
      paging:
        metrics:
          system.paging.utilization:
            enabled: true
      cpu:
        metrics:
          system.cpu.utilization:
            enabled: true
      disk:
      filesystem:
        metrics:
          system.filesystem.utilization:
            enabled: true
      load:
      memory:
      network:
      processes:
  # The prometheus receiver scrapes metrics needed for the OpenTelemetry Collector Dashboard.
  prometheus:
    config:
      scrape_configs:
      - job_name: 'otelcol'
        scrape_interval: 10s
        static_configs:
        - targets: ['0.0.0.0:8888']

  filelog:
    include_file_path: true
    poll_interval: 500ms
    include:
      - /var/log/**/*example*/*.log

processors:
  batch:
    send_batch_max_size: 100
    send_batch_size: 10
    timeout: 10s

connectors:
  datadog/connector:

exporters:
  datadog/exporter:
    api:
      site: 
      key: ${env:DD_API_KEY}

service:
  pipelines:
    metrics:
      receivers: [hostmetrics, prometheus, otlp, datadog/connector]
      processors: [batch]
      exporters: [datadog/exporter]
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [datadog/connector, datadog/exporter]
    logs:
      receivers: [otlp, filelog]
      processors: [batch]
      exporters: [datadog/exporter]

Esta configuración básica permite recibir datos de OTLP a través de HTTP y gRPC, y configura un procesador por lotes.

Si quieres consultar la lista completa de opciones de configuración del Datadog Exporter, consulta el archivo de configuración de ejemplo completamente documentado. Opciones adicionales como api::site y host_metadata pueden ser relevantes, dependiendo de tu despliegue.

Configuración del procesador por lotes

El procesador por lotes se requiere en entornos que no son de desarrollo. La configuración exacta depende de tu carga de trabajo específica y de los tipos de señales.

Configura el procesador por lotes basándote en los límites de ingesta de Datadog:

Pueden producirse errores en 413 - Request Entity Too Large, si se introducen demasiados datos de telemetría en el procesador por lotes.

3 - Configurar tu aplicación

Para obtener mejores metadatos para trazas y para simplificar la integración con Datadog:

  • Utiliza detectores de recursos: si los proporciona el SDK del lenguaje, adjunta información de contenedor como atributos de recurso. Por ejemplo, en Go, utiliza la opción de recurso WithContainer().

  • Aplica etiquetado de servicios unificado: asegúrate de haber configurado tu aplicación con los atributos de recursos apropiados para el etiquetado de servicios unificado. Esto vincula la telemetría de Datadog con etiquetas (tags) para nombre de servicio, entorno de despliegue y versión de servicio. La aplicación debe establecer estas etiquetas utilizando las convenciones semánticas de OpenTelemetry: service.name, deployment.environment y service.version.

4 - Configurar el generador de logs para tu aplicación

Un diagrama con el host, contenedor o aplicación que envía datos al receptor de log de archivo en el Collector y el Datadog Exporter en el Collector que envía los datos al backend de Datadog

Dado que la funcionalidad de generación de logs del SDK de OpenTelemetry no es totalmente compatible (consulta tu lenguaje específico en la documentación de OpenTelemetry para más información), Datadog recomienda el uso de una biblioteca de generación de logs estándar para tu aplicación. Sigue la documentación de recopilación de logs específica del lenguaje para configurar el generador de logs adecuado en tu aplicación. Datadog recomienda especialmente la configuración de tu biblioteca de registro para la salida de logs en JSON, a fin de evitar la necesidad de reglas de análisis personalizadas.

Configurar el receptor de log de archivo

Configura el receptor de log de archivo utilizando operadores. Por ejemplo, si hay un servicio checkoutservice que está escribiendo logs en /var/log/pods/services/checkout/0.log, un ejemplo de log podría tener este aspecto:

{"level":"info","message":"order confirmation email sent to \"jack@example.com\"","service":"checkoutservice","span_id":"197492ff2b4e1c65","timestamp":"2022-10-10T22:17:14.841359661Z","trace_id":"e12c408e028299900d48a9dd29b0dc4c"}

Ejemplo de configuración de log de archivo:

filelog:
   include:
     - /var/log/pods/**/*checkout*/*.log
   start_at: end
   poll_interval: 500ms
   operators:
     - id: parse_log
       type: json_parser
       parse_from: body
     - id: trace
       type: trace_parser
       trace_id:
         parse_from: attributes.trace_id
       span_id:
         parse_from: attributes.span_id
   attributes:
     ddtags: env:staging
  • include: Lista de archivos que el receptor rastrea
  • start_at: end: Indica que se lea el nuevo contenido que se está escribiendo
  • poll_internal: Define la frecuencia de sondeo
  • Operadores:
    • json_parser: analiza los logs JSON. Por defecto, el receptor de log de archivos convierte cada línea de log en un registro de log, que es el body del modelo de datos de logs. A continuación, el json_parser convierte el cuerpo JSON en atributos del modelo de datos.
    • trace_parser: Extrae trace_id y span_id del log para correlacionar logs y trazas en Datadog.

Reasignar el atributo service.name de OTel a service para logs

Para las versiones 0.83.0 y posteriores del Datadog Exporter, el campo service de logs de OTel se rellena como la convención semántica de OTel service.name. Sin embargo, service.name no es uno de los atributos de servicio predeterminados en el preprocesamiento de logs de Datadog.

Para que el campo service se rellene correctamente en tus logs, puedes especificar que service.name sea la fuente de un servicio de log estableciendo un procesador de reasignación de servicio de log.

Hay múltiples maneras de desplegar el OpenTelemetry Collector y el Datadog Exporter en una infraestructura Kubernetes. Para que el receptor filelog funcione, el despliegue del Agent/DaemonSet es el método de despliegue recomendado.

En entornos contenedorizados, las aplicaciones escriben logs en stdout o stderr. Kubernetes recopila los logs y los escribe en una localización estándar. Es necesario montar la localización en el nodo host del Collector para el receptor filelog. A continuación se muestra un ejemplo de extensión con los montajes necesarios para enviar logs.

apiVersion: apps/v1
metadata:
  name: otel-agent
  labels:
    app: opentelemetry
    component: otel-collector
spec:
  template:
    metadata:
      labels:
        app: opentelemetry
        component: otel-collector
    spec:
      containers:
        - name: collector
          command:
            - "/otelcol-contrib"
            - "--config=/conf/otel-agent-config.yaml"
          image: otel/opentelemetry-collector-contrib:0.71.0
          env:
            - name: POD_IP
              valueFrom:
                fieldRef:
                  fieldPath: status.podIP
            # The k8s.pod.ip is used to associate pods for k8sattributes
            - name: OTEL_RESOURCE_ATTRIBUTES
              value: "k8s.pod.ip=$(POD_IP)"
          ports:
            - containerPort: 4318 # default port for OpenTelemetry HTTP receiver.
              hostPort: 4318
            - containerPort: 4317 # default port for OpenTelemetry gRPC receiver.
              hostPort: 4317
            - containerPort: 8888 # Default endpoint for querying metrics.
          volumeMounts:
            - name: otel-agent-config-vol
              mountPath: /conf
            - name: varlogpods
              mountPath: /var/log/pods
              readOnly: true
            - name: varlibdockercontainers
              mountPath: /var/lib/docker/containers
              readOnly: true
      volumes:
        - name: otel-agent-config-vol
          configMap:
            name: otel-agent-conf
            items:
              - key: otel-agent-config
                path: otel-agent-config.yaml
        # Mount nodes log file location.
        - name: varlogpods
          hostPath:
            path: /var/log/pods
        - name: varlibdockercontainers
          hostPath:
            path: /var/lib/docker/containers

Configuración del Datadog Exporter predefinida

Puedes encontrar ejemplos de configuración predefinida del Datadog Exporter en la carpetaexporter/datadogexporter/examples en el proyecto OpenTelemetry Collector Contrib. Consulta el archivo de ejemplo de configuración completo, ootb-ec2.yaml. Configura cada uno de los siguientes componentes para adaptarlos a tus necesidades:


Referencias adicionales

Más enlaces, artículos y documentación útiles:

Documentación del CollectorSITIO EXTERNO more more Envío de métricas, trazas (traces) y logs desde OpenTelemetry Collector a Datadog con el Datadog ExporterBLOG more more