ddtrace 4.13.0__tar.gz → 4.13.2__tar.gz

{ddtrace-4.13.0 → ddtrace-4.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddtrace
-Version: 4.13.0
+Version: 4.13.2
 Summary: Datadog APM client library
 Author-email: "Datadog, Inc." <dev@datadoghq.com>
 License: LICENSE.BSD3

{ddtrace-4.13.0 → ddtrace-4.13.2}/ddtrace/contrib/internal/snowflake/patch.py

@@ -41,6 +41,12 @@ def _supported_versions() -> dict[str, str]:
 
 
 class _SFTracedCursor(TracedCursor):
+    def execute(self, command: str, *args: object, **kwargs: object) -> object:
+        return super(_SFTracedCursor, self).execute(command, *args, **kwargs)
+
+    def executemany(self, command: str, *args: object, **kwargs: object) -> object:
+        return super(_SFTracedCursor, self).executemany(command, *args, **kwargs)
+
     def _set_post_execute_tags(self, span):
         super(_SFTracedCursor, self)._set_post_execute_tags(span)
         span._set_attribute("sfqid", self.__wrapped__.sfqid)

{ddtrace-4.13.0 → ddtrace-4.13.2}/ddtrace/internal/datadog/profiling/stack/echion/echion/threads.h

@@ -52,7 +52,7 @@ class ThreadInfo
 #elif defined PL_DARWIN
     mach_port_t mach_port;
 #endif
-    microsecond_t cpu_time;
+    microsecond_t cpu_time = 0;
 
     uintptr_t asyncio_loop = 0;
     uintptr_t tstate_addr = 0; // Remote address of PyThreadState for accessing asyncio_tasks_head
@@ -87,10 +87,13 @@ class ThreadInfo
                                                                     const char* name)
     {
 #if defined PL_LINUX
-        clockid_t cpu_clock_id;
-        if (pthread_getcpuclockid(static_cast<pthread_t>(thread_id), &cpu_clock_id)) {
-            return ErrorKind::ThreadInfoError;
-        }
+        // pthread_getcpuclockid() dereferences pthread_t, but Python's thread_id can be
+        // a gevent greenlet ID or a stale value. Derive the Linux per-thread clock from
+        // the kernel TID instead. clock_gettime() safely rejects an invalid TID with EINVAL.
+        constexpr uint64_t CPUCLOCK_SCHED = 2;
+        constexpr uint64_t CPUCLOCK_PERTHREAD_MASK = 4;
+        auto cpu_clock_id =
+          static_cast<clockid_t>((~static_cast<uint64_t>(native_id) << 3) | (CPUCLOCK_SCHED | CPUCLOCK_PERTHREAD_MASK));
 
         auto result = std::make_unique<ThreadInfo>(thread_id, native_id, name, cpu_clock_id);
 #elif defined PL_DARWIN

{ddtrace-4.13.0 → ddtrace-4.13.2}/ddtrace/internal/datadog/profiling/stack/src/echion/vm.cc

@@ -1,6 +1,12 @@
 #include <cstdio>
 #include <cstring>
 
+#include <climits>
+
+#if defined PL_DARWIN
+#include <mach-o/dyld.h>
+#endif
+
 #include <echion/vm.h>
 
 // Returns true when _DD_PROFILING_STACK_FAST_COPY is set to a falsy value.
@@ -15,6 +21,50 @@ fast_copy_env_disabled()
     return strcmp(val, "0") == 0 || strcmp(val, "false") == 0 || strcmp(val, "False") == 0;
 }
 
