> ## Documentation Index
> Fetch the complete documentation index at: https://launchdarkly.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# OpenTelemetry versions and instrumentation support

<View title="Developer" />

<View title="Federal docs" />

<View title="EU docs" />

This topic documents the OpenTelemetry versions used by each LaunchDarkly observability SDK and the auto-instrumentation libraries available per language. Use this information to verify compatibility with your existing OpenTelemetry setup or to understand what telemetry is captured automatically versus what requires manual instrumentation.

## OpenTelemetry versions by SDK

The following table lists the core OpenTelemetry dependency versions for each SDK. These versions are current as of the latest SDK releases.

| SDK | OTel API | OTel SDK | Exporters | Semantic conventions |
| - | - | - | - | - |
| JavaScript (browser) | ^1.9.0 | ^2.0.1 | ^0.203.0 (HTTP) | ^1.34.0 |
| Node.js (server-side) | ^1.9.0 | ^0.203.0 | ^0.203.0 (HTTP) | ^1.34.0 |
| Python | 1.34.1 | 1.34.1 | 1.34.1 (gRPC) | Included |
| Go | 1.37.0 | 1.37.0 | 1.37.0 (HTTP) | Included |
| .NET (server-side) | 1.12.0 | 1.12.0 | 1.12.0 (HTTP/Protobuf) | Included |
| Ruby | \~1.4 | \~1.4 | \~0.28 (HTTP) | \~1.10 |
| Android | 1.51.0 | 1.51.0 | 1.51.0 (HTTP) | Included |
| React Native | ^1.9.0 | ^2.0.1 | ^0.203.0 (HTTP) | ^1.35.0 |

<Info>
  **Version compatibility**

  The LaunchDarkly observability SDKs bundle their own OpenTelemetry dependencies. If your application already uses OpenTelemetry, verify that the `@opentelemetry/api` version is compatible. The OpenTelemetry API follows semantic versioning, and the SDK is generally compatible with any `@opentelemetry/api` 1.x version.
</Info>

## Auto-instrumentation by SDK

Auto-instrumentation refers to libraries and frameworks that are automatically traced, logged, or metered by the SDK without requiring you to add manual instrumentation code. The level of auto-instrumentation support varies significantly by language.

### Node.js (server-side)

The Node.js SDK uses `@opentelemetry/auto-instrumentations-node` (^0.62.0) which provides comprehensive auto-instrumentation for common Node.js libraries.

**Automatically instrumented:**

