test(memtrack): add spawn wrapper integration test for static allocator discovery

Verify that CODSPEED_MEMTRACK_BINARIES-style static allocator discovery
works for spawned child processes. The test runs a wrapper binary that
exec's a child with statically linked jemalloc, confirming:

- Without discovery: no allocations are tracked
- With discovery: all marker-delimited allocations are captured

COD-2347

Author: not-matthias

crates/memtrack/testdata/spawn_wrapper/.gitignore

@@ -0,0 +1 @@
+/target

crates/memtrack/testdata/spawn_wrapper/Cargo.lock

@@ -0,0 +1,17 @@
+[workspace]
+
+[package]
+name = "spawn_wrapper"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "wrapper"
+path = "src/bin/wrapper.rs"
+
+[[bin]]
+name = "alloc_child"
+path = "src/bin/alloc_child.rs"
+
+[dependencies]
+jemallocator = { version = "0.5" }

crates/memtrack/testdata/spawn_wrapper/Cargo.toml

@@ -0,0 +1,35 @@
+use std::alloc::GlobalAlloc;
+
+#[global_allocator]
+static GLOBAL: jemallocator::Jemalloc = jemallocator::Jemalloc;
+
+fn main() {
+    std::thread::sleep(std::time::Duration::from_secs(1));
+
+    let emit_marker = || unsafe {
+        let layout = std::alloc::Layout::array::<u8>(0xC0D59EED).unwrap();
+        let ptr = GLOBAL.alloc(layout);
+        core::hint::black_box(ptr);
+        GLOBAL.dealloc(ptr, layout);
+    };
+
+    emit_marker();
+
+    // malloc
+    unsafe {
+        let layout = std::alloc::Layout::array::<u8>(4321).unwrap();
+        let ptr = GLOBAL.alloc(layout);
+        core::hint::black_box(ptr);
+        GLOBAL.dealloc(ptr, layout);
+    }
+
+    // alloc zeroed
+    unsafe {
+        let layout = std::alloc::Layout::array::<u8>(1234).unwrap();
+        let ptr = GLOBAL.alloc_zeroed(layout);
+        core::hint::black_box(ptr);
+        GLOBAL.dealloc(ptr, layout);
+    }
+
+    emit_marker();
+}

crates/memtrack/testdata/spawn_wrapper/src/bin/alloc_child.rs

@@ -0,0 +1,17 @@
+use std::process::Command;
+
+fn main() {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    if args.is_empty() {
+        eprintln!("Usage: wrapper <command> [args...]");
+        std::process::exit(1);
+    }
+
+    let mut child = Command::new(&args[0])
+        .args(&args[1..])
+        .spawn()
+        .expect("Failed to spawn child process");
+
+    let status = child.wait().expect("Failed to wait for child");
+    std::process::exit(status.code().unwrap_or(1));
+}

crates/memtrack/testdata/spawn_wrapper/src/bin/wrapper.rs

@@ -0,0 +1,11 @@
+---
+source: crates/memtrack/tests/spawn_tests.rs
+assertion_line: 90
+expression: formatted_events
+---
+[
+    "Malloc { size: 4321 }",
+    "Free",
+    "Calloc { size: 1234 }",
+    "Free",
+]

crates/memtrack/tests/snapshots/spawn_tests__spawn_with_discovery.snap

@@ -0,0 +1,6 @@
+---
+source: crates/memtrack/tests/spawn_tests.rs
+assertion_line: 71
+expression: formatted_events
+---
+[]

crates/memtrack/tests/snapshots/spawn_tests__spawn_without_discovery.snap

@@ -0,0 +1,51 @@
+#[macro_use]
+mod shared;
+
+use memtrack::AllocatorLib;
+use memtrack::prelude::*;
+use std::path::Path;
+use std::process::Command;
+
+fn compile_spawn_binary(name: &str) -> anyhow::Result<std::path::PathBuf> {
+    shared::compile_rust_binary(Path::new("testdata/spawn_wrapper"), name, &[])
+}
+
+/// Without discovering the child's static allocator, the spawned child's
+/// jemalloc allocations should NOT be tracked — we expect no marker-delimited events.
+#[test_with::env(GITHUB_ACTIONS)]
+#[test_log::test]
+fn test_spawn_without_static_allocator_discovery() -> Result<(), Box<dyn std::error::Error>> {
+    let wrapper = compile_spawn_binary("wrapper")?;
+    let child = compile_spawn_binary("alloc_child")?;
+
+    // No allocators attached — static jemalloc in alloc_child won't be found
+    let mut cmd = Command::new(&wrapper);
+    cmd.arg(&child);
+    let (events, thread_handle) = shared::track_command(cmd, &[], false)?;
+
+    assert_events_with_marker!("spawn_without_discovery", &events);
+
+    thread_handle.join().unwrap();
+    Ok(())
+}
+
+/// With the child binary's static allocator discovered (simulating
+/// CODSPEED_MEMTRACK_BINARIES), allocations from the spawned child should be tracked.
+#[test_with::env(GITHUB_ACTIONS)]
+#[test_log::test]
+fn test_spawn_with_static_allocator_discovery() -> Result<(), Box<dyn std::error::Error>> {
+    let wrapper = compile_spawn_binary("wrapper")?;
+    let child = compile_spawn_binary("alloc_child")?;
+
+    // Simulate what CODSPEED_MEMTRACK_BINARIES does: discover the static jemalloc
+    let allocator = AllocatorLib::from_path_static(&child)?;
+
+    let mut cmd = Command::new(&wrapper);
+    cmd.arg(&child);
+    let (events, thread_handle) = shared::track_command(cmd, &[allocator], false)?;
+
+    assert_events_with_marker!("spawn_with_discovery", &events);
+
+    thread_handle.join().unwrap();
+    Ok(())
+}