SLO OpenTelemetry dans Dynatrace : disponibilité et latence en DQL

SLO OpenTelemetry dans Dynatrace : transformez vos spans en SLO de disponibilité et de latence en DQL, maîtrisez le coût des requêtes et vérifiez-les.
SLO OpenTelemetry dans Dynatrace : disponibilité et latence en DQL

Vos services envoient leurs traces par OTLP, mais vos objectifs de fiabilité restent des chiffres sur une page wiki. Sans SLO OpenTelemetry branché sur ces données, personne ne sait si le service tient sa promesse, ni combien d’error budget il reste avant de geler les mises en production.

Objectif de ce tutoriel : créer deux SLO dans Dynatrace à partir de spans OpenTelemetry, l’un de disponibilité, l’autre de latence, écrits en DQL, puis vérifier leurs valeurs. Le contenu cible Dynatrace SaaS (Grail, application Service-Level Objectives). Une section indique l’alternative pour Dynatrace Managed.

Si vous hésitez encore sur les indicateurs à mesurer, lisez d’abord choisir ses SLI : la méthode pratique.

Ce que l’on mesure

  • Disponibilité : part des requêtes serveur qui ne sont pas en erreur. Cible : 99,5 % sur 28 jours.
  • Latence : part des requêtes serveur servies en moins de 500 ms. Cible : 95 % sur 28 jours.

Les deux SLI sont des ratios « bons événements / événements valides ». Ce format rend l’error budget lisible : 0,5 % des requêtes peuvent échouer sur la fenêtre.

Prérequis

  • SaaS sur la plateforme Grail, avec l’application Service-Level Objectives et les permissions de lecture des spans et d’écriture des SLO (liste exacte dans la documentation).
  • Des spans OpenTelemetry déjà présents dans Grail, avec l’attribut service.name. Si rien n’arrive, suivez la checklist traces OpenTelemetry absentes.
  • Des spans serveur (span.kind == "server") avec un statut renseigné par l’instrumentation.

Créer un SLO OpenTelemetry pas à pas

Étape 1 — Explorer les spans dans un Notebook

Avant d’écrire le SLI, vérifiez les champs disponibles :

fetch spans, from: now() - 1h
| filter service.name == "checkout" and span.kind == "server"
| summarize total = count(),
            erreurs = countIf(span.status_code == "error"),
            p95 = percentile(duration, 95)

Lignes critiques : span.kind == "server" ne garde que les requêtes reçues, pas les appels sortants. span.status_code porte le statut OpenTelemetry. Si vos spans HTTP ne passent pas en erreur sur les réponses 5xx, filtrez plutôt sur http.response.status_code >= 500. Les noms de champs exacts dans Grail sont décrits dans la documentation du Semantic Dictionary : vérifiez-les avant de continuer.

Étape 2 — Écrire le SLI de disponibilité

L’application SLO attend une série temporelle qui renvoie un pourcentage. On transforme donc les spans en séries avec makeTimeseries :

fetch spans
| filter service.name == "checkout" and span.kind == "server"
| makeTimeseries {
    total = count(),
    erreurs = countIf(span.status_code == "error")
  }, interval: 1m
| fieldsAdd sli = 100 * (total[] - erreurs[]) / total[]

Dans l’application Service-Level Objectives, créez un SLO avec un SLI personnalisé, collez la requête, puis fixez la cible à 99,5 et la fenêtre à 28 jours. La forme attendue (nom du champ résultat, fenêtre de requête gérée par l’application) peut évoluer : comparez avec un modèle proposé par l’application.

Étape 3 — Écrire le SLI de latence

fetch spans
| filter service.name == "checkout" and span.kind == "server"
| makeTimeseries {
    total = count(),
    rapides = countIf(duration < 500ms)
  }, interval: 1m
| fieldsAdd sli = 100 * rapides[] / total[]

On mesure un ratio de requêtes rapides plutôt qu’un percentile. Un percentile ne s’additionne pas sur 28 jours ; un ratio, si. Cible : 95. Créez ce second SLO de la même façon.

Étape 4 — Maîtriser le coût des requêtes

Un SLO réévalue sa requête régulièrement. Interroger tous les spans d’un service à fort trafic coûte cher en lecture Grail. Deux options plus sobres :

  • extraire une métrique depuis les spans avec OpenPipeline, puis écrire le SLI avec timeseries ;
  • utiliser la métrique OpenTelemetry http.server.request.duration (histogramme) si votre SDK l’exporte.

