fix(crashtracker): support socket based receiver for all thread collection (#2080)

# What does this PR do?

In [crash_handler.rs](https://github.com/DataDog/libdatadog/blob/582bee193e6f4688fa546ca0b3e3b382de672538/libdd-crashtracker/src/collector/crash_handler.rs#L308-L315), PR_SET_PTRACER is only called when receiver.handle.pid is `Some`:

```
if let Some(receiver_pid) = receiver.handle.pid {
        unsafe {
            libc::prctl(libc::PR_SET_PTRACER, receiver_pid as libc::c_ulong);
        }
    }
```

PHP connects to a pre-existing sidecar process [using a Unix socket](https://github.com/DataDog/dd-trace-php/blob/991880e2016965f09bc0093e10537737d283f121/ext/signals.c#L281-L289) (`optional_unix_socket_filename`). 


[In receiver_manager.rs](https://github.com/DataDog/libdatadog/blob/582bee193e6f4688fa546ca0b3e3b382de672538/libdd-crashtracker/src/collector/receiver_manager.rs#L64-L66), the from_socket() path creates a ProcessHandle with pid: None:
```
Ok(Self {
    handle: ProcessHandle::new(uds_fd, None),
})
```

If `ptrace_scope=1`, since pid is `None`, `PR_SET_PTRACER` is never called. The sidecar then cannot ptrace the crashed process's threads.


The fix is to resolve the peer process's PID using `getsockopt(SO_PEERCRED)` on the Unix socket fd, then call `PR_SET_PTRACER` with that PID.


# Motivation

I noticed that all PHP crash reports (schema 1.7) have [error.threads with 0 frames per thread.](https://app.datadoghq.com/logs?query=source%3Aphp%20data_schema_version%3A1.7&agg_m=count&agg_m_source=base&agg_t=count&clustering_pattern_field_path=message&cols=host%2Cservice&messageDisplay=inline&refresh_mode=paused&storage=hot&stream_sort=desc&viz=stream&from_ts=1780372800000&to_ts=1780545599999&live=false) Thread names are present (`ddprof_time`, `ddprof_upload`), but stacks are empty with incomplete: false. This affects 100% of PHP crashes. Ruby and Python are unaffected.


# Additional Notes

Anything else we should know when reviewing?

# How to test the change?

Describe here in detail how the change can be validated.


Co-authored-by: gyuheon.oh <gyuheon.oh@datadoghq.com>

Author: gyuheon0h

bin_tests/Cargo.toml

@@ -52,6 +52,10 @@ bench = false
 name = "crashing_test_app"
 bench = false
 
+[[bin]]
+name = "crashtracker_unix_socket_receiver"
+bench = false
+
 [[bin]]
 name = "prebuild"
 path = "src/bin/prebuild.rs"

bin_tests/src/artifacts.rs

@@ -39,6 +39,16 @@ pub fn crashing_app(profile: BuildProfile, panic_abort: bool) -> ArtifactsBuild
     }
 }
 
+/// Creates an ArtifactsBuild for the Unix socket receiver binary (sidecar-style).
+pub fn crashtracker_unix_socket_receiver(profile: BuildProfile) -> ArtifactsBuild {
+    ArtifactsBuild {
+        name: "crashtracker_unix_socket_receiver".to_owned(),
+        build_profile: profile,
+        artifact_type: ArtifactType::Bin,
+        ..Default::default()
+    }
+}
+
 /// Creates an ArtifactsBuild for the test_the_tests binary.
 pub fn test_the_tests(profile: BuildProfile) -> ArtifactsBuild {
     ArtifactsBuild {
@@ -87,6 +97,7 @@ pub fn all_prebuild_artifacts() -> Vec<ArtifactsBuild> {
     for profile in [BuildProfile::Debug, BuildProfile::Release] {
         artifacts.push(crashtracker_bin_test(profile, false));
         artifacts.push(crashtracker_receiver(profile));
+        artifacts.push(crashtracker_unix_socket_receiver(profile));
         artifacts.push(test_the_tests(profile));
         artifacts.push(profiling_ffi(profile));
         artifacts.push(crashing_app(profile, false));

bin_tests/src/bin/crashtracker_unix_socket_receiver.rs

@@ -0,0 +1,16 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Sidecar-style crashtracker receiver that listens on a Unix socket.
+//! Used by integration tests to verify the socket-based receiver path
+
+#[cfg(not(unix))]
+fn main() {}
+
+#[cfg(unix)]
+fn main() -> anyhow::Result<()> {
+    let socket_path = std::env::args()
+        .nth(1)
+        .expect("usage: crashtracker_unix_socket_receiver <socket_path>");
+    libdd_crashtracker::receiver_entry_point_unix_socket(&socket_path)
+}

bin_tests/src/modes/behavior.rs

@@ -140,6 +140,10 @@ pub fn get_behavior(mode_str: &str) -> Box<dyn Behavior> {
         "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),
+        "sidecar_donothing" => Box::new(test_019_sidecar_donothing::Test),
+        "sidecar_multi_thread_collection" => {
+            Box::new(test_020_sidecar_multi_thread_collection::Test)
+        }
         "runtime_preload_logger" => Box::new(test_000_donothing::Test),
         _ => panic!("Unknown mode: {mode_str}"),
     }

bin_tests/src/modes/unix/mod.rs

@@ -19,3 +19,5 @@ 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;
+pub mod test_019_sidecar_donothing;
+pub mod test_020_sidecar_multi_thread_collection;

bin_tests/src/modes/unix/test_019_sidecar_donothing.rs

@@ -0,0 +1,33 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Baseline crash test using a sidecar (Unix socket) receiver instead of fork/exec.
+//! The socket path is passed using the DD_TEST_UNIX_SOCKET_PATH env var, which
+//! the integration test sets after spawning the receiver process.
+
+use crate::modes::behavior::Behavior;
+use libdd_crashtracker::CrashtrackerConfiguration;
+use std::path::Path;
+
+pub struct Test;
+
+impl Behavior for Test {
+    fn setup(
+        &self,
+        _output_dir: &Path,
+        config: &mut CrashtrackerConfiguration,
+    ) -> anyhow::Result<()> {
+        let socket_path = std::env::var("DD_TEST_UNIX_SOCKET_PATH")
+            .expect("DD_TEST_UNIX_SOCKET_PATH must be set for sidecar tests");
+        config.set_unix_socket_path(socket_path);
+        Ok(())
+    }
+
+    fn pre(&self, _output_dir: &Path) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    fn post(&self, _output_dir: &Path) -> anyhow::Result<()> {
+        Ok(())
+    }
+}

bin_tests/src/modes/unix/test_020_sidecar_multi_thread_collection.rs

@@ -0,0 +1,77 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Multi-thread collection test using a sidecar (Unix socket) receiver.
+//! Combines the sidecar receiver path (SO_PEERCRED for PR_SET_PTRACER) with
+//! collect_all_threads to verify that ptrace works across non-descendant processes.
+
+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;
+
+#[inline(never)]
+fn worker_fn_0() {
+    loop {
+        std::hint::black_box(0x20_00u64);
+        std::hint::spin_loop();
+    }
+}
+
+#[inline(never)]
+fn worker_fn_1() {
+    loop {
+        std::hint::black_box(0x20_01u64);
+        std::hint::spin_loop();
+    }
+}
+
+impl Behavior for Test {
+    fn setup(
+        &self,
+        _output_dir: &Path,
+        config: &mut CrashtrackerConfiguration,
+    ) -> anyhow::Result<()> {
+        let socket_path = std::env::var("DD_TEST_UNIX_SOCKET_PATH")
+            .expect("DD_TEST_UNIX_SOCKET_PATH must be set for sidecar tests");
+        config.set_unix_socket_path(socket_path);
+        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(())
+    }
+}

bin_tests/src/test_types.rs

@@ -22,6 +22,8 @@ pub enum TestMode {
     ErrnoPreservation,
     MultiThreadCollection,
     ThreadLimit,
+    SidecarDoNothing,
+    SidecarMultiThreadCollection,
 }
 
 impl TestMode {
@@ -45,6 +47,8 @@ impl TestMode {
             Self::ErrnoPreservation => "errno_preservation",
             Self::MultiThreadCollection => "multi_thread_collection",
             Self::ThreadLimit => "thread_limit",
+            Self::SidecarDoNothing => "sidecar_donothing",
+            Self::SidecarMultiThreadCollection => "sidecar_multi_thread_collection",
         }
     }
 
@@ -68,6 +72,8 @@ impl TestMode {
             Self::ErrnoPreservation,
             Self::MultiThreadCollection,
             Self::ThreadLimit,
+            Self::SidecarDoNothing,
+            Self::SidecarMultiThreadCollection,
         ]
     }
 }
@@ -100,6 +106,8 @@ impl std::str::FromStr for TestMode {
             "errno_preservation" => Ok(Self::ErrnoPreservation),
             "multi_thread_collection" => Ok(Self::MultiThreadCollection),
             "thread_limit" => Ok(Self::ThreadLimit),
+            "sidecar_donothing" => Ok(Self::SidecarDoNothing),
+            "sidecar_multi_thread_collection" => Ok(Self::SidecarMultiThreadCollection),
             _ => Err(format!("Unknown test mode: {}", s)),
         }
     }