Parcours : Métriques Dynatrace SaaS · Module 3/7 — métriques de service Grail, requêtes, messagerie et service mesh · Format : fiches de référence · Plateforme : Dynatrace SaaS (Grail, DQL)
Dans ce module : 12 entrées dt.service.* (requêtes, messagerie, service mesh, métriques calculées), un tableau récapitulatif et une fiche par métrique.
Les métriques de service Grail sont les clés dt.service.* qui décrivent ce que vivent vos services. Troisième module du parcours métriques Dynatrace SaaS, il les range en fiches : requêtes HTTP et RPC par endpoint, messagerie (Kafka, RabbitMQ, SQS…) et service mesh. Chaque fiche donne l’unité, les dimensions, un cas d’usage et une requête DQL.
Les métriques de service mesurent ce que vivent les appelants : combien de requêtes arrivent, combien échouent, combien de temps elles prennent. Ce sont les signaux d’or sur lesquels on construit les SLO, et donc les alertes qui réveillent quelqu’un à juste titre. Dynatrace les produit automatiquement pour chaque endpoint détecté, sans configuration.
Le contenu vaut pour Dynatrace SaaS. Pour Dynatrace Managed, voyez le module métriques service builtin. Les clés d’hôte sont dans le module 2 ; ce module sert à retrouver vite la bonne clé de service et sa particularité.
Métriques de service Grail : le tableau récapitulatif
Douze entrées seulement : sur Grail, les dimensions remplacent la multiplication des clés. Là où Classic avait une clé pour les erreurs 4xx, une pour les 5xx et une pour les requêtes clés, Grail garde dt.service.request.count et vous laisse filtrer. Unités et dimensions viennent de la page de référence ; « voir le descripteur » signale ce qu’elle ne précise pas.
| Clé | Unité | Dimensions principales | Ce qu’elle mesure |
|---|---|---|---|
dt.service.request.count |
nombre | dt.entity.service, endpoint.name, http.request.method, http.response.status_code, failed |
Requêtes reçues par endpoint |
dt.service.request.failure_count |
nombre | dt.entity.service, endpoint.name, http.request.method, http.response.status_code |
Requêtes en échec par endpoint |
dt.service.request.response_time |
µs | dt.entity.service, endpoint.name, http.request.method, http.response.status_code, failed |
Temps de réponse des requêtes par endpoint |
dt.service.messaging.publish.count |
nombre | dt.entity.service, messaging.destination.name, messaging.system |
Messages envoyés vers des files ou des topics |
dt.service.messaging.receive.count |
nombre | dt.entity.service, messaging.destination.name, messaging.system |
Messages reçus depuis des files ou des topics |
dt.service.messaging.process.count |
nombre | dt.entity.service, messaging.destination.name, messaging.system |
Messages traités avec succès |
dt.service.messaging.process.duration |
voir le descripteur | dt.entity.service, messaging.destination.name, messaging.system |
Temps passé à traiter les messages |
dt.service.messaging.process.failure_count |
nombre | dt.entity.service, messaging.destination.name, messaging.system |
Messages dont le traitement a échoué |
dt.service.request.service_mesh.count |
nombre | voir le descripteur | Requêtes vues par le service mesh |
dt.service.request.service_mesh.failure_count |
nombre | voir le descripteur | Requêtes en échec vues par le service mesh |
dt.service.request.service_mesh.response_time |
voir le descripteur | voir le descripteur | Temps de réponse vu par le service mesh |
service.<nom_de_la_métrique> |
selon la définition | dimension Classic + placeholders éclatés | Métrique de service calculée, migrée depuis calc:service:… |
{{img:146-catalogue-metriques-service-1.png|Extrait de la documentation Built-in metrics on Grail : les dimensions des métriques d’endpoint dt.service.request avec leurs exemples de valeurs}}
Fiches : requêtes, messagerie et service mesh
Même ordre pour chaque fiche : utilité, cas d’usage, piège, requête DQL. Les dimensions d’infrastructure (k8s.namespace.name, k8s.cluster.name, aws.region, dt.host_group.id…) et les primary_tags.* sont aussi disponibles sur les métriques de requêtes et de messagerie, sans jointure de topologie.
dt.service.request.count
Utilité : le trafic, premier signal d’or, et le dénominateur de tout taux d’échec.
Cas d’usage : une seule clé remplace une trentaine de clés Classic (succès, 4xx, 5xx, requêtes clés) : on filtre par http.response.status_code ou failed au lieu de changer de métrique. Exemple : la part de réponses 5xx d’un service.
Piège : les métriques sont collectées à la minute : ajoutez rate: 1s si vous voulez des requêtes par seconde.
timeseries {all = sum(dt.service.request.count),
s5xx = sum(dt.service.request.count, filter: {http.response.status_code >= 500}, default: 0)},
by: {dt.entity.service}, union: true
| fieldsAdd pct_5xx = s5xx[] / all[] * 100
dt.service.request.failure_count
Utilité : le numérateur du taux d’erreur, base d’un SLI de disponibilité.
Cas d’usage : classer les endpoints par nombre d’échecs pour savoir lequel consomme le budget d’erreur.
Piège : la documentation précise que la métrique contient des points à zéro pour les requêtes réussies, afin de distinguer « des échecs », « aucun échec » et « aucune requête ». Une requête timeseries normale ne les renvoie pas : pensez à default: 0 dans les ratios.
timeseries failed = sum(dt.service.request.failure_count), by: {dt.entity.service, endpoint.name}
| sort arraySum(failed) desc
| limit 10
dt.service.request.response_time
Utilité : la latence, mesurée côté service.
Cas d’usage : le percentile 99 par service, tel que dans l’exemple de la documentation DQL, pour suivre la queue de distribution.
Piège : l’unité est la microseconde : un seuil de 300 ms s’écrit 300000.
timeseries p99 = percentile(dt.service.request.response_time, 99),
by: {dt.entity.service}
| limit 5
dt.service.messaging.publish.count
Utilité : le débit produit par un service, côté émetteur.
Cas d’usage : une chute à zéro de la publication sur un topic d’événements métier signale un producteur bloqué avant toute plainte.
Piège : ces métriques n’existent que sur Grail : aucune équivalence Classic à migrer.
timeseries pub = sum(dt.service.messaging.publish.count),
by: {messaging.destination.name, messaging.system}
dt.service.messaging.receive.count
Utilité : le pendant consommateur de la publication.
Cas d’usage : comparer publication et réception sur une même destination pour voir si les consommateurs suivent.
timeseries {pub = sum(dt.service.messaging.publish.count),
rec = sum(dt.service.messaging.receive.count)},
by: {messaging.destination.name}, union: true
dt.service.messaging.process.count
Utilité : le trafic utile d’un consommateur.
Cas d’usage : rapproché de receive.count, il montre si les messages reçus sont réellement traités.
timeseries done = sum(dt.service.messaging.process.count, rate: 1m),
by: {dt.entity.service, messaging.destination.name}
dt.service.messaging.process.duration
Utilité : la latence d’un consommateur, invisible dans les métriques de requêtes HTTP.
Cas d’usage : un temps de traitement qui double explique un retard qui s’accumule dans la file.
Piège : la page de référence ne donne pas l’unité : lisez-la dans le navigateur de métriques avant de fixer un seuil.
timeseries d = avg(dt.service.messaging.process.duration),
by: {dt.entity.service, messaging.destination.name}
dt.service.messaging.process.failure_count
Utilité : le taux d’erreur d’un consommateur.
Cas d’usage : des échecs concentrés sur une destination désignent un format de message ou une dépendance en aval.
timeseries {ok = sum(dt.service.messaging.process.count),
ko = sum(dt.service.messaging.process.failure_count, default: 0)},
by: {messaging.destination.name}, union: true
| fieldsAdd fail_pct = ko[] / (ok[] + ko[]) * 100
dt.service.request.service_mesh.count
Utilité : le trafic mesuré par le proxy du mesh plutôt que par le code instrumenté.
Cas d’usage : un écart durable avec dt.service.request.count révèle des requêtes rejetées par le proxy avant d’atteindre l’application.
timeseries mesh = sum(dt.service.request.service_mesh.count, rate: 1s)
dt.service.request.service_mesh.failure_count
Utilité : capte les échecs de réseau et de proxy (délais, connexions refusées) que l’application ne voit pas.
Cas d’usage : taux d’échec du mesh à suivre en parallèle de celui du service lors d’une montée de version du mesh.
timeseries {all = sum(dt.service.request.service_mesh.count),
ko = sum(dt.service.request.service_mesh.failure_count, default: 0)}, union: true
| fieldsAdd fail_pct = ko[] / all[] * 100
dt.service.request.service_mesh.response_time
Utilité : inclut le coût du proxy : la différence avec le temps du service mesure la surcharge du mesh.
Cas d’usage : percentile 90 à surveiller après l’activation du chiffrement mutuel (mTLS).
Piège : comparez dans la même unité : vérifiez-la dans le descripteur avant de la soustraire au temps du service.
timeseries p90 = percentile(dt.service.request.service_mesh.response_time, 90)
service.<nom_de_la_métrique>
Utilité : conserve un besoin métier précis (montant, client, type de commande) que les métriques intégrées ne couvrent pas.
Cas d’usage : une métrique existante calc:service:orders devient service.orders une fois activée sur Grail, avec ses placeholders transformés en dimensions séparées.
Piège : la documentation annonce la dépréciation des métriques de service calculées, sans date. Pour un nouveau besoin, partez des métriques d’endpoint ou d’une extraction de métrique depuis les spans dans OpenPipeline.
timeseries sum(service.orders), by: {dt.entity.service}
Comment vérifier que ça fonctionne
- Dans un notebook, exécutez
timeseries sum(dt.service.request.count), by: {dt.entity.service}: chaque service instrumenté doit apparaître. - Ajoutez
endpoint.nameauby: si la colonne est vide pour un service SDv1, activez les endpoints enrichis (Enhanced endpoints) comme l’indique la documentation. - Pour la messagerie, filtrez sur
messaging.system; une absence totale de série signifie souvent que la bibliothèque cliente n’est pas prise en charge ou pas instrumentée. - Comparez un taux d’échec calculé ici avec l’écran du service dans l’application Services : les deux doivent raconter la même histoire.
Bonnes pratiques
- Filtrez par dimension plutôt que de chercher une clé dédiée : statut HTTP, méthode, endpoint.
- Utilisez
default: 0etunion: truedans les ratios pour ne pas perdre les services sans échec. - Préférez les percentiles à la moyenne pour la latence, et convertissez les seuils en microsecondes.
Pour aller plus loin : alertes burn rate sur les SLO transforme ces séries en alertes sur le budget d’erreur, migrer ses SLO vers Grail traite le passage depuis les clés Classic et la propagation de contexte Kafka explique pourquoi les métriques de messagerie dépendent d’un contexte bien transmis. Sources : Built-in metrics on Grail et commandes de métriques DQL.
← Module 2 : Métriques hôte Grail · Sommaire du parcours · Module 4 : Métriques RUM Grail →
Questions fréquentes
Où sont passées les métriques de requêtes clés ?
Il n’y a plus de clé dédiée : les anciennes clés builtin:service.keyRequest.* correspondent aux métriques dt.service.request.*, filtrées par endpoint.name.
Une même requête fonctionne-t-elle pour SDv1 et SDv2 ?
Oui, selon la documentation, les métriques d’endpoint sont produites pour les services SDv1 (avec Enhanced endpoints) et SDv2, et une seule requête couvre les deux.
Faut-il encore créer des métriques de service calculées ?
Pas pour un nouveau besoin : elles sont annoncées comme dépréciées. Les métriques intégrées et leurs dimensions couvrent la plupart des découpages ; pour le reste, extrayez une métrique depuis les spans avec OpenPipeline.
Avec ces douze entrées, vous couvrez la latence, le trafic et les erreurs de vos services, synchrones ou asynchrones. Le module suivant passe du côté de l’utilisateur final : frontends RUM et monitoring synthétique.
span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Ce module est une sélection commentée, pas la liste officielle : clés, unités et dimensions ont été relevées dans la documentation publique de Dynatrace SaaS et peuvent évoluer ; vérifiez-les dans le navigateur de métriques de votre environnement.