+// Checks whether Python is running as an embedded interpreter by checking
+// whether the process executable looks like a Python binary.
+//
+// When the executable path cannot be read (for example no procfs),
+// we report "embedded". This constructor is the only gate that runs
+// before the SIGSEGV/SIGBUS handlers are installed, so an indeterminate
+// process must not keep handlers that may belong to a host.
+static bool
+is_python_embedded()
+{
+    char exe_path[PATH_MAX] = { 0 };
+
+#if defined PL_LINUX
+    ssize_t len = readlink("/proc/self/exe", exe_path, sizeof(exe_path) - 1);
+    if (len <= 0) {
+        return true;
+    }
+    exe_path[len] = '\0';
+#elif defined PL_DARWIN
+    uint32_t bufsize = sizeof(exe_path);
+    if (_NSGetExecutablePath(exe_path, &bufsize) != 0) {
+        return true;
+    }
+#else
+    return true;
+#endif
+
+    const char* base = strrchr(exe_path, '/');
+    base = base ? base + 1 : exe_path;
+
+    // Case-insensitive substring search for "python" in the basename.
+    size_t base_len = strlen(base);
+    if (base_len >= 6) {
+        for (size_t i = 0; i <= base_len - 6; ++i) {
+            if ((base[i] | 0x20) == 'p' && (base[i + 1] | 0x20) == 'y' && (base[i + 2] | 0x20) == 't' &&
+                (base[i + 3] | 0x20) == 'h' && (base[i + 4] | 0x20) == 'o' && (base[i + 5] | 0x20) == 'n') {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
 #if defined PL_LINUX
 static bool
 probe_process_vm_readv()
@@ -38,9 +88,11 @@ init_safe_copy()
     // Always probe process_vm_readv so we know whether it is a valid fallback.
     process_vm_readv_available = probe_process_vm_readv();
 
-    // Honor the fast-copy opt-out: when disabled via env var, skip installing
-    // the SIGSEGV/SIGBUS handlers and alt stack entirely.
-    if (fast_copy_env_disabled()) {
+    // Honor the fast-copy opt-out: when disabled via env var or when Python is
+    // embedded, skip installing the SIGSEGV/SIGBUS handlers entirely.
+    // Embedded interpreters must never use safe_memcpy because the host process
+    // owns the signal handlers.
+    if (fast_copy_env_disabled() || is_python_embedded()) {
         fast_copy_user_disabled = true;
         if (process_vm_readv_available) {
             safe_copy = process_vm_readv;
@@ -72,8 +124,9 @@ init_safe_copy()
 __attribute__((constructor)) void
 init_safe_copy()
 {
-    // Honor the fast-copy opt-out: skip installing signal handlers when disabled.
-    if (fast_copy_env_disabled()) {
+    // Honor the fast-copy opt-out: skip installing signal handlers when
+    // disabled or when Python is embedded (host owns signal handlers).
+    if (fast_copy_env_disabled() || is_python_embedded()) {
         fast_copy_user_disabled = true;
         return;
     }

{ddtrace-4.13.0 → ddtrace-4.13.2}/ddtrace/internal/datadog/profiling/stack/test/CMakeLists.txt

@@ -102,6 +102,11 @@ configure_stack_internal_test(test_sample_lifecycle)
 dd_wrapper_add_test(test_sampling_cycle_state test_sampling_cycle_state.cpp)
 configure_stack_internal_test(test_sampling_cycle_state)
 
+# vm.cc is compiled into the test binary: the fast-copy state lives in inline variables, so the copy in the test
+# executable is distinct from the one in the _stack library and only the constructor linked here initializes it.
+dd_wrapper_add_test(test_embedded_fast_copy test_embedded_fast_copy.cpp ../src/echion/vm.cc)
+configure_stack_internal_test(test_embedded_fast_copy)
+
 dd_wrapper_add_test(test_alt_stack_ownership test_alt_stack_ownership.cpp)
 # ThreadAltStack lives in the vendored echion header tree.
 target_include_directories(test_alt_stack_ownership PRIVATE ../echion)

ddtrace-4.13.2/ddtrace/internal/datadog/profiling/stack/test/test_embedded_fast_copy.cpp

@@ -0,0 +1,14 @@
+#include <echion/vm.h>
+#include <gtest/gtest.h>
+
+// Test that fast memory copy is disabled when Python runs as an embedded
+// interpreter.  This binary is not named "python*", so is_python_embedded()
+// returns true and init_safe_copy() never installs the SIGSEGV/SIGBUS
+// handlers.  vm.cc is compiled into this binary, so the constructor has
+// already fired on the state that the assertions below read.
+TEST(EmbeddedFastCopy, FastCopyDisabledWhenEmbedded)
+{
+    EXPECT_TRUE(fast_copy_user_disabled)
+      << "fast_copy_user_disabled must be true when the process exe is not a python binary";
+    EXPECT_FALSE(fast_copy_active) << "fast_copy_active must be false in an embedded interpreter";
+}

{ddtrace-4.13.0 → ddtrace-4.13.2}/ddtrace/internal/datadog/profiling/stack/test/test_sampling_cycle_state.cpp

@@ -5,6 +5,19 @@
 
 #include <memory>
 
+#if defined PL_LINUX
+TEST(ThreadInfoCreate, IgnoresNonPthreadPythonThreadId)
+{
+    // Linux limits TIDs to less than 2^22, so this exercises clock_gettime(EINVAL).
+    constexpr unsigned long invalid_native_id = 1UL << 24;
+    auto thread = ThreadInfo::create(1, invalid_native_id, "test-thread");
+
+    ASSERT_TRUE(thread);
+    EXPECT_EQ((*thread)->thread_id, 1);
+    EXPECT_EQ((*thread)->cpu_time, 0);
+}
+#endif
+
 TEST(SamplingCycleState, UnwindReplacesTaskAndGreenletStacksFromPriorCycle)
 {
     EchionSampler echion;

{ddtrace-4.13.0 → ddtrace-4.13.2}/ddtrace/internal/settings/profiling.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import itertools
 import math
+import os
 import sys
 import sysconfig
 import typing as t
@@ -27,6 +28,19 @@ from ddtrace.internal.utils.formats import parse_tags_str
 logger = get_logger(__name__)
 
 
+def _is_python_embedded() -> bool:
+    try:
+        real_exe = os.readlink("/proc/self/exe") if sys.platform == "linux" else ""
+    except OSError:
+        real_exe = ""
+
+    exe = real_exe or (getattr(sys, "executable", "") or "")
+    if not exe:
+        return True
+
+    return "python" not in os.path.basename(exe).lower()
+
+
 def _derive_default_heap_sample_size(
     heap_config: Env,
     default_heap_sample_size: int = 1024 * 1024,
@@ -655,6 +669,13 @@ exception_failure_msg, exception_is_available = _check_for_exception_available()
 if not exception_is_available and config.exception.enabled:
     config.exception.enabled = False  # pyright: ignore[reportAttributeAccessIssue]
 
+# Fast memory copy is unsafe in embedded interpreters: the host process may
+# install its own signal handlers that conflict with the SIGSEGV/SIGBUS
+# recovery mechanism used by safe_memcpy.
+if config.stack.fast_copy and _is_python_embedded():
+    logger.debug("Python is running as an embedded interpreter; disabling fast memory copy for stack profiling")
+    config.stack.fast_copy = False  # pyright: ignore[reportAttributeAccessIssue]
+
 # Report configuration after all availability overrides so telemetry
 # reflects the effective state.
 report_configuration(config)

{ddtrace-4.13.0 → ddtrace-4.13.2}/ddtrace/internal/settings/profiling.pyi

@@ -71,3 +71,4 @@ exception_failure_msg: str
 exception_is_available: bool
 
 def config_str(config: ProfilingConfig) -> str: ...
+def _is_python_embedded() -> bool: ...

{ddtrace-4.13.0 → ddtrace-4.13.2}/ddtrace/internal/wrapping/context.py

@@ -79,6 +79,10 @@ log = get_logger(__name__)
 
 T = t.TypeVar("T")
 
+# Hoisted out of the hot enter/exit/return paths: subscripting a generic alias
+# like dict[str, t.Any] allocates a new types.GenericAlias on every evaluation,
+# so re-typing it inline on each call is not free.
+WrappingContextStorage = dict[str, t.Any]
 StorageVar = ContextVar[t.Optional[dict[str, t.Any]]]
 
 _STORAGE_PREV = "__dd_wrapping_context_prev__"
@@ -438,7 +442,7 @@ class BaseWrappingContext(ABC):
         return self
 
     def _pop_storage(self) -> dict[str, t.Any]:
-        storage = t.cast(dict[str, t.Any], self._storage.get())
+        storage = t.cast(WrappingContextStorage, self._storage.get())
         self._storage.set(storage.pop(_STORAGE_PREV))
         del storage[_STORAGE_OWNER]
         return storage
@@ -456,10 +460,10 @@ class BaseWrappingContext(ABC):
         self._pop_storage()
 
     def get(self, key: str) -> t.Any:
-        return t.cast(dict[str, t.Any], self._storage.get())[key]
+        return t.cast(WrappingContextStorage, self._storage.get())[key]
 
     def set(self, key: str, value: T) -> T:
-        t.cast(dict[str, t.Any], self._storage.get())[key] = value
+        t.cast(WrappingContextStorage, self._storage.get())[key] = value
         return value
 
     @classmethod
@@ -647,11 +651,25 @@ class _UniversalWrappingContext(BaseWrappingContext):
     def __enter__(self) -> "_UniversalWrappingContext":
         super().__enter__()
 
-        # Make the frame object available to the contexts
-        self.set("__frame__", sys._getframe(1))
+        storage = t.cast(WrappingContextStorage, self._storage.get())
 
+        # Make the frame object available to the contexts
+        storage["__frame__"] = sys._getframe(1)
+
+        # Freeze the list of contexts so that we know exactly which ones to
+        # exit, in case new contexts are registered during the execution of
+        # the wrapped function. Contexts are appended only once entered, so
+        # that a failure partway through does not leave contexts that never
+        # entered in the snapshot.
+        entered: list[WrappingContext] = []
+        storage["__contexts__"] = entered
         for context in self._contexts:
-            context.__enter__()
+            try:
+                context.__enter__()
+            except Exception:
+                log.debug("Failed to enter wrapping context %r", context, exc_info=True)
+                continue
+            entered.append(context)
 
         return self
 
@@ -667,13 +685,25 @@ class _UniversalWrappingContext(BaseWrappingContext):
         if exc_value is None:
             return
 
-        for context in self._contexts[::-1]:
+        try:
+            contexts = t.cast(WrappingContextStorage, self._storage.get())["__contexts__"]
+        except (TypeError, KeyError):
+            log.debug("Universal wrapping context exited without entering")
+            return
+
+        for context in contexts[::-1]:
             context.__exit__(exc_type, exc_value, traceback)
 
         super().__exit__(exc_type, exc_value, traceback)
 
     def __return__(self, value: T) -> T:
-        for context in self._contexts[::-1]:
+        try:
+            contexts = t.cast(WrappingContextStorage, self._storage.get())["__contexts__"]
+        except (TypeError, KeyError):
+            log.debug("Universal wrapping context returned without entering")
+            return super().__return__(value)
+
+        for context in contexts[::-1]:
             context.__return__(value)
 
         return super().__return__(value)

{ddtrace-4.13.0 → ddtrace-4.13.2}/ddtrace.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddtrace
-Version: 4.13.0
+Version: 4.13.2
 Summary: Datadog APM client library
 Author-email: "Datadog, Inc." <dev@datadoghq.com>
 License: LICENSE.BSD3

{ddtrace-4.13.0 → ddtrace-4.13.2}/ddtrace.egg-info/SOURCES.txt

@@ -1077,6 +1077,7 @@ ddtrace/internal/datadog/profiling/stack/src/echion/threads.cc
 ddtrace/internal/datadog/profiling/stack/src/echion/vm.cc
 ddtrace/internal/datadog/profiling/stack/test/CMakeLists.txt
 ddtrace/internal/datadog/profiling/stack/test/test_alt_stack_ownership.cpp
+ddtrace/internal/datadog/profiling/stack/test/test_embedded_fast_copy.cpp
 ddtrace/internal/datadog/profiling/stack/test/test_origin_task_links.cpp
 ddtrace/internal/datadog/profiling/stack/test/test_sample_lifecycle.cpp
 ddtrace/internal/datadog/profiling/stack/test/test_sampling_cycle_state.cpp

{ddtrace-4.13.0 → ddtrace-4.13.2}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ddtrace"
-version = "4.13.0"
+version = "4.13.2"
 description = "Datadog APM client library"
 readme = "README.md"
 license = { text = "LICENSE.BSD3" }