Superviser collector OpenTelemetry : sa télémétrie interne dans Dynatrace (SaaS et Managed)

Superviser collector OpenTelemetry : exposez sa télémétrie interne, envoyez-la à Dynatrace, alertez sur les refus, la file d’attente et l’export raté.
Superviser collector OpenTelemetry : sa télémétrie interne dans Dynatrace (SaaS et Managed)

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-contrib ou la distribution Dynatrace). Ce tutoriel suppose une version 0.100 ou plus ; la syntaxe de service.telemetry a é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.com en SaaS, ou https://{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_spans et otelcol_receiver_refused_spans : ce qui entre et ce qui est refusé (équivalents _metric_points et _log_records) ;
  • otelcol_exporter_sent_spans et otelcol_exporter_send_failed_spans : ce qui sort et ce qui échoue ;
  • otelcol_exporter_queue_size et otelcol_exporter_queue_capacity : le remplissage de la file d’envoi ;
  • otelcol_process_memory_rss et otelcol_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 :

  1. Échecs d’export : send_failed supérieur à zéro pendant 10 minutes. C’est une perte de données réelle.
  2. File presque pleine : queue_size / queue_capacity au-dessus de 80 % pendant 10 minutes. Le collector va bientôt refuser des données.
  3. Refus en entrée : refused_spans en hausse, souvent le signe du memory_limiter qui 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/self dédié évite qu’une erreur de vos métriques métier masque la santé du collector.
  • Taguez chaque instance : ajoutez service.instance.id et le nom du cluster via le processor resource, pour savoir quel collector souffre.
  • Dimensionnez la file : réglez sending_queue et retry_on_failure sur l’exporter, puis vérifiez le ratio de remplissage sous charge.
  • Ne passez pas en detailed partout : ce niveau augmente le volume de séries. Gardez-le là où il apporte du diagnostic.
  • Doublez le contrôle : la sonde health_check dé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.

Total
0
Shares
Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

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

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

Next Post
Site Reliability Guardian : valider une release automatiquement sur vos SLO (Dynatrace SaaS)

Site Reliability Guardian : valider une release automatiquement sur vos SLO (Dynatrace SaaS)

Related Posts