feat(crashtracker): capture C assert expression in crash reports

Hook __assert_fail via GOT patching (using libdd-got-hook) during
crashtracker init. When a C assert() fails, the hook captures the
assertion expression, file, line, and function name before the
process aborts via SIGABRT. The signal handler includes this message
in the crash report.

Only supported on 64-bit Linux; no-op on other platforms.

Author: gyuheon0h

Cargo.lock

@@ -24,6 +24,40 @@ fn main() {
 
     // Make the built shared object path available at compile time for tests/tools.
     println!("cargo:rustc-env=PRELOAD_LOGGER_SO={}", so_path.display());
+
+    // --- trigger_assert static library (Linux only) ---
+    #[cfg(target_os = "linux")]
+    {
+        let assert_src = PathBuf::from("src/c/trigger_assert.c");
+        let assert_obj = out_dir.join("trigger_assert.o");
+        let assert_lib = out_dir.join("libtrigger_assert.a");
+
+        let status = Command::new("cc")
+            .args([
+                "-std=c11", "-fPIC", "-UNDEBUG", "-Wall", "-Wextra", "-c", "-o",
+            ])
+            .arg(&assert_obj)
+            .arg(&assert_src)
+            .status()
+            .expect("failed to compile trigger_assert.c");
+        if !status.success() {
+            panic!("compiling trigger_assert.c failed with status {status}");
+        }
+
+        let status = Command::new("ar")
+            .args(["rcs"])
+            .arg(&assert_lib)
+            .arg(&assert_obj)
+            .status()
+            .expect("failed to run ar");
+        if !status.success() {
+            panic!("creating libtrigger_assert.a failed with status {status}");
+        }
+
+        println!("cargo:rustc-link-search=native={}", out_dir.display());
+        println!("cargo:rustc-link-lib=static=trigger_assert");
+        println!("cargo:rerun-if-changed=src/c/trigger_assert.c");
+    }
 }
 
 #[cfg(not(unix))]

bin_tests/build.rs

