Address Codex comment

Author: tzanko-matev

codetracer-python-recorder/src/session/bootstrap.rs

@@ -65,7 +65,8 @@ impl TraceSessionBootstrap {
             enverr!(ErrorCode::Io, "failed to collect program metadata")
                 .with_context("details", err.to_string())
         })?;
-        let trace_filter = load_trace_filter(explicit_trace_filters, &metadata.program)?;
+        let trace_filter =
+            load_trace_filter(explicit_trace_filters, activation_path, &metadata.program)?;
         Ok(Self {
             trace_directory: trace_directory.to_path_buf(),
             format,
@@ -164,11 +165,12 @@ pub fn collect_program_metadata(py: Python<'_>) -> PyResult<ProgramMetadata> {
 
 fn load_trace_filter(
     explicit: Option<&[PathBuf]>,
+    activation_path: Option<&Path>,
     program: &str,
 ) -> Result<Option<Arc<TraceFilterEngine>>> {
     let mut chain: Vec<PathBuf> = Vec::new();
 
-    if let Some(default) = discover_default_trace_filter(program)? {
+    if let Some(default) = discover_default_trace_filter(activation_path, program)? {
         chain.push(default);
     }
 
@@ -183,17 +185,42 @@ fn load_trace_filter(
     Ok(Some(Arc::new(TraceFilterEngine::new(config))))
 }
 
-fn discover_default_trace_filter(program: &str) -> Result<Option<PathBuf>> {
-    let start_dir = resolve_program_directory(program)?;
-    let mut current: Option<&Path> = Some(start_dir.as_path());
-    while let Some(dir) = current {
+fn discover_default_trace_filter(
+    activation_path: Option<&Path>,
+    program: &str,
+) -> Result<Option<PathBuf>> {
+    if let Some(path) = activation_path {
+        let activation_dir = resolve_activation_directory(path)?;
+        if let Some(found) = discover_filter_near(activation_dir) {
+            return Ok(Some(found));
+        }
+    }
+
+    let program_dir = resolve_program_directory(program)?;
+    if let Some(found) = discover_filter_near(program_dir) {
+        return Ok(Some(found));
+    }
+    Ok(None)
+}
+
+fn discover_filter_near(mut dir: PathBuf) -> Option<PathBuf> {
+    loop {
         let candidate = dir.join(TRACE_FILTER_DIR).join(TRACE_FILTER_FILE);
         if matches!(fs::metadata(&candidate), Ok(metadata) if metadata.is_file()) {
-            return Ok(Some(candidate));
+            return Some(candidate);
+        }
+        if !dir.pop() {
+            break;
         }
-        current = dir.parent();
     }
-    Ok(None)
+    None
+}
+
+fn resolve_activation_directory(path: &Path) -> Result<PathBuf> {
+    if path.as_os_str().is_empty() {
+        return current_directory();
+    }
+    resolve_path_directory(path)
 }
 
 fn resolve_program_directory(program: &str) -> Result<PathBuf> {
@@ -203,6 +230,10 @@ fn resolve_program_directory(program: &str) -> Result<PathBuf> {
     }
 
     let path = Path::new(trimmed);
+    resolve_path_directory(path)
+}
+
+fn resolve_path_directory(path: &Path) -> Result<PathBuf> {
     if path.is_absolute() {
         if path.is_dir() {
             return Ok(path.to_path_buf());
@@ -434,6 +465,76 @@ mod tests {
         });
     }
 
+    #[test]
+    fn prepare_bootstrap_prefers_activation_path_filter_over_host_program() {
+        Python::with_gil(|py| {
+            let project = tempdir().expect("project");
+            let project_root = project.path();
+            let trace_dir = project_root.join("trace-out");
+
+            let wrapper_dir = project_root.join("wrapper");
+            std::fs::create_dir_all(&wrapper_dir).expect("create wrapper dir");
+            let wrapper_script = wrapper_dir.join("launcher.py");
+            std::fs::write(&wrapper_script, "print('wrapper')\n").expect("write wrapper");
+
+            let target_dir = project_root.join("target");
+            std::fs::create_dir_all(&target_dir).expect("create target dir");
+            let target_script = target_dir.join("app.py");
+            std::fs::write(&target_script, "print('target')\n").expect("write target");
+
+            let filters_dir = target_dir.join(TRACE_FILTER_DIR);
+            std::fs::create_dir_all(&filters_dir).expect("create filter dir");
+            let filter_path = filters_dir.join(TRACE_FILTER_FILE);
+            std::fs::write(
+                &filter_path,
+                r#"
+                [meta]
+                name = "target"
+                version = 1
+
+                [scope]
+                default_exec = "trace"
+                default_value_action = "allow"
+
+                [[scope.rules]]
+                selector = "pkg:target"
+                exec = "trace"
+                value_default = "allow"
+                "#,
+            )
+            .expect("write project filter");
+
+            let sys = py.import("sys").expect("import sys");
+            let original = sys.getattr("argv").expect("argv").unbind();
+            let argv = PyList::new(
+                py,
+                [wrapper_script.to_str().expect("utf8 path"), "--forwarded"],
+            )
+            .expect("argv");
+            sys.setattr("argv", argv).expect("set argv");
+
+            let result = TraceSessionBootstrap::prepare(
+                py,
+                trace_dir.as_path(),
+                "json",
+                Some(target_script.as_path()),
+                None,
+            );
+            sys.setattr("argv", original.bind(py))
+                .expect("restore argv");
+
+            let bootstrap = result.expect("bootstrap");
+            let engine = bootstrap.trace_filter().expect("filter engine");
+            let summary = engine.summary();
+            assert_eq!(summary.entries.len(), 2);
+            assert_eq!(
+                summary.entries[0].path,
+                PathBuf::from("<inline:builtin-default>")
+            );
+            assert_eq!(summary.entries[1].path, filter_path);
+        });
+    }
+
     #[test]
     fn prepare_bootstrap_merges_explicit_trace_filters() {
         Python::with_gil(|py| {