.NET Runtime Metrics (OpenTelemetry)
To find out if this integration is available in your organization, see your Datadog Integrations page or ask your organization administrator.
To initiate an exception request to enable this integration for your organization, email [email protected].
Overview
The .NET OpenTelemetry integration allows you to collect runtime metrics from your .NET applications instrumented with OpenTelemetry, covering the built-in System.Runtime metrics defined in the .NET runtime semantic conventions.
Setup
See the dedicated documentation for .NET Runtime Metrics via OpenTelemetry.
The System.Runtime meter emits the built-in dotnet.* metrics in .NET 9 and later. Earlier versions can produce the same data using the OpenTelemetry.Instrumentation.Runtime contrib package under the legacy process.runtime.dotnet.* namespace.
Note: this dashboard covers only the new dotnet.* metrics and does not include the legacy process.runtime.dotnet.* namespace.
Data Collected
Metrics
| |
|---|
dotnet.process.cpu.count
(gauge) | The number of processors available to the process.
Shown as core |
dotnet.process.cpu.time
(count) | CPU time used by the process.
Shown as second |
dotnet.process.memory.working_set
(gauge) | The number of bytes of physical memory mapped to the process context.
Shown as byte |
dotnet.gc.collections
(count) | The number of garbage collections that have occurred since the process started.
Shown as occurrence |
dotnet.gc.heap.total_allocated
(count) | The approximate number of bytes allocated on the managed GC heap since the process started.
Shown as byte |
dotnet.gc.last_collection.memory.committed_size
(gauge) | The amount of committed virtual memory in use by the .NET GC as observed during the last GC.
Shown as byte |
dotnet.gc.last_collection.heap.size
(gauge) | The managed GC heap size after the last GC.
Shown as byte |
dotnet.gc.last_collection.heap.fragmentation.size
(gauge) | The heap fragmentation as observed during the last GC.
Shown as byte |
dotnet.gc.pause.time
(count) | The total amount of time paused in GC since the process started.
Shown as second |
dotnet.jit.compiled_il.size
(count) | Count of bytes of intermediate language that have been compiled since the process started.
Shown as byte |
dotnet.jit.compiled_methods
(count) | The number of times the JIT compiler has compiled a method since the process started.
Shown as occurrence |
dotnet.jit.compilation.time
(count) | The amount of time the JIT compiler has spent compiling methods since the process started.
Shown as second |
dotnet.monitor.lock_contentions
(count) | The number of times there was contention when trying to acquire a monitor lock since the process started.
Shown as occurrence |
dotnet.thread_pool.thread.count
(gauge) | The number of thread pool threads that currently exist.
Shown as thread |
dotnet.thread_pool.work_item.count
(count) | The number of work items that the thread pool has completed since the process started.
Shown as occurrence |
dotnet.thread_pool.queue.length
(gauge) | The number of work items currently queued for processing by the thread pool.
Shown as item |
dotnet.timer.count
(gauge) | The number of active timers.
Shown as occurrence |
dotnet.assembly.count
(gauge) | The number of .NET assemblies currently loaded.
Shown as occurrence |
dotnet.exceptions
(count) | The number of exceptions that have been thrown in managed code.
Shown as occurrence |
Service Checks
The .NET Runtime Metrics (OpenTelemetry) integration does not include any service checks.
Events
The .NET Runtime Metrics (OpenTelemetry) integration does not include any events.
Support
Need help? Contact Datadog support.
