First pass, need to isolate only collector from test harness

Author: gyuheon0h

bin_tests/Cargo.toml

@@ -6,6 +6,7 @@ name = "bin_tests"
 version = "0.1.0"
 edition = "2021"
 publish = false
+build = "build.rs"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

bin_tests/build.rs

@@ -0,0 +1,30 @@
+// Copyright 2025-Present Datadog, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+#[cfg(unix)]
+fn main() {
+    use std::env;
+    use std::path::PathBuf;
+    use std::process::Command;
+
+    let out_dir = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR not set"));
+    let src = PathBuf::from("preload/malloc_logger.c");
+    let so_path = out_dir.join("libmalloc_logger.so");
+
+    let status = Command::new("cc")
+        .args(["-fPIC", "-shared", "-Wall", "-Wextra", "-o"])
+        .arg(&so_path)
+        .arg(&src)
+        .status()
+        .expect("failed to spawn cc");
+
+    if !status.success() {
+        panic!("compiling malloc_logger.c failed with status {status}");
+    }
+
+    // Make the built shared object path available at compile time for tests/tools.
+    println!("cargo:rustc-env=MALLOC_LOGGER_SO={}", so_path.display());
+}
+
+#[cfg(not(unix))]
+fn main() {}

bin_tests/preload/malloc_logger.c

@@ -0,0 +1,129 @@
+#define _GNU_SOURCE
+#include <dlfcn.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+static void *(*real_malloc)(size_t) = NULL;
+static void (*real_free)(void *) = NULL;
+static void *(*real_calloc)(size_t, size_t) = NULL;
+static void *(*real_realloc)(void *, size_t) = NULL;
+static int log_fd = -1;
+static pthread_once_t init_once = PTHREAD_ONCE_INIT;
+
+static int is_enabled(void) {
+    const char *v = getenv("MALLOC_LOG_ENABLED");
+    return v && v[0] == '1';
+}
+
+static void init_logger(void) {
+    const char *path = getenv("MALLOC_LOG_PATH");
+    if (path == NULL || path[0] == '\0') {
+        path = "/tmp/malloc_logger.log";
+    }
+
+    log_fd = open(path, O_CREAT | O_WRONLY | O_TRUNC, 0644);
+    real_malloc = dlsym(RTLD_NEXT, "malloc");
+    real_free = dlsym(RTLD_NEXT, "free");
+    real_calloc = dlsym(RTLD_NEXT, "calloc");
+    real_realloc = dlsym(RTLD_NEXT, "realloc");
+
+    // No logging here; deferred until enabled.
+}
+
+__attribute__((constructor)) static void preload_ctor(void) {
+    pthread_once(&init_once, init_logger);
+}
+
+__attribute__((destructor)) static void preload_dtor(void) {
+    if (log_fd >= 0) {
+        close(log_fd);
+    }
+}
+
+static void log_line(const char *tag, size_t size, void *ptr) {
+    if (log_fd < 0) {
+        return;
+    }
+
+    if (!is_enabled()) {
+        return;
+    }
+
+    char buf[200];
+    pid_t pid = getpid();
+    long tid = syscall(SYS_gettid);
+    int len;
+
+    if (strcmp(tag, "malloc") == 0) {
+        len = snprintf(buf, sizeof(buf), "pid=%d tid=%ld malloc size=%zu ptr=%p\n", pid, tid, size, ptr);
+    } else if (strcmp(tag, "calloc") == 0) {
+        len = snprintf(buf, sizeof(buf), "pid=%d tid=%ld calloc size=%zu ptr=%p\n", pid, tid, size, ptr);
+    } else if (strcmp(tag, "realloc") == 0) {
+        len = snprintf(buf, sizeof(buf), "pid=%d tid=%ld realloc size=%zu ptr=%p\n", pid, tid, size, ptr);
+    } else { // free
+        len = snprintf(buf, sizeof(buf), "pid=%d tid=%ld free ptr=%p\n", pid, tid, ptr);
+    }
+
+    if (len > 0) {
+        (void)write(log_fd, buf, (size_t)len);
+    }
+}
+
+void *malloc(size_t size) {
+    pthread_once(&init_once, init_logger);
+
+    if (real_malloc == NULL) {
+        errno = ENOMEM;
+        return NULL;
+    }
+
+    void *ptr = real_malloc(size);
+    log_line("malloc", size, ptr);
+    return ptr;
+}
+
+void free(void *ptr) {
+    pthread_once(&init_once, init_logger);
+
+    if (real_free == NULL) {
+        return;
+    }
+
+    log_line("free", 0, ptr);
+    real_free(ptr);
+}
+
+void *calloc(size_t nmemb, size_t size) {
+    pthread_once(&init_once, init_logger);
+
+    if (real_calloc == NULL) {
+        errno = ENOMEM;
+        return NULL;
+    }
+
+    void *ptr = real_calloc(nmemb, size);
+    log_line("calloc", nmemb * size, ptr);
+    return ptr;
+}
+
+void *realloc(void *ptr, size_t size) {
+    pthread_once(&init_once, init_logger);
+
+    if (real_realloc == NULL) {
+        errno = ENOMEM;
+        return NULL;
+    }
+
+    void *new_ptr = real_realloc(ptr, size);
+    log_line("realloc", size, new_ptr);
+    return new_ptr;
+}

