Automatic instrumentation

If you use OpenTelemetry automatic instrumentation for Java applications, runtime metrics are enabled by default.

Manual instrumentation

If you use OpenTelemetry manual instrumentation, follow the guides for your Java version:

• Java 8
• Java 17

Experimental telemetry

Enabling experimental OpenTelemetry runtime telemetry may provide additional metric mappings between Datadog and OpenTelemetry for Java. To enable it, set the following environment variable:

OTEL_INSTRUMENTATION_RUNTIME_TELEMETRY_EMIT_EXPERIMENTAL_TELEMETRY=true

Additional JMX metrics

To collect additional JVM metrics beyond the default runtime instrumentation, install the OpenTelemetry JMX Metric Scraper. The scraper scrapes MBeans over JMX and emits them as OpenTelemetry metrics, which Datadog then maps to runtime metrics (see the JVM Contrib table in Data collected).

Configure the scraper with otel.jmx.target.source=legacy to collect these additional metrics. The scraper’s instrumentation source emits the same semantic-convention metrics already produced natively by the OpenTelemetry Java SDK, so it does not provide additional coverage.

Collector configuration

The jvm.gc.collections.count and jvm.gc.collections.elapsed metrics require the Delta-to-Rate Processor in the OpenTelemetry Collector. Set OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE=delta or use the cumulativetodelta processor.

processors:
  deltatorate:
    metrics:
      - jvm.gc.collections.count
      - jvm.gc.collections.elapsed

Note: The minimum supported version of the OpenTelemetry Java agent is 2.0.0.

Manual instrumentation

OpenTelemetry Go applications are instrumented manually. To enable runtime metrics, see the documentation for the runtime package.

Collector configuration

Some Go runtime metrics are reported as monotonic sums, but Datadog expects them as gauges. The Transform Processor converts these sums to gauges, and the Cumulative-to-Delta Processor excludes them from delta conversion. Verify that OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE is not set to delta. Otherwise, metrics excluded by cumulativetodelta are ignored.

processors:
  transform/go-runtime:
    error_mode: ignore
    metric_statements:
      - context: metric
        statements:
          - convert_sum_to_gauge() where name == "process.runtime.go.gc.pause_total_ns" or name == "process.runtime.go.gc.count" or name == "go.memory.allocated" or name == "go.memory.allocations"

  cumulativetodelta:
    exclude:
      metrics:
        - process.runtime.go.gc.pause_total_ns
        - process.runtime.go.gc.count
        - go.memory.allocated
        - go.memory.allocations
      match_type: strict

Note: The minimum supported version of go.opentelemetry.io/contrib/instrumentation/runtime is v0.46.0, which also requires Go 1.20+ and OpenTelemetry Go SDK v1.21.0+.

Automatic instrumentation

If you use OpenTelemetry automatic instrumentation for .NET applications, runtime metrics are enabled by default.

Manual instrumentation

If you use OpenTelemetry manual instrumentation, see the documentation for the OpenTelemetry.Instrumentation.Runtime library.

Metric export interval

The default metric export interval for the .NET OTel SDK differs from the default for the Datadog .NET SDK. Datadog recommends setting the OTEL_METRIC_EXPORT_INTERVAL environment variable on your .NET service to match the default Datadog metric export interval:

OTEL_METRIC_EXPORT_INTERVAL=10000

Collector configuration

The dotnet.process.cpu.time and process.cpu.time metrics require the Delta-to-Rate Processor in the OpenTelemetry Collector. Set OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE=delta or use the cumulativetodelta processor.

processors:
  deltatorate:
    metrics:
      - dotnet.process.cpu.time
      - process.cpu.time

Note: The minimum supported version of the .NET OpenTelemetry SDK is 1.5.0.

Automatic instrumentation

If you use OpenTelemetry automatic instrumentation for Node.js applications, runtime metrics are enabled by default through the @opentelemetry/instrumentation-runtime-node package.

Manual instrumentation

If you use OpenTelemetry manual instrumentation, see the documentation for the @opentelemetry/instrumentation-runtime-node library.

Host metrics

Host-level metrics such as system CPU and memory usage are not included in OpenTelemetry automatic instrumentation. To collect these metrics:

1. Install and configure the @opentelemetry/host-metrics package:

   npm install @opentelemetry/host-metrics
   

2. Initialize the package with your existing MeterProvider:

   const { HostMetrics } = require('@opentelemetry/host-metrics');
   const { metrics } = require('@opentelemetry/api');
   const hostMetrics = new HostMetrics({
     meterProvider: metrics.getMeterProvider(),
   });
   hostMetrics.start();
   

For the list of metrics collected by this package, see the Node.js Contrib Host table.

Note: The minimum supported version of @opentelemetry/instrumentation-runtime-node is 0.9.0.

Installation

Runtime metrics are not enabled by default for Python applications. Install the opentelemetry-instrumentation-system-metrics package:

pip install opentelemetry-instrumentation-system-metrics

Automatic instrumentation

If you use OpenTelemetry automatic instrumentation for Python applications, opentelemetry-instrument discovers and enables the package after installation.

Manual instrumentation

If you use OpenTelemetry manual instrumentation, enable the package in your application:

from opentelemetry.instrumentation.system_metrics import SystemMetricsInstrumentor

SystemMetricsInstrumentor().instrument()

JVM Instrumentation

These metrics are collected when using the latest version of the OpenTelemetry Java SDK.

JVM Contrib

These metrics are collected when using the OpenTelemetry JMX Metric Scraper.

Deprecated JVM Metrics

These metrics are collected when using OpenTelemetry Java SDK versions 1.32.0 and earlier.

Go Runtime Metrics

These metrics are collected by the OpenTelemetry Go runtime instrumentation package.

.NET System.Runtime

These metrics are emitted by the .NET runtime's built-in System.Runtime meter on .NET 9.0 and later. The OpenTelemetry SDK collects and exports them automatically.

.NET Contrib Runtime

These metrics are collected by the OpenTelemetry.Instrumentation.Runtime package. On .NET 9.0 and later, these overlap with the System.Runtime metrics above.

.NET Contrib Process

These metrics are collected by the OpenTelemetry.Instrumentation.Process package.

Node.js Contrib Runtime

These metrics are emitted from auto-instrumentation with the latest version of the OpenTelemetry Node.js SDK.

Node.js Contrib Host

These metrics are collected by the @opentelemetry/host-metrics package. This package is not included in OpenTelemetry automatic instrumentation and must be installed and configured manually.

Python Runtime Metrics

These metrics are collected by the opentelemetry-instrumentation-system-metrics package. The following table lists the conceptual equivalences between OpenTelemetry and Datadog Python runtime metrics. There are no direct metric-name mappings because the metric types differ between the two systems.