Métricas de Tiempo de Ejecución

Documentos > APM > Métricas de APM > Métricas de Tiempo de Ejecución

Resumen

Las métricas de tiempo de ejecución monitorean el uso de memoria de tu aplicación, la recolección de basura y la paralelización. Los SDK de Datadog recopilan automáticamente estas métricas para entornos compatibles y las envían al Datadog Agent.

Estas métricas te ayudan a identificar cuellos de botella, solucionar problemas de rendimiento y optimizar la utilización de recursos. Al ver las métricas de tiempo de ejecución junto con trazas y registros, obtienes una visibilidad completa sobre la salud y el rendimiento de tu aplicación.

Si instrumentas tu aplicación con OpenTelemetry en lugar de las bibliotecas de trazado de Datadog, consulta Métricas de Tiempo de Ejecución de OpenTelemetry para las instrucciones de configuración.

Compatibilidad

Las métricas de tiempo de ejecución están disponibles para varios lenguajes de programación y entornos de ejecución, con diferentes niveles de soporte y opciones de configuración.

Habilitado por defecto: Sí
Versión de la Biblioteca: 0.29.0+
Entornos de Ejecución: Java 8+

La recopilación de métricas JMX no es compatible en entornos de AWS Lambda.

Habilitado por defecto: No
Versión de la biblioteca: 0.30.0+
Nivel de soporte: Vista previa
Entornos de ejecución: Todas las versiones de Python soportadas

Habilitado por defecto: No
Versión de la biblioteca: 0.44.0+
Entornos de ejecución: Todas las versiones de Ruby soportadas

Debes agregar la gema dogstatsd-ruby a tu aplicación.

Habilitado por defecto: No
Versión de la biblioteca: 1.18.0+
Entornos de ejecución: Todas las versiones de Go soportadas

Habilitado por defecto: No
Versión de la biblioteca: 3.0.0+
Entornos de ejecución: Todas las versiones de Node.js soportadas

Habilitado por defecto: Sí, en .NET 6+ (v3.40.0+).
Versión de la biblioteca: 1.23.0+
Entornos de ejecución: .NET Framework 4.6.1+ y .NET Core 3.1+ (incluyendo .NET 5 y versiones más recientes).

Permisos para Internet Information Services (IIS) (solo .NET Framework)

En .NET Framework, las métricas se recopilan utilizando contadores de rendimiento. Los usuarios en sesiones de inicio de sesión no interactivas (que incluyen cuentas de pool de aplicaciones de IIS y algunas cuentas de servicio) deben ser añadidos al grupo Usuarios de Seguimiento del Rendimiento para acceder a los datos de contadores.

Los pools de aplicaciones de IIS utilizan cuentas especiales que no aparecen en la lista de usuarios. Para añadirlos al grupo Usuarios de Seguimiento del Rendimiento, busque IIS APPPOOL\<name of the pool>. Por ejemplo, el usuario para el DefaultAppPool sería IIS APPPOOL\DefaultAppPool.

Esto se puede hacer desde la interfaz de “Computer Management” o desde un símbolo del sistema de administrador:

net localgroup "Performance Monitor Users" "IIS APPPOOL\DefaultAppPool" /add

Las métricas de tiempo de ejecución para PHP no son compatibles.

Las métricas de tiempo de ejecución para C++ no son compatibles.

Instrucciones de configuración

Para configurar las métricas de tiempo de ejecución, debes configurar tanto el Datadog Agent como tu aplicación.

1. Configura el Datadog Agent

Habilita DogStatsD para el Datadog Agent. Por defecto, el Datadog Agent está configurado para ingerir métricas con UDP a través del puerto 8125.

Configuración específica del contenedor

Al ejecutar el Datadog Agent en entornos contenedorizados, se requiere configuración adicional:

Verifica que el tráfico no local de DogStatsD esté habilitado. Esta configuración está habilitada por defecto. Si anteriormente lo has deshabilitado, configura dogstatsd_non_local_traffic: true en tu archivo principal de configuración datadog.yaml, o establece la variable de entorno DD_DOGSTATSD_NON_LOCAL_TRAFFIC=true.
Sigue estas instrucciones de configuración específicas del contenedor:

