DataDog
diff --git a/‎bin_tests/src/modes/behavior.rs‎
Lines changed: 2 additions & 0 deletions b/‎bin_tests/src/modes/behavior.rs‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎bin_tests/src/modes/unix/mod.rs‎
Lines changed: 2 additions & 0 deletions b/‎bin_tests/src/modes/unix/mod.rs‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎bin_tests/src/modes/unix/test_017_multi_thread_collection.rs‎
Lines changed: 74 additions & 0 deletions b/‎bin_tests/src/modes/unix/test_017_multi_thread_collection.rs‎
Lines changed: 74 additions & 0 deletions
diff --git a/‎bin_tests/src/modes/unix/test_018_thread_limit.rs‎
Lines changed: 53 additions & 0 deletions b/‎bin_tests/src/modes/unix/test_018_thread_limit.rs‎
Lines changed: 53 additions & 0 deletions
diff --git a/‎bin_tests/src/test_types.rs‎
Lines changed: 8 additions & 0 deletions b/‎bin_tests/src/test_types.rs‎
Lines changed: 8 additions & 0 deletions
diff --git a/‎bin_tests/tests/crashtracker_bin_test.rs‎
Lines changed: 174 additions & 1 deletion b/‎bin_tests/tests/crashtracker_bin_test.rs‎
Lines changed: 174 additions & 1 deletion
@@ -138,6 +138,8 @@ pub fn get_behavior(mode_str: &str) -> Box<dyn Behavior> {
         "panic_hook_string" => Box::new(test_014_panic_hook_string::Test),
         "panic_hook_unknown_type" => Box::new(test_015_panic_hook_unknown_type::Test),
         "errno_preservation" => Box::new(test_016_errno_preservation::Test),
+        "multi_thread_collection" => Box::new(test_017_multi_thread_collection::Test),
+        "thread_limit" => Box::new(test_018_thread_limit::Test),
         "runtime_preload_logger" => Box::new(test_000_donothing::Test),
         _ => panic!("Unknown mode: {mode_str}"),
     }
 
@@ -17,3 +17,5 @@ pub mod test_013_panic_hook_after_fork;
 pub mod test_014_panic_hook_string;
 pub mod test_015_panic_hook_unknown_type;
 pub mod test_016_errno_preservation;
+pub mod test_017_multi_thread_collection;
+pub mod test_018_thread_limit;
@@ -0,0 +1,74 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Tests that the crashtracker collects stack information for all threads, not
+//! just the crashing thread.
+
+use crate::modes::behavior::Behavior;
+use libdd_crashtracker::CrashtrackerConfiguration;
+use std::path::Path;
+use std::sync::{Arc, Barrier};
+use std::thread;
+use std::time::Duration;
+
+pub struct Test;
+
+// Black box to prevent compiler optimization
+#[inline(never)]
+fn worker_fn_0() {
+    loop {
+        std::hint::black_box(0x17_00u64);
+        std::hint::spin_loop();
+    }
+}
+
+#[inline(never)]
+fn worker_fn_1() {
+    loop {
+        std::hint::black_box(0x17_01u64);
+        std::hint::spin_loop();
+    }
+}
+
+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<()> {
+        let barrier = Arc::new(Barrier::new(3));
+
+        let b0 = Arc::clone(&barrier);
+        let h0 = thread::Builder::new()
+            .name("ct_worker_0".to_string())
+            .spawn(move || {
+                b0.wait();
+                worker_fn_0();
+            })?;
+
+        let b1 = Arc::clone(&barrier);
+        let h1 = thread::Builder::new()
+            .name("ct_worker_1".to_string())
+            .spawn(move || {
+                b1.wait();
+                worker_fn_1();
+            })?;
+
+        barrier.wait();
+        thread::sleep(Duration::from_millis(20));
+
+        std::mem::forget(h0);
+        std::mem::forget(h1);
+        Ok(())
+    }
+}
@@ -0,0 +1,53 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Stress-tests thread collection by spawning 512 named worker threads and
+//! verifying the crash report contains all of them.
+
+use crate::modes::behavior::Behavior;
+use libdd_crashtracker::{default_max_threads, CrashtrackerConfiguration};
+use std::path::Path;
+use std::sync::{Arc, Barrier};
+
+pub struct Test;
+
+fn worker_fn(i: usize) {
+    std::hint::black_box(i);
+    std::thread::sleep(std::time::Duration::from_millis(1000))
+}
+
+const THREAD_COUNT: usize = default_max_threads();
+
+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(THREAD_COUNT);
+        Ok(())
+    }
+
+    fn pre(&self, _output_dir: &Path) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    fn post(&self, _output_dir: &Path) -> anyhow::Result<()> {
+        let barrier = Arc::new(Barrier::new(THREAD_COUNT + 1));
+
+        for i in 0..THREAD_COUNT {
+            let barrier = Arc::clone(&barrier);
+            std::thread::Builder::new()
+                .name(format!("worker-{i}"))
+                .spawn(move || {
+                    barrier.wait();
+                    worker_fn(i);
+                })
+                .expect("failed to spawn thread");
+        }
+
+        barrier.wait();
+        Ok(())
+    }
+}
@@ -20,6 +20,8 @@ pub enum TestMode {
     RuntimeCallbackFrameInvalidUtf8,
     RuntimePreloadLogger,
     ErrnoPreservation,
+    MultiThreadCollection,
+    ThreadLimit,
 }
 
 impl TestMode {
@@ -41,6 +43,8 @@ impl TestMode {
             Self::RuntimeCallbackFrameInvalidUtf8 => "runtime_callback_frame_invalid_utf8",
             Self::RuntimePreloadLogger => "runtime_preload_logger",
             Self::ErrnoPreservation => "errno_preservation",
+            Self::MultiThreadCollection => "multi_thread_collection",
+            Self::ThreadLimit => "thread_limit",
         }
     }
 
