chore(native): declare PyContextVar_* locally for limited-API builds (PROF-15850)

.gitlab/scripts/prune-unsupported-wheels.sh

@@ -24,8 +24,9 @@ set -euo pipefail
 #
 # TODO(py-315): cp315 wheels are built by "build linux" and "build linux serverless" under
 # allow_failure so that 3.15 keeps producing CI signal, but they are compiled against the
-# 3.15.0b1 PyThreadState layout and are ABI-broken. Drop cp315 from this list once #19861
-# makes those wheels correct and 3.15 is a supported target.
+# 3.15.0b1 PyThreadState layout and are ABI-broken. #19861 does not fix that ABI; it only
+# makes cp315 optional in the package validator. Drop cp315 from this list after IMAGE_TAG
+# is on images that can build a correct wheel, and only once 3.15 is a supported target.
 UNSUPPORTED_TAGS=("cp315")
 
 if [ "$#" -eq 0 ]; then

hooks/pre-commit/05-run-bandit

@@ -1,6 +1,6 @@
 #!/bin/sh
 LINT_CMD="${LINT_CMD:-scripts/lint}"
-staged_files=$(git diff --staged --name-only HEAD --diff-filter=ACMR | grep -E '\.py$' | grep -v '^tests/' | grep -v '^lib-injection/' | tr '\n' ' ')
+staged_files=$(git diff --staged --name-only HEAD --diff-filter=ACMR | grep -E '\.py$' | grep -v '^tests/' | tr '\n' ' ')
 if [ -n "$staged_files" ]; then
     file_count=$(echo "$staged_files" | wc -w | tr -d ' ')
     echo "Running security scan on $file_count staged Python file(s)..."

hooks/scripts/run-mypy.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 LINT_CMD="${LINT_CMD:-scripts/lint}"
-staged_files=$(git diff --staged --name-only HEAD --diff-filter=ACMR | grep -E '\.(py|pyi)$' | grep -v '^lib-injection/' | tr '\n' ' ')
+staged_files=$(git diff --staged --name-only HEAD --diff-filter=ACMR | grep -E '\.(py|pyi)$' | tr '\n' ' ')
 if [ -n "$staged_files" ]; then
     # Drop .pyi stubs whose .py counterpart is also staged to avoid mypy
     # "Duplicate module named ..." errors. mypy discovers stubs automatically.

pyproject.toml

