ddtrace 4.15.0

on Python PyPI

Estimated end-of-life date, accurate to within three months: 05-2027

See the support level definitions for more information.

Upgrade Notes

• openfeature
  • Reports strings, numbers, booleans, datetimes, and null values from evaluation context; unsupported values are no longer converted to strings and are omitted without affecting flag resolution.
• AAP
  • Upgrades libddwaf to version 2.1.0.
• LLM Observability
  • The pydantic_ai integration now reports agent configuration using the shared agent manifest schema. framework, name, model, model_settings, instructions, system_prompts and tools keep their names and meaning. New keys are metadata, extra_instructions, capabilities, data_contracts, memory_policies, guardrails and agent_settings.
• ASM
  • Upgrades libddwaf to version 2.0.1.

New Features

• tracing
  • Adds a discard boolean field to DD_TRACE_SAMPLING_RULES rules to fully drop trace chunks which were rejected during sampling. See the DD_TRACE_SAMPLING_RULES configuration docs for details.
  • add consistent probability sampling support for distributed traces in mixed Datadog - OpenTelemetry environment
  • Adds OpenTelemetry consistent probability sampling state (ot.th and ot.rv) to spans exported through OTLP when OTEL_TRACES_EXPORTER=otlp is configured, allowing downstream collectors to preserve and extrapolate sampling decisions.
  • Runtime metrics now include CPython GC collection counts and stop-the-world pause time and max pause when DD_RUNTIME_METRICS_ENABLED is true.
  • Adds OpenTelemetry thread-context synchronization for applications using uvloop on Linux with Python 3.13 and earlier. It rides on the asyncio integration, is enabled by default, and can be disabled with DD_TRACE_OTEL_CTX_ENABLED=false or DD_TRACE_ASYNCIO_ENABLED=false.
  • Adds support for exporting Datadog trace metrics when OTLP trace export is enabled. Set OTEL_TRACES_SPAN_METRICS_ENABLED=true to enable it.
  • Adds support for DD_TRACE_STATS_ADDITIONAL_TAGS, which adds configured span tags to native v0.6 trace stats and OTLP trace metrics.
  • Adds Span.remove_tag(key) and Span.remove_metric(key) for removing a previously set tag or metric from a span. Both are no-ops if the key is not set.
  • Adds DD_AGENTLESS_ENABLED (default false), a single switch that submits all telemetry, traces, Remote Configuration, Dynamic Instrumentation, crash reports, Test Optimization and LLM Observability data directly to the Datadog intake instead of through a local Datadog Agent. It becomes the default for the per-product agentless settings, which can still be set individually to override it. DD_API_KEY is required when it is enabled. Note that tracer flares, runtime metrics and profiling are notably not supported in this mode.
  • Adds OpenTelemetry thread-context synchronization for applications using Python's built-in asyncio event loop on Linux with Python 3.13 and earlier. This is enabled by default and can be disabled with DD_TRACE_OTEL_CTX_ENABLED=false.
  • When DD_TRACE_OTEL_CTX_ENABLED is true (the default), propagated trace contexts are published to OpenTelemetry thread context records. This lets external readers retain trace and span correlation when no active span object is available.
  • Adds Python 3.14+ support for keeping OpenTelemetry thread-context records synchronized across asynchronous context switches. This behavior is enabled by default and can be disabled by setting DD_TRACE_OTEL_CTX_ENABLED to false.
  • Adds the DD_TRACE_PROPAGATION_AS_SPAN_LINKS environment variable, a comma-separated list of integration names (e.g. google_cloud_pubsub,kafka) for which propagated context is attached as span links instead of a parent-child relationship.