@@ -158,6 +158,15 @@ mod unix {
             "raise_sigill" => raise(Signal::SIGILL)?,
             "raise_sigbus" => raise(Signal::SIGBUS)?,
             "raise_sigsegv" => raise(Signal::SIGSEGV)?,
+            #[cfg(target_os = "linux")]
+            "assert_fail" => {
+                extern "C" {
+                    fn trigger_c_assert() -> !;
+                }
+                // SAFETY: trigger_c_assert calls the real C assert() macro,
+                // which expands to __assert_fail and never returns.
+                unsafe { trigger_c_assert() }
+            }
             "unhandled_exception" => {
                 let mut stacktrace = StackTrace::new_incomplete();
                 let mut stackframe1 = StackFrame::new();

bin_tests/src/bin/crashtracker_bin_test.rs

@@ -0,0 +1,13 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+// Calls the real C assert() macro so that the GOT hook is exercised
+// through the same code path as a genuine assertion failure.
+// NDEBUG must NOT be defined, otherwise assert() compiles to nothing.
+#undef NDEBUG
+#include <assert.h>
+
+void trigger_c_assert(void) {
+    int test_value = 0;
+    assert(test_value > 0);
+}

bin_tests/src/c/trigger_assert.c

@@ -140,6 +140,8 @@ pub enum CrashType {
     RaiseSigSegv,
     /// Unhandled Exception
     UnhandledException,
+    /// C assert() failure (calls __assert_fail, triggers SIGABRT)
+    AssertFail,
 }
 
 impl CrashType {
@@ -156,6 +158,7 @@ impl CrashType {
             Self::RaiseSigBus => "raise_sigbus",
             Self::RaiseSigSegv => "raise_sigsegv",
             Self::UnhandledException => "unhandled_exception",
+            Self::AssertFail => "assert_fail",
         }
     }
 
@@ -178,7 +181,7 @@ impl CrashType {
     pub const fn signal_number(self) -> i32 {
         match self {
             Self::NullDeref | Self::KillSigSegv | Self::RaiseSigSegv => 11, // SIGSEGV
-            Self::KillSigAbrt | Self::RaiseSigAbrt => 6,                    // SIGABRT
+            Self::KillSigAbrt | Self::RaiseSigAbrt | Self::AssertFail => 6, // SIGABRT
             Self::KillSigIll | Self::RaiseSigIll => 4,                      // SIGILL
             Self::KillSigBus | Self::RaiseSigBus => 7,                      // SIGBUS
             Self::UnhandledException => 0,                                  // no signal
@@ -189,7 +192,7 @@ impl CrashType {
     pub const fn signal_name(self) -> &'static str {
         match self {
             Self::NullDeref | Self::KillSigSegv | Self::RaiseSigSegv => "SIGSEGV",
-            Self::KillSigAbrt | Self::RaiseSigAbrt => "SIGABRT",
+            Self::KillSigAbrt | Self::RaiseSigAbrt | Self::AssertFail => "SIGABRT",
             Self::KillSigIll | Self::RaiseSigIll => "SIGILL",
             Self::KillSigBus | Self::RaiseSigBus => "SIGBUS",
             Self::UnhandledException => "Unhandled Exception",
@@ -218,6 +221,7 @@ impl std::str::FromStr for CrashType {
             "raise_sigbus" => Ok(Self::RaiseSigBus),
             "raise_sigsegv" => Ok(Self::RaiseSigSegv),
             "unhandled_exception" => Ok(Self::UnhandledException),
+            "assert_fail" => Ok(Self::AssertFail),
             _ => Err(format!("Unknown crash type: {}", s)),
         }
     }

bin_tests/src/test_types.rs

@@ -160,6 +160,44 @@ fn test_crash_tracking_bin_unhandled_exception() {
     run_crash_test_with_artifacts(&config, &artifacts_map, &artifacts, validator).unwrap();
 }
 
+/// Tests that when a C `assert()` fails, the crash report contains the assertion
+/// expression string in the error message.
+#[test]
+#[cfg(target_os = "linux")]
+#[cfg_attr(miri, ignore)]
+fn test_crash_tracking_bin_assert_fail() {
+    let config = CrashTestConfig::new(
+        BuildProfile::Release,
+        TestMode::DoNothing,
+        CrashType::AssertFail,
+    );
+    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("UnixSignal")?
+            // The assertion expression from the real C assert() macro
+            .validate_error_message_contains("test_value > 0")?
+            // The function name comes from the C compiler's __func__
+            .validate_error_message_contains("trigger_c_assert")?;
+
+        // Validate SIGABRT signal info
+        let sig_info = &payload["sig_info"];
+        let signo_hr = sig_info["si_signo_human_readable"].as_str().unwrap_or("");
+        anyhow::ensure!(
+            signo_hr.contains("SIGABRT"),
+            "Expected SIGABRT in signal info, got: {signo_hr}"
+        );
+
+        validate_telemetry(&fixtures.crash_telemetry_path, "assert_fail")?;
+
+        Ok(())
+    });
+
+    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.
@@ -1772,6 +1810,10 @@ fn assert_siginfo_message(sig_info: &Value, crash_typ: &str) {
                     || sig_info.is_object() && sig_info.as_object().is_none_or(|m| m.is_empty())
             );
         }
+        "assert_fail" => {
+            assert_eq!(sig_info["si_signo"], libc::SIGABRT);
+            assert_eq!(sig_info["si_signo_human_readable"], "SIGABRT");
+        }
         _ => panic!("unexpected crash_typ {crash_typ}"),
     }
 }
@@ -1906,6 +1948,10 @@ fn assert_telemetry_message(crash_telemetry: &[u8], crash_typ: &str) {
         "unhandled_exception" => {
             // Unhandled exceptions have no signal info tags
         }
+        "assert_fail" => {
+            assert!(tags.contains("si_signo_human_readable:SIGABRT"), "{tags:?}");
+            assert!(tags.contains("si_signo:6"), "{tags:?}");
+        }
         _ => panic!("{crash_typ}"),
     }
 

bin_tests/tests/crashtracker_bin_test.rs

@@ -41,6 +41,9 @@ cxx = ["dep:cxx", "dep:cxx-build"]
 # Should be kept in sync with the libdatadog symbolizer crate (also using blasesym)
 blazesym = "=0.2.3"
 
+[target.'cfg(all(target_os = "linux", target_pointer_width = "64"))'.dependencies]
+libdd-got-hook = { version = "1.0.0", path = "../libdd-got-hook" }
+
 [target.'cfg(target_os = "linux")'.dependencies]
 libdd-libunwind-sys = { version = "1.0.2" }
 

libdd-crashtracker/Cargo.toml

@@ -86,6 +86,7 @@ pub fn init(
     Receiver::update_stored_config(receiver_config)?;
     register_crash_handlers(&config)?;
     register_panic_hook()?;
+    super::assert_interceptor::install_assert_hook();
     enable();
     Ok(())
 }