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
- Exécutez chaque requête SLI dans un Notebook sur 24 heures : la courbe
slidoit rester entre 0 et 100, sans trou. - Dans l’application SLO, le statut et l’error budget restant s’affichent pour les deux SLO.
- 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.namedans 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.