Dix mille requêtes par seconde, toutes tracées, toutes envoyées : la facture d’ingestion grimpe et 99 % des traces décrivent des requêtes rapides et réussies que personne ne lira. Le tail sampling OpenTelemetry règle ce problème dans le Collector : il attend la fin de chaque trace, puis garde les erreurs et les requêtes lentes et n’échantillonne que le trafic normal.
Objectif : à la fin de ce tutoriel, vous avez un Collector qui applique des politiques de tail sampling avant d’exporter vers Dynatrace, une architecture à deux niveaux qui garantit que tous les spans d’une trace arrivent sur la même instance, et une méthode pour vérifier ce qui est gardé. Le principe vaut pour Dynatrace SaaS et Dynatrace Managed, puisque tout se passe dans le Collector, avant l’endpoint OTLP. Les requêtes de vérification DQL concernent SaaS ; en Managed, la vérification se fait dans la vue des traces distribuées.
Ce tutoriel suppose un Collector déjà en place ; sinon, commencez par le Collector OpenTelemetry sur Kubernetes.
Le problème : trop de traces, pas les bonnes
L’échantillonnage en tête (head sampling), décidé au début de la requête dans le SDK, est aveugle : il jette une trace avant de savoir si elle finira en erreur. Avec un taux de 10 %, vous perdez 90 % de vos erreurs rares, précisément celles dont l’astreinte a besoin pour réduire le MTTR. Le tail sampling décide après coup, avec la trace complète sous les yeux.
Prérequis
- La distribution
otelcol-contribdu Collector, ou une distribution qui inclut le processeurtail_samplinget l’exporteurloadbalancing. Vérifiez la liste des composants de la distribution Dynatrace du Collector dans sa documentation avant de la choisir. Dans les versions récentes du Collector contrib,loadbalancingetspanmetricss’appellentload_balancingetspan_metrics; les anciens noms, utilisés ci-dessous, restent acceptés comme alias dépréciés. - Un token Dynatrace avec le scope
openTelemetryTrace.ingest. - Des applications qui envoient 100 % de leurs spans au Collector (sampler SDK
parentbased_always_on).
Comment fonctionne le tail sampling OpenTelemetry
Le processeur tail_sampling garde en mémoire les spans par trace_id. Après un délai (decision_wait), il évalue des politiques. Si au moins une politique dit « garder », toute la trace est exportée. Deux conséquences pratiques :
- La mémoire du Collector augmente avec le débit et le délai d’attente.
- Tous les spans d’une trace doivent atteindre la même instance du Collector. Avec plusieurs replicas derrière un load balancer classique, les spans se dispersent et les décisions deviennent incohérentes.
Étapes de mise en place
Étape 1 : un premier niveau qui route par trace_id
Le premier niveau (agent ou passerelle de routage) reçoit l’OTLP et répartit les spans avec l’exporteur loadbalancing, en routant sur le 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]
Ligne critique : routing_key: traceID. Le résolveur DNS pointe vers un service Kubernetes headless, pour que l’exporteur voie chaque pod du second niveau.
Étape 2 : un second niveau qui échantillonne
# 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]
Lecture des politiques : elles sont combinées en OU. Une trace est gardée si elle contient une erreur, ou dure plus d’une seconde, ou touche payment-api, ou tombe dans les 5 % aléatoires. En Managed, remplacez l’endpoint par https://<votre-domaine>/e/<environment-id>/api/v2/otlp.
Réglages critiques :
decision_waitdoit dépasser la durée de vos traces les plus longues ; sinon les spans tardifs arrivent après la décision et forment des traces incomplètes.num_tracesborne le nombre de traces en mémoire. Dimensionnez-le à partir de débit ×decision_wait, avec une marge.memory_limiterpasse en premier : il protège le Collector d’un pic de trafic.
Étape 3 : préserver les métriques avant l’échantillonnage
Après échantillonnage, compter les spans dans Dynatrace sous-estime le trafic réel : vos SLI de débit et de taux d’erreurs deviennent faux. Calculez les métriques RED avant l’échantillonnage, au premier niveau, avec le connecteur spanmetrics, en temporalité 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]
Ajoutez dans ce Collector la définition de otlphttp/dynatrace vue plus haut. La temporalité delta est indispensable pour Dynatrace (voir temporalité des métriques OTLP). Vérifiez dans la documentation Dynatrace comment la plateforme traite les spans échantillonnés pour ses propres statistiques de service : ne présumez pas d’une extrapolation automatique.
Étape 4 : déployer et observer le Collector lui-même
Déployez le second niveau en StatefulSet ou Deployment avec un service headless, au moins deux replicas, et des limites mémoire alignées sur memory_limiter. Exposez la télémétrie interne du Collector pour suivre son comportement.
Comment vérifier que ça fonctionne
- Métriques internes du Collector : suivez les compteurs du processeur, par exemple
otelcol_processor_tail_sampling_count_traces_sampledpar politique et décision. Les noms exacts varient selon la version : listez-les sur l’endpoint de métriques internes. - Erreurs garanties : provoquez une erreur (endpoint qui renvoie 500) et vérifiez que sa trace arrive complète.
- Dynatrace SaaS : comparez le volume avant et après, et le taux de traces en erreur :
fetch spans, from: now() - 1h | filter isNull(span.parent_id) | summarize traces = count(), erreurs = countIf(span.status_code == "error"), by: {service.name}La proportion d’erreurs doit être nettement plus élevée qu’avant : c’est l’effet attendu.
- Dynatrace Managed : dans la vue des traces distribuées, filtrez sur les requêtes en échec et vérifiez que les traces ne sont pas tronquées.
- Traces incomplètes : si des traces arrivent sans span racine, augmentez
decision_waitou vérifiez le routage partraceID.
Bonnes pratiques
- Gardez 100 % des erreurs et des requêtes lentes ; échantillonnez seulement le trafic sain.
- Ne combinez pas head sampling agressif et tail sampling : ce qui est jeté dans le SDK ne revient jamais.
- Calculez les SLI à partir de métriques non échantillonnées, puis alertez par burn rate (voir alertes burn rate SLO).
- Si OneAgent instrumente aussi certains services, évitez les doublons : voir OneAgent et OpenTelemetry : doublons de spans.
- Révisez les politiques après chaque incident, sans chercher de coupable : la trace manquante est un défaut de configuration, pas d’équipe.
Questions fréquentes
Le tail sampling peut-il tourner sur un seul Collector ?
Oui, si une seule instance reçoit tous les spans. Dès que vous avez plusieurs replicas, le routage par traceID devient obligatoire.
Quelle valeur choisir pour decision_wait ?
Un peu plus que la durée de vos traces au 99e percentile. Dix secondes conviennent à beaucoup d’API synchrones ; les traitements asynchrones longs demandent plus, au prix de mémoire.
Les logs et les métriques sont-ils échantillonnés ?
Non, le processeur ne traite que les traces. Les logs corrélés à une trace écartée restent ingérés mais pointent vers une trace absente.
Conclusion
Le tail sampling transforme un flux de traces coûteux en un échantillon utile : toutes les erreurs, toutes les lenteurs, un peu de trafic normal. Le prix à payer est une architecture à deux niveaux et de la mémoire. Démarrez avec des politiques simples, mesurez avec les métriques internes du Collector, puis affinez. Référence : la documentation du processeur tail_sampling et la documentation Dynatrace OpenTelemetry.
span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de son propriétaire.