feat: add libdd-heap- allocation tracking

Author: scottgerring

.github/CODEOWNERS

@@ -49,6 +49,7 @@ libdd-crashtracker*/                 @DataDog/libdatadog-profiling
 libdd-data-pipeline*/                @DataDog/libdatadog-apm
 libdd-ddsketch*/                     @DataDog/libdatadog-apm @DataDog/apm-common-components-core
 libdd-dogstatsd-client               @DataDog/apm-common-components-core
+libdd-heap-*/                        @DataDog/libdatadog-profiling
 libdd-http-client                    @DataDog/apm-common-components-core
 libdd-agent-client                   @DataDog/apm-common-components-core
 libdd-library-config*/               @DataDog/apm-sdk-capabilities-rust

.github/workflows/miri.yml

@@ -79,6 +79,12 @@ jobs:
           # Override rust-toolchain.toml so miri runs on the dated nightly
           # (miri is nightly-only) instead of the workspace MSRV.
           RUSTUP_TOOLCHAIN: ${{ steps.nightly-version.outputs.version }}
-        run: MIRIFLAGS="-Zmiri-disable-isolation" cargo miri nextest run ${{ needs.setup.outputs.crates }} --partition count:${{ matrix.partition }}/5 --no-tests=pass
+        # Tests that require FFI/syscalls miri can't execute (e.g. the
+        # libdd-heap-* crates' C-side primitives) skip themselves via
+        # `#[cfg(not(miri))]` at the source level. No workflow-side
+        # filtering needed.
+        run: |
+          CRATES="${{ needs.setup.outputs.crates }}"
+          MIRIFLAGS="-Zmiri-disable-isolation" cargo miri nextest run $CRATES --partition count:${{ matrix.partition }}/5 --no-tests=pass
       # We need to disable isolation because
       # "unsupported operation: `clock_gettime` with `REALTIME` clocks not available when isolation is enabled"

.github/workflows/test.yml

@@ -321,6 +321,14 @@ jobs:
             -w /workspace \
             libdatadog-centos7 \
             sh -c "$NEXTEST_CMD"
+          # nextest with --no-tests=pass exits 0 without writing junit.xml
+          # when the filter selects zero tests; downstream junit-consuming
+          # steps still expect the file. Emit an empty report so they
+          # have something to read.
+          if [ ! -f target/nextest/ci/junit.xml ]; then
+            mkdir -p target/nextest/ci
+            printf '<?xml version="1.0" encoding="UTF-8"?>\n<testsuites name="nextest-run" tests="0" failures="0" errors="0" disabled="0" skipped="0" time="0"></testsuites>\n' > target/nextest/ci/junit.xml
+          fi
       - name: Add file attributes to JUnit XML
         if: success() || failure()
         run: cargo run --bin add_junit_file_attributes -- target/nextest/ci/junit.xml

.github/workflows/verify-heap-sampler-bindings.yml

