Métriques runtime

Aperçu

Les métriques d’exécution surveillent l’utilisation de la mémoire de votre application, le ramasse-miettes et la parallélisation. Les SDK Datadog collectent automatiquement ces métriques pour les environnements pris en charge et les envoient à l’Agent Datadog.

Ces métriques vous aident à identifier les goulets d’étranglement, à résoudre les problèmes de performance et à optimiser l’utilisation des ressources. En visualisant les métriques d’exécution aux côtés des traces et des journaux, vous obtenez une visibilité complète sur la santé et la performance de votre application.

Si vous instrumentez votre application avec OpenTelemetry au lieu des bibliothèques de traçage Datadog, consultez Métriques d’exécution OpenTelemetry pour les instructions d’installation.

Compatibilité

Les métriques runtime sont disponibles pour plusieurs langages de programmation et environnements d’exécution, avec des niveaux de support et des options de configuration variables.

  • Activé par défaut : Oui
  • Version de la bibliothèque : 0.29.0+
  • Environnements d’exécution : Java 8+
La collecte des métriques JMX n'est pas prise en charge dans les environnements AWS Lambda.
  • Activé par défaut : Non
  • Version de la bibliothèque : 0.30.0+
  • Niveau de support : Preview
  • Environnements d’exécution : Toutes les versions Python prises en charge
  • Activé par défaut : Non
  • Version de la bibliothèque : 0.44.0+
  • Environnements d’exécution : Toutes les versions Ruby prises en charge
Vous devez ajouter la gem dogstatsd-ruby à votre application.
  • Activé par défaut : Non
  • Version de la bibliothèque : 1.18.0+
  • Environnements d’exécution : Toutes les versions Go prises en charge
  • Activé par défaut : Non
  • Version de la bibliothèque: 3.0.0+
  • Environnements d’exécution: Toutes les versions de Node.js prises en charge
  • Activé par défaut: Oui, sur .NET 6+ (v3.40.0+).
  • Version de la bibliothèque: 1.23.0+
  • Environnements d’exécution: .NET Framework 4.6.1+ et .NET Core 3.1+ (y compris .NET 5 et versions ultérieures).

Permissions pour les services d’information Internet (IIS) (uniquement .NET Framework)

Sur .NET Framework, les métriques sont collectées à l’aide de compteurs de performance. Les utilisateurs dans des sessions de connexion non interactives (y compris les comptes de pool d’applications IIS et certains comptes de service) doivent être ajoutés au groupe Utilisateurs de surveillance des performances pour accéder aux données des compteurs.

Les pools d’applications IIS utilisent des comptes spéciaux qui n’apparaissent pas dans la liste des utilisateurs. Pour les ajouter au groupe Utilisateurs de surveillance des performances, recherchez IIS APPPOOL\<name of the pool>. Par exemple, l’utilisateur pour le DefaultAppPool serait IIS APPPOOL\DefaultAppPool.

Cela peut être effectué soit depuis l’IU “Computer Management”, soit depuis un invité de commande d’administrateur :

net localgroup "Performance Monitor Users" "IIS APPPOOL\DefaultAppPool" /add
Les métriques d'exécution pour PHP ne sont pas prises en charge.
Les métriques d'exécution pour C++ ne sont pas prises en charge.

Instructions d’installation

Pour configurer les métriques runtime, vous devez configurer à la fois l’Agent Datadog et votre application.

1. Configurer l’Agent Datadog

Activer DogStatsD pour l’Agent. Par défaut, l’Agent Datadog est configuré pour ingérer des métriques via UDP sur le port 8125.

Lors de l’exécution de l’Agent dans des environnements conteneurisés, une configuration supplémentaire est nécessaire :

  1. Vérifiez que le trafic non local de DogStatsD est activé. Ce paramètre est activé par défaut. Si vous l’avez désactivé précédemment, définissez dogstatsd_non_local_traffic: true dans votre fichier de configuration principal datadog.yaml, ou définissez la variable d’environnement DD_DOGSTATSD_NON_LOCAL_TRAFFIC=true.
  2. Suivez ces instructions de configuration spécifiques au conteneur :
