---
title: Using DDOT SDKs
description: >-
  Use DDOT SDKs, Datadog's version of OpenTelemetry SDKs, with support for
  OpenTelemetry APIs, OTLP, and additional Datadog-specific capabilities.
breadcrumbs: >-
  Docs > OpenTelemetry in Datadog > Instrument Your Applications > Using DDOT
  SDKs
---

> For the complete documentation index, see [llms.txt](https://docs.datadoghq.com/llms.txt).

# Using DDOT SDKs

{% callout %}
DDOT SDKs are in Preview.
{% /callout %}

DDOT SDKs are Datadog's version of OpenTelemetry SDKs. They emit traces, metrics, and logs that follow OpenTelemetry Semantic Conventions over OTLP. They use standard OpenTelemetry configuration and deployment tooling, and add Datadog-specific capabilities. DDOT SDKs are available for Java, .NET, Node.js, Python, and Go.

DDOT SDKs add capabilities such as Live Debugger, Dynamic Instrumentation, SQL query-level Database Monitoring, and Data Streams Monitoring. Some capabilities require the Datadog Agent. See [feature compatibility](https://docs.datadoghq.com/opentelemetry/compatibility.md#ddot-sdk-setups) for additional capabilities and requirements.

## Prerequisites{% #prerequisites %}

Install and attach a DDOT SDK to your service, and provide a reachable OTLP-compatible receiver that forwards telemetry to Datadog. Datadog recommends the [DDOT Collector](https://docs.datadoghq.com/opentelemetry/setup/ddot_collector.md). DDOT SDKs also work well with the [upstream OpenTelemetry Collector](https://docs.datadoghq.com/opentelemetry/setup/collector_exporter.md).

## Deployment methods{% #deployment-methods %}

Install DDOT SDKs the same way as upstream OpenTelemetry SDKs. Every installation method available for upstream OpenTelemetry SDKs works for DDOT SDKs, including OpenTelemetry Operator injection and installation in the application build or deployment.

| Environment                                        | Method                                                                                                                      | What it does                                                                        |
| -------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| Kubernetes                                         | [OpenTelemetry Operator](https://opentelemetry.io/docs/platforms/kubernetes/operator/automatic/)                            | Injects the auto-instrumentation image configured in an `Instrumentation` resource. |
| Kubernetes, other containers, hosts, or serverless | [SDK package installation](https://docs.datadoghq.com/tracing/trace_collection/dd_libraries.md#instrument-your-application) | Installs the SDK in the application build or deployment.                            |

### Kubernetes deployment{% #kubernetes-deployment %}

The OpenTelemetry Operator's `Instrumentation` resource selects the SDK images injected into workloads. DDOT SDK images replace the default upstream images for Java, Python, Node.js, and .NET.

The [DDOT Kubernetes installation guide](https://github.com/DataDog/opentelemetry-examples/tree/main/guides/kubernetes/configuration/opentelemetry-kube-stack/ddot#instrument-kubernetes-workloads-with-ddot-sdks) includes OpenTelemetry SDK instrumentation images, an `Instrumentation` resource, and workload annotations. For an existing Operator or Collector deployment, see [Adapt an existing configuration for DDOT](https://github.com/DataDog/opentelemetry-examples/blob/main/guides/kubernetes/configuration/opentelemetry-kube-stack/ddot/ADAPT-EXISTING-CONFIG.md). For OpenTelemetry Operator concepts and configuration options, see [OpenTelemetry Operator automatic instrumentation](https://opentelemetry.io/docs/platforms/kubernetes/operator/automatic/).

Go applications include the SDK and instrumentation at build time, typically in the Dockerfile. For DDOT Go, use [Orchestrion](https://docs.datadoghq.com/tracing/guide/orchestrion_dockerfile.md). The upstream OpenTelemetry Go SDK uses OpenTelemetry Go compile-time instrumentation (`otelc`) instead. The OpenTelemetry Operator's `instrumentation.opentelemetry.io/inject-sdk` annotation supplies configuration to the application, but it doesn't install an SDK.

### Application installation{% #application-installation %}

For installation without the OpenTelemetry Operator, follow the [installation instructions for your language](https://docs.datadoghq.com/tracing/trace_collection/dd_libraries.md#instrument-your-application), then apply the OpenTelemetry configuration below to send OTLP telemetry to your Collector. Some capabilities require the Datadog Agent; see [feature compatibility](https://docs.datadoghq.com/opentelemetry/compatibility.md#ddot-sdk-setups).

## Configure OpenTelemetry mode and export{% #configure-opentelemetry-mode-and-export %}

DDOT SDKs send traces, metrics, and logs over OTLP to an OpenTelemetry Collector. The Collector can batch, enrich, and route telemetry before exporting it to Datadog or another OTLP-compatible backend. These signals don't go through the Datadog Agent. Datadog recommends running a Datadog Agent alongside the Collector for the Datadog-specific capabilities of DDOT SDKs, such as Live Debugger and Dynamic Instrumentation. It acts mainly as a Remote Configuration proxy, while traces, metrics, and logs keep flowing over OTLP to the Collector, so it doesn't affect your OpenTelemetry setup's freedom from vendor lock-in. See [feature compatibility](https://docs.datadoghq.com/opentelemetry/compatibility.md#ddot-sdk-setups) for language support and capability requirements.

### Language support{% #language-support %}

Select your language to see the minimum SDK version and supported protocols for OTLP trace export.

{% tab title="Java" %}

- **Minimum version**: v1.62.0
- **Supported protocols**: `http/protobuf` (default), `grpc`, `http/json` (v1.65.0+)

{% /tab %}

{% tab title="Python" %}

- **Minimum version**: v4.8.0
- **Supported protocols**: `http/protobuf` (v4.14.0+, default), `http/json` (default before v4.14.0), `grpc` (v4.17.0+)

{% /tab %}

{% tab title="Node.js" %}

- **Minimum version**: v5.98.0
- **Supported protocols**: `http/json`

{% /tab %}

{% tab title="Go" %}

- **Minimum version**: v2.8.0
- **Supported protocols**: `http/protobuf`

{% /tab %}

{% tab title=".NET" %}

- **Minimum version**: v3.41.0
- **Supported protocols**: `http/protobuf` (v3.45.0+, default from v3.58.0), `http/json` (default before v3.58.0)

{% /tab %}

### Activate OpenTelemetry mode{% #enable-otlp-trace-export %}

Set the following environment variables to activate OpenTelemetry mode: OTLP export of traces, metrics, and logs, the OpenTelemetry APIs, and OpenTelemetry trace semantic conventions:

```text
OTEL_TRACES_EXPORTER=otlp
DD_TRACE_OTEL_ENABLED=true
DD_TRACE_OTEL_SEMANTICS_ENABLED=true
DD_METRICS_OTEL_ENABLED=true
DD_LOGS_OTEL_ENABLED=true
```

To send traces to a receiver at a different address, set `OTEL_EXPORTER_OTLP_ENDPOINT` or the trace-specific `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`. DDOT Go versions 2.8.0 to 2.11.2 ignore `OTEL_EXPORTER_OTLP_ENDPOINT`; with these versions, set `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` (for example, `http://<collector>:4318/v1/traces`), or upgrade to 2.12.0 or later. See the [OTLP Exporter Configuration](https://opentelemetry.io/docs/specs/otel/protocol/exporter/) documentation for details. See [OpenTelemetry API support](https://docs.datadoghq.com/opentelemetry/instrument/ddot_sdks/api_support.md) and the [environment variable reference](https://docs.datadoghq.com/opentelemetry/config/environment_variable_support.md) for signal-specific configuration.

### OpenTelemetry trace semantics{% #opentelemetry-trace-semantics %}

Set `DD_TRACE_OTEL_SEMANTICS_ENABLED=true` to enable OpenTelemetry trace conventions. For HTTP client and server instrumentation, use the versions below or later:

| SDK     | Version                                                                   |
| ------- | ------------------------------------------------------------------------- |
| Java    | [1.68.0](https://github.com/DataDog/dd-trace-java/releases/tag/v1.68.0)   |
| Python  | [4.17.0](https://github.com/DataDog/dd-trace-py/releases/tag/v4.17.0)     |
| Node.js | [5.110.0](https://github.com/DataDog/dd-trace-js/releases/tag/v5.110.0)   |
| Go      | [2.12.0](https://github.com/DataDog/dd-trace-go/releases/tag/v2.12.0)     |
| .NET    | [3.55.0](https://github.com/DataDog/dd-trace-dotnet/releases/tag/v3.55.0) |

These versions provide a baseline for HTTP instrumentation. OTLP export versions and protocols are listed in Language support. Semantic convention coverage varies by instrumentation; see the linked SDK release notes for details.

### Sampling and trace metrics{% #sampling-and-trace-metrics %}

DDOT SDKs apply sampling before OTLP export and record the sampling probability in spans' `tracestate`. Use the versions below and a [compatible receiver](https://docs.datadoghq.com/opentelemetry/ingestion_sampling.md#trace-metric-extrapolation-for-datadog-sdks) to extrapolate trace metrics from that probability.

| DDOT SDK | Minimum version for sampling probability in OTLP spans                                                                                           |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| Java     | [1.67.0](https://github.com/DataDog/dd-trace-java/releases/tag/v1.67.0)                                                                          |
| Python   | [4.15.0](https://github.com/DataDog/dd-trace-py/releases/tag/v4.15.0)                                                                            |
| Node.js  | [6.20.0](https://github.com/DataDog/dd-trace-js/releases/tag/v6.20.0) or [5.131.0](https://github.com/DataDog/dd-trace-js/releases/tag/v5.131.0) |
| Go       | [2.11.0](https://github.com/DataDog/dd-trace-go/releases/tag/v2.11.0)                                                                            |
| .NET     | [3.55.0](https://github.com/DataDog/dd-trace-dotnet/releases/tag/v3.55.0)                                                                        |

## Switch instrumentation{% #switch-instrumentation %}

- **From a Datadog SDK using Datadog semantics and protocols:** Apply the OpenTelemetry settings above to the installed SDK. Keep the existing installation method and intentional instrumentation settings. If Single Step Instrumentation (SSI) manages the installation, see [Adapt an existing configuration for DDOT](https://github.com/DataDog/opentelemetry-examples/blob/main/guides/kubernetes/configuration/opentelemetry-kube-stack/ddot/ADAPT-EXISTING-CONFIG.md) before changing injection or export settings.
- **From an upstream OpenTelemetry SDK:** Replace the SDK package, auto-instrumentation image, or build-time instrumentation. Keep OpenTelemetry API instrumentation and standard configuration, and review SDK-specific provider, processor, and exporter configuration.
- **To an upstream OpenTelemetry SDK:** Change the SDK package or auto-instrumentation image, or, for Go, the build-time instrumentation. OpenTelemetry API instrumentation and standard configuration remain available. Datadog-specific capabilities are no longer available, and code that uses Datadog-specific APIs may need changes.

The [existing-configuration guide](https://github.com/DataDog/opentelemetry-examples/blob/main/guides/kubernetes/configuration/opentelemetry-kube-stack/ddot/ADAPT-EXISTING-CONFIG.md) covers these migration paths.



**Note**: For OpenTelemetry trace conventions, enable OpenTelemetry trace semantics. Without this setting, traces use Datadog semantics, such as `http.status_code` instead of `http.response.status_code`.

## Configure capabilities{% #configure-capabilities %}



- [
  ### Use the OpenTelemetry API
Create custom traces, metrics, and logs with OpenTelemetry APIs. Review support for your language and signal.](https://docs.datadoghq.com/opentelemetry/instrument/ddot_sdks/api_support.md)
- [
  ### Use OpenTelemetry instrumentation libraries
Review which OpenTelemetry instrumentation libraries work with DDOT SDKs and how to avoid duplicate spans.](https://docs.datadoghq.com/opentelemetry/instrument/ddot_sdks/instrumentation_libraries.md)
- [
  ### Configure environment variables
Review the OpenTelemetry SDK and OTLP exporter environment variables supported by DDOT SDKs.](https://docs.datadoghq.com/opentelemetry/config/environment_variable_support.md)
 
## View your telemetry{% #view-your-telemetry %}



Use the [SDK startup logs](https://docs.datadoghq.com/tracing/troubleshooting/tracer_startup_logs.md#opentelemetry-configuration) to check the effective OpenTelemetry configuration when troubleshooting missing telemetry or unexpected behavior. The settings reported depend on the SDK language and version.

View your application's traces in [Trace Explorer](https://docs.datadoghq.com/tracing/trace_explorer.md), metrics in [Metrics Explorer](https://docs.datadoghq.com/metrics/explorer.md), and logs in [Log Explorer](https://docs.datadoghq.com/logs/explorer.md). For missing telemetry, see [OpenTelemetry troubleshooting](https://docs.datadoghq.com/opentelemetry/troubleshooting.md).

## Further reading{% #further-reading %}

Additional helpful documentation, links, and articles:

- [OpenTelemetry feature compatibility](https://docs.datadoghq.com/opentelemetry/compatibility.md)
- [DDOT Collector](https://docs.datadoghq.com/opentelemetry/setup/ddot_collector.md)
- [OpenTelemetry Operator automatic instrumentation](https://opentelemetry.io/docs/platforms/kubernetes/operator/automatic/)