bin_tests/src/bin/crashtracker_bin_test.rs

@@ -19,6 +19,7 @@ mod unix {
     };
     use std::env;
     use std::path::Path;
+    use std::process;
     use std::time::Duration;
 
     use libdd_common::{tag, Endpoint};
@@ -43,14 +44,37 @@ mod unix {
     }
 
     pub fn main() -> anyhow::Result<()> {
-        let mut args = env::args().skip(1);
+        let raw_args: Vec<String> = env::args().collect();
+        let mut args = raw_args.iter().skip(1);
         let output_url = args.next().context("Unexpected number of arguments")?;
         let receiver_binary = args.next().context("Unexpected number of arguments")?;
         let output_dir = args.next().context("Unexpected number of arguments")?;
         let mode_str = args.next().context("Unexpected number of arguments")?;
         let crash_typ = args.next().context("Missing crash type")?;
         anyhow::ensure!(args.next().is_none(), "unexpected extra arguments");
 
+        // For malloc logger mode, re-exec with LD_PRELOAD but keep logging disabled
+        // until the Behavior explicitly enables it (MALLOC_LOG_ENABLED=1). This
+        // ensures the logger is loaded before any allocator calls while avoiding
+        // harness noise.
+        if mode_str == "runtime_malloc_logger"
+            && env::var_os("LD_PRELOAD").is_none()
+            && env::var_os("MALLOC_LOGGER_BOOTSTRAPPED").is_none()
+        {
+            if let Some(so_path) = option_env!("MALLOC_LOGGER_SO") {
+                let status = process::Command::new(&raw_args[0])
+                    .args(&raw_args[1..])
+                    .env("LD_PRELOAD", so_path)
+                    .env("MALLOC_LOGGER_BOOTSTRAPPED", "1")
+                    .env("MALLOC_LOG_ENABLED", "0")
+                    .status()
+                    .context("failed to re-exec with LD_PRELOAD")?;
+
+                let code = status.code().unwrap_or(1);
+                process::exit(code);
+            }
+        }
+
         let stderr_filename = format!("{output_dir}/out.stderr");
         let stdout_filename = format!("{output_dir}/out.stdout");
         let output_dir: &Path = output_dir.as_ref();
@@ -101,7 +125,7 @@ mod unix {
             CrashtrackerReceiverConfig::new(
                 vec![],
                 env::vars().collect(),
-                receiver_binary,
+                receiver_binary.to_string(),
                 Some(stderr_filename),
                 Some(stdout_filename),
             )?,

bin_tests/src/modes/behavior.rs

@@ -134,6 +134,7 @@ pub fn get_behavior(mode_str: &str) -> Box<dyn Behavior> {
         "runtime_callback_frame_invalid_utf8" => {
             Box::new(test_012_runtime_callback_frame_invalid_utf8::Test)
         }
+        "runtime_malloc_logger" => Box::new(test_013_runtime_malloc_logger::Test),
         _ => panic!("Unknown mode: {mode_str}"),
     }
 }

bin_tests/src/modes/unix/mod.rs

@@ -13,3 +13,4 @@ pub mod test_009_prechain_with_abort;
 pub mod test_010_runtime_callback_frame;
 pub mod test_011_runtime_callback_string;
 pub mod test_012_runtime_callback_frame_invalid_utf8;
+pub mod test_013_runtime_malloc_logger;

bin_tests/src/modes/unix/test_013_runtime_malloc_logger.rs

@@ -0,0 +1,47 @@
+// Copyright 2024-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+//
+// Exercise the collector under an LD_PRELOAD malloc logger.
+
+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<()> {
+        use anyhow::Context;
+
+        // Ensure the collector loads the malloc logger via LD_PRELOAD.
+        if std::env::var("LD_PRELOAD").is_err() {
+            let so_path = option_env!("MALLOC_LOGGER_SO")
+                .context("MALLOC_LOGGER_SO not set; rebuild bin_tests?")?;
+            std::env::set_var("LD_PRELOAD", so_path);
+        }
+
+        // Direct malloc log into the test output directory.
+        let log_path = output_dir.join("malloc_logger.log");
+        std::env::set_var("MALLOC_LOG_PATH", &log_path);
+        // Enable logging now that path is set.
+        std::env::set_var("MALLOC_LOG_ENABLED", "1");
+        let _ = std::fs::remove_file(&log_path);
+        Ok(())
+    }
+
+    fn pre(&self, _output_dir: &Path) -> anyhow::Result<()> {
+        // The collector (this process) should already be running with LD_PRELOAD.
+        // Drop LD_PRELOAD before spawning the receiver to keep the preload scoped
+        // to the collector only.
+        std::env::remove_var("LD_PRELOAD");
+        Ok(())
+    }
+
+    fn post(&self, _output_dir: &Path) -> anyhow::Result<()> {
+        Ok(())
+    }
+}