@@ -1,13 +1,7 @@
 [build-system]
 requires = [
-    # Cython 3.3.0 is the first stable release to publish compiled cp315 wheels,
-    # and its cp315 manylinux wheel is compiled against the 3.15.0rc1 PyThreadState
-    # layout, which grew a member in 3.15.0b4 (python/cpython#151614). Our
-    # manylinux2014 images still ship 3.15.0b1, so that wheel segfaults the moment
-    # setup.py imports Cython.Build. <3.3 has no cp315-tagged wheel, so on these
-    # images 3.15 resolves the pure-Python cython-*-py3-none-any.whl instead, which
-    # has no ABI to mismatch. Drop this once the image mirror ships a cp315
-    # interpreter >= 3.15.0rc1; pypa manylinux 2026.08.04-1 is the first such tag.
+    # Cython 3.3 cp315 manylinux wheels SIGSEGV on the current 3.15 interpreter; <3.3 pins 3.2.x.
+    # TODO(py-315): drop this pin once IMAGE_TAG is on the 2026.08.04-1 images.
     "cython<3.3; python_version >= '3.15'",
     "cython; python_version < '3.15'",
     "cmake>=3.24.2,<3.28",
@@ -135,7 +129,9 @@ lint = [
     "cmake-format==0.6.13",
     "ruamel.yaml==0.18.6",
     "ast-grep-cli==0.39.4",
-    "bytecode==0.18.1; python_version >= '3.15'",
+    # Lint extra; 0.19.0 matches the runtime lower bound so uv can resolve
+    # both extras when requires-python includes 3.15.
+    "bytecode==0.19.0; python_version >= '3.15'",
     "bytecode==0.17.0; python_version < '3.15'",
 ]
 clean = [

src/native/contextvar.rs

@@ -2,6 +2,23 @@ use pyo3::ffi;
 use pyo3::prelude::*;
 use std::ffi::CString;
 
+/// PyContextVar_New/_Get/_Set are absent from pyo3-ffi's limited-API bindings (Py_LIMITED_API),
+/// which can be enabled via PYO3_USE_ABI3_FORWARD_COMPATIBILITY.
+/// Declare the CPython C-API entry points locally so this module builds either way.
+/// Context variables were introduced in Python 3.7, so these symbols exist on every supported CPython.
+unsafe extern "C" {
+    fn PyContextVar_New(
+        name: *const std::os::raw::c_char,
+        def: *mut ffi::PyObject,
+    ) -> *mut ffi::PyObject;
+    fn PyContextVar_Get(
+        var: *mut ffi::PyObject,
+        default_value: *mut ffi::PyObject,
+        value: *mut *mut ffi::PyObject,
+    ) -> std::os::raw::c_int;
+    fn PyContextVar_Set(var: *mut ffi::PyObject, value: *mut ffi::PyObject) -> *mut ffi::PyObject;
+}
+
 /// Create a new `contextvars.ContextVar` via the C API (`PyContextVar_New`)
 /// with `default` as its default value. Avoids importing the `contextvars`
 /// module from Rust.
@@ -13,9 +30,7 @@ pub fn contextvar_new<'py>(
     let c_name = CString::new(name).expect("contextvar name must not contain NUL bytes");
     // SAFETY: `c_name` is a valid NUL-terminated string for the duration of the call;
     // `default.as_ptr()` is a valid borrowed reference (PyContextVar_New takes its own ref).
-    unsafe {
-        Bound::from_owned_ptr_or_err(py, ffi::PyContextVar_New(c_name.as_ptr(), default.as_ptr()))
-    }
+    unsafe { Bound::from_owned_ptr_or_err(py, PyContextVar_New(c_name.as_ptr(), default.as_ptr())) }
 }
 
 /// Read the current value of `var` via `PyContextVar_Get`.
@@ -28,7 +43,7 @@ pub fn contextvar_get<'py>(
 ) -> PyResult<Bound<'py, PyAny>> {
     let mut value: *mut ffi::PyObject = std::ptr::null_mut();
     // SAFETY: `var` is a valid ContextVar object; `value` is a valid out-pointer.
