DataDog · taegyunkim · Jul 13, 2026 · Jul 13, 2026 · Jul 13, 2026 · Jul 13, 2026
@@ -59,6 +59,11 @@ class ProfilerStats
     // Total CPU time (in microseconds) spent by the sampler thread capturing samples
     size_t sample_capture_cpu_time_us = 0;
 
+    // CPU time spent collecting wall samples and draining/rendering CPU timer samples.
+    // These components are subsets of sample_capture_cpu_time_us.
+    size_t wall_sample_capture_cpu_time_us = 0;
+    size_t cpu_timer_drain_cpu_time_us = 0;
+
   public:
     ProfilerStats() = default;
     ~ProfilerStats() = default;
@@ -108,6 +113,9 @@ class ProfilerStats
     void add_sample_capture_cpu_time_us(size_t cpu_time_us);
     size_t get_sample_capture_cpu_time_us() const;
 
+    void add_wall_sample_capture_cpu_time_us(size_t cpu_time_us);
+    void add_cpu_timer_drain_cpu_time_us(size_t cpu_time_us);
+
     // Returns a JSON string containing relevant Profiler Stats to be included
     // in the libdatadog payload.
     std::string get_internal_metadata_json();

@@ -64,6 +64,8 @@ Datadog::ProfilerStats::reset_state()
     asyncio_task_count = std::nullopt;
     greenlet_count = std::nullopt;
     sample_capture_cpu_time_us = 0;
+    wall_sample_capture_cpu_time_us = 0;
+    cpu_timer_drain_cpu_time_us = 0;
     // fast_copy_memory_* static fields are intentionally not reset (see setters).
 }
 
@@ -232,6 +234,18 @@ Datadog::ProfilerStats::get_sample_capture_cpu_time_us() const
     return sample_capture_cpu_time_us;
 }
 
