feat(crashtracking): collect all native stacks for unhandled exception and also crashing thread (#2155)

# What does this PR do?

Previously, when a runtime reported an unhandled exception, only the
runtime-provided stack trace was captured; no native stacks were
collected for any thread because `PR_SET_PTRACER` was not set for
unhandled exceptions. Additionally, when all-thread collection was
enabled for signal-based crashes, the crashing thread was excluded from
the threads array.

This change:
1. Enables native stack collection for all threads (including the
crashing thread) when reporting unhandled exceptions with
`collect_all_threads` enabled. The receiver now has the necessary ptrace
permissions to unwind every thread in the process.
2. Includes the crashing thread in the `error.threads` array (marked
with `crashed: true`) for both signal-based crashes and unhandled
exceptions. Its native stack is collected by the receiver using ptrace,
same as every other thread.

The runtime-provided stack remains in `error.stack` as the canonical
crash context, while `error.threads` provides a uniform native view of
all threads at the time of the crash.

This gives us two immediate benefits:
1. Unhandled exception crash reports now include native stacks for all
threads, providing visibility into what the process was doing at the OS
level; not just the managed runtime view.
2. The crashing thread's native stack is now collected in the receiver
alongside all other threads, establishing a path toward consolidating
all stack collection in the receiver process in the future.

# Motivation

What inspired you to submit this pull request?

# Additional Notes

Anything else we should know when reviewing?

# How to test the change?

Describe here in detail how the change can be validated.

Author: gyuheon0h

bin_tests/src/bin/crashtracker_bin_test.rs

@@ -161,12 +161,10 @@ mod unix {
             "unhandled_exception" => {
                 let mut stacktrace = StackTrace::new_incomplete();
                 let mut stackframe1 = StackFrame::new();
-                stackframe1.with_ip(1234);
                 stackframe1.with_function("test_function1".to_string());
                 stackframe1.with_file("test_file1".to_string());
 
                 let mut stackframe2 = StackFrame::new();
-                stackframe2.with_ip(5678);
                 stackframe2.with_function("test_function2".to_string());
                 stackframe2.with_file("test_file2".to_string());
 

bin_tests/src/modes/behavior.rs

@@ -144,6 +144,9 @@ pub fn get_behavior(mode_str: &str) -> Box<dyn Behavior> {
         "sidecar_multi_thread_collection" => {
             Box::new(test_020_sidecar_multi_thread_collection::Test)
         }
+        "unhandled_exception_multi_thread" => {
+            Box::new(test_021_unhandled_exception_multi_thread::Test)
+        }
         "runtime_preload_logger" => Box::new(test_000_donothing::Test),
         _ => panic!("Unknown mode: {mode_str}"),
     }

bin_tests/src/modes/unix/mod.rs

@@ -21,3 +21,4 @@ pub mod test_017_multi_thread_collection;
 pub mod test_018_thread_limit;
 pub mod test_019_sidecar_donothing;
 pub mod test_020_sidecar_multi_thread_collection;
+pub mod test_021_unhandled_exception_multi_thread;

bin_tests/src/modes/unix/test_018_thread_limit.rs

@@ -34,9 +34,10 @@ impl Behavior for Test {
     }
 
     fn post(&self, _output_dir: &Path) -> anyhow::Result<()> {
-        let barrier = Arc::new(Barrier::new(THREAD_COUNT + 1));
+        let barrier = Arc::new(Barrier::new(THREAD_COUNT));
 
-        for i in 0..THREAD_COUNT {
+        // Make space for the crashing thread
+        for i in 0..(THREAD_COUNT - 1) {
             let barrier = Arc::clone(&barrier);
             std::thread::Builder::new()
                 .name(format!("worker-{i}"))

bin_tests/src/modes/unix/test_021_unhandled_exception_multi_thread.rs

@@ -0,0 +1,76 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Tests that the crashtracker collects stack information for all threads when
+//! reporting an unhandled exception (not just signal-based crashes).
+
+use crate::modes::behavior::Behavior;
+use libdd_crashtracker::CrashtrackerConfiguration;
+use std::path::Path;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::thread;
+use std::time::{Duration, Instant};
+
+pub struct Test;
+
+impl Behavior for Test {
+    fn setup(
+        &self,
+        _output_dir: &Path,
+        config: &mut CrashtrackerConfiguration,
+    ) -> anyhow::Result<()> {
+        config.set_collect_all_threads(true);
+        config.set_max_threads(32);
+        Ok(())
+    }
+
+    fn pre(&self, _output_dir: &Path) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    fn post(&self, _output_dir: &Path) -> anyhow::Result<()> {
+        static WORKER_0_READY: AtomicBool = AtomicBool::new(false);
+        static WORKER_1_READY: AtomicBool = AtomicBool::new(false);
+
+        #[inline(never)]
+        fn worker_fn_0() {
+            WORKER_0_READY.store(true, Ordering::Relaxed);
+            loop {
+                std::hint::black_box(0x21_00u64);
+                std::hint::spin_loop();
+            }
+        }
+
+        #[inline(never)]
+        fn worker_fn_1() {
+            WORKER_1_READY.store(true, Ordering::Relaxed);
+            loop {
+                std::hint::black_box(0x21_01u64);
+                std::hint::spin_loop();
+            }
+        }
+
+        WORKER_0_READY.store(false, Ordering::Relaxed);
+        WORKER_1_READY.store(false, Ordering::Relaxed);
+
+        let h0 = thread::Builder::new()
+            .name("ct_worker_0".to_string())
+            .spawn(worker_fn_0)?;
+
+        let h1 = thread::Builder::new()
+            .name("ct_worker_1".to_string())
+            .spawn(worker_fn_1)?;
+
+        let deadline = Instant::now() + Duration::from_secs(5);
+        while !WORKER_0_READY.load(Ordering::Acquire) || !WORKER_1_READY.load(Ordering::Acquire) {
+            if Instant::now() >= deadline {
+                panic!("Workers did not reach spin loop within 5s");
+            }
+            thread::yield_now();
+        }
+
+        std::mem::forget(h0);
+        std::mem::forget(h1);
+        Ok(())
+    }
+}

bin_tests/src/test_types.rs

@@ -24,6 +24,7 @@ pub enum TestMode {
     ThreadLimit,
     SidecarDoNothing,
     SidecarMultiThreadCollection,
+    UnhandledExceptionMultiThread,
 }
 
 impl TestMode {
@@ -49,6 +50,7 @@ impl TestMode {
             Self::ThreadLimit => "thread_limit",
             Self::SidecarDoNothing => "sidecar_donothing",
             Self::SidecarMultiThreadCollection => "sidecar_multi_thread_collection",
+            Self::UnhandledExceptionMultiThread => "unhandled_exception_multi_thread",
         }
     }
 
@@ -74,6 +76,7 @@ impl TestMode {
             Self::ThreadLimit,
             Self::SidecarDoNothing,
             Self::SidecarMultiThreadCollection,
+            Self::UnhandledExceptionMultiThread,
         ]
     }
 }
@@ -108,6 +111,7 @@ impl std::str::FromStr for TestMode {
             "thread_limit" => Ok(Self::ThreadLimit),
             "sidecar_donothing" => Ok(Self::SidecarDoNothing),
             "sidecar_multi_thread_collection" => Ok(Self::SidecarMultiThreadCollection),
+            "unhandled_exception_multi_thread" => Ok(Self::UnhandledExceptionMultiThread),
             _ => Err(format!("Unknown test mode: {}", s)),
         }
     }

bin_tests/tests/crashtracker_bin_test.rs

@@ -159,6 +159,115 @@ fn test_crash_tracking_bin_unhandled_exception() {
     run_crash_test_with_artifacts(&config, &artifacts_map, &artifacts, validator).unwrap();
 }
 
+/// Tests that when `collect_all_threads` is enabled and the crash is reported via
+/// `report_unhandled_exception`, the crash report contains entries in `error.threads`
+/// for background threads with valid stack traces.
+///
+/// This verifies that `PR_SET_PTRACER` is correctly called in the unhandled exception
+/// path so the receiver can ptrace the still-alive parent process.
+#[test]
+#[cfg(target_os = "linux")]
+#[cfg_attr(miri, ignore)]
+fn test_crash_tracking_bin_unhandled_exception_multi_thread() {
+    let config = CrashTestConfig::new(
+        BuildProfile::Release,
+        TestMode::UnhandledExceptionMultiThread,
+        CrashType::UnhandledException,
+    );
+    let artifacts = StandardArtifacts::new(config.profile);
+    let artifacts_map = fetch_built_artifacts(&artifacts.as_slice()).unwrap();
+
+    let validator: ValidatorFn = Box::new(|payload, _fixtures| {
+        PayloadValidator::new(payload)
+            .validate_error_kind("UnhandledException")?
+            .validate_error_message_contains(
+                "Process was terminated due to an unhandled exception of type 'RuntimeException'",
+            )?;
+
+        let all_threads = payload["error"]["threads"]
+            .as_array()
+            .expect("error.threads should be a JSON array of thread objects");
+
+        assert!(
+            all_threads.len() >= 3,
+            "error.threads should contain at least 3 threads (1 crashed + 2 workers); got {} in payload: {}",
+            all_threads.len(),
+            serde_json::to_string_pretty(payload).unwrap_or_default()
+        );
+
+        let thread_names: Vec<&str> = all_threads
+            .iter()
+            .map(|t| t["name"].as_str().unwrap_or("<none>"))
+            .collect();
+
+        let crashed_threads: Vec<_> = all_threads
+            .iter()
+            .filter(|t| t["crashed"].as_bool() == Some(true))
+            .collect();
+        assert_eq!(
+            crashed_threads.len(),
+            1,
+            "exactly one thread should have crashed=true; got: {crashed_threads:?}"
+        );
+
+        for thread in all_threads {
+            assert!(
+                thread["name"].is_string(),
+                "thread entry missing 'name': {thread:?}"
+            );
+            assert!(
+                thread["crashed"].is_boolean(),
+                "thread entry missing 'crashed': {thread:?}"
+            );
+            assert!(
+                thread["stack"].is_object(),
+                "thread entry missing 'stack': {thread:?}"
+            );
+        }
+
+        for expected in ["ct_worker_0", "ct_worker_1"] {
+            assert!(
+                thread_names.contains(&expected),
+                "Expected worker thread '{expected}' in error.threads; got: {thread_names:?}"
+            );
+
+            let worker = all_threads
+                .iter()
+                .find(|t| t["name"].as_str() == Some(expected))
+                .unwrap_or_else(|| panic!("{expected} should be in threads"));
+
+            let frames = worker["stack"]["frames"]
+                .as_array()
+                .unwrap_or_else(|| panic!("{expected} stack.frames should be an array"));
+
+            assert!(
+                !frames.is_empty(),
+                "{expected} should have non-empty stack frames (ptrace should succeed with PR_SET_PTRACER)"
+            );
+
+            let worker_fn = if expected == "ct_worker_0" {
+                "worker_fn_0"
+            } else {
+                "worker_fn_1"
+            };
+            let has_worker_frame = frames.iter().any(|f| {
+                f["function"]
+                    .as_str()
+                    .map(|name| name.contains(worker_fn))
+                    .unwrap_or(false)
+            });
+            assert!(
+                has_worker_frame,
+                "{expected} stack should contain a frame for '{worker_fn}' but got: {frames:?}"
+            );
+        }
+
+        Ok(())
+    });
+
+    run_crash_test_with_artifacts(&config, &artifacts_map, &artifacts, validator).unwrap();
+}
+
 #[test]
 #[cfg_attr(miri, ignore)]
 fn test_crash_tracking_bin_runtime_callback_frame() {
@@ -189,7 +298,7 @@ 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.
+/// entries in `error.threads` for all threads including the crashing 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.
@@ -200,8 +309,8 @@ fn test_crash_tracking_bin_runtime_callback_frame() {
 ///
 /// We verify:
 ///   - `error.threads` is a non-empty array of thread objects.
-///   - Each thread entry is well-formed: `crashed=false`, `name`, and `stack` present.
-///   - The crashing thread stack is in `error.stack`, not `error.threads`.
+///   - Each thread entry is well-formed: `crashed`, `name`, and `stack` present.
+///   - Exactly one thread has `crashed=true` (the crashing thread).
 ///   - Both worker threads are present by name (ct_worker_0, ct_worker_1).
 ///   - Each worker has their work frame in the stack trace.
 #[test]
@@ -220,10 +329,9 @@ fn test_crash_tracking_multi_thread_collection() {
         let all_threads = payload["error"]["threads"]
             .as_array()
             .expect("error.threads should be a JSON array of thread objects");
-
         assert!(
-            all_threads.len() >= 2,
-            "error.threads should be non-empty when collect_all_threads is enabled; got payload: {}",
+            all_threads.len() >= 3,
+            "error.threads should contain at least 3 threads (1 crashed + 2 workers); got payload: {}",
             serde_json::to_string_pretty(payload).unwrap_or_default()
         );
 
@@ -232,6 +340,16 @@ fn test_crash_tracking_multi_thread_collection() {
             .map(|t| t["name"].as_str().unwrap_or("<none>"))
             .collect();
 
+        let crashed_threads: Vec<_> = all_threads
+            .iter()
+            .filter(|t| t["crashed"].as_bool() == Some(true))
+            .collect();
+        assert_eq!(
+            crashed_threads.len(),
+            1,
+            "exactly one thread should have crashed=true; got: {crashed_threads:?}"
+        );
+
         for thread in all_threads {
             assert!(
                 thread["name"].is_string(),
@@ -245,10 +363,6 @@ fn test_crash_tracking_multi_thread_collection() {
                 thread["stack"].is_object(),
                 "thread entry missing 'stack': {thread:?}"
             );
-            assert!(
-                !thread["crashed"].as_bool().unwrap_or(true),
-                "threads in error.threads must have crashed=false: {thread:?}"
-            );
         }
 
         for expected in ["ct_worker_0", "ct_worker_1"] {
@@ -312,11 +426,22 @@ fn test_crash_tracking_thread_limit() {
             .expect("error.threads should be a JSON array of thread objects");
 
         assert!(
-            thread_array.len() >= THREAD_COUNT,
-            "expected at least {THREAD_COUNT} thread entries, got {}",
+            thread_array.len() == THREAD_COUNT,
+            "expected {} thread entries ({THREAD_COUNT} workers), got {}",
+            THREAD_COUNT,
             thread_array.len(),
         );
 
+        let crashed_threads: Vec<_> = thread_array
+            .iter()
+            .filter(|t| t["crashed"].as_bool() == Some(true))
+            .collect();
+        assert_eq!(
+            crashed_threads.len(),
+            1,
+            "exactly one thread should have crashed=true; got: {crashed_threads:?}"
+        );
+
         for thread in thread_array {
             assert!(
                 thread["name"].is_string(),
@@ -330,10 +455,6 @@ fn test_crash_tracking_thread_limit() {
                 thread["stack"].is_object(),
                 "thread entry missing 'stack': {thread:?}"
             );
-            assert!(
-                !thread["crashed"].as_bool().unwrap_or(true),
-                "threads in error.threads must have crashed=false: {thread:?}"
-            );
         }
 
         Ok(())
@@ -529,8 +650,8 @@ fn test_crash_tracking_sidecar_multi_thread_collection() {
     let all_threads = all_threads.unwrap();
 
     assert!(
-        all_threads.len() >= 2,
-        "error.threads should have at least 2 entries (sidecar multi-thread); got {}: {}",
+        all_threads.len() >= 3,
+        "error.threads should have at least 3 entries (1 crashed + 2 workers, sidecar multi-thread); got {}: {}",
         all_threads.len(),
         serde_json::to_string_pretty(&crash_payload).unwrap_or_default()
     );