-    let rc = unsafe { ffi::PyContextVar_Get(var.as_ptr(), std::ptr::null_mut(), &mut value) };
+    let rc = unsafe { PyContextVar_Get(var.as_ptr(), std::ptr::null_mut(), &mut value) };
     if rc < 0 {
         return Err(PyErr::take(py).unwrap_or_else(|| {
             pyo3::exceptions::PyRuntimeError::new_err("PyContextVar_Get failed")
@@ -80,7 +95,7 @@ pub fn safe_contextvar_set(
             }));
         }
 
-        let token = ffi::PyContextVar_Set(var.as_ptr(), value.as_ptr());
+        let token = PyContextVar_Set(var.as_ptr(), value.as_ptr());
 
         // Capture any error before the decrefs below can perturb interpreter state.
         let err = if token.is_null() {
@@ -113,7 +128,7 @@ pub fn safe_contextvar_set(
 ) -> PyResult<()> {
     // SAFETY: the GIL (`py`) is held for the duration of the call.
     unsafe {
-        let token = ffi::PyContextVar_Set(var.as_ptr(), value.as_ptr());
+        let token = PyContextVar_Set(var.as_ptr(), value.as_ptr());
         if token.is_null() {
             return Err(PyErr::take(py).unwrap_or_else(|| {
                 PyErr::new::<pyo3::exceptions::PyRuntimeError, _>("PyContextVar_Set failed")

src/native/crashtracker/crashtracker_runtime_stacks.rs

@@ -19,11 +19,24 @@ extern "C" {
 /// This is signal-safe: it's just a thread-local read + comparison.
 /// Returns false if the GIL is not held (e.g. during a ctypes foreign function call),
 /// in which case it's unsafe to call any Python C API functions.
-#[cfg(unix)]
+///
+/// `PyGILState_Check` is not limited-API: it lives in CPython's
+/// `Include/cpython/pystate.h` and is absent from `Misc/stable_abi.toml`
+/// (3.15 lists Ensure / Release / GetThisThreadState only). pyo3-ffi therefore
+/// omits it under `Py_LIMITED_API` (3.15 via `PYO3_USE_ABI3_FORWARD_COMPATIBILITY`).
+/// This runs in a crash signal handler, so `PyGILState_Ensure` is not a
+/// substitute (not async-signal-safe). On limited-API builds we cannot probe,
+/// so skip Python C API use rather than acquire or guess.
+#[cfg(all(unix, not(Py_LIMITED_API)))]
 unsafe fn gil_is_held() -> bool {
     pyo3_ffi::PyGILState_Check() != 0
 }
 
+#[cfg(all(unix, Py_LIMITED_API))]
+unsafe fn gil_is_held() -> bool {
+    false
+}
+
 /************************************************************
  Emit runtime stacktrace as string using _Py_DumpTracebackThreads /
  PyUnstable_DumpTracebackThreads

tests/internal/test_py315_import_degrade.py

@@ -1,12 +1,10 @@
-"""Python 3.15 import-time degrade: wrapping must load, wrap() still raises.
+"""Python 3.15 import-time degrade: wrapping must load.
 
-Until #17849 lands bytecode wrapping for 3.15, products that import wrapping
-(e.g. ModuleWatchdog) must not crash the process. wrap()/inject_hook still
-raise NotImplementedError when actually used.
+Products that import wrapping (e.g. ModuleWatchdog) must not crash the process.
+Monitoring ``inject_hook`` already works on 3.15; this module does not assert
+that wrap() raises. Wrap lift is a later PR.
 """
 
-import re
-
 import pytest
 
 from ddtrace.internal.compat import NEXT_PY_UNSUPPORTED_MSG
@@ -31,20 +29,6 @@ def test_wrapping_modules_import():
     import ddtrace.internal.wrapping.generators  # noqa: F401
 
 
-@pytest.mark.skipif(PYTHON_VERSION_INFO < NEXT_PY_VERSION_INFO, reason=f"{NEXT_PY_VERSION} wrap() degrade")
-def test_wrap_raises_not_implemented_on_315():
-    from ddtrace.internal.wrapping import wrap
-
-    def f() -> None:
-        return None
-
-    def wrapper(wrapped, args, kwargs):  # noqa: ANN001, ANN202
-        return wrapped(*args, **kwargs)
-
-    with pytest.raises(NotImplementedError, match=re.escape(_UNSUPPORTED_MSG)):
-        wrap(f, wrapper)
-
-
 @pytest.mark.skipif(PYTHON_VERSION_INFO < NEXT_PY_VERSION_INFO, reason=f"{NEXT_PY_VERSION} lazy module degrade")
 def test_lazy_module_decorator_without_bytecode_wrap():
     import tests.internal.lazy as lazy_module
@@ -75,17 +59,3 @@ def test_debugging_products_load_without_failure():
         "live-debugger",
     ):
         assert product_name not in product_manager._failed
-
-
-@pytest.mark.skipif(PYTHON_VERSION_INFO < NEXT_PY_VERSION_INFO, reason=f"{NEXT_PY_VERSION} inject_hook degrade")
-def test_inject_hook_raises_not_implemented_on_315():
-    from ddtrace.internal.bytecode_injection import inject_hook
-
-    def f() -> None:
-        return None
-
-    def hook(_arg: object) -> None:
-        return None
-
-    with pytest.raises(NotImplementedError, match=re.escape(_UNSUPPORTED_MSG)):
-        inject_hook(f, hook, f.__code__.co_firstlineno, None)