Parcours : Métriques Dynatrace SaaS · Module 4/7 — métriques RUM Grail et monitoring synthétique · Format : fiches de référence · Plateforme : Dynatrace SaaS (Grail, DQL)
Dans ce module : 21 clés (13 dt.frontend.*, 8 dt.synthetic.*), deux tableaux récapitulatifs et une fiche par métrique avec sa requête DQL.
Quatrième module du parcours métriques Dynatrace SaaS : les métriques RUM Grail des frontends (dt.frontend.*) et celles du monitoring synthétique (dt.synthetic.*). Chaque fiche donne l’unité, les dimensions, un cas d’usage et une requête DQL.
Les modules précédents regardaient les serveurs ; celui-ci regarde l’utilisateur. Le RUM mesure ce que vivent les vrais visiteurs, le synthétique rejoue des parcours à intervalle fixe, même la nuit quand personne ne navigue. Les deux ensemble donnent la vue de bout en bout qui manque aux métriques de service.
Le contenu vaut pour Dynatrace SaaS avec le nouveau RUM. Les clés builtin:apps.* de RUM Classic n’existent pas sur Grail ; Dynatrace Managed les utilise toujours, avec le metric selector. Pour la mise en place, voir RUM et Core Web Vitals et le monitoring synthétique HTTP et navigateur.
Métriques RUM Grail : le tableau des frontends
Treize clés dt.frontend.*, toutes produites par le nouveau RUM sur Grail. Unités et dimensions viennent de la page Built-in RUM metrics ; seules les dimensions les plus utiles sont listées, dt.rum.application.entity, os.name et dt.rum.user_type sont aussi disponibles.
| Clé | Unité | Dimensions principales | Ce qu’elle mesure |
|---|---|---|---|
dt.frontend.user_action.count |
nombre | frontend.name, device.type, browser.name, geo.country.iso_code |
Actions utilisateur |
dt.frontend.user_action.duration |
ms | frontend.name, device.type, browser.name, geo.country.iso_code |
Durée des actions utilisateur |
dt.frontend.request.count |
nombre | frontend.name, url.provider, http.response.status_code_class |
Requêtes émises par le frontend |
dt.frontend.request.duration |
ms | frontend.name, url.provider, http.response.status_code_class |
Durée des requêtes du frontend |
dt.frontend.error.count |
nombre | frontend.name, error.type, app.short_version |
Erreurs du frontend |
dt.frontend.session.active.estimated_count |
nombre | frontend.name, device.type, browser.name, geo.country.iso_code |
Sessions actives (estimation) |
dt.frontend.user.active.estimated_count |
nombre | frontend.name, device.type, browser.name, geo.country.iso_code |
Utilisateurs uniques actifs (estimation) |
dt.frontend.web.page.largest_contentful_paint |
ms | frontend.name, device.type, browser.name, geo.country.iso_code |
Largest Contentful Paint (LCP) |
dt.frontend.web.page.interaction_to_next_paint |
ms | frontend.name, device.type, browser.name, geo.country.iso_code |
Interaction to Next Paint (INP) |
dt.frontend.web.page.cumulative_layout_shift |
sans unité (×10 000) | frontend.name, device.type, browser.name, geo.country.iso_code |
Cumulative Layout Shift (CLS) |
dt.frontend.web.navigation.time_to_first_byte |
ms | frontend.name, device.type, browser.name, geo.country.iso_code |
Time to First Byte (navigation) |
dt.frontend.web.navigation.load_event_end |
ms | frontend.name, device.type, browser.name, geo.country.iso_code |
Fin de l’événement load (W3C) |
dt.frontend.mobile.app_start.duration |
ms | frontend.name, app_start.type, os.name, app.short_version |
Durée de démarrage de l’application mobile |
{{img:147-catalogue-metriques-rum-1.png|Extrait de la page Built-in RUM metrics de la documentation Dynatrace : dix clés dt.frontend avec leur unité, count ou ms}}
Fiches RUM : ce que vit l’utilisateur
Même ordre pour chaque fiche : utilité, cas d’usage, piège éventuel, requête DQL. Les seuils sont à fixer vous-même sur votre historique.
dt.frontend.user_action.count
Utilité : le trafic vu du navigateur ou de l’application mobile, avant tout appel serveur.
Cas d’usage : une baisse brutale des actions sur un frontend alors que les services répondent normalement oriente vers le CDN, le DNS ou une erreur JavaScript bloquante.
Piège : RUM sur Grail n’a pas le même modèle de données que RUM Classic : la documentation prévient que les valeurs diffèrent de builtin:apps.web.actionCount.*.
timeseries actions = sum(dt.frontend.user_action.count), by: {frontend.name}
dt.frontend.user_action.duration
Utilité : la latence ressentie par l’utilisateur, réseau et rendu compris.
Cas d’usage : suivre le percentile 90 par type d’appareil : un écart entre mobile et ordinateur révèle souvent un poids de page excessif.
timeseries p90 = percentile(dt.frontend.user_action.duration, 90),
by: {frontend.name, device.type}
dt.frontend.request.count
Utilité : le dénominateur du taux d’erreur des appels XHR et fetch.
Cas d’usage : séparer les appels vers vos API des appels vers des tiers grâce à url.provider.
timeseries req = sum(dt.frontend.request.count),
by: {frontend.name, http.response.status_code_class}
dt.frontend.request.duration
Utilité : la latence des API telle que le client la vit, réseau compris.
Cas d’usage : comparée à dt.service.request.response_time (module 3), elle isole la part du réseau et du CDN.
Piège : unités différentes : millisecondes ici, microsecondes côté service.
timeseries p75 = percentile(dt.frontend.request.duration, 75), by: {url.provider}
dt.frontend.error.count
Utilité : remplace à elle seule les clés Classic d’erreurs JavaScript, de plantages et d’erreurs de requêtes.
Cas d’usage : après une mise en production, comparer les erreurs par app.short_version pour décider d’un retour arrière.
timeseries errors = sum(dt.frontend.error.count),
by: {frontend.name, error.type, app.short_version}
dt.frontend.session.active.estimated_count
Utilité : la charge réelle d’un frontend, utile pour lire les autres métriques en proportion.
Cas d’usage : rapporter le nombre d’erreurs au nombre de sessions pour comparer deux frontends de tailles différentes.
Piège : c’est une estimation probabiliste (algorithme UltraLogLog selon la documentation) : ne l’utilisez pas comme un compte exact pour la facturation.
timeseries sessions = max(dt.frontend.session.active.estimated_count), by: {frontend.name}
dt.frontend.user.active.estimated_count
Utilité : mesure l’audience touchée, ce qui donne le poids d’un incident.
Cas d’usage : pendant un incident, estimer combien d’utilisateurs d’un pays ou d’un navigateur sont exposés.
Piège : additionner les séries de plusieurs dimensions compte deux fois un même utilisateur : estimez au niveau voulu.
timeseries users = max(dt.frontend.user.active.estimated_count),
by: {frontend.name, geo.country.iso_code}
dt.frontend.web.page.largest_contentful_paint
Utilité : la Core Web Vital du chargement : quand le contenu principal devient visible.
Cas d’usage : suivre le percentile 75 par frontend, la statistique habituellement retenue pour les Core Web Vitals, et la comparer à votre objectif.
timeseries lcp = percentile(dt.frontend.web.page.largest_contentful_paint, 75),
by: {frontend.name}
dt.frontend.web.page.interaction_to_next_paint
Utilité : la réactivité de la page après un clic ou une saisie.
Cas d’usage : un INP qui se dégrade après l’ajout d’un script tiers se lit par navigateur et par type d’appareil.
Piège : dt.frontend.web.page.first_input_delay existe encore, mais INP l’a remplacé parmi les Core Web Vitals : préférez INP pour les nouveaux tableaux de bord.
timeseries inp = percentile(dt.frontend.web.page.interaction_to_next_paint, 75),
by: {frontend.name, device.type}
dt.frontend.web.page.cumulative_layout_shift
Utilité : la stabilité visuelle : les éléments qui bougent pendant le chargement.
Cas d’usage : après un changement de bannière publicitaire ou de police, vérifier que le CLS n’a pas bondi.
Piège : la valeur est stockée multipliée par 10 000 : multipliez par 0,0001 pour retrouver le score entre 0 et 1, comme l’indique la documentation.
timeseries cls = percentile(dt.frontend.web.page.cumulative_layout_shift, 75),
by: {frontend.name}
| fieldsAdd cls_score = cls[] * 0.0001
dt.frontend.web.navigation.time_to_first_byte
Utilité : la part serveur et réseau du chargement d’une page.
Cas d’usage : un TTFB qui monte avec un LCP stable désigne le back-end ou le CDN plutôt que le rendu.
timeseries ttfb = percentile(dt.frontend.web.navigation.time_to_first_byte, 75),
by: {frontend.name, geo.country.iso_code}
dt.frontend.web.navigation.load_event_end
Utilité : le repère de chargement complet, continuité avec les anciens tableaux de bord.
Cas d’usage : suivre la tendance mois par mois pour un frontend, en complément du LCP.
timeseries load = avg(dt.frontend.web.navigation.load_event_end),
by: {frontend.name}, interval: 1d, from: -30d
dt.frontend.mobile.app_start.duration
Utilité : le premier contact de l’utilisateur avec l’application.
Cas d’usage : comparer les démarrages par app_start.type et par version pour détecter une régression dans une nouvelle version.
Piège : le compte associé est dt.frontend.mobile.app_start.count ; lisez toujours la durée avec le volume.
timeseries start = percentile(dt.frontend.mobile.app_start.duration, 90),
by: {app_start.type, app.short_version}
Le tableau du monitoring synthétique
Huit clés dt.synthetic.* pour les moniteurs HTTP et navigateur. Les moniteurs réseau (dt.synthetic.multi_protocol.*) et tiers (dt.synthetic.third_party.*) existent aussi sur Grail ; ils sortent du périmètre de cette sélection.
| Clé | Unité | Dimensions principales | Ce qu’elle mesure |
|---|---|---|---|
dt.synthetic.http.availability |
% | dt.entity.http_check, dt.entity.synthetic_location, step.name |
Taux de disponibilité d’un moniteur HTTP |
dt.synthetic.http.duration |
ms | dt.entity.http_check, dt.entity.synthetic_location, step.name |
Durée cumulée des requêtes du moniteur |
dt.synthetic.http.executions |
nombre | dt.entity.http_check, result.state, result.status.code |
Exécutions du moniteur, par statut |
dt.synthetic.http.time_to_first_byte |
ms | dt.entity.http_check, dt.entity.synthetic_location, step.name |
Temps jusqu’au premier octet |
dt.synthetic.http.tls_handshake_time |
ms | dt.entity.http_check, dt.entity.synthetic_location, step.name |
Durée de la négociation TLS |
dt.synthetic.browser.availability |
% | dt.entity.synthetic_test, dt.entity.synthetic_location, step.name |
Taux de disponibilité d’un moniteur navigateur |
dt.synthetic.browser.duration |
ms | dt.entity.synthetic_test, dt.entity.synthetic_location, step.name |
Durée du moniteur navigateur (somme des étapes) |
dt.synthetic.browser.executions |
nombre | dt.entity.synthetic_test, result.state, result.status.code |
Exécutions du moniteur navigateur, par statut |
Fiches synthétiques : mesurer sans attendre l’utilisateur
dt.synthetic.http.availability
Utilité : le SLI de disponibilité le plus simple, mesuré de l’extérieur et indépendant du trafic réel.
Cas d’usage : classer les moniteurs du moins au plus disponible, comme dans l’exemple de la documentation.
Piège : pas d’équivalent Classic direct (N/A dans la table de correspondance) : un SLO migré doit être recalculé.
timeseries avail = avg(dt.synthetic.http.availability), by: {dt.entity.http_check}
| fieldsAdd monitor = entityName(dt.entity.http_check)
| sort arrayAvg(avail) asc
dt.synthetic.http.duration
Utilité : le temps de réponse de bout en bout d’un parcours d’API.
Cas d’usage : comparer la durée entre emplacements : un seul emplacement lent oriente vers le réseau, tous lents vers l’application.
timeseries d = avg(dt.synthetic.http.duration),
by: {dt.entity.http_check, dt.entity.synthetic_location}
dt.synthetic.http.executions
Utilité : dit pourquoi un moniteur échoue, pas seulement qu’il échoue.
Cas d’usage : répartir les échecs par result.status.code pour distinguer un délai dépassé d’une réponse HTTP inattendue.
timeseries runs = sum(dt.synthetic.http.executions),
by: {dt.entity.http_check, result.state, result.status.code}
dt.synthetic.http.time_to_first_byte
Utilité : isole le temps de traitement côté serveur dans la durée totale.
Cas d’usage : si la durée monte mais pas le TTFB, regardez le téléchargement ou les redirections.
timeseries ttfb = avg(dt.synthetic.http.time_to_first_byte), by: {dt.entity.http_check}
dt.synthetic.http.tls_handshake_time
Utilité : signale un problème de certificat, de chaîne ou de terminaison TLS.
Cas d’usage : un saut après un renouvellement de certificat ou un changement de répartiteur se voit immédiatement.
timeseries tls = avg(dt.synthetic.http.tls_handshake_time),
by: {dt.entity.http_check, dt.entity.synthetic_location}
dt.synthetic.browser.availability
Utilité : la disponibilité d’un parcours complet (connexion, panier, paiement) tel qu’un utilisateur le jouerait.
Cas d’usage : SLO de disponibilité d’un parcours critique, avec une alerte sur le budget d’erreur.
timeseries avail = avg(dt.synthetic.browser.availability), by: {dt.entity.synthetic_test}
| fieldsAdd monitor = entityName(dt.entity.synthetic_test)
| sort arrayAvg(avail) asc
dt.synthetic.browser.duration
Utilité : la performance d’un parcours scénarisé, stable d’une exécution à l’autre.
Cas d’usage : pour trouver l’étape lente, descendez à dt.synthetic.browser.step.duration par step.name.
timeseries d = avg(dt.synthetic.browser.duration), by: {dt.entity.synthetic_test}
dt.synthetic.browser.executions
Utilité : compte les réussites et les échecs, avec le code de résultat.
Cas d’usage : vérifier qu’un moniteur s’exécute bien à la fréquence prévue : un trou dans la série est une absence de mesure, pas une réussite.
Piège : la dimension maintenance_window n’existe que dans Synthetic Classic ; sur Grail, utilisez dt.maintenance_window_ids pour écarter les fenêtres de maintenance.
timeseries runs = sum(dt.synthetic.browser.executions, default: 0),
by: {dt.entity.synthetic_test, result.state}
Comment vérifier que ça fonctionne
- Dans un notebook, exécutez
timeseries sum(dt.frontend.user_action.count), by: {frontend.name}: chaque frontend instrumenté avec le nouveau RUM doit apparaître. - Si rien ne sort alors que l’application est surveillée, elle tourne probablement encore en RUM Classic : ses métriques restent sous
builtin:apps.*, hors Grail. - Pour le synthétique, exécutez
timeseries avg(dt.synthetic.http.availability), by: {dt.entity.http_check}et comparez avec l’écran du moniteur dans l’application Synthetic. - Vérifiez l’unité avant chaque seuil : millisecondes pour le RUM et le synthétique, ×10 000 pour le CLS.
Bonnes pratiques
- Lisez les Core Web Vitals au percentile 75, pas en moyenne.
- Associez chaque durée à son volume (actions, sessions, exécutions) avant de conclure.
- Gardez un moniteur synthétique sur chaque parcours critique : il alerte même sans trafic.
Pour aller plus loin : alertes burn rate sur les SLO transforme une disponibilité synthétique en alerte sur le budget d’erreur. Sources : Built-in RUM metrics, HTTP monitor metrics et Browser monitor metrics.
← Module 3 : Métriques de service Grail · Sommaire du parcours · Module 5 : Métriques Kubernetes Grail →
Questions fréquentes
Où sont passées les métriques builtin:apps de RUM Classic ?
Elles ne sont pas prises en charge sur Grail. La page de migration RUM propose des remplaçants au rôle analogue, par exemple dt.frontend.user_action.count pour builtin:apps.web.actionCount.*, avec des valeurs qui peuvent différer.
Où est l’Apdex ?
Aucune clé Apdex ne figure dans la liste des métriques RUM intégrées ni dans la table de correspondance. Suivez plutôt les percentiles de durée et les Core Web Vitals.
RUM ou synthétique pour un SLO de disponibilité ?
Le synthétique donne une mesure régulière, même sans trafic ; le RUM reflète l’expérience réelle mais dépend du volume. Beaucoup d’équipes utilisent le synthétique pour le SLO et le RUM pour le diagnostic.
Ces vingt et une clés couvrent l’expérience vue par l’utilisateur, réelle ou simulée. Le module suivant redescend dans l’infrastructure applicative : processus, runtimes, conteneurs et Kubernetes.
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.