WS2

codetracer-python-recorder/src/runtime/tracer/events.rs: 
codetracer-python-recorder/src/runtime/tracer/runtime_tracer.rs: 
design-docs/module-call-event-naming-implementation-plan.status.md: 

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

Author: tzanko-matev

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

@@ -508,6 +508,7 @@ impl Tracer for RuntimeTracer {
                     .map_err(ffi::map_recorder_error)?;
             }
             self.function_ids.clear();
+            self.module_names.clear();
             self.io.clear_snapshots();
             self.filter.reset();
             self.lifecycle.reset_event_state();
@@ -521,6 +522,7 @@ impl Tracer for RuntimeTracer {
             .finalise(&mut self.writer, &self.filter)
             .map_err(ffi::map_recorder_error)?;
         self.function_ids.clear();
+        self.module_names.clear();
         self.filter.reset();
         self.io.clear_snapshots();
         self.lifecycle.reset_event_state();

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

@@ -4,6 +4,7 @@ use super::io::IoCoordinator;
 use super::lifecycle::LifecycleController;
 use crate::code_object::CodeObjectWrapper;
 use crate::ffi;
+use crate::module_identity::{ModuleIdentityCache, ModuleNameHints};
 use crate::policy::RecorderPolicy;
 use crate::runtime::io_capture::{IoCaptureSettings, ScopedMuteIoCapture};
 use crate::runtime::line_snapshots::LineSnapshotStore;
@@ -12,7 +13,7 @@ use crate::trace_filter::engine::TraceFilterEngine;
 use pyo3::prelude::*;
 use runtime_tracing::NonStreamingTraceWriter;
 use runtime_tracing::{Line, TraceEventsFileFormat, TraceWriter};
-use std::collections::{hash_map::Entry, HashMap};
+use std::collections::HashMap;
 use std::path::Path;
 use std::sync::Arc;
 use std::thread::ThreadId;
@@ -26,6 +27,7 @@ pub struct RuntimeTracer {
     pub(super) function_ids: HashMap<usize, runtime_tracing::FunctionId>,
     pub(super) io: IoCoordinator,
     pub(super) filter: FilterCoordinator,
+    pub(super) module_names: ModuleIdentityCache,
 }
 
 impl RuntimeTracer {
@@ -46,6 +48,7 @@ impl RuntimeTracer {
             function_ids: HashMap::new(),
             io: IoCoordinator::new(),
             filter: FilterCoordinator::new(trace_filter),
+            module_names: ModuleIdentityCache::new(),
         }
     }
 
@@ -101,21 +104,20 @@ impl RuntimeTracer {
         py: Python<'_>,
         code: &CodeObjectWrapper,
     ) -> PyResult<runtime_tracing::FunctionId> {
-        match self.function_ids.entry(code.id()) {
-            Entry::Occupied(entry) => Ok(*entry.get()),
-            Entry::Vacant(slot) => {
-                let name = code.qualname(py)?;
-                let filename = code.filename(py)?;
-                let first_line = code.first_line(py)?;
-                let function_id = TraceWriter::ensure_function_id(
-                    &mut self.writer,
-                    name,
-                    Path::new(filename),
-                    Line(first_line as i64),
-                );
-                Ok(*slot.insert(function_id))
-            }
+        if let Some(fid) = self.function_ids.get(&code.id()) {
+            return Ok(*fid);
         }
+        let name = self.function_name(py, code)?;
+        let filename = code.filename(py)?;
+        let first_line = code.first_line(py)?;
+        let function_id = TraceWriter::ensure_function_id(
+            &mut self.writer,
+            name.as_str(),
+            Path::new(filename),
+            Line(first_line as i64),
+        );
+        self.function_ids.insert(code.id(), function_id);
+        Ok(function_id)
     }
 
     pub(super) fn should_trace_code(
@@ -125,6 +127,34 @@ impl RuntimeTracer {
     ) -> TraceDecision {
         self.filter.decide(py, code)
     }
+
+    fn function_name(&self, py: Python<'_>, code: &CodeObjectWrapper) -> PyResult<String> {
+        let qualname = code.qualname(py)?;
+        if qualname == "<module>" {
+            Ok(self
+                .derive_module_name(py, code)
+                .map(|module| format!("<{module}>"))
+                .unwrap_or_else(|| qualname.to_string()))
+        } else {
+            Ok(qualname.to_string())
+        }
+    }
+
+    fn derive_module_name(&self, py: Python<'_>, code: &CodeObjectWrapper) -> Option<String> {
+        let resolution = self.filter.cached_resolution(code.id());
+        if let Some(resolution) = resolution.as_ref() {
+            let hints = ModuleNameHints {
+                preferred: resolution.module_name(),
+                relative_path: resolution.relative_path(),
+                absolute_path: resolution.absolute_path(),
+                globals_name: None,
+            };
+            self.module_names.resolve_for_code(py, code, hints)
+        } else {
+            self.module_names
+                .resolve_for_code(py, code, ModuleNameHints::default())
+        }
+    }
 }
 
 #[cfg(test)]
@@ -1039,6 +1069,58 @@ sensitive("s3cr3t")
         });
     }
 
