WS3

Author: tzanko-matev

codetracer-python-recorder/src/runtime/tracer/events.rs

@@ -1,6 +1,5 @@
 //! Event handling pipeline for `RuntimeTracer`.
 
-use super::filtering::TraceDecision;
 use super::runtime_tracer::RuntimeTracer;
 use crate::code_object::CodeObjectWrapper;
 use crate::ffi;
@@ -177,18 +176,8 @@ impl Tracer for RuntimeTracer {
         code: &CodeObjectWrapper,
         _offset: i32,
     ) -> CallbackResult {
-        let is_active = self
-            .lifecycle
-            .activation_mut()
-            .should_process_event(py, code);
-        if matches!(
-            self.should_trace_code(py, code),
-            TraceDecision::SkipAndDisable
-        ) {
-            return Ok(CallbackOutcome::Continue);
-        }
-        if !is_active {
-            return Ok(CallbackOutcome::Continue);
+        if let Some(outcome) = self.evaluate_gate(py, code, true) {
+            return Ok(outcome);
         }
 
         if should_inject_failure(FailureStage::PyStart) {
@@ -244,18 +233,8 @@ impl Tracer for RuntimeTracer {
         code: &CodeObjectWrapper,
         _offset: i32,
     ) -> CallbackResult {
-        let is_active = self
-            .lifecycle
-            .activation_mut()
-            .should_process_event(py, code);
-        if matches!(
-            self.should_trace_code(py, code),
-            TraceDecision::SkipAndDisable
-        ) {
-            return Ok(CallbackOutcome::Continue);
-        }
-        if !is_active {
-            return Ok(CallbackOutcome::Continue);
+        if let Some(outcome) = self.evaluate_gate(py, code, false) {
+            return Ok(outcome);
         }
 
         log_event(py, code, "on_py_resume", None);
@@ -264,18 +243,8 @@ impl Tracer for RuntimeTracer {
     }
 
     fn on_line(&mut self, py: Python<'_>, code: &CodeObjectWrapper, lineno: u32) -> CallbackResult {
-        let is_active = self
-            .lifecycle
-            .activation_mut()
-            .should_process_event(py, code);
-        if matches!(
-            self.should_trace_code(py, code),
-            TraceDecision::SkipAndDisable
-        ) {
-            return Ok(CallbackOutcome::Continue);
-        }
-        if !is_active {
-            return Ok(CallbackOutcome::Continue);
+        if let Some(outcome) = self.evaluate_gate(py, code, false) {
+            return Ok(outcome);
         }
 
         if should_inject_failure(FailureStage::Line) {
@@ -378,18 +347,8 @@ impl Tracer for RuntimeTracer {
         _offset: i32,
         exception: &Bound<'_, PyAny>,
     ) -> CallbackResult {
-        let is_active = self
-            .lifecycle
-            .activation_mut()
-            .should_process_event(py, code);
-        if matches!(
-            self.should_trace_code(py, code),
-            TraceDecision::SkipAndDisable
-        ) {
-            return Ok(CallbackOutcome::Continue);
-        }
-        if !is_active {
-            return Ok(CallbackOutcome::Continue);
+        if let Some(outcome) = self.evaluate_gate(py, code, false) {
+            return Ok(outcome);
         }
 
         log_event(py, code, "on_py_throw", None);
@@ -564,22 +523,8 @@ impl RuntimeTracer {
         exit_kind: Option<ActivationExitKind>,
         allow_disable: bool,
     ) -> CallbackResult {
-        let is_active = self
-            .lifecycle
-            .activation_mut()
-            .should_process_event(py, code);
-        if matches!(
-            self.should_trace_code(py, code),
-            TraceDecision::SkipAndDisable
-        ) {
-            return Ok(if allow_disable {
-                CallbackOutcome::DisableLocation
-            } else {
-                CallbackOutcome::Continue
-            });
-        }
-        if !is_active {
-            return Ok(CallbackOutcome::Continue);
+        if let Some(outcome) = self.evaluate_gate(py, code, allow_disable) {
+            return Ok(outcome);
         }
 
         log_event(py, code, label, None);

codetracer-python-recorder/src/runtime/tracer/runtime_tracer.rs

@@ -5,6 +5,7 @@ use super::lifecycle::LifecycleController;
 use crate::code_object::CodeObjectWrapper;
 use crate::ffi;
 use crate::module_identity::{ModuleIdentityCache, ModuleNameHints};
+use crate::monitoring::CallbackOutcome;
 use crate::policy::RecorderPolicy;
 use crate::runtime::io_capture::{IoCaptureSettings, ScopedMuteIoCapture};
 use crate::runtime::line_snapshots::LineSnapshotStore;
@@ -201,6 +202,29 @@ impl RuntimeTracer {
         self.session_exit.set_exit_code(exit_code);
     }
 
+    pub(super) fn evaluate_gate(
+        &mut self,
+        py: Python<'_>,
+        code: &CodeObjectWrapper,
+        allow_disable: bool,
+    ) -> Option<CallbackOutcome> {
+        let is_active = self.lifecycle.activation_mut().should_process_event(py, code);
+        if matches!(
+            self.should_trace_code(py, code),
+            TraceDecision::SkipAndDisable
+        ) {
+            return Some(if allow_disable {
+                CallbackOutcome::DisableLocation
+            } else {
+                CallbackOutcome::Continue
+            });
+        }
+        if !is_active {
+            return Some(CallbackOutcome::Continue);
+        }
+        None
+    }
+
     pub(super) fn ensure_function_id(
         &mut self,
         py: Python<'_>,

design-docs/toplevel-exit-and-trace-gating-implementation-plan.status.md

@@ -28,7 +28,10 @@
   - Verification: `just cargo-test` (workspace) and `just py-test` exercises the new Rust test (`finish_emits_toplevel_return_with_exit_code`) and Python integration tests (`test_exit_payloads`).
 
 ### WS3 – Unified Trace Gate Abstraction
-- **Status:** _Not Started_.
+- **Status:** _Completed_
+  - Added a single `evaluate_gate` helper so callbacks defer to shared activation+filter logic, ensuring consistent disable decisions and reducing duplicated guards.
+  - All tracer callbacks now consult the helper; return handlers pass through the same decision pipeline before emitting events.
+  - Verification: `just cargo-test` and `just py-test`.
 
 ### WS4 – Lifecycle & Metadata Updates
 - **Status:** _Not Started_.