• LLM Observability
  • botocore: The Amazon Bedrock integration now captures tool definitions, tool calls, and tool results on InvokeModel spans for Anthropic models, matching the Converse API.
  • Adds finish_reason to LLM spans to indicate the reason the model stopped generating for the openai, litellm, and anthropic integrations.
  • APM spans for LLM and agent operations now carry gen_ai.* attributes, so model, provider, application, conversation, and token usage can be searched, faceted, and monitored directly in APM.
  • The OpenAI Realtime integration now traces each conversation turn as a span tree instead of a single llm span.
  • The Anthropic integration now captures inline base64 image inputs on message requests as image_parts on LLM span messages, so they can be rendered in LLM Observability. Note: images referenced by a URL or a file ID are not captured, and a very large inline image is replaced with a text placeholder.
  • Datasets, experiments, and custom evaluator publishing no longer require DD_APP_KEY on the application when a Datadog Agent is used.
  • Adds LLMObs.list_experiments() to query experiments by logical name, metadata containment (e.g. {"tags": ["git.commit.sha:abc123"]}). Returns run status and aggregate data (evals, token costs, error rates), so CI/CD workflows can compare a run against a baseline commit and gate on the result.
  • Adds support for manually versioning agents. Pass version when starting an agent span, either with LLMObs.agent(name="my-agent", version="v3") or with the @agent(version="v3") decorator. For agents created by an auto-instrumented framework, use LLMObs.annotation_context(agent={"version": "v3"}). This sets the agent_version tag on agent spans. The agent argument accepts a plain dictionary or the new ddtrace.llmobs.Agent TypedDict class.
  • The OpenAI integration now captures inline base64 images from message content as image_parts on LLM span messages, for both Chat Completions and the Responses API, so image inputs render in LLM Observability. This also applies to the OpenAI Agents SDK and to the LiteLLM integration, which share the same message extraction. Images referenced by a remote URL or file_id are not fetched and keep their existing text reference. A single inline image whose base64 payload exceeds 4 MiB is left as an [image omitted: too large] marker instead. Note that this budget is per image, not per request: several inline images (or an image alongside inline audio) can still take a span event past the 5 MB per-event limit, at which point the event's input and output are replaced with a placeholder. To stop image bytes from being recorded, register a span processor with LLMObs.register_processor and remove the image_parts key from the messages on span.input.
  • Adds LLMObs.submit_feedback() for submitting end-user feedback associated with a span, trace, session, or customer-defined feedback join key.
• openfeature
  • Limits the amount and nesting depth of evaluation context data reported with flag evaluations; data outside these limits is omitted without affecting flag resolution.
  • Adds agentless delivery for the Feature Flagging and Experimentation (FFE) OpenFeature provider, loading Universal Flag Configuration directly from Datadog over HTTPS without requiring a Datadog Agent. Agentless is now the default source and requires DD_API_KEY; set DD_FEATURE_FLAGS_CONFIGURATION_SOURCE=remote_config to keep loading configuration through the Datadog Agent's Remote Configuration.
  • Datadog now uses a serial id to attribute an exposure to the experiment or holdout that assigned the variant.
• CI visibility
  • Adds DD_CIVISIBILITY_DYNAMIC_ATR_ENABLED to enable dynamic Auto Test Retries budgets based on test duration, instead of the flat per-test retry limit. Optionally configure the five duration-based budgets with DD_CIVISIBILITY_DYNAMIC_ATR_BUCKETS (five comma-separated integers in [1, 20]), corresponding to the Early Flake Detection duration buckets.
  • Adds a new ci.pipeline.display_name tag for the Buildkite provider, populated from the BUILDKITE_PIPELINE_NAME environment variable.
• uWSGI
  • added support for normal, non-lazy mode, provided threads are enabled and the py-call-uwsgi-fork-hooks option is set.
• anyio
  • Adds native trace-context support for synchronous FastAPI handlers running in AnyIO worker threads on Linux. The integration is enabled by default and can be disabled with DD_TRACE_ANYIO_ENABLED=false.
• kafka
  • Adds support for kafka in the DD_TRACE_PROPAGATION_AS_SPAN_LINKS environment variable. When enabled together with distributed tracing, the kafka.consume span starts a new trace and relates to every consumed message's producer via span links, instead of continuing a single producer's trace. This is disabled by default.