Docker
Kubernetes
Amazon ECS
ECS Fargate

  1. Définissez DD_SITE dans l’Agent Datadog pour pour garantir que l’Agent envoie les données vers l’emplacement Datadog approprié.

2. Configurez votre application

Configurez les métriques d’exécution dans votre application en utilisant des variables d’environnement. Certaines langues prennent également en charge la configuration des métriques d’exécution directement dans le code.

Variables d’environnement

Utilisez les variables d’environnement suivantes pour configurer les métriques runtime dans votre application :

DD_RUNTIME_METRICS_ENABLED
Par défaut: true pour Java et .NET 6+ (v3.40.0+), false pour tous les autres langages et environnements d’exécution.
Description: Active la collecte de métriques d’exécution. Les métriques sont envoyées à l’agent Datadog, comme configuré pour l’application instrumentée.
DD_RUNTIME_METRICS_RUNTIME_ID_ENABLED
Par défaut: true pour Java, false pour Node.js, Ruby et Python. N’existe pas pour .NET et Go ; le runtime_id est toujours signalé.
Description : Active des métriques d’exécution améliorées, fournissant un runtime_id tag avec chaque métrique. Le runtime_id représente l’identifiant de processus de l’application et vous permet de corréler directement les métriques d’exécution avec les applications en cours d’exécution individuelles.
DD_AGENT_HOST
Par défaut : localhost
Description : Définit l’adresse hôte pour la soumission des métriques du SDK. Peut être un nom d’hôte ou une adresse IP.
DD_DOGSTATSD_PORT
Par défaut : 8125
Description : Définit le port pour la soumission des métriques du SDK.
DD_RUNTIME_METRICS_DIAGNOSTICS_METRICS_API_ENABLED
Par défaut: true démarrage du traceur v3.40.0+ sur .NET 8+ et (.NET 6/7 lorsque DD_RUNTIME_METRICS_ENABLED n’est pas explicitement défini), sinon false.
Description: Disponible à partir de .NET 6. Cela contrôle si le traceur .NET utilise la nouvelle System.Diagnostics.Metrics API pour collecter les métriques au lieu du collecteur basé sur EventListener.

Configuration basée sur le code

En plus des variables d’environnement, certains langages permettent de configurer les métriques runtime directement dans le code.

Vous ne pouvez activer les métriques d’exécution qu’avec variables d’environnement.

Cependant, vous pouvez étendre les métriques collectées en ajoutant des métriques JMX personnalisées. Pour plus d’informations, consultez la documentation sur l’intégration JMX.

Vous pouvez activer les métriques d’exécution avec variables d’environnement ou dans le code :

from ddtrace.runtime import RuntimeMetrics
RuntimeMetrics.enable()
Cela ne s'applique que si vous n'utilisez pas ddtrace-run

Vous pouvez activer les métriques d’exécution avec variables d’environnement ou dans le code :

# config/initializers/datadog.rb
require 'datadog/statsd'
require 'datadog' # Use 'ddtrace' if you're using v1.x

Datadog.configure do |c|
  c.runtime_metrics.enabled = true

  # Optionally, you can configure the DogStatsD instance used for sending runtime metrics.
  # DogStatsD is automatically configured with default settings if `dogstatsd-ruby` is available.
  # You can configure with host and port of Datadog agent; defaults to 'localhost:8125'.
  c.runtime_metrics.statsd = Datadog::Statsd.new
end

Vous pouvez activer les métriques d’exécution avec variables d’environnement ou dans le code :

// Basic configuration
tracer.Start(tracer.WithRuntimeMetrics())

// With custom DogStatsD address
tracer.Start(
  tracer.WithRuntimeMetrics(),
  tracer.WithDogstatsdAddr("custom-host:8125")
)

L’option WithDogstatsdAddr vous permet de spécifier une adresse personnalisée pour le serveur DogStatsD. Utilisez l’option WithDogstatsdAddr (ou WithDogstatsdAddress v1) si votre adresse diffère de la localhost:8125 par défaut. (Disponible pour 1.18.0+)

Vous pouvez activer les métriques d’exécution avec variables d’environnement ou dans le code :

