.NET Runtime metrics
This article describes the built-in metrics for .NET runtime libraries that are produced using the System.Diagnostics.Metrics API. For a listing of metrics based on the older EventCounters API, see Available counters.
Tip
For more information about how to collect and report these metrics, see Collecting Metrics.
System.Runtime
The System.Runtime Meter reports measurements from the GC, JIT, AssemblyLoader, Threadpool, and exception handling portions of the .NET runtime as well as some CPU and memory metrics from the OS. These metrics are available automatically for all .NET apps.
Metric: dotnet.process.cpu.time
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.process.cpu.time |
Counter | s |
CPU time used by the process. |
| Attribute | Type | Description | Examples | Presence |
|---|---|---|---|---|
cpu.mode |
string | The mode of the CPU. | user; system |
Always |
This metric reports the same values as accessing the processor time properties on System.Diagnostics.Process for the current process. The system mode corresponds to PrivilegedProcessorTime and user mode corresponds to UserProcessorTime
Available starting in: .NET 9.0.
Metric: dotnet.process.memory.working_set
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.process.memory.working_set |
UpDownCounter | By |
The number of bytes of physical memory mapped to the process context. |
This metric reports the same values as calling Environment.WorkingSet property.
Available starting in: .NET 9.0.
Metric: dotnet.gc.collections
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.gc.collections |
Counter | {collection} |
The number of garbage collections that have occurred since the process has started. |
| Attribute | Type | Description | Examples | Presence |
|---|---|---|---|---|
dotnet.gc.heap.generation |
string | Name of the maximum managed heap generation being collected. | gen0; gen1; gen2 |
Always |
The .NET GC is a generational garbage collector. Each time the garbage collector runs, it uses heuristics to select a maximum generation and then collects objects in all generations up to the selected maximum. For example, a gen1 collection collects all objects in generations 0 and 1. A gen2 collection collects all objects in generations 0, 1, and 2. For more information about the .NET GC and generational garbage collection, see the .NET garbage collection guide.
Available starting in: .NET 9.0.
Metric: dotnet.gc.heap.total_allocated
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.gc.heap.total_allocated |
Counter | By |
The approximate number of bytes allocated on the managed GC heap since the process started. The returned value does not include any native allocations. |
This metric reports the same values as calling GC.GetTotalAllocatedBytes. For more information about the .NET GC, see the .NET garbage collection guide.
Available starting in: .NET 9.0.
Metric: dotnet.gc.last_collection.memory.committed_size
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.gc.last_collection.memory.committed_size |
UpDownCounter | By |
The amount of committed virtual memory in use by the .NET GC, as observed during the latest garbage collection. |
This metric reports the same values as calling GCMemoryInfo.TotalCommittedBytes. Committed virtual memory may be larger than the heap size because it includes both memory for storing existing objects (the heap size) and some extra memory that is ready to handle newly allocated objects in the future. For more information about the .NET GC, see the .NET garbage collection guide.
Available starting in: .NET 9.0.
Metric: dotnet.gc.last_collection.heap.size
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.gc.last_collection.heap.size |
UpDownCounter | By |
The managed GC heap size (including fragmentation), as observed during the latest garbage collection. |
| Attribute | Type | Description | Examples | Presence |
|---|---|---|---|---|
dotnet.gc.heap.generation |
string | Name of the garbage collector managed heap generation. | gen0; gen1; gen2;loh;poh |
Always |
The .NET GC divides the heap into generations. In addition to the standard numbered generations, the GC also puts some objects into two special generations:
- Large object heap (LOH) stores .NET objects that are very large compared to typical objects.
- Pinned object heap (POH) stores objects allocated using the GC.AllocateArray API when the
pinnedparameter is true.
Both of these special generations are collected during gen2 GC collections. For more information about the .NET GC, see the .NET Garbage collection guide.
Available starting in: .NET 9.0.
Metric: dotnet.gc.last_collection.heap.fragmentation.size
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.gc.last_collection.heap.fragmentation.size |
UpDownCounter | By |
The heap fragmentation, as observed during the latest garbage collection. |
This metric reports the same values as calling GCGenerationInfo.FragmentationAfterBytes.
When .NET objects are allocated, initially they tend to be laid out contiguously in memory. However, if some of those objects are later collected by the GC, this creates gaps of unused memory between the live objects that remain. These gaps represent the portion of the GC heap that's not currently being used to store objects, often called "fragmentation." The GC can reuse the fragmentation bytes in the future for new object allocations if the object size is small enough to fit in one of the gaps. The GC can also perform a special compacting garbage collection that moves remaining live objects next to each other as long as the objects haven't been pinned in place.
For more information about how the .NET GC works, analyzing GC performance, and what role fragmentation plays, see .NET memory performance analysis.
Available starting in: .NET 9.0.
Metric: dotnet.gc.pause.time
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.gc.pause.time |
Counter | s |
The total amount of time paused in GC since the process started. |
This metric reports the same values as calling GC.GetTotalPauseDuration().
Each time the .NET GC does a collection it needs to briefly pause all threads running managed code to determine which objects are still referenced. This metric reports the sum of all these pause times since the process began. You can use this metric to determine what fraction of time threads spend paused for GC versus the time they're able to run managed code.
Available starting in: .NET 9.0.
Metric: dotnet.jit.compiled_il.size
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.jit.compiled_il.size |
Counter | By |
Count of bytes of intermediate language that have been compiled since the process started. |
This metric reports the same values as calling JitInfo.GetCompiledILBytes.
When you build a .NET app, managed code is initially compiled from a high-level language like C#, VB, or F# into Intermediate language (IL). Then when the program is run, the .NET just-in-time (JIT) compiler converts the IL into machine code.
Since JIT compilation occurs the first time a method runs, most JIT compilation tends to occur during application startup. Reducing the amount of IL that is JIT compiled can improve application startup time.
Available starting in: .NET 9.0.
Metric: dotnet.jit.compiled_methods
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.jit.compiled_methods |
Counter | {method} |
The number of times the JIT compiler (re)compiled methods since the process started. |
This metric reports the same values as calling JitInfo.GetCompiledMethodCount.
When you build a .NET app, managed code is initially compiled from a high-level language like C#, VB, or F# into Intermediate language (IL). Then when the program is run, the .NET just-in-time (JIT) compiler converts the IL into machine code.
Since JIT compilation occurs the first time a method runs, most JIT compilation tends to occur during application startup. Reducing the number of methods that need to be JIT compiled can improve application startup time.
Available starting in: .NET 9.0.
Metric: dotnet.jit.compilation.time
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.jit.compilation.time |
Counter | s |
The amount of time the JIT compiler has spent compiling methods since the process started. |
This metric reports the same values as calling JitInfo.GetCompilationTime.
When you build a .NET app, managed code is initially compiled from a high-level language like C#, VB, or F# into Intermediate language (IL). Then when the program is run, the .NET just-in-time (JIT) compiler converts the IL into machine code.
Since JIT compilation occurs the first time a method runs, most JIT compilation tends to occur during application startup. Reducing the time spent JIT compiling can improve application startup time.
Available starting in: .NET 9.0.
Metric: dotnet.thread_pool.thread.count
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.thread_pool.thread.count |
UpDownCounter | {thread} |
The number of thread pool threads that currently exist. |
This metric reports the same values as calling ThreadPool.ThreadCount.
.NET uses a thread pool to schedule work items onto other threads. This metric provides the number of worker threads currently managed by that thread pool.
Available starting in: .NET 9.0.
Metric: dotnet.thread_pool.work_item.count
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.thread_pool.work_item.count |
Counter | {work_item} |
The number of work items that the thread pool has completed since the process started. |
This metric reports the same values as calling ThreadPool.CompletedWorkItemCount.
.NET uses a thread pool to schedule work items onto other threads. This metric provides the number of work items that have been executed by the thread pool threads.
Available starting in: .NET 9.0.
Metric: dotnet.thread_pool.queue.length
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.thread_pool.queue.length |
UpDownCounter | {work_item} |
The number of work items that are currently queued to be processed by the thread pool. |
This metric reports the same values as calling ThreadPool.PendingWorkItemCount.
.NET uses a thread pool to schedule work items onto other threads. This metric provides the number of work items that are currently queued to be executed by one of the thread pool threads.
Available starting in: .NET 9.0.
Metric: dotnet.monitor.lock_contentions
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.monitor.lock_contentions |
Counter | {contention} |
The number of times there was contention when trying to acquire a monitor lock since the process started. |
This metric reports the same values as calling Monitor.LockContentionCount.
.NET supports using any managed object as a lock, either with APIs such as Monitor.Enter or with the lock statement. If one thread already holds a lock while a second thread tries to acquire it, this is called lock contention.
Available starting in: .NET 9.0.
Metric: dotnet.timer.count
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.timer.count |
UpDownCounter | {timer} |
The number of timer instances that are currently active. |
This metric reports the same values as calling Timer.ActiveCount.
Available starting in: .NET 9.0.
Metric: dotnet.assembly.count
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.assembly.count |
UpDownCounter | {assembly} |
The number of .NET assemblies that are currently loaded. |
This metric reports the same values as calling AppDomain.GetAssemblies() and then checking the length of the returned array.
Available starting in: .NET 9.0.
Metric: dotnet.exceptions
| Name | Instrument Type | Unit (UCUM) | Description |
|---|---|---|---|
dotnet.exceptions |
Counter | {exception} |
The number of exceptions that have been thrown in managed code. |
| Attribute | Type | Description | Examples | Presence |
|---|---|---|---|---|
error.type |
string | The exception type that was thrown. | System.OperationCanceledException; Contoso.MyException |
Required |
This metric reports the same values as counting calls to the AppDomain.FirstChanceException event.
Available starting in: .NET 9.0.