• profiling
  • DD_PROFILING_MEMORY_MEM_DOMAIN_ENABLED now defaults to true, so the heap profiler also tracks allocations in the Mem domain on Python 3.12+.
  • This introduces inclusion of birth timestamp to allocation samples.
  • Add experimental native (C/C++) heap profiling for Python processes on Linux (glibc only). Enabled with DD_PROFILING_NATIVE_HEAP_ENABLED=true.
  • Time spent in garbage collection is now tracked by the profiler and appears in flame graphs. It can be enable with DD_PROFILING_STACK_GC_ENABLED=true.
  • It is now possible to set a maximum number of asyncio tasks/greenlets to sample per cycle.
• AAP
  • Adds the build_py option --no-bundle-libddwaf, set through the [build_py] section of setup.cfg, which builds the package without a bundled libddwaf. The library is then loaded from the system at import time (libddwaf.so.2, then libddwaf.so, resolved by the dynamic linker, and required to be 2.x). Intended for Linux distribution packages; default builds bundle libddwaf as before.
  • Adds SSRF exploit prevention and OWASP API Top 10 security risk analysis for the httpx2 client.
• httpx2
  • Adds automatic tracing for synchronous and asynchronous HTTP requests made with httpx2>=2.0.0
• AI Guard
  • Added a redaction feature, which can be enabled in the UI. For more info, see https://docs.datadoghq.com/security/ai_guard/setup/sdk/
• ASM
  • Adds SQL injection attack detection and blocking for applications using the aiomysql, aiopg, psycopg async, and MySQL Connector/Python asyncio database drivers.
• data streams monitoring
  • This adds an optional tags argument to ddtrace.data_streams.set_produce_checkpoint and ddtrace.data_streams.set_consume_checkpoint. Pass a list of "key:value" strings to attach additional edge tags to a manual checkpoint alongside the automatically set type, topic, and direction tags, for example set_produce_checkpoint("eventbridge", detail_type, carrier_set, tags=["exchange:my-bus"]). Existing calls that do not pass tags are unaffected.
• gevent
  • Adds automatic synchronization of OpenTelemetry thread context when gevent switches between greenlets.
• opentelemetry
  • OTLP trace export now supports the http/protobuf protocol (the default) and http/json, selected via the OTEL_EXPORTER_OTLP_TRACES_PROTOCOL environment variable.

Bug Fixes

• AAP
  • Fixes an issue where exceptions raised by urllib3 requests include an Exploit Prevention frame in their traceback, which caused ordinary application errors to be misattributed to Datadog. Enabling urllib3 APM tracing, which is off by default, still contributes a frame of its own.
  • Fixes a rare crash that can occur when rules are updated concurrently.
  • Fixes an issue where memory usage grows over time when AAP is enabled for applications making traced outbound HTTP requests.
  • Fixes an issue where setting DD_APPSEC_RULES to an empty value prevents AppSec rules from being updated through remote configuration.
  • Fixes an issue where exploit prevention misses command injection attempts when subprocess commands are passed as tuples.
  • Fixes incorrect request fingerprints when a web application is wrapped by same-service tracing middleware.
• crashtracking
  • fix crash reports being sent to the wrong intake when DD_AGENTLESS_ENABLED is set. The errors-intake upload was incorrectly reusing the same endpoint configured for the telemetry crash-report path, sending it to the telemetry intake host instead of the dedicated errors-intake host.
  • Strips the bootstrap directory from the inherited PYTHONPATH before spawning the receiver, so it stays an uninstrumented script. Empty PYTHONPATH entries (the current working directory) are preserved so the receiver can still import ddtrace when it is loaded from the working directory.
