OpenTelemetry versions and instrumentation support

Overview

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.