bin_tests/src/test_types.rs

@@ -18,6 +18,7 @@ pub enum TestMode {
     RuntimeCallbackFrame,
     RuntimeCallbackString,
     RuntimeCallbackFrameInvalidUtf8,
+    RuntimeMallocLogger,
 }
 
 impl TestMode {
@@ -37,6 +38,7 @@ impl TestMode {
             Self::RuntimeCallbackFrame => "runtime_callback_frame",
             Self::RuntimeCallbackString => "runtime_callback_string",
             Self::RuntimeCallbackFrameInvalidUtf8 => "runtime_callback_frame_invalid_utf8",
+            Self::RuntimeMallocLogger => "runtime_malloc_logger",
         }
     }
 
@@ -56,6 +58,7 @@ impl TestMode {
             Self::RuntimeCallbackFrame,
             Self::RuntimeCallbackString,
             Self::RuntimeCallbackFrameInvalidUtf8,
+            Self::RuntimeMallocLogger,
         ]
     }
 }
@@ -84,6 +87,7 @@ impl std::str::FromStr for TestMode {
             "runtime_callback_frame" => Ok(Self::RuntimeCallbackFrame),
             "runtime_callback_string" => Ok(Self::RuntimeCallbackString),
             "runtime_callback_frame_invalid_utf8" => Ok(Self::RuntimeCallbackFrameInvalidUtf8),
+            "runtime_malloc_logger" => Ok(Self::RuntimeMallocLogger),
             _ => Err(format!("Unknown test mode: {}", s)),
         }
     }

bin_tests/tests/crashtracker_bin_test.rs

@@ -177,6 +177,20 @@ fn test_crash_tracking_bin_no_runtime_callback() {
     run_crash_test_with_artifacts(&config, &artifacts_map, &artifacts, validator).unwrap();
 }
 
+// Manual/diagnostic malloc logger check. This is ignored by default to keep the
+// regular bin test suite fast and hermetic. Run with:
+// cargo test --test crashtracker_bin_test -- --ignored manual_runtime_malloc_logger
+// Log output is written to tmp/malloc_logger.log.
+#[test]
+#[ignore]
+fn manual_runtime_malloc_logger() {
+    run_standard_crash_test_refactored(
+        BuildProfile::Release,
+        TestMode::RuntimeMallocLogger,
+        CrashType::NullDeref,
+    );
+}
+
 #[test]
 #[cfg_attr(miri, ignore)]
 fn test_crash_tracking_bin_runtime_callback_frame_invalid_utf8() {