Exemple avec une métrique extraite (nom à adapter à votre pipeline) :

timeseries {
    total = sum(otel.checkout.requests),
    erreurs = sum(otel.checkout.requests, filter: { status == "error" })
  }
| fieldsAdd sli = 100 * (total[] - erreurs[]) / total[]

Voir métriques et histogrammes avec OpenPipeline pour l’extraction.

Et dans Dynatrace Managed ?

Managed n’a pas Grail ni DQL. Les spans OpenTelemetry ingérés y deviennent des requêtes de service : un SLO classique peut alors s’appuyer sur une expression de métrique, par exemple (100)*(builtin:service.errors.server.successCount:splitBy())/(builtin:service.requestCount.server:splitBy()), filtrée sur le service. Vérifiez dans la documentation de votre version que le service OpenTelemetry expose bien ces métriques.

Étape 5 — Lire l’error budget

Avec 99,5 % sur 28 jours et 2 millions de requêtes sur la fenêtre, le budget autorise 10 000 requêtes en erreur. Si 4 000 ont déjà échoué à mi-fenêtre, 40 % du budget est consommé : le rythme est sain. Si 8 000 ont échoué en une semaine, l’équipe ralentit les mises en production et priorise la fiabilité. Cette règle, écrite à l’avance et acceptée par le produit, évite les débats pendant l’incident.

Comment vérifier que ça fonctionne

  1. Exécutez chaque requête SLI dans un Notebook sur 24 heures : la courbe sli doit rester entre 0 et 100, sans trou.
  2. Dans l’application SLO, le statut et l’error budget restant s’affichent pour les deux SLO.
  3. Générez des erreurs sur un environnement de test (par exemple un endpoint qui renvoie 500) : le SLI de disponibilité doit baisser dans les minutes qui suivent.

Bonnes pratiques

  • Filtrez sur les requêtes valides : excluez les health checks et le trafic synthétique du dénominateur.
  • Gardez le seuil de latence aligné sur l’expérience utilisateur, pas sur la performance actuelle.
  • Normalisez service.name dans le Collector pour que le SLO survive à un renommage de déploiement.
  • Ajoutez des alertes de burn rate dès la création : voir alertes burn rate SLO dans Dynatrace.
  • Pour déployer ces SLO sur tous vos services, versionnez-les : voir générer les SLO Dynatrace avec Terraform.

Questions fréquentes

Faut-il des métriques OpenTelemetry ou les spans suffisent-ils ?

Les spans suffisent pour démarrer. Pour un service à fort trafic, une métrique dérivée est plus économique et plus rapide à évaluer.

Pourquoi 28 jours plutôt qu’un mois ?

Une fenêtre de 28 jours contient toujours quatre semaines complètes : chaque jour de la semaine pèse autant, ce qui rend les SLO comparables d’une période à l’autre.

Que faire si le SLI dépasse 100 ou devient vide ?

Un SLI vide signale une absence de trafic sur l’intervalle (division par zéro). Un SLI au-dessus de 100 signale un numérateur mal filtré. Reprenez l’étape 1 et comparez les compteurs.

Conclusion

Deux requêtes DQL suffisent pour passer de traces OpenTelemetry à des SLO de disponibilité et de latence. Commencez par un service critique, validez les chiffres dans un Notebook, puis ajoutez les alertes de burn rate.

Prochaine étape conseillée : présenter ces deux SLO en revue d’équipe, avec la règle de gel des mises en production associée à l’error budget. Un SLO partagé et compris par le produit vaut plus qu’un SLO parfait que seule l’astreinte consulte. Revoyez ensuite les seuils après un mois de données réelles.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de Dynatrace LLC. Les fonctionnalités SaaS évoluent vite : vérifiez leur disponibilité dans votre environnement et dans la documentation officielle.

Total
0
Shares
Laisser un commentaire

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

Previous Post
Traces OpenTelemetry absentes de Dynatrace : checklist de dépannage OTLP en 8 étapes

Traces OpenTelemetry absentes de Dynatrace : checklist de dépannage OTLP en 8 étapes

Next Post
Choisir ses SLI : la méthode pratique, des requêtes DQL aux objectifs

Choisir ses SLI : la méthode pratique, des requêtes DQL aux objectifs

Related Posts