@@ -0,0 +1,53 @@
+name: 'Verify libdd-heap-sampler bindings'
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+    paths:
+      - 'libdd-heap-sampler/**'
+      - '.github/workflows/verify-heap-sampler-bindings.yml'
+env:
+  CARGO_TERM_COLOR: always
+  CARGO_INCREMENTAL: 0
+jobs:
+  verify-bindings:
+    name: "Verify libdd-heap-sampler generated bindings are in sync"
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # 4.2.2
+      - name: Install libclang-dev + cross libc headers
+        # Only this verification job needs libclang; the normal build
+        # path for libdd-heap-sampler consumes the checked-in bindings
+        # under `src/generated/<arch>/` and does not depend on bindgen
+        # at all. The `*-cross` packages provide `<stdint.h>`,
+        # `<string.h>`, etc. for the non-native target arch, letting
+        # `build.rs` regenerate both aarch64 and x86_64 bindings from a
+        # single runner via clang's `--target=<arch>-linux-gnu` flag.
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libclang-dev libc6-dev-amd64-cross libc6-dev-arm64-cross
+      - name: Read Rust version from rust-toolchain.toml
+        id: rust-version
+        run: echo "version=$(grep -Po '^channel = "\K[^"]+' rust-toolchain.toml)" >> $GITHUB_OUTPUT
+      - name: Install ${{ steps.rust-version.outputs.version }} toolchain
+        run: rustup set profile minimal && rustup install ${{ steps.rust-version.outputs.version }} && rustup default ${{ steps.rust-version.outputs.version }}
+      - name: Cache [rust]
+        uses: Swatinem/rust-cache@f13886b937689c021905a6b90929199931d60db1 # 2.8.1
+        with:
+          cache-targets: true
+          cache-bin: true
+      - name: Regenerate bindings
+        # `LIBDD_HEAP_SAMPLER_REGEN=1` rewrites `src/generated/<arch>/*`
+        # in-place via bindgen. If the committed files were stale the
+        # git diff below fails and instructs the author how to refresh
+        # them. We use an env var (rather than a cargo feature) so that
+        # unrelated `--all-features` CI jobs cannot accidentally invoke
+        # bindgen — see libdd-heap-sampler/Cargo.toml for the rationale.
+        run: LIBDD_HEAP_SAMPLER_REGEN=1 cargo build -p libdd-heap-sampler
+      - name: Verify committed bindings match regenerated output
+        run: |
+          if ! git diff --exit-code libdd-heap-sampler/src/generated/; then
+            echo "::error::libdd-heap-sampler/src/generated/ is out of date."
+            echo "Run \`LIBDD_HEAP_SAMPLER_REGEN=1 cargo build -p libdd-heap-sampler\` locally and commit the result."
+            exit 1
+          fi

Cargo.lock

@@ -5,6 +5,10 @@
 members = [
   "builder",
   "libdd-alloc",
+  "libdd-heap-sampler",
+  "libdd-heap-allocator",
+  "libdd-heap-gotter",
+  "libdd-heap-gotter-ffi",
   "libdd-crashtracker",
   "libdd-crashtracker-ffi",
   "datadog-ffe",

Cargo.toml

@@ -2,3 +2,11 @@ Datadog libdatadog
 Copyright 2021-2022 Datadog, Inc.
 
 This product includes software developed at Datadog (<https://www.datadoghq.com/>).
+
+--
+
+This product bundles a copy of the libbpf/usdt single-header USDT
+library in `libdd-heap-sampler/vendor/usdt.h`. That file is licensed
+under the BSD 2-Clause License, Copyright (c) 2024 Meta Platforms, Inc.
+and affiliates. The SPDX identifier and copyright notice are retained
+verbatim in the file header. Upstream: <https://github.com/libbpf/usdt>.

NOTICE

@@ -0,0 +1,19 @@
+# Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "libdd-heap-allocator"
+version = "0.1.0"
+description = "Rust GlobalAlloc wrapper that drives libdd-heap-sampler."
+homepage = "https://github.com/DataDog/libdatadog/tree/main/libdd-heap-allocator"
+repository = "https://github.com/DataDog/libdatadog/tree/main/libdd-heap-allocator"
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+publish = false
+
+[lib]
+bench = false
+
+[dependencies]
+libdd-heap-sampler = { path = "../libdd-heap-sampler" }

libdd-heap-allocator/Cargo.toml

@@ -0,0 +1,25 @@
+# libdd-heap-allocator
+
+Rust `GlobalAlloc` wrapper with USDT-based heap profiling, effectively implementing [libdd-heap-sampler](../libdd-heap-sampler) for Rust apps at compile time. This lets Rust users quickly setup sampled heap profiling within their application regardless of the particular allocator they are using.
+
+For this to work _well_, you should make sure everything passes through the global allocator!
+
+Usage:
+
+```rust
+use libdd_heap_allocator::SampledAllocator;
+use std::alloc::System;
+
+// Wrap the default system allocator 
+#[global_allocator]
+static ALLOC: SampledAllocator<System> = SampledAllocator::<System>::DEFAULT;
+```
+
+To wrap a custom allocator instead; note that this is kind of ill-advised; we want to see _all_ allocations for the process:
+
+```rust
+#[global_allocator]
+static ALLOC: SampledAllocator<MyAllocator> = SampledAllocator::new(MyAllocator::new());
+```
+
+See [`examples/usdt_demo.rs`](examples/usdt_demo.rs) for a runnable demo that fires USDT probes in a loop for `bpftrace` to observe.

libdd-heap-allocator/README.md

@@ -0,0 +1,61 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Sample app exercising `libdd-heap-allocator` as the global allocator.
+//!
+//! Install `SampledAllocator<System>` globally, then loop producing
+//! allocations (strings joined into a single buffer) so a tracer attached
+//! to the `ddheap:alloc` USDT probe sees samples fire periodically.
+//!
+//! Run (Linux, inside the crate's Lima VM):
+//! ```
+//! cargo run --example usdt_demo -p libdd-heap-allocator
+//! ```
+//! and in another shell, attach a tracer, e.g.
+//! ```
+//! sudo bpftrace -p <pid> -e 'usdt:*:ddheap:alloc { printf("alloc %p %d %d\n", arg0, arg1, arg2); }'
+//! ```
+//!
+//! `SampledAllocator` is Linux-only; on other targets the example
+//! compiles to an empty `main` so clippy/test on non-Linux don't fail
+//! with "configured out".
+
+#[cfg(not(target_os = "linux"))]
+fn main() {}
+
+#[cfg(target_os = "linux")]
+fn main() {
+    linux::main();
+}
+
+#[cfg(target_os = "linux")]
+mod linux {
+    use libdd_heap_allocator::SampledAllocator;
+    use std::alloc::System;
+    use std::thread::sleep;
+    use std::time::Duration;
+
+    #[global_allocator]
+    static ALLOC: SampledAllocator<System> = SampledAllocator::<System>::DEFAULT;
+
+    pub fn main() {
+        println!(
+            "pid={}; attach a tracer on 'usdt:*:ddheap:alloc'",
+            std::process::id()
+        );
+
+        let mut i: u64 = 0;
+        loop {
+            // ~1000 small allocations + one larger join: plenty of alloc
+            // pressure to cross the default 512 KiB sampling interval over
+            // a handful of iterations.
+            let parts: Vec<String> = (0..1000)
+                .map(|j| format!("chunk-{i}-{j}-with-some-padding-to-make-it-meaningful"))
+                .collect();
+            let joined = parts.join(", ");
+            println!("[{i}] joined {} bytes", joined.len());
+            i = i.wrapping_add(1);
+            sleep(Duration::from_secs(1));
+        }
+    }
+} // mod linux