• LLM Observability
  • botocore: This fix resolves an issue where the Amazon Bedrock InvokeModel integration only captured the first content block of an Anthropic response, so output messages were empty or truncated when a response began with a tool_use or thinking block.
  • Fixes an issue where span and evaluation metric events can be lost when intake temporarily returns a server error.
  • Fixes an issue where enabling LLM Observability together with DD_APM_TRACING_ENABLED=false discarded every trace, so AI Guard, App and API Protection, Code Security and Software Composition Analysis reported no spans while running in standalone mode. These traces are now sent, and APM billing stays opted out.
  • This fix resolves an issue where reasoning content from streamed google_genai responses was merged into the output message instead of being captured as a separate reasoning message.
  • fixes an issue where _DD_TRACE_WRITER_ADDITIONAL_HEADERS header values containing a whitespace (for example Bearer <token>) were incorrectly parsed, resulting in a truncated header value that caused LLM Observability spans to be dropped.
  • Fixes an issue where token counts were not captured properly on LLM spans generated via the Claude Agent SDK integration. The integration now reads the accurate per-turn token counts from the SDK's streaming events, leaving the caller's message stream unchanged. This also enables token counts on claude-agent-sdk versions prior to 0.1.49, which do not report usage on the assistant message. Note that explicitly setting include_partial_messages=False on ClaudeAgentOptions opts out of this behavior and will result in inaccurate per-turn output token counts.
  • Fixes an issue where spans created under an auto-instrumented agent span (CrewAI, Google ADK, LangGraph, LlamaIndex, Amazon Bedrock Agents, Claude Agent SDK, and OpenAI Agents) were not attributed to that agent, leaving agent_attribution missing or pointing at the wrong ancestor.
  • Resolves a TypeError raised during streamed tool-call reconstruction when an OpenAI-compatible backend (e.g. DashScope/Qwen) emits a tool-call delta with function.arguments or custom.input set to None instead of "".
  • Fixes missing Prompt Experimentation exposures when DD_FEATURE_FLAGS_CONFIGURATION_SOURCE is set to agentless or remote_config.
  • Fixes an issue where the agentless exporter dropped traces due to non-JSON-serializable objects being stored on a span. All LLM Observability span data is now made JSON-serializable before the span is submitted. Non-string span tag keys, span metric keys, and agent versions supplied via LLMObs.annotate(agent=...) are also now coerced to strings.
  • Fixes an issue where an inline base64 image sent in message content to the OpenAI Responses API (including through the OpenAI Agents SDK) was recorded as the entire base64 data URL inside the message text, producing unreadable multi-megabyte span content.
  • Fixes an issue where an inline base64 image passed as a reusable-prompt variable to the OpenAI Responses API was recorded as the entire base64 data URL on the span. Such a variable is now recorded as [image]; remote URL and file_id references are unchanged.
  • Fixes an issue where OpenAI Responses API image-generation results and computer-use screenshots were recorded as a stringified dump of the whole response item, which embedded the image's base64 payload in the output message. They are now recorded as an [image] marker, or as the screenshot's URL when it is a remote reference.
  • Resolves an issue where the OpenAI and LiteLLM integrations reported zero cost for OpenRouter requests using a bring-your-own-key setup.
• CI Visibility
  • Fixes an issue where the pytest plugin entered a code coverage collection context around every test even when code coverage was disabled, which reported coverage as active while no coverage was being collected and, on Python 3.12 and later, restarted sys.monitoring events once per test.
  • Fixes an issue where collecting coverage could abort the session with a TypeError.
  • Fixes ValueError: I/O operation on closed file logging tracebacks at the end of pytest sessions when standard stream handlers point to streams closed by pytest. Tracer logs continue to reach healthy root handlers, including file output and log forwarding.
  • Fixes an issue where test events can be reported without their test session when running pytest-xdist with the legacy pytest plugin.
  • Fixes an issue where code coverage collected for Intelligent Test Runner (ITR) included files from site-packages or dist-packages directories.
  • fix the session status being reported as pass instead of fail when pytest exits with a non-OK, non-NO_TESTS_COLLECTED exit code (e.g. collection errors, interruptions, internal errors).
  • Fixes an issue where test sessions running with pytest-xdist on shallow Git checkouts can spend excessive time unshallowing the repository and may fail or time out during collection.