+    #[test]
+    fn module_import_records_module_name() {
+        Python::with_gil(|py| {
+            ensure_test_module(py);
+
+            let mut tracer =
+                RuntimeTracer::new("runner.py", &[], TraceEventsFileFormat::Json, None, None);
+
+            let project = tempfile::tempdir().expect("project dir");
+            let pkg_root = project.path().join("lib");
+            let pkg_dir = pkg_root.join("my_pkg");
+            fs::create_dir_all(&pkg_dir).expect("create package dir");
+            fs::write(pkg_dir.join("__init__.py"), "\n").expect("write __init__");
+            fs::write(
+                pkg_dir.join("mod.py"),
+                "value = 1\nprint('imported module value', value)\n",
+            )
+            .expect("write module file");
+
+            let script = format!(
+                "import sys\nsys.path.insert(0, r\"{root}\")\nimport my_pkg.mod\n",
+                root = pkg_root.display()
+            );
+
+            {
+                let _guard = ScopedTracer::new(&mut tracer);
+                LAST_OUTCOME.with(|cell| cell.set(None));
+                let script_c = CString::new(script).expect("script contains nul byte");
+                py.run(script_c.as_c_str(), None, None)
+                    .expect("execute module import");
+            }
+
+            let function_records: Vec<String> = tracer
+                .writer
+                .events
+                .iter()
+                .filter_map(|event| {
+                    if let TraceLowLevelEvent::Function(record) = event {
+                        Some(record.name.clone())
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            assert!(
+                function_records.iter().any(|name| name == "<my_pkg.mod>"),
+                "expected module function name to be rewritten: {function_records:?}"
+            );
+        });
+    }
+
     #[test]
     fn user_drop_default_overrides_builtin_allowance() {
         Python::with_gil(|py| {

design-docs/module-call-event-naming-implementation-plan.status.md

@@ -18,13 +18,13 @@
 
 ### WS1 – Shared Module Identity Helper
 - **Scope recap:** Extract and centralise module-name derivation (relative path stripping + `sys.modules` lookup) so both filters and the runtime tracer can reuse it with caching.
-- **Status:** _In Progress_
-- **Notes:** Created `src/module_identity.rs` housing `ModuleIdentityResolver`, a per-code `ModuleIdentityCache`, sanitisation helpers, and unit tests (covering `.py`/`.pyc`, package roots, and hint precedence). `TraceFilterEngine` now consumes the resolver instead of bespoke logic, and shared helpers (`module_from_relative`, `normalise_to_posix`, etc.) moved into the new module. `just dev` + `just test` succeed after the changeset; the cache will be hooked into `RuntimeTracer` during WS2.
+- **Status:** _Completed_
+- **Notes:** `src/module_identity.rs` now owns `ModuleIdentityResolver`, `ModuleIdentityCache`, sanitisation helpers, and unit tests covering `.py` vs `.pyc`, package roots, and hint precedence. `TraceFilterEngine` uses the shared resolver for all module lookups, keeping behaviour aligned between filtering and runtime components.
 
 ### WS2 – Runtime Tracer Integration
 - **Scope recap:** Detect module-level code (`co_qualname == "<module>"`) and rename call events to `<module-name>` using the shared resolver; plumb filter-derived names to avoid duplicate work.
-- **Status:** _Not Started_
-- **Notes:** Will require updates to `RuntimeTracer::ensure_function_id`, cache management, and potentially `capture_call_arguments` to surface `globals["__name__"]` when needed.
+- **Status:** _In Progress_
+- **Notes:** `RuntimeTracer` now owns a `ModuleIdentityCache`, rewrites module-level function names via shared hints, clears the cache between runs, and has a regression test (`module_import_records_module_name`) confirming `<my_pkg.mod>` call records. Remaining work: thread globals-based hints (if needed) and add higher-level integration tests / documentation (see WS3).
 
 ### WS3 – Testing, Tooling, and Docs
 - **Scope recap:** Add regression tests (Python + Rust) validating the new naming, update documentation/changelog, and refresh any snapshot expectations.