2. Configura tu aplicación

Configura las métricas de tiempo de ejecución en tu aplicación utilizando variables de entorno. Algunos lenguajes también permiten configurar métricas de tiempo de ejecución directamente en el código.

Variables de entorno

Utiliza las siguientes variables de entorno para configurar métricas de tiempo de ejecución en tu aplicación:

DD_RUNTIME_METRICS_ENABLED: Predeterminado: true para Java y .NET 6+ (v3.40.0+), false para todos los demás lenguajes y entornos de ejecución.
Descripción: Habilita la recopilación de métricas de tiempo de ejecución. Las métricas se envían al Datadog Agent, según lo configurado para la aplicación instrumentada.
DD_RUNTIME_METRICS_RUNTIME_ID_ENABLED: Predeterminado: true para Java, false para Node.js, Ruby y Python. No existe para .NET y Go; el runtime_id siempre se informa.
Descripción: Habilita métricas de tiempo de ejecución mejoradas, proporcionando una runtime_id etiqueta junto con cada métrica. La runtime_id representa el identificador de proceso de la aplicación y te permite correlacionar directamente las métricas de tiempo de ejecución con aplicaciones individuales en ejecución.
DD_AGENT_HOST: Predeterminado: localhost
Descripción: Establece la dirección del servidor para el envío de métricas del SDK. Puede ser un nombre de servidor o una dirección IP.
DD_DOGSTATSD_PORT: Predeterminado: 8125
Descripción: Establece el puerto para el envío de métricas del SDK.
DD_RUNTIME_METRICS_DIAGNOSTICS_METRICS_API_ENABLED: Predeterminado: true iniciando el rastreador v3.40.0+ en .NET 8+ y (.NET 6/7 cuando DD_RUNTIME_METRICS_ENABLED no está configurado explícitamente), de lo contrario false.
Descripción: Disponible a partir de .NET 6. Controla si el rastreador de .NET utiliza la nueva API de System.Diagnostics.Metrics para recopilar las métricas en lugar del colector basado en EventListener.

Configuración basada en código

Además de las variables de entorno, algunos lenguajes permiten configurar métricas de tiempo de ejecución directamente en el código.

Solo puedes habilitar métricas de tiempo de ejecución con variables de entorno.

Sin embargo, puedes ampliar las métricas recopiladas agregando métricas JMX personalizadas. Para más información, consulta la documentación de Integración JMX.

Puedes habilitar métricas de tiempo de ejecución con variables de entorno o en código:

from ddtrace.runtime import RuntimeMetrics
RuntimeMetrics.enable()

Esto solo se aplica si no estás utilizando ddtrace-run

Puedes habilitar métricas de tiempo de ejecución con variables de entorno o en código:

# 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

Puedes habilitar métricas de tiempo de ejecución con variables de entorno o en código:

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

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

La opción WithDogstatsdAddr te permite especificar una dirección personalizada para el servidor DogStatsD. Utiliza la opción WithDogstatsdAddr (o WithDogstatsdAddress v1) si tu dirección difiere de la predeterminada localhost:8125. (Disponible para 1.18.0+)

Puedes habilitar métricas de tiempo de ejecución con variables de entorno o en código:

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

Solo puedes habilitar métricas de tiempo de ejecución con variables de entorno.

Tableros

Una vez que la configuración esté completa, puedes ver las métricas de tiempo de ejecución en:

La página de detalles del servicio instrumentado
La gráfica de llamas, pestaña Métricas
Tableros de tiempo de ejecución predeterminados

Solución de problemas

Para asociar métricas de tiempo de ejecución dentro de flame graphs, asegúrese de que la etiqueta env (sensible a mayúsculas) esté configurada y coincida en su entorno.
Para que las métricas de tiempo de ejecución aparezcan en la página del servicio al usar Fargate, asegúrese de que DD_DOGSTATSD_TAGS esté configurado en su tarea de Agent, y que la etiqueta env configurada coincida con el env del servicio instrumentado.

Datos recopilados

Cada lenguaje soportado recopila un conjunto de métricas de tiempo de ejecución que proporcionan información sobre el uso de memoria, la recolección de basura, la utilización de CPU y otros indicadores de rendimiento.


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