Tail sampling OpenTelemetry antes de Dynatrace: controla costes y volumen de trazas

Tail sampling OpenTelemetry: conserva todos los errores y las lentitudes, muestrea el resto en el Collector y reduce el volumen enviado a Dynatrace.
Tail sampling OpenTelemetry avant Dynatrace : maîtriser coûts et volume de traces

Diez mil peticiones por segundo, todas trazadas, todas enviadas: la factura de ingesta se dispara y el 99 % de las trazas describen peticiones rápidas y correctas que nadie leerá. El tail sampling OpenTelemetry resuelve este problema en el Collector: espera a que termine cada traza, conserva los errores y las peticiones lentas y muestrea solo el tráfico normal.

Objetivo: al terminar este tutorial tienes un Collector que aplica políticas de tail sampling (muestreo por cola) antes de exportar a Dynatrace, una arquitectura de dos niveles que garantiza que todos los spans de una traza llegan a la misma instancia, y un método para comprobar qué se conserva. El principio vale para Dynatrace SaaS y Dynatrace Managed, ya que todo ocurre en el Collector, antes del endpoint OTLP. Las consultas de verificación DQL se aplican a SaaS; en Managed, la verificación se hace en la vista de trazas distribuidas.

Este tutorial da por hecho que ya tienes un Collector; si no, empieza por el Collector de OpenTelemetry en Kubernetes.

El problema: demasiadas trazas, y no las adecuadas

El muestreo en cabecera (head sampling), decidido al inicio de la petición en el SDK, es ciego: descarta una traza antes de saber si acabará en error. Con una tasa del 10 %, pierdes el 90 % de tus errores poco frecuentes, justo los que el equipo de guardia necesita para reducir el MTTR. El tail sampling decide a posteriori, con la traza completa delante.

Requisitos previos

  • La distribución otelcol-contrib del Collector, o una distribución que incluya el procesador tail_sampling y el exportador loadbalancing. Revisa la lista de componentes de la distribución de Dynatrace del Collector en su documentación antes de elegirla. En las versiones recientes del Collector contrib, loadbalancing y spanmetrics se llaman load_balancing y span_metrics; los nombres antiguos, usados a continuación, se siguen aceptando como alias obsoletos.
  • Un token de Dynatrace con el scope openTelemetryTrace.ingest.
  • Aplicaciones que envían el 100 % de sus spans al Collector (sampler del SDK parentbased_always_on).

Cómo funciona el tail sampling OpenTelemetry

El procesador tail_sampling mantiene en memoria los spans agrupados por trace_id. Tras un plazo (decision_wait), evalúa unas políticas. Si al menos una política dice «conservar», se exporta toda la traza. Dos consecuencias prácticas:

  • La memoria del Collector aumenta con el caudal y con el tiempo de espera.
  • Todos los spans de una traza deben llegar a la misma instancia del Collector. Con varias réplicas detrás de un balanceador de carga clásico, los spans se dispersan y las decisiones se vuelven incoherentes.

Pasos de la puesta en marcha

Paso 1: un primer nivel que enruta por trace_id

El primer nivel (agente o pasarela de enrutado) recibe el OTLP y reparte los spans con el exportador loadbalancing, enrutando por traceID:

# collector-routing.yaml
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

exporters:
  loadbalancing:
    routing_key: traceID
    protocol:
      otlp:
        tls:
          insecure: true
    resolver:
      dns:
        hostname: otel-sampler-headless.observability.svc.cluster.local
        port: 4317

service:
  pipelines:
    traces:
      receivers: [otlp]
      exporters: [loadbalancing]

Línea crítica: routing_key: traceID. El resolvedor DNS apunta a un servicio de Kubernetes headless, para que el exportador vea cada pod del segundo nivel.

Paso 2: un segundo nivel que muestrea

# collector-sampler.yaml
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317

processors:
  memory_limiter:
    check_interval: 1s
    limit_percentage: 80
    spike_limit_percentage: 20
  tail_sampling:
    decision_wait: 10s
    num_traces: 100000
    expected_new_traces_per_sec: 2000
    policies:
      - name: erreurs
        type: status_code
        status_code:
          status_codes: [ERROR]
      - name: lentes
        type: latency
        latency:
          threshold_ms: 1000
      - name: paiement-toujours
        type: string_attribute
        string_attribute:
          key: service.name
          values: [payment-api]
      - name: echantillon-normal
        type: probabilistic
        probabilistic:
          sampling_percentage: 5
  batch: {}

exporters:
  otlphttp/dynatrace:
    endpoint: "https://<environment-id>.live.dynatrace.com/api/v2/otlp"
    headers:
      Authorization: "Api-Token ${env:DT_API_TOKEN}"

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [memory_limiter, tail_sampling, batch]
      exporters: [otlphttp/dynatrace]

