Module 5 du parcours métriques Dynatrace Managed : les métriques processus builtin, celles des runtimes (JVM, .NET, Node.js, Go), des conteneurs et de Kubernetes, en 24 fiches avec clé exacte, unité, cas d’usage et selector prêt à coller.
Parcours : Formation aux métriques Dynatrace Managed · Module 5/7 · Type : référence · Plateforme : Dynatrace Managed (métriques classiques)
Dans ce module :
- un tableau récapitulatif des 24 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
Quand un hôte va mal, la question suivante est toujours la même : quel processus, quelle JVM, quel conteneur ? Les métriques de ce module répondent à cette question. Elles se situent sous le service et au-dessus de l’hôte, et ce sont elles qui raccourcissent le diagnostic, donc le MTTR, quand une alerte d’infrastructure tombe la nuit.
Tout ce qui suit vaut pour Dynatrace Managed : clés builtin:, metric selector, API Metrics v2 et Data Explorer. Il n’y a ni Grail ni DQL ici. Sur Dynatrace SaaS, les mêmes mesures portent des clés dt.process.*, dt.runtime.* ou dt.kubernetes.* ; elles sont traitées dans le parcours métriques SaaS.
Ce module fait le lien entre le module 2 sur les hôtes et le module 3 sur les services. Ici, on va droit à la fiche.
Les métriques processus 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 la section de la documentation ; les dimensions exactes se lisent dans le descripteur de chaque métrique.
| Clé | Unité | Agrégations | Portée | Ce qu’elle mesure |
|---|---|---|---|---|
builtin:tech.generic.cpu.usage |
Percent (%) | avg, max, min | Processus | CPU du processus, en % du CPU de l’hôte |
builtin:tech.generic.mem.workingSetSize |
Byte | avg, max, min | Processus | Mémoire utilisée par le processus |
builtin:tech.generic.mem.exhaustedMem |
Count | value | Processus | Événements « Memory resource exhausted » |
builtin:tech.generic.handles.fileDescriptorsPercentUsed |
Percent (%) | avg, max, min | Processus (Linux) | % de la limite de descripteurs de fichiers |
builtin:tech.generic.network.packets.retransmission |
Percent (%) | avg, max, min | Processus (réseau) | % de paquets retransmis |
builtin:tech.generic.network.sessions.reset |
Per second | avg, max, min | Processus (réseau) | Sessions TCP entrantes réinitialisées |
builtin:tech.generic.processCount |
Count | avg, max, min | Processus | Nombre de processus workers |
builtin:pgi.availability.state |
Count | value | Instance de processus | État de disponibilité du processus, par minute |
builtin:tech.jvm.memory.pool.used |
Byte | avg, max, min | JVM | Mémoire utilisée par pool du tas |
builtin:tech.jvm.memory.gc.suspensionTime |
Percent (%) | avg, max, min | JVM | Part du temps passée en pause GC |
builtin:tech.jvm.memory.gc.collectionTime |
Millisecond | value | JVM | Temps cumulé de collecte, tous pools |
builtin:tech.jvm.threads.count |
Count | avg, max, min | JVM | Threads vivants de la JVM |
builtin:tech.dotnet.gc.timePercentage |
Percent (%) | avg, max, min | .NET | % du temps passé dans le GC .NET |
builtin:tech.dotnet.threadpool.queuedWorkItems |
Count | avg, max, min | .NET | Éléments en attente dans le pool de threads |
builtin:tech.nodejs.uvLoop.loopLatency |
Nanosecond | avg, max, min | Node.js | Latence de la boucle d’événements |
builtin:tech.nodejs.v8heap.used |
Byte | avg, max, min | Node.js | Tas V8 occupé par les données |
builtin:tech.go.memory.heap.live |
Byte | avg, max, min | Go | Tas Go considéré vivant par le GC |
builtin:containers.cpu.throttledMilliCores |
Millicores | avg, max, min | Conteneur | Bridage CPU du conteneur |
builtin:containers.memory.limitPercent |
Percent (%) | avg | Conteneur | Limite mémoire, en % de la mémoire physique |
builtin:containers.memory.outOfMemoryKills |
Count | value | Conteneur | Arrêts pour dépassement mémoire (OOM kills) |
builtin:kubernetes.container.restarts |
Count | value | Kubernetes (conteneur) | Redémarrages de conteneurs |
builtin:kubernetes.node.requests_cpu |
Millicores | avg, max, min | Kubernetes (nœud) | Requests CPU des pods, par nœud |
builtin:kubernetes.workload.pods_desired |
Count | avg, max, min | Kubernetes (workload) | Pods désirés par workload |
builtin:kubernetes.persistentvolumeclaim.used |
Byte | avg, max, min | Kubernetes (PVC) | Octets utilisés dans le volume |
{{img:142-metriques-processus-builtin-1.png|Extrait de la documentation Dynatrace Managed : clés builtin:tech.jvm, tech.dotnet et tech.nodejs avec leur nom et leur unité}}
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.process_group_instance quand la métrique porte sur un processus, et utilisent seulement les transformations documentées (splitBy, sort, limit, agrégations). Les seuils évoqués sont des repères à calibrer sur votre historique, pas des valeurs officielles.
Processus : CPU, mémoire, réseau et disponibilité
builtin:tech.generic.cpu.usage
Somme du temps CPU de tous les workers du processus, rapportée au CPU disponible de l’hôte : 100 % signifie que le processus consomme tout l’hôte. C’est la première métrique à ouvrir quand builtin:host.cpu.usage monte : elle dit quel processus en est responsable. Cas d’usage : classer les dix processus les plus gourmands d’un hôte saturé. Piège : sur un hôte à 16 cœurs, un processus mono-thread plafonne vers 6 % ; un chiffre bas ne prouve pas l’absence de goulot.
builtin:tech.generic.cpu.usage:splitBy("dt.entity.process_group_instance"):sort(value(avg,descending)):limit(10)
builtin:tech.generic.mem.workingSetSize
Somme de la mémoire utilisée par chaque worker, mémoire partagée comprise. La documentation la présente comme l’outil pour repérer les gros consommateurs et les fuites. Cas d’usage : une courbe en dents de scie qui ne redescend jamais au même niveau après chaque redémarrage signale une fuite probable. Piège : la mémoire partagée est comptée, donc additionner plusieurs processus d’un même hôte surestime le total.
builtin:tech.generic.mem.workingSetSize:splitBy("dt.entity.process_group_instance"):sort(value(max,descending)):limit(10)
builtin:tech.generic.mem.exhaustedMem
Nombre d’événements « Memory resource exhausted » émis par les workers en une minute ; la JVM les génère quand elle manque de mémoire. Cas d’usage : toute valeur non nulle sur une JVM de production mérite une analyse, souvent avant le OutOfMemoryError visible dans les logs. Piège : l’absence de point ne veut pas dire zéro ; vérifiez que le processus est bien une JVM surveillée en profondeur.
builtin:tech.generic.mem.exhaustedMem:splitBy("dt.entity.process_group_instance")
builtin:tech.generic.handles.fileDescriptorsPercentUsed
Plus fort pourcentage de la limite de descripteurs de fichiers utilisé parmi les workers, sous Linux. Cas d’usage : un serveur qui ouvre des connexions sans les fermer approche lentement de 100 %, puis échoue avec « Too many open files ». Une alerte bien avant la limite laisse le temps d’agir. Piège : la métrique n’existe pas sous Windows.
builtin:tech.generic.handles.fileDescriptorsPercentUsed:splitBy("dt.entity.process_group_instance"):max
builtin:tech.generic.network.packets.retransmission
Pourcentage de paquets TCP retransmis pour le processus, mesuré par l’analyse réseau de OneAgent. Cas d’usage : un service lent sans cause applicative visible ; une hausse des retransmissions pointe vers le réseau (perte, saturation, MTU) plutôt que vers le code. Piège : sur un faible volume de paquets, quelques retransmissions donnent un pourcentage spectaculaire ; regardez-le avec le trafic.
builtin:tech.generic.network.packets.retransmission:splitBy("dt.entity.process_group_instance"):max
builtin:tech.generic.network.sessions.reset
Nombre par seconde de sessions TCP entrantes terminées par une erreur de réinitialisation (RST). Cas d’usage : après un changement de répartiteur de charge ou de pare-feu, une hausse soudaine trahit des connexions coupées en cours de route. Piège : certains clients ferment volontairement par RST ; comparez à une période de référence plutôt qu’à zéro.
builtin:tech.generic.network.sessions.reset:splitBy("dt.entity.process_group_instance"):avg
builtin:tech.generic.processCount
Nombre de workers d’un processus (Apache, PHP-FPM, IIS…). La documentation rappelle qu’un nombre trop faible dégrade les performances et qu’un nombre trop élevé gaspille des ressources. Cas d’usage : vérifier que le pool monte réellement en charge lors d’un pic. Piège : à ne pas confondre avec builtin:tech.generic.count, qui compte les processus d’un groupe.
builtin:tech.generic.processCount:splitBy("dt.entity.process_group_instance"):max
builtin:pgi.availability.state
État de disponibilité de l’instance de processus, publié toutes les minutes. Cas d’usage : construire un SLO de disponibilité d’un composant sans dépendre du trafic, ou repérer les redémarrages nocturnes. Piège : c’est un état, pas un pourcentage ; lisez le descripteur pour connaître la dimension d’état avant de filtrer.
builtin:pgi.availability.state:splitBy("dt.entity.process_group_instance")
Technologies : JVM, .NET, Node.js et Go
builtin:tech.jvm.memory.pool.used
Mémoire actuellement occupée dans chaque pool de la JVM (Eden, Survivor, Old Gen selon le collecteur). Cas d’usage : l’Old Gen qui remonte après chaque collecte majeure est le signe classique d’une fuite. Piège : l’Eden oscille naturellement entre vide et plein ; additionner tous les pools masque la seule courbe qui compte.
builtin:tech.jvm.memory.pool.used:splitBy("dt.entity.process_group_instance"):max
builtin:tech.jvm.memory.gc.suspensionTime
Temps passé entre le début et la fin des pauses du ramasse-miettes, exprimé en pourcentage. C’est la métrique qui relie le GC au ressenti utilisateur : pendant une pause, l’application ne répond pas. Cas d’usage : corréler des pics de temps de réponse avec des pics de suspension. Piège : une moyenne sur une heure lisse les pauses longues ; utilisez max.
builtin:tech.jvm.memory.gc.suspensionTime:splitBy("dt.entity.process_group_instance"):max
builtin:tech.jvm.memory.gc.collectionTime
Temps approximatif passé à collecter, tous pools confondus. Cas d’usage : comparer deux versions d’une application ou deux réglages de collecteur sur la même charge. Piège : la documentation SaaS signale que cette clé diverge de son équivalent Grail pour les processus Go ; en Managed, tenez-vous-en à la clé builtin: et à son descripteur.
builtin:tech.jvm.memory.gc.collectionTime:splitBy("dt.entity.process_group_instance")
builtin:tech.jvm.threads.count
Nombre de threads vivants, démons compris. Cas d’usage : une croissance continue trahit un pool sans borne ou des threads jamais libérés, avant que la JVM ne manque de mémoire native. Piège : un nombre élevé et stable est normal sur un serveur d’applications ; c’est la tendance qui compte.
builtin:tech.jvm.threads.count:splitBy("dt.entity.process_group_instance"):max
builtin:tech.dotnet.gc.timePercentage
Pourcentage du temps passé dans le ramasse-miettes du CLR. Cas d’usage : une application ASP.NET qui ralentit sous charge alors que le CPU de l’hôte reste raisonnable ; un % de GC élevé oriente vers les allocations (chaînes, grands objets) plutôt que vers la base. Piège : lisez-la avec la consommation du tas des grands objets (LOH), souvent en cause.
builtin:tech.dotnet.gc.timePercentage:splitBy("dt.entity.process_group_instance"):max
builtin:tech.dotnet.threadpool.queuedWorkItems
Nombre d’éléments de travail en file dans le pool de threads managé. Cas d’usage : la file qui grossit pendant que les temps de réponse explosent est la signature d’une saturation du pool, souvent due à des appels bloquants dans du code asynchrone. Piège : une file brève lors d’un pic est normale ; alertez sur une file qui dure.
builtin:tech.dotnet.threadpool.queuedWorkItems:splitBy("dt.entity.process_group_instance"):max
builtin:tech.nodejs.uvLoop.loopLatency
Latence moyenne entre le moment où un événement est attendu et celui où il est traité. Node.js étant mono-thread, une boucle bloquée retarde toutes les requêtes. Cas d’usage : repérer un traitement synchrone coûteux (JSON volumineux, chiffrement) introduit par une nouvelle version. Piège : l’unité est la nanoseconde ; convertissez avant de comparer à des temps de réponse en millisecondes.
builtin:tech.nodejs.uvLoop.loopLatency:splitBy("dt.entity.process_group_instance"):max
builtin:tech.nodejs.v8heap.used
Taille du tas V8 occupée par les données de l’application, mesurée par instantané périodique. Cas d’usage : une hausse continue jusqu’au plafond du tas précède les plantages « heap out of memory ». Piège : à comparer à builtin:tech.nodejs.v8heap.total ; seule la marge entre les deux renseigne sur le risque.
builtin:tech.nodejs.v8heap.used:splitBy("dt.entity.process_group_instance"):max
builtin:tech.go.memory.heap.live
Mémoire considérée comme vivante par le ramasse-miettes Go : ce qu’a retenu la dernière collecte, plus ce qui a été alloué depuis. Cas d’usage : suivre l’empreinte réelle d’un service Go après une montée de version. Piège : la mémoire du processus vue par l’OS reste plus haute, le runtime gardant des pages inactives.
builtin:tech.go.memory.heap.live:splitBy("dt.entity.process_group_instance"):max
Conteneurs et Kubernetes
builtin:containers.cpu.throttledMilliCores
CPU refusé au conteneur par sa limite, en millicœurs. Cas d’usage : un conteneur lent alors que l’hôte a du CPU libre ; un bridage non nul montre que la limite, pas la machine, est le goulot. Piège : sans limite CPU définie, il n’y a pas de bridage à mesurer.
builtin:containers.cpu.throttledMilliCores:sort(value(max,descending)):limit(10)
builtin:containers.memory.limitPercent
Limite mémoire du conteneur rapportée à la mémoire physique de l’hôte ; vide si aucune limite n’est posée. Cas d’usage : faire l’inventaire des conteneurs sans limite, ceux qui peuvent affamer leurs voisins. Piège : une valeur absente est ici une information, pas un trou de collecte.
builtin:containers.memory.limitPercent:sort(value(avg,descending))
builtin:containers.memory.outOfMemoryKills
Nombre d’arrêts du conteneur par le noyau pour dépassement de mémoire. Cas d’usage : expliquer des redémarrages sans trace dans les logs applicatifs ; toute valeur non nulle se traite comme un incident. Piège : en Kubernetes, croisez-la avec builtin:kubernetes.container.oom_kills qui porte le contexte du workload.
builtin:containers.memory.outOfMemoryKills
builtin:kubernetes.container.restarts
Delta du compteur restartCount du statut du conteneur ; écrit seulement lorsqu’au moins un redémarrage a eu lieu. Cas d’usage : détecter un CrashLoopBackOff avant qu’un utilisateur ne s’en plaigne. Piège : l’absence de données est le cas normal, pas une panne de collecte.
builtin:kubernetes.container.restarts
builtin:kubernetes.node.requests_cpu
Somme des requests CPU des conteneurs applicatifs des pods, agrégée par nœud. Cas d’usage : comparée à builtin:kubernetes.node.cpu_allocatable, elle dit combien de place reste à l’ordonnanceur, indépendamment de la consommation réelle. Piège : un nœud « plein » en requests peut être presque oisif ; c’est un sujet de dimensionnement, pas de charge.
builtin:kubernetes.node.requests_cpu:sort(value(max,descending))
builtin:kubernetes.workload.pods_desired
Nombre de pods attendus : le champ replicas d’un deployment, ou desiredNumberScheduled d’un daemon set. Cas d’usage : comparée au nombre de pods en marche, elle révèle un déploiement bloqué ou un autoscaler au plafond. Piège : c’est une intention, pas un état ; elle ne baisse pas quand les pods échouent.
builtin:kubernetes.workload.pods_desired:max
builtin:kubernetes.persistentvolumeclaim.used
Octets utilisés dans le volume d’une persistent volume claim. Cas d’usage : rapportée à builtin:kubernetes.persistentvolumeclaim.capacity, elle anticipe le volume plein d’une base de données ou d’un broker. Piège : un volume plein ne fait pas toujours planter le pod ; l’application peut simplement cesser d’écrire.
builtin:kubernetes.persistentvolumeclaim.used:sort(value(max,descending)):limit(10)
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:tech.jvm.threads.countavec un jeton portant le scopemetrics.read. Il liste unité, agrégations et dimensions. - Pour les métriques de runtime, vérifiez dans l’écran du processus que la surveillance approfondie est active et que le processus a été redémarré après l’installation de OneAgent.
- Pour Kubernetes, confirmez que le cluster est surveillé par l’opérateur Dynatrace ; sans lui, les clés
builtin:kubernetes.*restent vides.
curl -s -H "Authorization: Api-Token $DT_TOKEN" \
"https://managed.example.com/e/ENV-ID/api/v2/metrics/query?metricSelector=builtin:tech.jvm.threads.count:max&from=now-2h"
Bonnes pratiques
- Partez du symptôme : CPU d’hôte haut →
builtin:tech.generic.cpu.usage; JVM lente → suspension GC ; redémarrages → OOM kills et restarts. - Alertez sur la durée plutôt que sur un pic : GC, file .NET et partitions sous-répliquées ont tous des pointes normales.
- Gardez les selectors dans le dépôt de vos tableaux de bord, comme décrit dans l’article sur les tuiles JSON des dashboards Managed.
Questions fréquentes
Pourquoi une métrique JVM reste-t-elle vide sur mon processus Java ?
Les clés builtin:tech.jvm.* exigent la surveillance approfondie du processus. Un processus démarré avant OneAgent, ou exclu par une règle, ne remonte que les métriques génériques builtin:tech.generic.*.
Quelle différence entre builtin:containers.* et builtin:kubernetes.* ?
Les premières viennent de OneAgent sur l’hôte et décrivent le conteneur (CPU, mémoire, bridage). Les secondes viennent de la surveillance Kubernetes et décrivent les objets du cluster (nœuds, workloads, quotas, volumes). Pour diagnostiquer un pod, on croise les deux, comme dans le diagnostic CrashLoopBackOff et OOMKilled.
Ces clés fonctionnent-elles sur Dynatrace SaaS ?
Dans l’interface classique de SaaS, oui. Sur Grail, les équivalents portent des clés dt.* et s’interrogent en DQL, avec parfois des différences de calcul signalées par la documentation de migration.
Avec ces 24 fiches, vous pouvez descendre de l’hôte au processus, au runtime et au conteneur sans chercher la clé. Le module suivant couvre le cloud, la virtualisation et les extensions.
← Module 4 : applications et synthétique · Sommaire du parcours · Module 6 : cloud et extensions →
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.