• botocore
  • EventBridge PutEvents now propagates Data Streams Monitoring (DSM) context when DD_DATA_STREAMS_ENABLED is enabled.
  • This fix resolves an issue where LLM Observability spans for Bedrock invoke_model_with_response_stream calls reported all token usage metrics as 0. Token counts are now extracted from the streamed response and set on the span.
• AI Guard
  • Fixes an issue where transport and unexpected internal evaluation failures were reported as client_error, making them difficult to diagnose.
• ASM
  • Fixes an issue where Exploit Prevention does not evaluate SSRF rules for calls to webbrowser.open, or for calls to urllib.request.urlopen that pass the URL positionally or go through a custom opener installed with urllib.request.install_opener.
  • Fixes an issue where exceptions raised by urllib.request.urlopen and http.client requests include an internal Datadog frame in their traceback when Exploit Prevention is enabled, which caused ordinary application errors to be misattributed to the tracer.
  • Fixes an issue where exceptions raised by open() or pathlib.Path.open() are reported with a corrupted traceback when Exploit Prevention is enabled, showing a duplicated caller frame and omitting the frame that actually raised.
• opentelemetry
  • Fixes an issue where empty OTEL_* environment variables override ddtrace defaults instead of being treated as unset.
• httplib
  • Fixes an issue where an outgoing request blocked by Exploit Prevention leaves the http.client.request span unfinished and active, so it is never sent and every later span on that thread is parented to it.
• internal
  • Fixes a memory leak that causes memory usage to grow over time in long-running processes, when instrumentation applied to a function fails while entering, returning from or unwinding that function. Each such call retained per-call state, and in some cases the frame of the instrumented function.
  • Fixes race conditions after process forks that can cause telemetry recording to stall or background workers to restart incorrectly when multiple threads resume concurrently or forks are nested.
  • Fixes an issue where Python-forked child processes can emit incorrect telemetry lifecycle events or block while cleaning up an inherited telemetry worker.
  • Fixes an issue on Python 3.9 through 3.12.3 where applications can crash when background worker threads clean up thread-local or context-local data.
  • A memory leak triggered when using @tracer.wrap on functions created at run time has been fixed.
• mysql
  • Fixes an issue where tracing and SQL-injection detection or blocking are skipped for database connections created with mysql.connector.Connect().
• rq
  • Fixes an issue where the rq.worker.perform_job span was not created when jobs were processed by rq.SimpleWorker on rq >= 2.7.
• selenium
  • Fixes a memory leak where memory usage grows over the lifetime of a browser test session, proportionally to the number of WebDriver.get, WebDriver.quit and WebDriver.close calls made.
