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-contribdel Collector, o una distribución que incluya el procesadortail_samplingy el exportadorloadbalancing. 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,loadbalancingyspanmetricsse llamanload_balancingyspan_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_waitdebe 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_tracesacota el número de trazas en memoria. Dimensiónalo a partir de caudal ×decision_wait, con margen.memory_limiterva 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
- Métricas internas del Collector: sigue los contadores del procesador, por ejemplo
otelcol_processor_tail_sampling_count_traces_sampledpor política y decisión. Los nombres exactos varían según la versión: lístalos en el endpoint de métricas internas. - Errores garantizados: provoca un error (un endpoint que devuelva 500) y comprueba que su traza llega completa.
- 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.
- Dynatrace Managed: en la vista de trazas distribuidas, filtra por las peticiones fallidas y comprueba que las trazas no están truncadas.
- Trazas incompletas: si llegan trazas sin span raíz, aumenta
decision_waito revisa el enrutado portraceID.
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.