---
title: .NET Runtime Metrics (OpenTelemetry)
description: Collect runtime metrics from your .NET applications via OpenTelemetry.
breadcrumbs: Docs > Integrations > .NET Runtime Metrics (OpenTelemetry)
---

# .NET Runtime Metrics (OpenTelemetry)

{% callout %}
# Important note for users on the following Datadog sites: us2.ddog-gov.com

{% alert level="info" %}
To find out if this integration is available in your organization, see your [Datadog Integrations](https://app.datadoghq.com/integrations) page or ask your organization administrator.

To initiate an exception request to enable this integration for your organization, email [support@ddog-gov.com](mailto:support@ddog-gov.com).
{% /alert %}

{% /callout %}

## Overview{% #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](https://opentelemetry.io/docs/specs/semconv/runtime/dotnet-metrics/).

## Setup{% #setup %}

See the dedicated documentation for [.NET Runtime Metrics via OpenTelemetry](https://opentelemetry.io/docs/specs/semconv/runtime/dotnet-metrics/).

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`](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/tree/main/src/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{% #data-collected %}

### Metrics{% #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{% #service-checks %}

The .NET Runtime Metrics (OpenTelemetry) integration does not include any service checks.

### Events{% #events %}

The .NET Runtime Metrics (OpenTelemetry) integration does not include any events.

## Support{% #support %}

Need help? Contact [Datadog support](https://docs.datadoghq.com/help/).