• tracing
  • Fixes an issue where switching a product into standalone mode at runtime with tracer.configure(apm_tracing_disabled=True) did not apply the standalone sampling settings, so traces were sent without the one trace per minute limit and without the _dd.apm.enabled=0 metric that opts them out of APM billing.
  • Fixes an issue where the datadog.runtime_id resource attribute on OTLP trace and trace-metrics exports was a randomly generated value instead of the tracer's runtime id, preventing those exports from being correlated with the other signals emitted by the same process.
  • Fixes an issue where untraced work in a reused thread-pool worker could expose stale OpenTelemetry trace context.
  • Fixes an issue where APM Tracing remote configuration is not applied when the environment is configured only on the Datadog Agent.
  • Fixed a memory leak in the HTTP client integrations (aiohttp, httpx, requests, urllib3) where a strong reference to each response object was retained, preventing garbage collection of response bodies and causing linear RSS growth on sequential requests.
  • Fixes an issue where the sampling decision of an incoming distributed trace was discarded, reported as a propagation error on the local root span, and logged as a warning when the trace was sampled by a mechanism that is not known to this version of the library. Well-formed sampling decisions are now propagated unchanged.
  • When DD_TRACE_OTEL_SEMANTICS_ENABLED=true, HTTP client spans now use the HTTP method as their resource name. This keeps the resource name distinct from the operation name and adds method-level information that better aligns with OpenTelemetry semantics; default resource names are unchanged.
  • Fixes an issue where OpenTelemetry thread-context record publication could not be disabled on Linux. Publication can now be disabled by setting the experimental DD_TRACE_OTEL_CTX_ENABLED environment variable to false.
  • Fixes an issue where OTLP trace export failures report the Datadog Agent intake URL instead of the configured OTLP endpoint.
  • Fixes an issue where runtime.python.* metrics stopped carrying the dd.internal.entity_id tag after the first flush, even when DD_ENTITY_ID was set. This prevented the Datadog Agent from attaching pod_name and kube_namespace to runtime metrics in Kubernetes.
  • Fixes an issue where runtime metrics (memory RSS, thread count, CPU usage, context switches) reported the parent process's values instead of the current process's values after a fork, for example under a pre-fork server like gunicorn.
  • Fixes an issue where applications using uWSGI can experience request stalls after worker processes start.
  • Fixes an issue where the v0.5 trace API (DD_TRACE_API_VERSION=v0.5) drops traces when a single payload contains between 65,536 and 131,071 unique tag keys and values.
  • Fixes an issue where the Datadog environment is not set from the deployment.environment.name attribute in OTEL_RESOURCE_ATTRIBUTES.
  • Fixes an issue where _dd.svc_src was incorrectly set to either "m" or the name of the service
• dynamic instrumentation
  • Fixes an issue where Symbol Database uploads could be disabled in the first worker when multiple processes fork concurrently.
• telemetry
  • Fixes an issue where an extra, redundant telemetry request was sent at process shutdown, adding avoidable latency to application teardown. The final telemetry payload is now sent as a single request.
• mcp
  • Resolves an error logged when a module named mcp is importable but is not the MCP SDK. Patching is now skipped instead of raising.
• profiling
  • Stack collection now honors configured frame limits, reducing profiler CPU and memory overhead for deep Python call stacks.
  • Fixes an issue where asyncio tasks can be duplicated in profiles on Python 3.14, causing inflated task counts and wall time and increased profiler CPU usage.
  • Fixes an issue where asyncio task samples could be reported with the coroutine frames at the top of the stack and the calling frames duplicated underneath them.
  • Fixes potential process memory growth when a stack profiling sampling cycle exits before completing a sample.
  • Fixes potential process memory growth in asyncio and gevent workloads after stack profiling sampling cycles exit before completion.
  • Fixes an issue where applications using uWSGI with --lazy-apps and --skip-atexit can crash while workers shut down on Python 3.12 or later.
  • Fixes an issue where untraced work is attributed to the endpoint of a previously finished trace on the same thread.
  • Fast memory copy is now automatically disabled when Python is running as an embedded interpreter.
  • A rare crash happening when using gevent has been fixed.
  • Fixes an issue where child spans created from propagated tracing contexts can lose local-root and endpoint attribution when greenlets share a thread.
• anthropic
  • Fixes an issue where spans were not exported when streamed responses were consumed using get_final_message() or get_final_text().
• code origin for spans
  • fix a potential memory leak triggered by having code origin for span explicitly disabled via environment variables.
  • prevent view or traced functions from raising an exception in situations where their number is large.