@@ -62,6 +66,8 @@ impl TestMode {
             Self::RuntimeCallbackFrameInvalidUtf8,
             Self::RuntimePreloadLogger,
             Self::ErrnoPreservation,
+            Self::MultiThreadCollection,
+            Self::ThreadLimit,
         ]
     }
 }
@@ -92,6 +98,8 @@ impl std::str::FromStr for TestMode {
             "runtime_callback_frame_invalid_utf8" => Ok(Self::RuntimeCallbackFrameInvalidUtf8),
             "runtime_preload_logger" => Ok(Self::RuntimePreloadLogger),
             "errno_preservation" => Ok(Self::ErrnoPreservation),
+            "multi_thread_collection" => Ok(Self::MultiThreadCollection),
+            "thread_limit" => Ok(Self::ThreadLimit),
             _ => Err(format!("Unknown test mode: {}", s)),
         }
     }
 
@@ -21,7 +21,8 @@ use bin_tests::{
     ArtifactsBuild, BuildProfile,
 };
 use libdd_crashtracker::{
-    CrashtrackerConfiguration, Metadata, SiCodes, SigInfo, SignalNames, StacktraceCollection,
+    default_max_threads, CrashtrackerConfiguration, Metadata, SiCodes, SigInfo, SignalNames,
+    StacktraceCollection,
 };
 use serde_json::Value;
 
@@ -188,6 +189,178 @@ fn test_crash_tracking_bin_runtime_callback_frame() {
     run_crash_test_with_artifacts(&config, &artifacts_map, &artifacts, validator).unwrap();
 }
 
+/// 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 (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=false`, `name`, and `stack` present.
+///   - None of the additional threads are marked as crashed (the crashing thread is in
+///     `error.stack`, not `error.threads`).
+///   - Both worker threads are present by name (ct_worker_0, ct_worker_1).
+///   - Each worker has their work frame in the stack trace.
+#[test]
+#[cfg(target_os = "linux")]
+#[cfg_attr(miri, ignore)]
+fn test_crash_tracking_multi_thread_collection() {
+    let config = CrashTestConfig::new(
+        BuildProfile::Release,
+        TestMode::MultiThreadCollection,
+        CrashType::NullDeref,
+    );
+    let artifacts = StandardArtifacts::new(config.profile);
+    let artifacts_map = fetch_built_artifacts(&artifacts.as_slice()).unwrap();
+
+    let validator: ValidatorFn = Box::new(|payload, _fixtures| {
+        let error = &payload["error"];
+        let threads = &error["threads"];
+
+        let thread_count = threads["count"]
+            .as_u64()
+            .expect("threads.count should be a number");
+        let all_threads = threads["threads"]
+            .as_array()
+            .expect("threads.threads should be a JSON array");
+
+        let thread_names: Vec<&str> = all_threads
+            .iter()
+            .map(|t| t["name"].as_str().unwrap_or("<none>"))
+            .collect();
+
+        assert!(
+            !all_threads.is_empty(),
+            "error.threads should be non-empty when collect_all_threads is enabled; got payload: {}",
+            serde_json::to_string_pretty(payload).unwrap_or_default()
+        );
+
+        // Every thread entry must be structurally valid and non-crashing
+        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:?}"
+            );
+            assert!(
+                !thread["crashed"].as_bool().unwrap_or(true),
+                "threads in error.threads must have crashed=false: {thread:?}"
+            );
+        }
+
+        // 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),
+                "Expected worker thread '{expected}' in error.threads; \
+                 got: {thread_names:?}"
+            );
+        }
+
+        for expected in ["ct_worker_0", "ct_worker_1"] {
+            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"));
+
+            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:?}"
+            );
+        }
+
+        assert!(
+            thread_count == 2,
+            "expected 2 threads, got {}",
+            thread_count
+        );
+
+        Ok(())
+    });
+
+    run_crash_test_with_artifacts(&config, &artifacts_map, &artifacts, validator).unwrap();
+}
+
+/// Spawns default max threads and verifies the crash report contains all of them.
+#[test]
+#[cfg(target_os = "linux")]
+#[cfg_attr(miri, ignore)]
+fn test_crash_tracking_thread_limit() {
+    const THREAD_COUNT: usize = default_max_threads();
+
+    let config = CrashTestConfig::new(
+        BuildProfile::Release,
+        TestMode::ThreadLimit,
+        CrashType::NullDeref,
+    );
+    let artifacts = StandardArtifacts::new(config.profile);
+    let artifacts_map = fetch_built_artifacts(&artifacts.as_slice()).unwrap();
+
+    let validator: ValidatorFn = Box::new(move |payload, _fixtures| {
+        let threads = &payload["error"]["threads"];
+
+        let thread_array = threads["threads"]
+            .as_array()
+            .expect("error.threads.threads should be a JSON array");
+        let count = threads["count"]
+            .as_u64()
+            .expect("error.threads.count should be a number") as usize;
+
+        assert!(
+            thread_array.len() >= THREAD_COUNT,
+            "expected at least {THREAD_COUNT} thread entries, got {} \
+             (count field: {})",
+            thread_array.len(),
+            count,
+        );
+        assert_eq!(
+            count,
+            thread_array.len(),
+            "threads.count ({count}) should equal the number of thread entries ({})",
+            thread_array.len(),
+        );
+
+        // All entries must be non-crashing
+        for thread in thread_array {
+            assert!(
+                !thread["crashed"].as_bool().unwrap_or(true),
+                "threads in error.threads must have crashed=false: {thread:?}"
+            );
+        }
+
+        Ok(())
+    });
+
+    run_crash_test_with_artifacts(&config, &artifacts_map, &artifacts, validator).unwrap();
+}
+
 #[test]
 #[cfg(target_os = "linux")]
 #[cfg_attr(miri, ignore)]