All libraries supported by [`@opentelemetry/auto-instrumentations-node`](https://www.npmjs.com/package/@opentelemetry/auto-instrumentations-node) are automatically instrumented, including:

* HTTP / HTTPS (incoming and outgoing requests)
* Express, Fastify, Hapi, Koa, Restify
* GraphQL
* MySQL, MySQL2, PostgreSQL (pg), MongoDB, Redis, Memcached
* gRPC
* AWS SDK
* DNS
* Pino (log correlation with trace/span IDs)

**Requires opt-in using environment variables:**

* Filesystem (`@opentelemetry/instrumentation-fs`): set `LAUNCHDARKLY_OTEL_NODE_ENABLE_FILESYSTEM_INSTRUMENTATION=true`
* Outgoing HTTP: enabled by default, disable with `LAUNCHDARKLY_OTEL_NODE_ENABLE_OUTGOING_HTTP_INSTRUMENTATION=false`

**Requires additional dependency:**

* Prisma ORM: install `@prisma/instrumentation` (>=5.0.0)

### Python

The Python SDK uses OpenTelemetry's auto-instrumentation framework and includes instrumentation packages for a wide range of libraries.

**Automatically instrumented (standard libraries):**

* Django, FastAPI, Flask, Starlette
* requests, urllib, urllib3, httpx, aiohttp
* SQLAlchemy, psycopg, psycopg2, sqlite3
* Redis, Celery, gRPC
* Boto / Boto3 (AWS SDK)
* Jinja2, logging, system metrics

**Automatically instrumented (AI/ML libraries):**

* OpenAI, Anthropic
* LangChain, LlamaIndex, Haystack
* Amazon Bedrock, Google Vertex AI
* Cohere, Replicate, Transformers
* ChromaDB, Pinecone, Weaviate, Qdrant

**Configuration:**

* Disable specific instrumentations with `disabled_instrumentations` in `ObservabilityConfig` or the `OTEL_PYTHON_DISABLED_INSTRUMENTATIONS` environment variable
* Control log instrumentation separately with the `instrument_logging` config parameter

### Ruby

The Ruby SDK uses `opentelemetry-instrumentation-all` (\~0.62) for broad auto-instrumentation.

**Automatically instrumented (with default configuration):**

* Rails (`enable_recognize_route: true`)
* ActiveRecord (`db_statement: :include`)
* Net::HTTP
* Rack (excludes `/health`, `/healthz`, `/ready` by default)

All libraries in `opentelemetry-instrumentation-all` are available. The SDK calls `config.use_all()`, which activates instrumentation for any detected library. You can override the defaults by providing a custom instrumentation configuration.

### Go

The Go SDK does not include auto-instrumentation libraries. Go's OpenTelemetry ecosystem uses explicit instrumentation.

**Manual instrumentation required:**

* HTTP handlers and clients
* Database drivers
* gRPC
* Any application-specific logic

**Built-in integration:**

* LaunchDarkly SDK flag evaluation tracing via `ldotel.NewTracingHook()`

To add instrumentation for specific libraries, use the corresponding [OpenTelemetry Go contrib instrumentation packages](https://pkg.go.dev/go.opentelemetry.io/contrib/instrumentation) and configure them alongside the observability plugin.

### .NET (server-side)

The .NET SDK includes several OpenTelemetry instrumentation packages by default.

**Automatically instrumented (tracing):**

* ASP.NET Core (or ASP.NET for .NET Framework)
* HTTP Client (System.Net.Http)
* gRPC Client
* SQL Client
* WCF
* Quartz.NET

**Automatically instrumented (metrics):**

* Runtime metrics (GC, thread pool, JIT)
* Process metrics (CPU, memory, handles)
* HTTP Client metrics
* ASP.NET Core metrics
* SQL Client metrics

**Extension points:**

* `WithExtendedTracingConfig()` provides additional tracing instrumentation
* `WithExtendedLoggingConfig()` provides additional log sources
* `WithExtendedMeterConfiguration()` provides additional metric instruments

### Android

The Android SDK uses the OpenTelemetry Android SDK (0.11.0-alpha).

**Automatically instrumented:**

* Application crashes (crash reporting)
* Activity lifecycle events

**Opt-in:**

* Application launch time tracking

**Manual instrumentation required:**

* Network requests
* Custom spans and metrics

You can suppress specific auto-instrumentations using `OtelRumConfig.suppressInstrumentation()`.

### React Native

The React Native SDK includes limited auto-instrumentation.

**Automatically instrumented:**

* Fetch API requests
* XMLHttpRequest requests

**Manual instrumentation required:**

* Navigation/routing events
* Custom spans, logs, and metrics

### JavaScript (browser)

The browser SDK includes auto-instrumentation for browser-specific APIs.

**Automatically instrumented:**

* Document load and resource timing
* User interactions (click events via `addEventListener`)
* Page navigation (History API changes)
* Fetch API requests
* XMLHttpRequest requests
* Console messages
* JavaScript errors

**Manual instrumentation required:**

* Custom business logic spans
* Custom metrics
* WebSocket message content (connection events are automatic when `recordHeadersAndBody` is `true`)

### iOS

**Manual instrumentation required:**

* All traces, logs, and metrics must be recorded using the `LDObserve` API

To learn more about using manual instrumentation, read [Recording metrics](/docs/sdk/features/observability-metrics), [Recording traces](/docs/sdk/features/observability-traces), [Sending errors](/docs/sdk/features/observability-errors), and [Sending logs](/docs/sdk/features/observability-logs).