• django
  • Fixes an issue (#19454) where Django processes that never serve HTTP requests, such as Celery and dramatiq workers, used substantially more memory and took longer to start. API endpoint discovery now runs when the WSGI or ASGI application is built rather than during django.setup().
• kombu
  • This fix resolves an issue where messages published to the RabbitMQ default (unnamed) exchange were not linked to their consumers in the Data Streams Monitoring map.
• gevent
  • Fixes an issue where running an application with ddtrace-run (or single-step instrumentation) could raise a PydanticSchemaGenerationError at import time for models that use forward references, when gevent is installed and the application runs on CPython 3.14 or later. The annotationlib module, which now owns the ForwardRef class on CPython 3.14, is preserved during module cloning so that pydantic resolves forward references correctly.
  • Fixes an issue where context propagation bypasses a custom context provider configured on the tracer.
• google-adk
  • Fixes an AttributeError on google-adk >= 2.7.0 caused by the removal of __call_tool_live. Applications with LLM Observability enabled failed to start.
  • Fixes an issue on google-adk < 2.7.0 where streaming tool call spans recorded no output.
• Code Security (IAST)
  • Fixes a SystemError raised inside an instrumented request when an operation handled a container holding an object that cannot be hashed, such as the cookie objects Django builds in HttpResponse.set_cookie, and fixes the same error when a regular expression matched against a bytearray.
  • Fixes a NameError raised from application code that calls eval() when the wrapt C extension is unavailable and its pure-Python implementation is used, which caused Code Security to resolve the wrong caller scope.
• openfeature
  • This fix resolves an issue where replacing the feature flag configuration could leave a forked worker process (for example under gunicorn or uWSGI) with no configuration, so every subsequent flag evaluation returned the caller-provided default with the PROVIDER_NOT_READY error code.
  • This fix resolves an issue where an invalid value for a numeric Feature Flagging environment variable raised an exception while importing ddtrace.openfeature, preventing the application from starting. Such values are now logged and the documented default is used instead.
• otel
  • Fixes an issue where OTLP gRPC exporter requests are incorrectly traced when OpenTelemetry logs or metrics collection is enabled with opentelemetry-exporter-otlp-proto-grpc 1.34.0 or later.
• OpenTelemetry logs
  • Fixes an issue where enabling OpenTelemetry logs collection (DD_LOGS_OTEL_ENABLED=true) could cause the tracer to export its own internal log records, producing a growing volume of exported logs. The tracer's own log records and the OpenTelemetry exporter's log records are now excluded from OpenTelemetry logs export, while application logs continue to be collected and exported as before.
• pytorch
  • Fix an issue where the pytorch.rank span could end too soon.
• requests
  • Fixes an issue where distributed tracing context propagated on outbound requests calls pointed at the wrong span when the urllib3 integration was also enabled (for example via DD_TRACE_URLLIB3_ENABLED=true), causing those requests to be missing or show incorrect latency in downstream traces.
• snowflake
  • Fixes an issue where traced cursor calls fail when command is passed as a keyword argument to execute or executemany.
• vllm
  • Fixes an issue where the integration failed to instrument vLLM >= 0.14.0 with ModuleNotFoundError: No module named 'vllm.v1.engine.processor', silently disabling all vLLM tracing and metrics.
• Code Security
  • Fixes an issue where applications could crash when asynchronous tasks accessed request data after the originating request completed.

Other Changes

• CI Visibility
  • Reduces the cost of the source-location lookup the pytest plugin performs once per test, which is most noticeable on large suites of fast tests.
• botocore
  • Payload tagging redaction now uses python-jsonpath in place of the vendored jsonpath-ng and ply, so ddtrace no longer ships ply, which is unmaintained and reported by dependency scanners as CVE-2025-56005. Existing redaction paths continue to work.

Deprecation Notes

• tracing
  • The tracer parameter of ddtrace.runtime.RuntimeMetrics.enable is deprecated and will be removed in a future version. It has no effect.
• google_cloud_pubsub
  • The DD_GOOGLE_CLOUD_PUBSUB_PROPAGATION_AS_SPAN_LINKS environment variable is deprecated and will be removed in a future release. Add google_cloud_pubsub to the DD_TRACE_PROPAGATION_AS_SPAN_LINKS list instead.