Original file line number	Diff line number	Diff line change
`@@ -138,6 +138,8 @@ pub fn get_behavior(mode_str: &str) -> Box<dyn Behavior> {`
`138`	`138`	`"panic_hook_string" => Box::new(test_014_panic_hook_string::Test),`
`139`	`139`	`"panic_hook_unknown_type" => Box::new(test_015_panic_hook_unknown_type::Test),`
`140`	`140`	`"errno_preservation" => Box::new(test_016_errno_preservation::Test),`
	`141`	`+ "multi_thread_collection" => Box::new(test_017_multi_thread_collection::Test),`
	`142`	`+ "thread_limit" => Box::new(test_018_thread_limit::Test),`
`141`	`143`	`"runtime_preload_logger" => Box::new(test_000_donothing::Test),`
`142`	`144`	`_ => panic!("Unknown mode: {mode_str}"),`
`143`	`145`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,8 @@ pub enum TestMode {`
`20`	`20`	`RuntimeCallbackFrameInvalidUtf8,`
`21`	`21`	`RuntimePreloadLogger,`
`22`	`22`	`ErrnoPreservation,`
	`23`	`+ MultiThreadCollection,`
	`24`	`+ ThreadLimit,`
`23`	`25`	`}`
`24`	`26`
`25`	`27`	`impl TestMode {`
`@@ -41,6 +43,8 @@ impl TestMode {`
`41`	`43`	`Self::RuntimeCallbackFrameInvalidUtf8 => "runtime_callback_frame_invalid_utf8",`
`42`	`44`	`Self::RuntimePreloadLogger => "runtime_preload_logger",`
`43`	`45`	`Self::ErrnoPreservation => "errno_preservation",`
	`46`	`+ Self::MultiThreadCollection => "multi_thread_collection",`
	`47`	`+ Self::ThreadLimit => "thread_limit",`
`44`	`48`	`}`
`45`	`49`	`}`
`46`	`50`
`@@ -62,6 +66,8 @@ impl TestMode {`
`62`	`66`	`Self::RuntimeCallbackFrameInvalidUtf8,`
`63`	`67`	`Self::RuntimePreloadLogger,`
`64`	`68`	`Self::ErrnoPreservation,`
	`69`	`+ Self::MultiThreadCollection,`
	`70`	`+ Self::ThreadLimit,`
`65`	`71`	`]`
`66`	`72`	`}`
`67`	`73`	`}`
`@@ -92,6 +98,8 @@ impl std::str::FromStr for TestMode {`
`92`	`98`	`"runtime_callback_frame_invalid_utf8" => Ok(Self::RuntimeCallbackFrameInvalidUtf8),`
`93`	`99`	`"runtime_preload_logger" => Ok(Self::RuntimePreloadLogger),`
`94`	`100`	`"errno_preservation" => Ok(Self::ErrnoPreservation),`
	`101`	`+ "multi_thread_collection" => Ok(Self::MultiThreadCollection),`
	`102`	`+ "thread_limit" => Ok(Self::ThreadLimit),`
`95`	`103`	`_ => Err(format!("Unknown test mode: {}", s)),`
`96`	`104`	`}`
`97`	`105`	`}`