Votre collector OpenTelemetry transporte toutes vos traces, métriques et logs. S’il sature, refuse des données ou n’arrive plus à exporter, vous perdez de la visibilité sans le moindre message d’erreur côté application. Superviser collector OpenTelemetry, c’est donc protéger le pipeline qui alimente vos SLO, vos alertes et vos analyses d’incident.
Objectif de ce tutoriel : activer la télémétrie interne du collector, l’envoyer vers Dynatrace, puis poser trois contrôles simples sur les refus, les échecs d’export et la file d’attente. Le contenu vaut pour Dynatrace SaaS (métriques dans Grail, requêtes DQL) et pour Dynatrace Managed (ingestion OTLP via ActiveGate, explorateur de données et événements de métrique classiques). Les différences sont signalées à chaque étape.
Si votre collector n’envoie pas encore de données à Dynatrace, commencez par le guide de configuration du collector OpenTelemetry pour Dynatrace.
Le problème : un pipeline aveugle sur lui-même
Un collector qui rate des exports ne crée pas d’incident visible. Les spans disparaissent, les graphiques montrent un creux, et l’astreinte cherche une panne applicative qui n’existe pas. Résultat : un MTTR qui s’allonge et des SLO calculés sur des données incomplètes. La bonne nouvelle : le collector expose déjà ses propres métriques. Il suffit de les collecter.
Prérequis
- Un collector OpenTelemetry récent (distribution
otelcol-contribou la distribution Dynatrace). Ce tutoriel suppose une version 0.100 ou plus ; la syntaxe deservice.telemetrya évolué, vérifiez le changelog de votre version. - Un token d’API Dynatrace avec le scope
metrics.ingest(ingestion de métriques OTLP). - L’URL de votre environnement :
https://{environment-id}.live.dynatrace.comen SaaS, ouhttps://{activegate}:9999/e/{environment-id}en Managed.
Étape 1 : exposer la télémétrie interne du collector
Le bloc service.telemetry contrôle la télémétrie du collector lui-même. Le plus robuste est d’exposer les métriques au format Prometheus en local, puis de les relire avec le receiver Prometheus. Ainsi, elles suivent le même pipeline que vos autres métriques.
service:
telemetry:
logs:
level: info
metrics:
level: detailed # basic, normal ou detailed
readers:
- pull:
exporter:
prometheus:
host: 0.0.0.0
port: 8888
Lignes critiques : level: detailed ajoute des métriques utiles sur les files et les lots ; le reader pull publie les métriques sur :8888/metrics. Sur les versions plus anciennes, l’équivalent était address: 0.0.0.0:8888 sous metrics.
Étape 2 : relire ces métriques et les envoyer vers Dynatrace
Ajoutez un receiver Prometheus qui interroge le port 8888, puis un pipeline dédié. Dynatrace attend des métriques OTLP en temporalité delta : le processor cumulativetodelta convertit les compteurs Prometheus, qui sont cumulatifs. Ce point est détaillé dans l’article sur la temporalité des métriques OTLP.
receivers:
prometheus/self:
config:
scrape_configs:
- job_name: otelcol-self
scrape_interval: 30s
static_configs:
- targets: ["127.0.0.1:8888"]
processors:
cumulativetodelta: {}
batch: {}
exporters:
otlphttp/dynatrace:
endpoint: https://{environment-id}.live.dynatrace.com/api/v2/otlp
headers:
Authorization: "Api-Token ${env:DT_API_TOKEN}"
service:
pipelines:
metrics/self:
receivers: [prometheus/self]
processors: [cumulativetodelta, batch]
exporters: [otlphttp/dynatrace]
En Managed, remplacez l’endpoint par https://{activegate}:9999/e/{environment-id}/api/v2/otlp. Le token reste dans une variable d’environnement, jamais dans le fichier.
Un piège classique : si l’exporter vers Dynatrace tombe, les métriques internes tombent avec lui. Gardez en plus un contrôle externe, par exemple l’extension health_check sondée par Kubernetes.
extensions:
health_check:
endpoint: 0.0.0.0:13133
service:
extensions: [health_check]
Étape 3 : identifier les métriques qui comptent
Le collector publie des dizaines de séries. Pour l’astreinte, quatre familles suffisent :
otelcol_receiver_accepted_spansetotelcol_receiver_refused_spans: ce qui entre et ce qui est refusé (équivalents_metric_pointset_log_records) ;otelcol_exporter_sent_spansetotelcol_exporter_send_failed_spans: ce qui sort et ce qui échoue ;otelcol_exporter_queue_sizeetotelcol_exporter_queue_capacity: le remplissage de la file d’envoi ;otelcol_process_memory_rssetotelcol_process_cpu_seconds: la santé du processus.
Attention au nommage : selon la version et le passage par Prometheus, les compteurs portent souvent le suffixe _total (par exemple otelcol_exporter_send_failed_spans_total). Vérifiez les noms exacts sur /metrics avant d’écrire vos requêtes.
Comment vérifier que ça fonctionne
Commencez en local, sur la machine ou le pod du collector :
curl -s http://127.0.0.1:8888/metrics | grep -E "otelcol_exporter_(sent|send_failed)_spans"
curl -s http://127.0.0.1:13133/
Vous devez voir des compteurs non nuls et une réponse de santé. Ensuite, côté Dynatrace SaaS, ouvrez un Notebook et lancez :
timeseries failed = sum(otelcol_exporter_send_failed_spans_total),
sent = sum(otelcol_exporter_sent_spans_total),
by: { exporter },
interval: 5m
Si la requête ne renvoie rien, cherchez le nom réel de la métrique avec fetch dt.metrics | filter contains(metric.key, "otelcol") ; la disponibilité de cette commande dépend de votre environnement, consultez la documentation DQL. En Managed, ouvrez l’explorateur de données et tapez otelcol dans le sélecteur de métriques.
Étape 4 : alerter sur les bons signaux
Trois alertes couvrent l’essentiel, sans bruit :
- Échecs d’export :
send_failedsupérieur à zéro pendant 10 minutes. C’est une perte de données réelle. - File presque pleine :
queue_size / queue_capacityau-dessus de 80 % pendant 10 minutes. Le collector va bientôt refuser des données. - Refus en entrée :
refused_spansen hausse, souvent le signe dumemory_limiterqui protège le processus.
En SaaS, créez ces alertes avec Davis Anomaly Detection à partir d’une requête DQL, par exemple :
timeseries q = max(otelcol_exporter_queue_size), cap = max(otelcol_exporter_queue_capacity),
by: { exporter }, interval: 1m
| fieldsAdd ratio = q[] / cap[] * 100
En Managed, créez un événement de métrique (Paramètres, Détection d’anomalies, Événements de métrique) sur la métrique ingérée, avec un seuil statique. Routez ensuite ces alertes comme les autres, via un profil d’alerte ou un Workflow, selon la méthode décrite pour les alertes burn rate.
Bonnes pratiques pour superviser collector OpenTelemetry
- Isolez le pipeline interne : un pipeline
metrics/selfdédié évite qu’une erreur de vos métriques métier masque la santé du collector. - Taguez chaque instance : ajoutez
service.instance.idet le nom du cluster via le processorresource, pour savoir quel collector souffre. - Dimensionnez la file : réglez
sending_queueetretry_on_failuresur l’exporter, puis vérifiez le ratio de remplissage sous charge. - Ne passez pas en
detailedpartout : ce niveau augmente le volume de séries. Gardez-le là où il apporte du diagnostic. - Doublez le contrôle : la sonde
health_checkdétecte un collector mort, ce que ses propres métriques ne peuvent pas faire.
Sur Kubernetes, les mêmes réglages s’appliquent via les valeurs Helm : voir le déploiement du collector OpenTelemetry sur Kubernetes. Et si des traces manquent malgré un collector sain, suivez la checklist des traces OpenTelemetry absentes.
Questions fréquentes
Le collector peut-il envoyer sa télémétrie interne directement en OTLP ?
Oui, les versions récentes acceptent un reader periodic avec un exporter OTLP dans service.telemetry.metrics. La syntaxe change encore d’une version à l’autre ; la méthode Prometheus décrite ici reste plus stable. Vérifiez la documentation de votre version sur opentelemetry.io.
Ces métriques sont-elles facturées ?
Oui, ce sont des métriques personnalisées ingérées comme les autres. Le volume reste faible si vous gardez un intervalle de 30 secondes et le niveau normal hors diagnostic.
La distribution Dynatrace du collector change-t-elle quelque chose ?
Le principe reste le même : service.telemetry fait partie du cœur du collector. Vérifiez seulement que les composants utilisés ici (receiver Prometheus, processor cumulativetodelta) sont inclus dans la distribution choisie.
Conclusion
Un collector non supervisé est un point de défaillance silencieux. Avec un pipeline interne dédié, quatre familles de métriques et trois alertes, vous savez en quelques minutes si une perte de données vient du collector ou de l’application. C’est moins de fausses pistes en incident, et des SLO calculés sur des données fiables.
span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de son propriétaire.