WS4-2

codetracer-python-recorder/tests/python/test_monitoring_events.py: 
codetracer-python-recorder/tests/rust/print_tracer.rs: 
design-docs/balanced-call-stack-events-implementation-plan.status.md: 

Signed-off-by: Tzanko Matev <[email protected]>

Author: tzanko-matev

codetracer-python-recorder/tests/python/test_monitoring_events.py

@@ -441,6 +441,102 @@ def test_coroutine_await_records_balanced_events(tmp_path: Path) -> None:
     ), "Expected coroutine return value 'done' to be recorded"
 
 
+def test_coroutine_send_and_throw_events_capture_resume_and_exception(tmp_path: Path) -> None:
+    code = (
+        "import types\n\n"
+        "@types.coroutine\n"
+        "def checkpoint():\n"
+        "    payload = yield 'suspended'\n"
+        "    return payload\n\n"
+        "async def worker():\n"
+        "    try:\n"
+        "        payload = await checkpoint()\n"
+        "        return f'ok:{payload}'\n"
+        "    except RuntimeError as err:\n"
+        "        return f'err:{err}'\n\n"
+        "def drive_success():\n"
+        "    coro = worker()\n"
+        "    coro.send(None)\n"
+        "    try:\n"
+        "        coro.send('data')\n"
+        "    except StopIteration:\n"
+        "        pass\n\n"
+        "def drive_throw():\n"
+        "    coro = worker()\n"
+        "    coro.send(None)\n"
+        "    try:\n"
+        "        coro.throw(RuntimeError('boom'))\n"
+        "    except StopIteration:\n"
+        "        pass\n\n"
+        "if __name__ == '__main__':\n"
+        "    drive_success()\n"
+        "    drive_throw()\n"
+    )
+    script = tmp_path / "script_coroutine_send_throw.py"
+    script.write_text(code)
+
+    out_dir = ensure_trace_dir(tmp_path)
+    session = codetracer.start(out_dir, format=codetracer.TRACE_JSON, start_on_enter=script)
+    try:
+        runpy.run_path(str(script), run_name="__main__")
+    finally:
+        codetracer.flush()
+        codetracer.stop()
+
+    parsed = _parse_trace(out_dir)
+    assert str(script) in parsed.paths
+    script_path_id = parsed.paths.index(str(script))
+
+    worker_fids = [
+        i
+        for i, f in enumerate(parsed.functions)
+        if f["name"] == "worker" and f["path_id"] == script_path_id
+    ]
+    assert worker_fids, "Expected worker() coroutine to be registered"
+    worker_fid = worker_fids[0]
+
+    worker_calls = [
+        call for call in parsed.call_records if int(call["function_id"]) == worker_fid
+    ]
+    assert (
+        len(worker_calls) == 4
+    ), f"Expected two starts plus resume/throw edges, saw {len(worker_calls)}"
+
+    def arg_name(arg: Dict[str, Any]) -> str:
+        return parsed.varnames[int(arg["variable_id"])]
+
+    def decode_text(value: Dict[str, Any]) -> str:
+        if value.get("kind") == "String":
+            return value.get("text", "")
+        if value.get("kind") == "Raw":
+            return value.get("r", "")
+        return ""
+
+    exception_calls = [
+        arg
+        for call in worker_calls
+        for arg in call.get("args", [])
+        if arg_name(arg) == "exception"
+    ]
+    assert exception_calls, "Expected coroutine throw to record an exception argument"
+    assert any("boom" in decode_text(arg["value"]) for arg in exception_calls)
+
+    def recorded_strings() -> List[str]:
+        values: List[str] = []
+        for rv in parsed.returns:
+            rv_value = rv.get("return_value")
+            if not rv_value:
+                continue
+            text = decode_text(rv_value)
+            if text:
+                values.append(text)
+        return values
+
+    strings = recorded_strings()
+    assert "ok:data" in strings, f"Expected successful resume payload, saw {strings}"
+    assert "err:boom" in strings, f"Expected exception handling result, saw {strings}"
+
+
 def test_py_unwind_records_exception_return(tmp_path: Path) -> None:
     code = (
         "def explode():\n"

codetracer-python-recorder/tests/rust/print_tracer.rs

@@ -65,6 +65,25 @@ static EXCEPTION_HANDLED_COUNT: AtomicUsize = AtomicUsize::new(0);
 static C_RETURN_COUNT: AtomicUsize = AtomicUsize::new(0);
 static C_RAISE_COUNT: AtomicUsize = AtomicUsize::new(0);
 
+fn reset_all_counts() {
+    LINE_COUNT.store(0, Ordering::SeqCst);
+    INSTRUCTION_COUNT.store(0, Ordering::SeqCst);
+    JUMP_COUNT.store(0, Ordering::SeqCst);
+    BRANCH_COUNT.store(0, Ordering::SeqCst);
+    PY_START_COUNT.store(0, Ordering::SeqCst);
+    PY_RESUME_COUNT.store(0, Ordering::SeqCst);
+    PY_RETURN_COUNT.store(0, Ordering::SeqCst);
+    PY_YIELD_COUNT.store(0, Ordering::SeqCst);
+    PY_THROW_COUNT.store(0, Ordering::SeqCst);
+    PY_UNWIND_COUNT.store(0, Ordering::SeqCst);
+    RAISE_COUNT.store(0, Ordering::SeqCst);
+    RERAISE_COUNT.store(0, Ordering::SeqCst);
+    EXCEPTION_HANDLED_COUNT.store(0, Ordering::SeqCst);
+    // STOP_ITERATION_COUNT.store(0, Ordering::SeqCst); // Not currently triggered in tests.
+    C_RETURN_COUNT.store(0, Ordering::SeqCst);
+    C_RAISE_COUNT.store(0, Ordering::SeqCst);
+}
+
 struct CountingTracer;
 
 impl Tracer for CountingTracer {
@@ -313,22 +332,7 @@ impl Tracer for CountingTracer {
 #[test]
 fn tracer_handles_all_events() {
     Python::with_gil(|py| {
-        LINE_COUNT.store(0, Ordering::SeqCst);
-        INSTRUCTION_COUNT.store(0, Ordering::SeqCst);
-        JUMP_COUNT.store(0, Ordering::SeqCst);
-        BRANCH_COUNT.store(0, Ordering::SeqCst);
-        PY_START_COUNT.store(0, Ordering::SeqCst);
-        PY_RESUME_COUNT.store(0, Ordering::SeqCst);
-        PY_RETURN_COUNT.store(0, Ordering::SeqCst);
-        PY_YIELD_COUNT.store(0, Ordering::SeqCst);
-        PY_THROW_COUNT.store(0, Ordering::SeqCst);
-        PY_UNWIND_COUNT.store(0, Ordering::SeqCst);
-        RAISE_COUNT.store(0, Ordering::SeqCst);
-        RERAISE_COUNT.store(0, Ordering::SeqCst);
-        EXCEPTION_HANDLED_COUNT.store(0, Ordering::SeqCst);
-        // STOP_ITERATION_COUNT.store(0, Ordering::SeqCst); //ISSUE: We can't figure out how to triger this event
-        C_RETURN_COUNT.store(0, Ordering::SeqCst);
-        C_RAISE_COUNT.store(0, Ordering::SeqCst);
+        reset_all_counts();
         if let Err(e) = install_tracer(py, Box::new(CountingTracer)) {
             e.print(py);
             panic!("Install Tracer failed");
@@ -479,3 +483,67 @@ for _ in only_stop_iter():
         );
     });
 }
+
+#[test]
+fn tracer_counts_resume_throw_and_unwind_events() {
+    Python::with_gil(|py| {
+        reset_all_counts();
+        if let Err(e) = install_tracer(py, Box::new(CountingTracer)) {
+            e.print(py);
+            panic!("Install Tracer failed");
+        }
+        let code = CString::new(
+            r#"
+def ticker():
+    try:
+        yield "tick"
+        yield "tock"
+    except RuntimeError:
+        return "handled"
+
+g = ticker()
+next(g)
+next(g)
+try:
+    g.throw(RuntimeError("boom"))
+except StopIteration:
+    pass
+
+def explode():
+    raise ValueError("kaboom")
+
+try:
+    explode()
+except ValueError:
+    pass
+"#,
+        )
+        .expect("CString::new failed");
+        if let Err(e) = py.run(code.as_c_str(), None, None) {
+            e.print(py);
+            uninstall_tracer(py).ok();
+            panic!("Python raised an exception");
+        }
+        uninstall_tracer(py).unwrap();
+        assert_eq!(
+            PY_RESUME_COUNT.load(Ordering::SeqCst),
+            1,
+            "expected exactly one PY_RESUME event from next(g)"
+        );
+        assert_eq!(
+            PY_THROW_COUNT.load(Ordering::SeqCst),
+            1,
+            "expected exactly one PY_THROW event from g.throw(...)"
+        );
+        assert_eq!(
+            PY_YIELD_COUNT.load(Ordering::SeqCst),
+            2,
+            "expected two PY_YIELD events from the generator body"
+        );
+        assert_eq!(
+            PY_UNWIND_COUNT.load(Ordering::SeqCst),
+            1,
+            "expected one PY_UNWIND event from explode()"
+        );
+    });
+}

design-docs/balanced-call-stack-events-implementation-plan.status.md

@@ -38,12 +38,13 @@
   - Verification: `just dev test` passes end-to-end.
 
 ### WS4 – Testing & Validation
-- **Status:** _In progress_
-  - Added Python integration tests covering generator yield/resume sequences, `g.throw(...)` exception injection, coroutine awaits (`asyncio.run`) and plain exception unwinds to verify balanced call/return pairs and recorded payloads.
-  - The new coverage exercises the trace JSON to assert call counts, argument capture (including the synthetic `exception` arg), and recorded return values for unwind paths.
-  - TODO: extend coverage to async `send()`/`throw()` scenarios and consider rust-side assertions for the integration print tracer if further confidence is needed.
+- **Status:** _Completed_
+  - Added Python integration tests covering generator yield/resume sequences, `g.throw(...)` exception injection, coroutine awaits (`asyncio.run`), and plain exception unwinds to verify balanced call/return pairs and recorded payloads.
+  - Added `test_coroutine_send_and_throw_events_capture_resume_and_exception` to exercise coroutine `send()` and `throw()` paths, asserting the additional call edges plus the encoded `exception` argument and final return payloads.
+  - Extended `tests/rust/print_tracer.rs` with a focused scenario (`tracer_counts_resume_throw_and_unwind_events`) to prove that `PY_RESUME`, `PY_THROW`, `PY_YIELD`, and `PY_UNWIND` fire the expected number of times for a simple generator/unwind script.
+  - Verification: `just dev test` (maturin develop + cargo nextest + pytest) now passes end-to-end.
 
 ## Next Checkpoints
-1. Extend WS4 coverage to additional async edge cases (e.g., `send()`/`throw()` on coroutines) and consider verifying `print_tracer` output in Rust.
+1. Monitor nightly runs for regressions around generator/coroutine call balancing and expand coverage again if new CPython events appear.
 2. Document any telemetry/logging updates before shipping the feature.
-3. Prepare release notes / changelog once WS4 closes out.
+3. Prepare release notes / changelog entries summarising the balanced call-stack support once release packaging starts.