Cómo leer las políticas: se combinan con OR. Una traza se conserva si contiene un error, o dura más de un segundo, o toca payment-api, o cae en el 5 % aleatorio. En Managed, sustituye el endpoint por https://<votre-domaine>/e/<environment-id>/api/v2/otlp.

Ajustes críticos:

  • decision_wait debe superar la duración de tus trazas más largas; si no, los spans tardíos llegan después de la decisión y forman trazas incompletas.
  • num_traces acota el número de trazas en memoria. Dimensiónalo a partir de caudal × decision_wait, con margen.
  • memory_limiter va primero: protege al Collector de un pico de tráfico.

Paso 3: preservar las métricas antes del muestreo

Después del muestreo, contar los spans en Dynatrace subestima el tráfico real: tus SLI de rendimiento (throughput) y de tasa de errores dejan de ser correctos. Calcula las métricas RED antes del muestreo, en el primer nivel, con el conector spanmetrics, en temporalidad delta:

connectors:
  spanmetrics:
    aggregation_temporality: "AGGREGATION_TEMPORALITY_DELTA"
    histogram:
      explicit:
        buckets: [50ms, 100ms, 250ms, 500ms, 1s, 2s]

service:
  pipelines:
    traces:
      receivers: [otlp]
      exporters: [loadbalancing, spanmetrics]
    metrics:
      receivers: [spanmetrics]
      exporters: [otlphttp/dynatrace]

Añade en este Collector la definición de otlphttp/dynatrace vista más arriba. La temporalidad delta es indispensable para Dynatrace (consulta temporalidad de las métricas OTLP). Comprueba en la documentación de Dynatrace cómo trata la plataforma los spans muestreados en sus propias estadísticas de servicio: no des por hecha una extrapolación automática.

Paso 4: desplegar y observar el propio Collector

Despliega el segundo nivel como StatefulSet o Deployment con un servicio headless, al menos dos réplicas y límites de memoria alineados con memory_limiter. Expón la telemetría interna del Collector para seguir su comportamiento.

Cómo comprobar que funciona

  1. Métricas internas del Collector: sigue los contadores del procesador, por ejemplo otelcol_processor_tail_sampling_count_traces_sampled por política y decisión. Los nombres exactos varían según la versión: lístalos en el endpoint de métricas internas.
  2. Errores garantizados: provoca un error (un endpoint que devuelva 500) y comprueba que su traza llega completa.
  3. Dynatrace SaaS: compara el volumen antes y después, y la tasa de trazas con error:
    fetch spans, from: now() - 1h
    | filter isNull(span.parent_id)
    | summarize traces = count(), erreurs = countIf(span.status_code == "error"),
        by: {service.name}
    

    La proporción de errores debe ser claramente más alta que antes: es el efecto esperado.

  4. Dynatrace Managed: en la vista de trazas distribuidas, filtra por las peticiones fallidas y comprueba que las trazas no están truncadas.
  5. Trazas incompletas: si llegan trazas sin span raíz, aumenta decision_wait o revisa el enrutado por traceID.

Buenas prácticas

  • Conserva el 100 % de los errores y de las peticiones lentas; muestrea solo el tráfico sano.
  • No combines un head sampling agresivo con el tail sampling: lo que se descarta en el SDK no vuelve nunca.
  • Calcula los SLI a partir de métricas sin muestrear y alerta después por burn rate (consulta alertas de burn rate de SLO).
  • Si OneAgent también instrumenta algunos servicios, evita los duplicados: consulta OneAgent y OpenTelemetry: duplicados de spans.
  • Revisa las políticas después de cada incidente, sin buscar culpables: la traza que falta es un defecto de configuración, no de un equipo.

Preguntas frecuentes

¿Puede funcionar el tail sampling con un solo Collector?

Sí, si una única instancia recibe todos los spans. En cuanto tienes varias réplicas, el enrutado por traceID pasa a ser obligatorio.

¿Qué valor elegir para decision_wait?

Un poco más que la duración de tus trazas en el percentil 99. Diez segundos sirven para muchas API síncronas; los procesamientos asíncronos largos requieren más, a costa de memoria.

¿Se muestrean también los logs y las métricas?

No, el procesador solo trata trazas. Los logs correlacionados con una traza descartada se siguen ingiriendo, pero apuntan a una traza ausente.

Conclusión

El tail sampling convierte un flujo de trazas caro en una muestra útil: todos los errores, todas las lentitudes y algo de tráfico normal. El precio es una arquitectura de dos niveles y memoria. Empieza con políticas sencillas, mide con las métricas internas del Collector y afina después. Referencia: la documentación del procesador tail_sampling y la documentación de Dynatrace sobre OpenTelemetry.

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
Propagation contexte Kafka : des traces W3C de bout en bout dans Dynatrace

Propagación de contexto Kafka: trazas W3C de extremo a extremo en Dynatrace

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

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

Related Posts