Use remote ptrace

Author: gyuheon0h

Cargo.lock

@@ -191,14 +191,21 @@ fn test_crash_tracking_bin_runtime_callback_frame() {
 /// Tests that when `collect_all_threads` is enabled, the crash report contains
 /// entries in `error.threads` for background threads beyond the crashing thread.
 ///
-/// The behavior enables `collect_all_threads`, spawns two named
-/// sleeping worker threads in `post()`, and then crashes the main thread.
+/// The behavior (test_017_multi_thread_collection.rs) enables `collect_all_threads`,
+/// spawns two named sleeping worker threads in `post()`, and then crashes the main thread.
+///
+/// Thread collection now happens in the receiver process using libunwind remote unwinding
+/// via ptrace (_UPT_create / unw_init_remote / unw_step_remote). The parent process stays
+/// alive until the receiver completes, guaranteeing threads are valid ptrace targets.
+///
 /// We verify:
-///   - `error.threads` is non-empty
-///   - Each thread entry is well-formed: `crashed`, `name`, `stack` present.
+///   - `error.threads` is non-empty.
+///   - Each thread entry is well-formed: `crashed=false`, `name`, and `stack` present.
 ///   - None of the additional threads are marked as crashed (the crashing thread is in
 ///     `error.stack`, not `error.threads`).
-///   - The worker thread names are recognizable (ct_worker_0, ct_worker_1).
+///   - Both worker threads are present by name (ct_worker_0, ct_worker_1).
+///   - Each worker has a multi-frame stack trace including their entry function, confirming that
+///     libunwind remote unwinding produced a full call chain rather than a single syscall frame.
 #[test]
 #[cfg(target_os = "linux")]
 #[cfg_attr(miri, ignore)]
@@ -213,11 +220,11 @@ fn test_crash_tracking_multi_thread_collection() {
 
     let validator: ValidatorFn = Box::new(|payload, _fixtures| {
         let error = &payload["error"];
-        assert!(
-            false,
-            "{}",
-            serde_json::to_string_pretty(error).unwrap_or_default()
-        );
+        // assert!(
+        //     false,
+        //     "{}",
+        //     serde_json::to_string_pretty(error).unwrap_or_default()
+        // );
         let threads = error["threads"]
             .as_array()
             .expect("error.threads should be a JSON array");
@@ -254,8 +261,7 @@ fn test_crash_tracking_multi_thread_collection() {
             );
         }
 
-        // Both named workers must be present; the behavior (test_017_multi_thread_collection.rs)
-        //spawns exactly two
+        // Both named workers must be present; the behavior spawns exactly two
         for expected in ["ct_worker_0", "ct_worker_1"] {
             assert!(
                 thread_names.contains(&expected),
@@ -264,9 +270,13 @@ fn test_crash_tracking_multi_thread_collection() {
             );
         }
 
-        // Each worker must have captured at least one stack frame
-        // (they were sleeping in a syscall, so SIGUSR2 interrupted them and
-        // unw_init_local2 should produce at minimum the syscall entry frame).
+        // Each worker must have a multi-frame stack trace.
+        //
+        // The workers sleep in thread::sleep -> wait_for_work_N -> worker_entry_N.
+        // With libunwind remote unwinding, we expect the full call chain rather than
+        // a single syscall frame. We verify:
+        //   - More than one frame was captured.
+        //   - At least one frame contains the worker's entry function by name.
         for expected in ["ct_worker_0", "ct_worker_1"] {
             let worker = threads
                 .iter()
@@ -278,8 +288,26 @@ fn test_crash_tracking_multi_thread_collection() {
                 .unwrap_or_else(|| panic!("{expected} stack.frames should be an array"));
 
             assert!(
-                !frames.is_empty(),
-                "{expected} should have at least one stack frame; worker: {worker:?}"
+                frames.len() > 1,
+                "{expected} should have a multi-frame stack trace from remote libunwind; \
+                 got {} frame(s): {frames:?}",
+                frames.len()
+            );
+
+            let entry_fn = if expected == "ct_worker_0" {
+                "worker_entry_0"
+            } else {
+                "worker_entry_1"
+            };
+            let has_entry_frame = frames.iter().any(|f| {
+                f["function"]
+                    .as_str()
+                    .map(|name| name.contains(entry_fn))
+                    .unwrap_or(false)
+            });
+            assert!(
+                has_entry_frame,
+                "{expected} stack should contain a frame for '{entry_fn}' but got: {frames:?}"
             );
         }
 

bin_tests/tests/crashtracker_bin_test.rs

@@ -42,7 +42,7 @@ cxx = ["dep:cxx", "dep:cxx-build"]
 blazesym = "=0.2.3"
 
 [target.'cfg(target_os = "linux")'.dependencies]
-libdd-libunwind-sys = { version = "1.0.0" }
+libdd-libunwind-sys = { git = "https://github.com/DataDog/libdatadog-libunwind", branch = "gyuheon0h/remote-unwind-api" }
 
 [dependencies]
 anyhow = "1.0"

libdd-crashtracker/Cargo.toml

@@ -20,9 +20,6 @@ use std::{
 };
 use thiserror::Error;
 
-#[cfg(target_os = "linux")]
-use std::io::BufRead;
-
 #[derive(Debug, Error)]
 pub enum EmitterError {
     #[error("Failed to write to output: {0}")]
@@ -423,63 +420,6 @@ unsafe fn emit_whole_stacktrace(
     Ok(())
 }
 
-/// Emit one thread block over the wire protocol.
-///
-/// Format:
-/// ```text
-/// DD_CRASHTRACK_BEGIN_THREAD
-/// {"tid": <tid>, "crashed": <bool>, "name": "<name>", "state": "<state>"}
-/// DD_CRASHTRACK_BEGIN_STACKTRACE
-/// ...frame JSON lines (if a ucontext was captured for this thread)...
-/// DD_CRASHTRACK_END_STACKTRACE
-/// DD_CRASHTRACK_END_THREAD
-/// ```
-#[cfg(target_os = "linux")]
-fn emit_thread_block(
-    w: &mut impl Write,
-    tid: libc::pid_t,
-    crashed: bool,
-    name: &str,
-    state: Option<&str>,
-    resolve_frames: StacktraceCollection,
-    ucontext: Option<*const ucontext_t>,
-) -> Result<(), EmitterError> {
-    writeln!(w, "{DD_CRASHTRACK_BEGIN_THREAD}")?;
-
-    // Header JSON line
-    write!(w, "{{\"tid\": {tid}, \"crashed\": {crashed}")?;
-    let safe_name = name
-        .replace('\\', "\\\\")
-        .replace('"', "\\\"")
-        .replace('\n', "\\n");
-    write!(w, ", \"name\": \"{safe_name}\"")?;
-    if let Some(s) = state {
-        let safe_state = s
-            .replace('\\', "\\\\")
-            .replace('"', "\\\"")
-            .replace('\n', "\\n");
-        write!(w, ", \"state\": \"{safe_state}\"")?;
-    }
-    writeln!(w, "}}")?;
-    w.flush()?;
-
-    // Stack trace (only if we have a ucontext for this thread)
-    writeln!(w, "{DD_CRASHTRACK_BEGIN_STACKTRACE}")?;
-    if let Some(uc) = ucontext {
-        if resolve_frames != StacktraceCollection::Disabled {
-            // SAFETY: uc was written by handle_collect_context_signal and is valid for
-            // the duration of the collector child (COW mapping from the parent).
-            let _ = unsafe { emit_backtrace_via_libunwind(w, resolve_frames, uc) };
-        }
-    }
-    writeln!(w, "{DD_CRASHTRACK_END_STACKTRACE}")?;
-    w.flush()?;
-
-    writeln!(w, "{DD_CRASHTRACK_END_THREAD}")?;
-    w.flush()?;
-    Ok(())
-}
-
 fn emit_config(w: &mut impl Write, config_str: &str) -> Result<(), EmitterError> {
     writeln!(w, "{DD_CRASHTRACK_BEGIN_CONFIG}")?;
     writeln!(w, "{config_str}")?;

libdd-crashtracker/src/collector/emitters.rs

@@ -206,17 +206,6 @@ unsafe fn register_signal_handler(
     Ok((signal_type, old_handler))
 }
 
-/// Register the SIGUSR2 handler used to capture thread contexts for multi-thread
-/// stack collection.
-///
-/// This must be called from a non-signal context before any crash can occur.
-/// The previous SIGUSR2 `sigaction` is saved so the handler can chain to it.
-///
-/// Note: if the application installs its own SIGUSR2 handler after this call
-/// and does not chain to the previous action, our handler will be silently lost and
-/// thread contexts will not be captured. Applications that own SIGUSR2 should
-/// install their handler first and chain correctly, or not enable `collect_all_threads`.
-
 #[cfg(test)]
 mod tests {
     #[cfg(target_os = "linux")]