OpenTelemetry versions and instrumentation support

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.

​

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 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 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, Recording traces, Sending errors, and Sending logs.