+void
+Datadog::ProfilerStats::add_wall_sample_capture_cpu_time_us(size_t cpu_time_us)
+{
+    wall_sample_capture_cpu_time_us += cpu_time_us;
+}
+
+void
+Datadog::ProfilerStats::add_cpu_timer_drain_cpu_time_us(size_t cpu_time_us)
+{
+    cpu_timer_drain_cpu_time_us += cpu_time_us;
+}
+
 std::string
 Datadog::ProfilerStats::get_internal_metadata_json()
 {
@@ -308,6 +322,14 @@ Datadog::ProfilerStats::get_internal_metadata_json()
 
     internal_metadata_json += R"("sample_capture_cpu_time_us": )";
     append_to_string(internal_metadata_json, sample_capture_cpu_time_us);
+    internal_metadata_json += ",";
+
+    internal_metadata_json += R"("wall_sample_capture_cpu_time_us": )";
+    append_to_string(internal_metadata_json, wall_sample_capture_cpu_time_us);
+    internal_metadata_json += ",";
+
+    internal_metadata_json += R"("cpu_timer_drain_cpu_time_us": )";
+    append_to_string(internal_metadata_json, cpu_timer_drain_cpu_time_us);
 
     internal_metadata_json += "}";
 

@@ -57,6 +57,7 @@ endif()
 # Specify the target C-extension that we want to build
 add_library(
     ${EXTENSION_NAME} SHARED
+    src/cpu_timer.cpp
     src/echion/danger.cc
     src/echion/frame.cc
     src/echion/greenlets.cc

@@ -13,6 +13,8 @@
 
     from . import _stack
     from ._stack import *  # noqa: F403, F401  # type: ignore[assignment]
+    from ._stack import _cpu_timer_debug_set_fault_injection  # noqa: F401
+    from ._stack import _cpu_timer_debug_stats  # noqa: F401
 
     is_available = True
 

@@ -8,6 +8,7 @@ from ddtrace._trace import context
 from ddtrace._trace import span as ddspan
 
 # Core stack v2 functions
+
 def start(min_interval: float = ...) -> bool: ...
 def stop() -> None: ...
 def is_origin_task_linking_enabled() -> bool: ...
@@ -18,13 +19,17 @@ def link_origin_task(task_id: int, task_name: str) -> None: ...
 def unlink_origin_task() -> None: ...
 
 # Sampling configuration
+
 def set_adaptive_sampling(do_adaptive_sampling: bool = False) -> None: ...
 def set_target_overhead(target_overhead: float) -> None: ...
 def set_max_sampling_period(max_interval_us: int) -> None: ...
 def set_adaptive_sampling_baseline(baseline_core_pct: float) -> None: ...
 def set_p_stable_window_s(p_stable_window_s: int) -> None: ...
 def set_p_stable_percentile(p_stable_percentile: float) -> None: ...
 def set_max_threads(max_threads: int) -> None: ...
+def set_cpu_timer(enabled: bool, interval_ms: int) -> None: ...
+def _cpu_timer_debug_stats() -> dict[str, bool | int]: ...
+def _cpu_timer_debug_set_fault_injection(enabled: bool) -> None: ...
 def set_max_tasks(max_tasks: int) -> None: ...
 def set_uvloop_mode(thread_id: int, uvloop_mode: bool) -> None:
     """Enable uvloop-specific stack unwinding in the native profiler for a specific thread.
@@ -41,6 +46,7 @@ def set_uvloop_mode(thread_id: int, uvloop_mode: bool) -> None:
 def set_interval(new_interval: float) -> None: ...
 
 # Memory copy strategy
+
 def set_fast_copy(enabled: bool) -> None: ...
 def is_safe_copy_failed() -> bool: ...
 def fast_copy_memory_active() -> bool: ...  # test introspection: is safe_memcpy active?
@@ -66,6 +72,7 @@ def segv_handler_installed() -> bool:
     ...
 
 # Pause/resume sampling
+
 def pause_sampling() -> bool | None:
     """Pause the sampling thread and wait for any in-flight sample to complete.
 
@@ -80,14 +87,17 @@ def pause_sampling() -> bool | None:
 def resume_sampling() -> None: ...
 
 # span <-> profile association
+
 def link_span(span: Optional[Union[context.Context, ddspan.Span]]) -> None: ...
 def _unlink_finished_span(span: ddspan.Span) -> None: ...
 
 # Thread management
+
 def register_thread(python_thread_id: int, native_id: int, name: str) -> None: ...
 def unregister_thread(python_thread_id: int) -> None: ...
 
 # Asyncio support
+
 def track_asyncio_loop(thread_id: int, loop: Optional[asyncio.AbstractEventLoop]) -> None: ...
 def link_tasks(parent: asyncio.Task, child: asyncio.Future) -> None: ...
 def weak_link_tasks(parent: asyncio.Task, child: asyncio.Future) -> None: ...
@@ -97,6 +107,7 @@ def init_asyncio(
 ) -> None: ...
 
 # Greenlet support
+
 def track_greenlet(greenlet_id: int, name: str, frame: Union[FrameType, bool, None]) -> None: ...
 def untrack_greenlet(greenlet_id: int) -> None: ...
 def link_greenlets(greenlet_id: int, parent_id: int) -> None: ...
@@ -109,5 +120,6 @@ def record_greenlet_switch(
 ) -> None: ...
 
 # Module attributes
+
 is_available: bool
 failure_msg: str
@@ -8,20 +8,26 @@ from typing import Sequence
 from typing import Union
 
 # Core stack v2 functions
+
 def start(min_interval: float = ...) -> bool: ...
 def stop() -> None: ...
 def is_origin_task_linking_enabled() -> bool: ...
 
 # Sampling configuration
+
 def set_adaptive_sampling(do_adaptive_sampling: bool = False) -> None: ...
 def set_target_overhead(target_overhead: float) -> None: ...
 def set_max_sampling_period(max_interval_us: int) -> None: ...
 def set_max_threads(max_threads: int) -> None: ...
+def set_cpu_timer(enabled: bool, interval_ms: int) -> None: ...
+def _cpu_timer_debug_stats() -> dict[str, bool | int]: ...
+def _cpu_timer_debug_set_fault_injection(enabled: bool) -> None: ...
 def set_max_tasks(max_tasks: int) -> None: ...
 def set_uvloop_mode(thread_id: int, uvloop_mode: bool) -> None: ...
 def set_interval(new_interval: float) -> None: ...
 
 # Memory copy strategy
+
 def set_fast_copy(enabled: bool) -> None: ...
 def is_safe_copy_failed() -> bool: ...
 def fast_copy_memory_active() -> bool: ...  # test introspection: is safe_memcpy active?
@@ -35,6 +41,7 @@ def segv_handler_installed() -> bool:
     ...
 
 # span <-> profile association
+
 def link_span(
     span_id: int,
     local_root_span_id: int,
@@ -52,10 +59,12 @@ def link_origin_task(
 def unlink_origin_task() -> None: ...
 
 # Thread management
+
 def register_thread(python_thread_id: int, native_id: int, name: str) -> None: ...
 def unregister_thread(python_thread_id: int) -> None: ...
 
 # Asyncio support
+
 def track_asyncio_loop(thread_id: int, loop: Optional[asyncio.AbstractEventLoop]) -> None: ...
 def link_tasks(parent: asyncio.Task[Any], child: asyncio.Future[Any]) -> None: ...
 def weak_link_tasks(parent: asyncio.Task[Any], child: asyncio.Future[Any]) -> None: ...
@@ -65,6 +74,7 @@ def init_asyncio(
 ) -> None: ...
 
 # Greenlet support
+
 def track_greenlet(greenlet_id: int, name: str, frame: Union[FrameType, bool, None]) -> None: ...
 def untrack_greenlet(greenlet_id: int) -> None: ...
 def link_greenlets(greenlet_id: int, parent_id: int) -> None: ...
@@ -77,5 +87,6 @@ def record_greenlet_switch(
 ) -> None: ...
 
 # Native call monitoring (sys.monitoring bridge)
+
 def start_native_monitoring() -> None: ...
 def stop_native_monitoring() -> None: ...
@@ -21,6 +21,20 @@
 #include <sys/types.h>
 #endif
 
+using ProfilingFaultRecover = bool (*)(int signo, siginfo_t* si, void* ucontext);
+
+int
+init_profiling_fault_handler();
+
+bool
+profiling_fault_handler_still_installed();
+
+void
+register_profiling_fault_recover(ProfilingFaultRecover recover);
+
+void
+unregister_profiling_fault_recover(ProfilingFaultRecover recover);
+
 int
 init_segv_catcher();
 

@@ -25,6 +25,8 @@
 #include <mach/mach.h>
 #endif
 
+#include "cpu_sample_ring.hpp"
+
 #include <echion/errors.h>
 #include <echion/greenlets.h>
 #include <echion/interp.h>
@@ -60,7 +62,12 @@ class ThreadInfo
 
     [[nodiscard]] Result<void> update_cpu_time();
 
-    [[nodiscard]] Result<void> sample(EchionSampler&, PyThreadState*, microsecond_t);
+    [[nodiscard]] Result<void> sample(EchionSampler&, PyThreadState*, microsecond_t, bool include_cpu_time = true);
+    void sample_cpu_timer(EchionSampler&,
+                          PyThreadState*,
+                          FrameStack&&,
+                          microsecond_t,
+                          const Datadog::CpuTimer::RawSample&);
     void unwind(EchionSampler&, PyThreadState*, microsecond_t wall_time_us);
 
     // ------------------------------------------------------------------------
@@ -114,20 +121,21 @@ class ThreadInfo
     };
 
   private:
+    using TaskAddressCallback = std::function<void(TaskObj*)>;
+
     void reset_cycle_state() noexcept;
     void render_unwound_stacks(EchionSampler&);
     [[nodiscard]] Result<void> unwind_tasks(EchionSampler&, PyThreadState*, microsecond_t wall_time_us);
     void unwind_greenlets(EchionSampler&, PyThreadState*, unsigned long, microsecond_t wall_time_us);
     [[nodiscard]] Result<std::vector<TaskInfo::Ptr>> get_all_tasks(EchionSampler&, PyThreadState* tstate);
+    [[nodiscard]] Result<void> for_each_task_address(EchionSampler&,
+                                                     PyThreadState* tstate,
+                                                     const TaskAddressCallback& callback);
 #if PY_VERSION_HEX >= 0x030e0000
-    [[nodiscard]] Result<void> get_tasks_from_thread_linked_list(EchionSampler& echion,
-                                                                 std::vector<TaskInfo::Ptr>& tasks);
-    [[nodiscard]] Result<void> get_tasks_from_interpreter_linked_list(EchionSampler& echion,
-                                                                      PyThreadState* tstate,
-                                                                      std::vector<TaskInfo::Ptr>& tasks);
-    [[nodiscard]] Result<void> get_tasks_from_linked_list(EchionSampler& echion,
-                                                          uintptr_t head_addr,
-                                                          std::vector<TaskInfo::Ptr>& tasks);
+    [[nodiscard]] Result<void> get_tasks_from_thread_linked_list(const TaskAddressCallback& callback);
+    [[nodiscard]] Result<void> get_tasks_from_interpreter_linked_list(PyThreadState* tstate,
+                                                                      const TaskAddressCallback& callback);
+    [[nodiscard]] Result<void> get_tasks_from_linked_list(uintptr_t head_addr, const TaskAddressCallback& callback);
 #endif
 };