const tracer = require('dd-trace').init({
  // Other tracer options...
  runtimeMetrics: true
})

Vous ne pouvez activer les métriques d’exécution qu’avec variables d’environnement.

Tableaux de bord

Une fois la configuration terminée, vous pouvez afficher les métriques runtime dans :

  • La page de détails du service instrumenté
  • L’onglet du graphique de flamme Métriques
  • Tableaux de bord d’exécution par défaut
Trace d'exécution JVM

Dépannage

  • Pour associer les métriques d’exécution dans les graphiques de flamme, assurez-vous que le tag env (sensible à la casse) est défini et correspond à travers votre environnement.
  • Pour que les métriques d’exécution apparaissent sur la page du service lors de l’utilisation de Fargate, assurez-vous que DD_DOGSTATSD_TAGS est défini sur votre tâche Agent, et que le tag env configuré correspond à env du service instrumenté.

Données collectées

Chaque langage pris en charge collecte un ensemble de métriques runtime fournissant des informations sur l’utilisation de la mémoire, la collecte des déchets, l’utilisation du CPU et d’autres indicateurs de performance.

jvm.heap_memory
(gauge)
The total Java heap memory used.
Shown as byte
jvm.heap_memory_committed
(gauge)
The total Java heap memory committed to be used.
Shown as byte
jvm.heap_memory_init
(gauge)
The initial Java heap memory allocated.
Shown as byte
jvm.heap_memory_max
(gauge)
The maximum Java heap memory available.
Shown as byte
jvm.loaded_classes
(gauge)
Number of classes currently loaded.
jvm.non_heap_memory
(gauge)
The total Java non-heap memory used. Non-heap memory is calculated as follows: Metaspace + CompressedClassSpace + CodeCache
Shown as byte
jvm.non_heap_memory_committed
(gauge)
The total Java non-heap memory committed to be used.
Shown as byte
jvm.non_heap_memory_init
(gauge)
The initial Java non-heap memory allocated.
Shown as byte
jvm.non_heap_memory_max
(gauge)
The maximum Java non-heap memory available.
Shown as byte
jvm.thread_count
(count)
The number of live threads.
Shown as thread
jvm.gc.cms.count
(count)
The total number of garbage collections that have occurred.
jvm.gc.major_collection_count
(gauge)
The rate of major garbage collections. Set new_gc_metrics: true to receive this metric.
jvm.gc.minor_collection_count
(gauge)
The rate of minor garbage collections. Set new_gc_metrics: true to receive this metric.
jvm.gc.parnew.time
(gauge)
The approximate accumulated garbage collection time elapsed.
Shown as millisecond
jvm.gc.major_collection_time
(gauge)
The fraction of time spent in major garbage collection. Set new_gc_metrics: true to receive this metric.
Shown as permille
jvm.gc.minor_collection_time
(gauge)
The fraction of time spent in minor garbage collection. Set new_gc_metrics: true to receive this metric.
Shown as permille
jvm.gc.old_gen_size
(gauge)
The current Java heap memory usage of the Old Generation memory pool.
Shown as byte
jvm.gc.eden_size
(gauge)
The current Java heap memory usage of the Eden memory pool.
Shown as byte
jvm.gc.survivor_size
(gauge)
The current Java heap memory usage of the Survivor memory pool.
Shown as byte
jvm.gc.metaspace_size
(gauge)
The current Java non-heap memory usage of the Metaspace memory pool.
Shown as byte
jvm.cpu_load.system
(gauge)
Recent CPU utilization for the whole system.
Shown as fraction
jvm.cpu_load.process
(gauge)
Recent CPU utilization for the process.
Shown as fraction
jvm.buffer_pool.direct.used
(gauge)
Measure of memory used by direct buffers.
Shown as byte
jvm.buffer_pool.direct.count
(gauge)
Number of direct buffers in the pool.
jvm.buffer_pool.direct.capacity
(gauge)
Measure of total memory capacity of direct buffers.
Shown as byte
jvm.buffer_pool.mapped.used
(gauge)
Measure of memory used by mapped buffers.
Shown as byte
jvm.buffer_pool.mapped.count
(gauge)
Number of mapped buffers in the pool.
jvm.buffer_pool.mapped.capacity
(gauge)
Measure of total memory capacity of mapped buffers.
Shown as byte
jvm.os.open_file_descriptors
(gauge)
The number of open file descriptors.

