Module 4 du parcours métriques Dynatrace Managed : les métriques application builtin du RUM web et mobile (Apdex, actions utilisateur, Core Web Vitals, erreurs, crashs) et des moniteurs synthétiques, en 23 fiches avec clé exacte, unité, cas d’usage et selector prêt à coller.
Parcours : Formation aux métriques Dynatrace Managed · Module 4/7 · Type : référence · Plateforme : Dynatrace Managed (métriques classiques)
Dans ce module :
- un tableau récapitulatif des 23 clés, à garder sous la main
- une fiche par métrique : ce qu’elle mesure, quand l’utiliser, le piège à éviter
- un metric selector par fiche, testable dans le Data Explorer
Les modules précédents regardent le système de l’intérieur : hôtes, services, bases. Ce module regarde depuis l’utilisateur. Le RUM mesure ce que vivent les vrais visiteurs dans leur navigateur ou leur application mobile ; le synthétique rejoue un parcours à intervalle fixe, même la nuit quand personne ne se connecte. Ensemble, ils fournissent les SLI les plus proches de ce que ressent le client.
Tout ce qui suit vaut pour Dynatrace Managed : clés builtin:apps.* et builtin:synthetic.*, metric selector, API Metrics v2 et Data Explorer. Il n’y a ni Grail ni DQL ici. Sur Dynatrace SaaS avec Grail, le RUM et le synthétique utilisent d’autres clés ; elles sont traitées dans le parcours métriques SaaS.
Ce module prolonge le module 3 consacré aux services : une action utilisateur lente se lit souvent avec le service qu’elle appelle. Pour la mise en place, voir le RUM et les Core Web Vitals et le monitoring synthétique HTTP et navigateur.
Les métriques application builtin en un tableau
Toutes les clés, unités et agrégations ci-dessous proviennent de la liste officielle des métriques intégrées de Dynatrace Managed. La colonne « Portée » reprend l’étiquette de la documentation ([web], [mobile, custom], [browser monitor], [HTTP monitor]) ; les dimensions exactes se lisent dans le descripteur de chaque métrique. Une unité vide signifie un score sans unité.
| Clé | Unité | Agrégations | Portée | Ce qu’elle mesure |
|---|---|---|---|---|
builtin:apps.web.apdex.userType |
(score) | avg | Web | Apdex des actions utilisateur, par type d’utilisateur |
builtin:apps.web.actionCount.load.browser |
Count | value | Web | Nombre d’actions de chargement, par navigateur |
builtin:apps.web.actionDuration.load.browser |
Millisecond | avg, count, max, median, min, percentile, sum | Web | Durée des actions de chargement |
builtin:apps.web.actionDuration.xhr.browser |
Millisecond | avg, count, max, median, min, percentile, sum | Web | Durée des actions XHR |
builtin:apps.web.visuallyComplete.load.browser |
Millisecond | avg, count, max, median, min, percentile, sum | Web | Temps de rendu complet de la zone visible |
builtin:apps.web.largestContentfulPaint.load.browser |
Millisecond | avg, count, max, median, min, percentile, sum | Web | Largest Contentful Paint (LCP) |
builtin:apps.web.cumulativeLayoutShift.load.browser |
(score) | avg, count, max, median, min, percentile, sum | Web | Cumulative Layout Shift (CLS) |
builtin:apps.web.interactionToNextPaint |
Millisecond | count, max, median, min, percentile | Web | Interaction to Next Paint (INP) |
builtin:apps.web.activeSessions |
Count | value | Web | Sessions actives estimées |
builtin:apps.web.bouncedSessionRatio |
Percent (%) | value | Web | Taux de rebond |
builtin:apps.web.countOfErrors |
Count | value | Web | Erreurs détectées, par type et origine |
builtin:apps.web.jsErrorsDuringUa |
Count | value | Web | Erreurs JavaScript pendant une action utilisateur |
builtin:apps.web.percentageOfUserActionsAffectedByErrors |
Percent (%) | value | Web | % d’actions utilisateur touchées par une erreur |
builtin:apps.other.apdex.osAndVersion |
(score) | value | Mobile, custom | Apdex par OS et version de l’app |
builtin:apps.other.uaDuration.osAndVersion |
Microsecond | avg, count, max, median, min, percentile, sum | Mobile, custom | Durée des actions utilisateur |
builtin:apps.other.crashCount.osAndVersion |
Count | value | Mobile, custom | Crashs détectés, par OS et version |
builtin:apps.other.crashFreeUsersRate.os |
Percent (%) | value | Mobile, custom | % estimé d’utilisateurs sans crash |
builtin:synthetic.browser.availability.location.total |
Percent (%) | avg | Moniteur navigateur | Taux de disponibilité, par emplacement |
builtin:synthetic.browser.failure |
Count | value | Moniteur navigateur | Exécutions en échec |
builtin:synthetic.browser.totalDuration |
Millisecond | avg, count, max, median, min, percentile, sum | Moniteur navigateur | Durée totale des actions d’une exécution |
builtin:synthetic.http.availability.location.total |
Percent (%) | avg | Moniteur HTTP | Taux de disponibilité, par emplacement |
builtin:synthetic.http.duration.geo |
Millisecond | avg, count, max, min, sum | Moniteur HTTP | Durée cumulée des requêtes, par emplacement |
builtin:synthetic.http.statusCode |
Count | value | Moniteur HTTP | Exécutions par code de statut HTTP |
{{img:141-metriques-application-builtin-1.png|Extrait de la documentation Dynatrace Managed : clés builtin:apps.web, apps.other et synthetic avec leur nom, leur unité et leurs agrégations}}
Comment lire une fiche
Chaque fiche suit le même ordre : ce que mesure la métrique, un cas d’usage concret, un piège, puis un selector. Les selectors découpent par dt.entity.application pour le web, dt.entity.synthetic_test pour les moniteurs navigateur et dt.entity.http_check pour les moniteurs HTTP, avec seulement les transformations documentées (splitBy, sort, limit, agrégations, percentile). Les seuils évoqués sont des repères à calibrer sur votre historique, pas des valeurs officielles, sauf mention explicite.
Applications web : expérience et performance
builtin:apps.web.apdex.userType
Score Apdex de 0 à 1 calculé sur les actions utilisateur, découpable par type d’utilisateur (réel, synthétique, robot). C’est l’indicateur de synthèse de l’expérience : il combine satisfaits, tolérants et frustrés selon les seuils configurés dans l’application. Cas d’usage : un SLO « Apdex des utilisateurs réels » par application. Piège : sans filtrer le type d’utilisateur, les robots et le synthétique se mélangent au trafic réel.
builtin:apps.web.apdex.userType:splitBy("dt.entity.application"):avg:sort(value(avg,ascending)):limit(10)
builtin:apps.web.actionCount.load.browser
Nombre d’actions de chargement de page, découpé par navigateur. C’est le trafic vu du client, la contrepartie du débit des services. Cas d’usage : une chute brutale alors que les services répondent normalement signale souvent un problème de CDN, de DNS ou d’injection du JavaScript RUM. Piège : les actions XHR et custom ont leurs propres clés ; une application monopage génère peu de « load ».
builtin:apps.web.actionCount.load.browser:splitBy("dt.entity.application"):sum
builtin:apps.web.actionDuration.load.browser
Durée des actions de chargement, du clic à la fin du chargement. Cas d’usage : suivre le 90e percentile par application plutôt que la moyenne, qui masque la queue lente. Piège : cette durée inclut le réseau du client et le rendu ; une hausse ne vient pas forcément du back-end.
builtin:apps.web.actionDuration.load.browser:splitBy("dt.entity.application"):percentile(90)
builtin:apps.web.actionDuration.xhr.browser
Durée des actions XHR, c’est-à-dire les appels asynchrones déclenchés par un clic dans une page déjà chargée. Pour une application monopage, c’est souvent la métrique de performance principale. Cas d’usage : corréler une hausse avec le temps de réponse du service appelé (module 3). Piège : des appels de fond mal regroupés peuvent gonfler ou fausser la mesure.
builtin:apps.web.actionDuration.xhr.browser:splitBy("dt.entity.application"):percentile(90)
builtin:apps.web.visuallyComplete.load.browser
Temps nécessaire pour que le contenu de la zone visible soit entièrement rendu. Métrique propre à Dynatrace, elle colle à la perception « la page est prête ». Cas d’usage : comparer avant et après un déploiement front-end. Piège : un carrousel ou une animation sans fin peuvent retarder la valeur sans gêner l’utilisateur.
builtin:apps.web.visuallyComplete.load.browser:splitBy("dt.entity.application"):median
builtin:apps.web.largestContentfulPaint.load.browser
Temps de rendu du plus grand élément de la zone visible, l’un des Core Web Vitals. Google qualifie de « bon » un LCP inférieur ou égal à 2,5 s au 75e percentile ; ce repère vient de web.dev, pas de Dynatrace. Cas d’usage : suivre le LCP des pages d’atterrissage, sensibles au référencement. Piège : calculé seulement pour les actions de chargement et les navigateurs qui exposent l’API.
builtin:apps.web.largestContentfulPaint.load.browser:splitBy("dt.entity.application"):percentile(75)
builtin:apps.web.cumulativeLayoutShift.load.browser
Score sans unité des déplacements inattendus d’éléments visibles pendant le chargement. Cas d’usage : détecter une bannière ou une publicité insérée sans réserver sa place, qui fait cliquer au mauvais endroit. Piège : c’est un score, pas une durée ; ne le mettez pas sur le même axe que les métriques en millisecondes.
builtin:apps.web.cumulativeLayoutShift.load.browser:splitBy("dt.entity.application"):percentile(75)
builtin:apps.web.interactionToNextPaint
Interaction to Next Paint : délai entre une interaction (clic, saisie) et l’affichage suivant. Le Core Web Vital de réactivité qui remplace le First Input Delay. Cas d’usage : repérer un JavaScript trop lourd qui fige l’interface. Piège : la documentation ne liste pas l’agrégation avg pour cette clé ; utilisez médiane ou percentile.
builtin:apps.web.interactionToNextPaint:splitBy("dt.entity.application"):percentile(75)
builtin:apps.web.activeSessions
Nombre estimé de sessions actives, c’est-à-dire où l’utilisateur est confirmé encore présent. La documentation précise que l’estimation repose sur l’algorithme HyperLogLog. Cas d’usage : savoir combien d’utilisateurs un incident touche en ce moment, chiffre attendu dans toute communication d’incident. Piège : valeur approchée ; ne la réconciliez pas au chiffre près avec un outil marketing.
builtin:apps.web.activeSessions:splitBy("dt.entity.application"):max
builtin:apps.web.bouncedSessionRatio
Pourcentage de sessions limitées à une seule page et une seule requête web. Cas d’usage : une hausse brusque après une mise en production peut révéler une page d’accueil cassée que les métriques techniques ne voient pas. Piège : le rebond dépend beaucoup du type de page ; une page d’information a naturellement un taux élevé.
builtin:apps.web.bouncedSessionRatio:splitBy("dt.entity.application"):avg
builtin:apps.web.countOfErrors
Nombre d’erreurs détectées, découpable par type d’utilisateur, type d’erreur et origine. Cas d’usage : séparer les erreurs JavaScript des erreurs de requête pour savoir quelle équipe appeler. Piège : un script tiers bruyant (publicité, chat) peut dominer le compteur ; filtrez l’origine avant d’alerter.
builtin:apps.web.countOfErrors:splitBy("dt.entity.application"):sum:sort(value(sum,descending)):limit(10)
builtin:apps.web.jsErrorsDuringUa
Erreurs JavaScript survenues pendant une action utilisateur. Sa jumelle builtin:apps.web.jsErrorsWithoutUa compte celles survenues entre deux actions. Cas d’usage : les erreurs pendant une action touchent directement un clic, elles sont plus urgentes. Piège : un compteur brut grandit avec le trafic ; rapportez-le au nombre d’actions.
builtin:apps.web.jsErrorsDuringUa:splitBy("dt.entity.application"):sum
builtin:apps.web.percentageOfUserActionsAffectedByErrors
Pourcentage d’actions utilisateur avec au moins une erreur détectée. Déjà normalisée par le trafic, elle fait un bon SLI d’erreur côté client. Cas d’usage : un SLO « moins de X % d’actions en erreur », X fixé à partir de votre historique. Piège : une erreur sans impact visible compte autant qu’une page blanche.
builtin:apps.web.percentageOfUserActionsAffectedByErrors:splitBy("dt.entity.application"):avg
Applications mobiles et custom
builtin:apps.other.apdex.osAndVersion
Apdex des actions utilisateur d’une application mobile ou custom, par OS et version de l’application. Cas d’usage : vérifier qu’une nouvelle version publiée sur les stores ne dégrade pas l’expérience avant d’élargir le déploiement progressif. Piège : les anciennes versions gardent peu d’utilisateurs ; leur Apdex varie fortement sur un petit échantillon.
builtin:apps.other.apdex.osAndVersion:splitBy():avg
builtin:apps.other.uaDuration.osAndVersion
Durée des actions utilisateur mobiles, par OS et version. Cas d’usage : comparer le 90e percentile entre deux versions de l’app. Piège : l’unité est la microseconde, pas la milliseconde comme pour le web ; vérifiez l’axe avant de conclure à une régression.
builtin:apps.other.uaDuration.osAndVersion:splitBy():percentile(90)
builtin:apps.other.crashCount.osAndVersion
Nombre de crashs détectés, par OS et version. Cas d’usage : une version qui concentre les crashs juste après sa publication justifie un gel du déploiement. Piège : un compteur absolu suit le nombre d’utilisateurs ; préférez le taux d’utilisateurs sans crash pour comparer.
builtin:apps.other.crashCount.osAndVersion:splitBy():sum
builtin:apps.other.crashFreeUsersRate.os
Pourcentage estimé d’utilisateurs uniques non touchés par un crash, par OS (estimation HyperLogLog selon la documentation). C’est le SLI de stabilité mobile le plus lisible pour une équipe produit. Cas d’usage : suivre un objectif de stabilité par plateforme iOS et Android. Piège : valeur estimée, peu fiable sur une application à très faible audience.
builtin:apps.other.crashFreeUsersRate.os:splitBy():avg
Moniteurs synthétiques navigateur et HTTP
builtin:synthetic.browser.availability.location.total
Taux de disponibilité des moniteurs navigateur, par emplacement. Cas d’usage : SLI de disponibilité d’un parcours critique (connexion, paiement), mesuré même sans trafic réel. La variante …totalWoMaintenanceWindow exclut les fenêtres de maintenance, utile pour un rapport de SLA. Piège : un seul emplacement en échec fait baisser la moyenne ; regardez le découpage par lieu avant d’escalader.
builtin:synthetic.browser.availability.location.total:splitBy("dt.entity.synthetic_test"):avg
builtin:synthetic.browser.failure
Nombre d’exécutions en échec d’un moniteur navigateur. Rapporté à builtin:synthetic.browser.total, il donne un taux d’échec. Cas d’usage : alerter sur plusieurs échecs consécutifs plutôt que sur un seul, souvent dû à un aléa réseau de l’emplacement. Piège : un script cassé par un changement d’interface échoue aussi ; vérifiez le détail avant d’accuser la production.
builtin:synthetic.browser.failure:splitBy("dt.entity.synthetic_test"):sum
builtin:synthetic.browser.totalDuration
Durée de toutes les actions d’une exécution, par moniteur. Cas d’usage : une ligne de base stable, sans la variabilité des réseaux clients, pour détecter une régression de performance au déploiement. Piège : ajouter une étape au script allonge la durée ; annotez ces changements sur vos graphiques.
builtin:synthetic.browser.totalDuration:splitBy("dt.entity.synthetic_test"):avg
builtin:synthetic.http.availability.location.total
Taux de disponibilité des moniteurs HTTP, par emplacement. Plus légers que les moniteurs navigateur, ils surveillent API et points de santé à haute fréquence. Cas d’usage : SLI de disponibilité d’une API publique. Piège : un moniteur HTTP valide une réponse, pas le rendu d’une page ; il ne remplace pas un moniteur navigateur pour un parcours.
builtin:synthetic.http.availability.location.total:splitBy("dt.entity.http_check"):avg
builtin:synthetic.http.duration.geo
Durée cumulée de toutes les requêtes d’un moniteur HTTP, par emplacement. Les clés voisines …dns.geo, …tcpConnectTime.geo, …tlsHandshakeTime.geo et …timeToFirstByte.geo décomposent ce temps. Cas d’usage : une hausse limitée à un seul emplacement oriente vers le réseau plutôt que l’application. Piège : pas de médiane ni de percentile documentés pour cette clé.
builtin:synthetic.http.duration.geo:splitBy("dt.entity.http_check"):max
builtin:synthetic.http.statusCode
Nombre d’exécutions par code de statut HTTP, par emplacement. Cas d’usage : distinguer un 503 (service indisponible) d’un 401 (jeton expiré dans le moniteur), deux incidents très différents. Piège : un 200 ne garantit pas un contenu correct ; ajoutez une règle de validation dans le moniteur.
builtin:synthetic.http.statusCode:splitBy("dt.entity.http_check"):sum
Comment vérifier que ça fonctionne
- Ouvrez le Data Explorer, passez en mode Code et collez un selector d’une fiche : un graphique doit s’afficher en quelques secondes.
- Si la réponse est vide, lisez le descripteur :
GET /api/v2/metrics/builtin:apps.web.apdex.userTypeavec un jeton portant le scopemetrics.read. Il liste unité, agrégations et dimensions. - Pour le RUM web, vérifiez que l’application est bien détectée et que le JavaScript RUM est injecté dans les pages (onglet réseau du navigateur).
- Pour le synthétique, vérifiez que le moniteur est actif et qu’un emplacement (public ou privé, ActiveGate synthétique) lui est assigné.
curl -s -H "Authorization: Api-Token $DT_TOKEN" \
"https://managed.example.com/e/ENV-ID/api/v2/metrics/query?metricSelector=builtin:synthetic.http.availability.location.total:avg&from=now-24h"
Bonnes pratiques
- Combinez RUM et synthétique : le RUM dit ce que vivent les utilisateurs, le synthétique dit si le service répond quand personne ne l’utilise.
- Percentiles plutôt que moyennes pour les durées : la moyenne cache les utilisateurs les plus lents.
- Filtrez les robots et le synthétique des SLO d’expérience réelle grâce au type d’utilisateur.
Questions fréquentes
Pourquoi les clés mobiles commencent-elles par apps.other ?
Dans Dynatrace Managed, les applications mobiles et custom partagent la famille builtin:apps.other.*, étiquetée [mobile, custom] dans la documentation. Seules quelques clés, comme builtin:apps.mobile.sessionCount, portent un préfixe dédié.
Les Core Web Vitals de Dynatrace sont-ils les mêmes que ceux de Google ?
Ils mesurent les mêmes phénomènes (LCP, CLS, INP) chez vos vrais utilisateurs, mais sur votre population et vos navigateurs. Les chiffres peuvent donc différer des rapports de Google, qui s’appuient sur un autre échantillon.
Ces clés fonctionnent-elles sur Dynatrace SaaS ?
Dans l’interface classique de SaaS, oui. Sur Grail, le RUM et le synthétique exposent d’autres clés interrogées en DQL ; le parcours métriques SaaS les détaille.
Avec ces 23 fiches, vous disposez des SLI côté utilisateur : expérience, réactivité, erreurs, stabilité mobile et disponibilité synthétique. Le module suivant redescend vers les processus, les runtimes et les conteneurs.
← Module 3 : services · Sommaire du parcours · Module 5 : processus et conteneurs →
span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Ce module est une sélection commentée : la référence reste la documentation officielle de votre version de Dynatrace Managed, où chaque clé, unité et agrégation doit être vérifiée.