Note: Set new_gc_metrics: true in your jmx.d/conf.yaml to replace the following metrics:

jvm.gc.cms.count   => jvm.gc.minor_collection_count
                      jvm.gc.major_collection_count
jvm.gc.parnew.time => jvm.gc.minor_collection_time
                      jvm.gc.major_collection_time
runtime.python.cpu.time.sys
(gauge)
Number of seconds executing in the kernel
Shown as second
runtime.python.cpu.time.user
(gauge)
Number of seconds executing outside the kernel
Shown as second
runtime.python.cpu.percent
(gauge)
CPU utilization percentage
Shown as percent
runtime.python.cpu.ctx_switch.voluntary
(gauge)
Number of voluntary context switches
Shown as invocation
runtime.python.cpu.ctx_switch.involuntary
(gauge)
Number of involuntary context switches
Shown as invocation
runtime.python.gc.count.gen0
(gauge)
Number of generation 0 objects
Shown as resource
runtime.python.gc.count.gen1
(gauge)
Number of generation 1 objects
Shown as resource
runtime.python.gc.count.gen2
(gauge)
Number of generation 2 objects
Shown as resource
runtime.python.mem.rss
(gauge)
Resident set memory
Shown as byte
runtime.python.thread_count
(gauge)
Number of threads
Shown as thread
runtime.ruby.class_count
(gauge)
Total number of classes loaded
Shown as resource
runtime.ruby.gc.remembered_wb_unprotected_objects
(gauge)
Number of write-barrier unprotected objects in the remembered set
Shown as resource
runtime.ruby.gc.remembered_wb_unprotected_objects_limit
(gauge)
Limit on write-barrier unprotected objects allowed in the remembered set
Shown as resource
runtime.ruby.gc.oldmalloc_increase_bytes
(gauge)
Total bytes allocated to old objects
Shown as byte
runtime.ruby.gc.oldmalloc_increase_bytes_limit
(gauge)
Bytes limit that will trigger garbage collection of old objects
Shown as byte
runtime.ruby.gc.malloc_increase_bytes
(gauge)
Total bytes allocated to objects
Shown as byte
runtime.ruby.gc.malloc_increase_bytes_limit
(gauge)
Bytes limit that will trigger garbage collection of objects
Shown as byte
runtime.ruby.gc.total_allocated_objects
(gauge)
Total number of allocated objects over the lifetime of this process
Shown as resource
runtime.ruby.gc.total_freed_objects
(gauge)
Total number of freed objects over the lifetime of this process
Shown as resource
runtime.ruby.gc.total_allocated_pages
(gauge)
Total number of allocated pages over the lifetime of this process
Shown as page
runtime.ruby.gc.total_freed_pages
(gauge)
Total number of freed pages over the lifetime of this process
Shown as page
runtime.ruby.gc.heap_live_slots
(gauge)
Number of live objects slots
Shown as resource
runtime.ruby.gc.heap_final_slots
(gauge)
Number of object slots with finalizers attached to them
Shown as resource
runtime.ruby.gc.heap_marked_slots
(gauge)
Count of old objects which survived more than 3 GC cycles and number of write-barrier unprotected objects
Shown as resource
runtime.ruby.gc.heap_available_slots
(gauge)
Total number of slots in heap pages
Shown as resource
runtime.ruby.gc.heap_free_slots
(gauge)
Number of free slots in heap pages
Shown as resource
runtime.ruby.thread_count
(gauge)
Total number of threads
Shown as thread
runtime.ruby.gc.old_objects
(gauge)
Total number of old objects
Shown as resource
runtime.ruby.gc.old_objects_limit
(gauge)
Limit on number of old objects
Shown as resource
runtime.ruby.global_constant_state
(gauge)
Global constant cache generation
Shown as event
runtime.ruby.global_method_state
(gauge)
Global method cache generation
Shown as event
runtime.ruby.constant_cache_invalidations
(gauge)
Constant cache invalidations
Shown as resource
runtime.ruby.constant_cache_misses
(gauge)
Constant cache misses
Shown as resource
runtime.go.num_cpu
(gauge)
CPUs detected by the runtime.
Shown as resource
runtime.go.num_goroutine
(gauge)
goroutines spawned.
Shown as invocation
runtime.go.num_cgo_call
(gauge)
CGO calls made.
Shown as invocation
runtime.go.mem_stats.alloc
(gauge)
Alloc is bytes of allocated heap objects.
Shown as byte
runtime.go.mem_stats.total_alloc
(gauge)
TotalAlloc is cumulative bytes allocated for heap objects.
Shown as byte
runtime.go.mem_stats.sys
(gauge)
Sys is the total bytes of memory obtained from the OS.
Shown as byte
runtime.go.mem_stats.lookups
(gauge)
Lookups is the number of pointer lookups performed by the
Shown as unit
runtime.go.mem_stats.mallocs
(gauge)
Mallocs is the cumulative count of heap objects allocated.
Shown as unit
runtime.go.mem_stats.frees
(gauge)
Frees is the cumulative count of heap objects freed.
Shown as unit
runtime.go.mem_stats.heap_alloc
(gauge)
HeapAlloc is bytes of allocated heap objects.
Shown as byte
runtime.go.mem_stats.heap_sys
(gauge)
HeapSys is bytes of heap memory obtained from the OS.
Shown as byte
runtime.go.mem_stats.heap_idle
(gauge)
HeapIdle is bytes in idle (unused) spans.
Shown as byte
runtime.go.mem_stats.heap_inuse
(gauge)
HeapInuse is bytes in in-use spans.
Shown as byte
runtime.go.mem_stats.heap_released
(gauge)
HeapReleased is bytes of physical memory returned to the OS.
Shown as byte
runtime.go.mem_stats.heap_objects
(gauge)
HeapObjects is the number of allocated heap objects.
Shown as unit
runtime.go.mem_stats.stack_inuse
(gauge)
StackInuse is bytes in stack spans.
Shown as byte
runtime.go.mem_stats.stack_sys
(gauge)
StackSys is bytes of stack memory obtained from the OS.
Shown as byte
runtime.go.mem_stats.m_span_inuse
(gauge)
MSpanInuse is bytes of allocated mspan structures.
Shown as byte
runtime.go.mem_stats.m_span_sys
(gauge)
MSpanSys is bytes of memory obtained from the OS for mspan structures.
Shown as byte
runtime.go.mem_stats.m_cache_inuse
(gauge)
MCacheInuse is bytes of allocated mcache structures.
Shown as byte
runtime.go.mem_stats.m_cache_sys
(gauge)
MCacheSys is bytes of memory obtained from the OS for
Shown as byte
runtime.go.mem_stats.buck_hash_sys
(gauge)
BuckHashSys is bytes of memory in profiling bucket hash tables.
Shown as byte
runtime.go.mem_stats.gc_sys
(gauge)
GCSys is bytes of memory in garbage collection metadata.
Shown as byte
runtime.go.mem_stats.other_sys
(gauge)
OtherSys is bytes of memory in miscellaneous off-heap
Shown as byte
runtime.go.mem_stats.next_gc
(gauge)
NextGC is the target heap size of the next GC cycle.
Shown as byte
runtime.go.mem_stats.last_gc
(gauge)
LastGC is the time the last garbage collection finished, as nanoseconds since 1970 (the UNIX epoch).
Shown as nanosecond
runtime.go.mem_stats.pause_total_ns
(gauge)
PauseTotalNs is the cumulative nanoseconds in GC
Shown as nanosecond
runtime.go.mem_stats.num_gc
(gauge)
NumGC is the number of completed GC cycles.
Shown as unit
runtime.go.mem_stats.num_forced_gc
(gauge)
NumForcedGC is the number of GC cycles that were forced by the application calling the GC function.
Shown as unit
runtime.go.mem_stats.gc_cpu_fraction
(gauge)
GCCPUFraction is the fraction of this program’s available CPU time used by the GC since the program started.
Shown as fraction
runtime.go.gc_stats.pause_quantiles.min
(gauge)
Distribution of GC pause times: minimum values
Shown as nanosecond
runtime.go.gc_stats.pause_quantiles.25p
(gauge)
Distribution of GC pause times: 25th percentile
Shown as nanosecond
runtime.go.gc_stats.pause_quantiles.75p
(gauge)
Distribution of GC pause times: 50th percentile
Shown as nanosecond
runtime.go.gc_stats.pause_quantiles.95p
(gauge)
Distribution of GC pause times: 75th percentile
Shown as nanosecond
runtime.go.gc_stats.pause_quantiles.max
(gauge)
Distribution of GC pause times: maximum values
Shown as nanosecond
runtime.node.cpu.user
(gauge)
CPU usage in user code
Shown as percent
runtime.node.cpu.system
(gauge)
CPU usage in system code
Shown as percent
runtime.node.cpu.total
(gauge)
Total CPU usage
Shown as percent
runtime.node.mem.rss
(gauge)
Resident set size
Shown as byte
runtime.node.mem.heap_total
(gauge)
Total heap memory
Shown as byte
runtime.node.mem.heap_used
(gauge)
Heap memory usage
Shown as byte
runtime.node.mem.total
(gauge)
Total system memory size
Shown as byte
runtime.node.mem.free
(gauge)
Free system memory size
Shown as byte
runtime.node.mem.external
(gauge)
External memory
Shown as byte
runtime.node.heap.total_heap_size
(gauge)
Total heap size
Shown as byte
runtime.node.heap.total_heap_size_executable
(gauge)
Total executable heap size
Shown as byte
runtime.node.heap.total_physical_size
(gauge)
Total physical heap size
Shown as byte
runtime.node.heap.used_heap_size
(gauge)
Used heap size
Shown as byte
runtime.node.heap.heap_size_limit
(gauge)
Heap size limit
Shown as byte
runtime.node.heap.malloced_memory
(gauge)
Malloced memory
Shown as byte
runtime.node.heap.peak_malloced_memory
(gauge)
Peak allocated memory
Shown as byte
runtime.node.heap.size.by.space
(gauge)
Heap space size
Shown as byte
runtime.node.heap.used_size.by.space
(gauge)
Heap space used size
Shown as byte
runtime.node.heap.available_size.by.space
(gauge)
Heap space available size
Shown as byte
runtime.node.heap.physical_size.by.space
(gauge)
Heap space physical size
Shown as byte
runtime.node.process.uptime
(gauge)
Process uptime
Shown as second
runtime.node.event_loop.delay.max
(gauge)
Maximum event loop delay
Shown as nanosecond
runtime.node.event_loop.delay.min
(gauge)
Minimum event loop delay
Shown as nanosecond
runtime.node.event_loop.delay.avg
(gauge)
Average event loop delay
Shown as nanosecond
runtime.node.event_loop.delay.sum
(rate)
Total event loop delay
Shown as nanosecond
runtime.node.event_loop.delay.median
(gauge)
Median event loop delay
Shown as nanosecond
runtime.node.event_loop.delay.95percentile
(gauge)
95th percentile event loop delay
Shown as nanosecond
runtime.node.event_loop.delay.count
(rate)
Event loop iteration count where a delay is detected
Shown as execution
runtime.node.event_loop.utilization
(gauge)
Fraction of time the event loop is active
Shown as unit
runtime.node.gc.pause.max
(gauge)
Maximum garbage collection pause
Shown as nanosecond
runtime.node.gc.pause.min
(gauge)
Minimum garbage collection pause
Shown as nanosecond
runtime.node.gc.pause.avg
(gauge)
Average garbage collection pause
Shown as nanosecond
runtime.node.gc.pause.sum
(rate)
Total garbage collection pause
Shown as nanosecond
runtime.node.gc.pause.median
(gauge)
Median garbage collection pause
Shown as nanosecond
runtime.node.gc.pause.95percentile
(gauge)
95th percentile garbage collection pause
Shown as nanosecond
runtime.node.gc.pause.count
(rate)
Number of garbage collections
Shown as garbage collection
runtime.node.gc.pause.by.type.max
(gauge)
Maximum garbage collection pause by type
Shown as nanosecond
runtime.node.gc.pause.by.type.min
(gauge)
Minimum garbage collection pause by type
Shown as nanosecond
runtime.node.gc.pause.by.type.avg
(gauge)
Average garbage collection pause by type
Shown as nanosecond
runtime.node.gc.pause.by.type.sum
(rate)
Total garbage collection pause by type
Shown as nanosecond
runtime.node.gc.pause.by.type.median
(gauge)
Median garbage collection pause by type
Shown as nanosecond
runtime.node.gc.pause.by.type.95percentile
(gauge)
95th percentile garbage collection pause by type
Shown as nanosecond
runtime.node.gc.pause.by.type.count
(rate)
Number of garbage collections by type
Shown as garbage collection
runtime.dotnet.cpu.system
(gauge)
The number of milliseconds executing in the kernel
Shown as millisecond
runtime.dotnet.cpu.user
(gauge)
The number of milliseconds executing outside the kernel
Shown as millisecond
runtime.dotnet.cpu.percent
(gauge)
The percentage of total CPU used by the application
Shown as percent
runtime.dotnet.mem.committed
(gauge)
Memory usage
Shown as byte
runtime.dotnet.threads.count
(gauge)
The number of threads
Shown as thread
runtime.dotnet.threads.workers_count
(gauge)
The number of workers in the threadpool (.NET Core 3.1+ only)
Shown as thread
runtime.dotnet.threads.contention_time
(gauge)
The cumulated time spent by threads waiting on a lock (.NET Core 3.1+ only)
Shown as millisecond
runtime.dotnet.threads.contention_count
(count)
The number of times a thread stopped to wait on a lock
runtime.dotnet.exceptions.count
(count)
The number of first-chance exceptions
Shown as exception
runtime.dotnet.gc.size.gen0
(gauge)
The size of the gen 0 heap
Shown as byte
runtime.dotnet.gc.size.gen1
(gauge)
The size of the gen 1 heap
Shown as byte
runtime.dotnet.gc.size.gen2
(gauge)
The size of the gen 2 heap
Shown as byte
runtime.dotnet.gc.size.loh
(gauge)
The size of the large object heap
Shown as byte
runtime.dotnet.gc.memory_load
(gauge)
The percentage of the total memory used by the process. The GC changes its behavior when this value gets above 85. (.NET Core 3.1+ only)
Shown as percent
runtime.dotnet.gc.pause_time
(gauge)
The amount of time the GC paused the application threads (.NET Core 3.1+ only)
Shown as millisecond
runtime.dotnet.gc.count.gen0
(count)
The number of gen 0 garbage collections
Shown as garbage collection
runtime.dotnet.gc.count.gen1
(count)
The number of gen 1 garbage collections
Shown as garbage collection
runtime.dotnet.gc.count.gen2
(count)
The number of gen 2 garbage collections
Shown as garbage collection
runtime.dotnet.aspnetcore.requests.total
(gauge)
The total number of HTTP requests received by the server (.NET Core 3.1+ only)
Shown as request
runtime.dotnet.aspnetcore.requests.failed
(gauge)
The number of failed HTTP requests received by the server (.NET Core 3.1+ only)
Shown as request
runtime.dotnet.aspnetcore.requests.current
(gauge)
The total number of HTTP requests that have started but not yet stopped (.NET Core 3.1+ only)
Shown as request
runtime.dotnet.aspnetcore.requests.queue_length
(gauge)
The current length of the server HTTP request queue (.NET 5+ only)
Shown as request
runtime.dotnet.aspnetcore.connections.total
(gauge)
The total number of HTTP connections established to the server (.NET 5+ only)
Shown as connection
runtime.dotnet.aspnetcore.connections.current
(gauge)
The current number of active HTTP connections to the server (.NET 5+ only)
Shown as connection
runtime.dotnet.aspnetcore.connections.queue_length
(gauge)
The current length of the HTTP server connection queue (.NET 5+ only)
Shown as connection

Lectures complémentaires