Reference-chain tracker and leak-signal engine

.gitlab/fuzzing/.gitlab-ci.yml

@@ -2,6 +2,47 @@ variables:
   FUZZ_IMAGE: registry.ddbuild.io/java-profiler-fuzz
   FUZZYDOG_VERSION: "0.28.0"
 
+# Compile-gate the libFuzzer targets and soak the chaos suites.
+#
+# fuzz_infra below only runs on scheduled/manual pipelines and is
+# allow_failure, so a fuzz target that stops compiling can survive an entire
+# PR unnoticed - PR 797 broke fuzz_callTraceStorage exactly this way, caught
+# only by a manual buildFuzz run. This job runs on every branch push like the
+# sanitizer jobs: build the fuzz targets (asserting they were actually
+# produced - hasFuzzer()'s probe failing would otherwise silently no-op the
+# gate), then soak the concurrency-dependent chaos suites under TSan with
+# --gtest_repeat/--gtest_shuffle, which is the only way race code gets
+# statistical confidence from a single CI run.
+fuzz-build-and-soak:
+  stage: sanitizer
+  extends: .cache-config
+  needs: []
+  timeout: 45m
+  interruptible: true
+  # TSan on amd64 requires a non-Kata runner - same constraint as the TSan
+  # sanitizer job (Kata maps host-guest communication structures into TSan's
+  # shadow region regardless of LLVM version or sysctl).
+  tags: [ "docker-in-docker:amd64" ]
+  image: $BUILD_IMAGE_X64
+  variables:
+    GRADLE_USER_HOME: .gradle
+  rules:
+    - if: '$JDK_VERSION != null || $DEBUG_LEVEL != null || $HASH != null || $DOWNSTREAM != null'
+      when: never
+    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
+      when: never
+    - when: on_success
+  script:
+    - ./gradlew :ddprof-lib:fuzz:buildFuzz --no-daemon --parallel --build-cache
+    - |
+      if ! find ddprof-lib/fuzz/build/bin/fuzz -maxdepth 2 -type f -executable | grep -q .; then
+        echo "No fuzz binaries produced - the libFuzzer availability probe must have failed; failing the compile gate"
+        exit 1
+      fi
+    - ./gradlew :ddprof-lib:buildGtestTsan --no-daemon --parallel --build-cache
+    - GTEST_DEATH_TEST_STYLE=threadsafe ./ddprof-lib/build/bin/gtest/tsan_referenceChains_ut/referenceChains_ut --gtest_repeat=50 --gtest_shuffle --gtest_filter='ReferenceChainsLifecycleTest.*:RcDebugLevelTest.ReadFileConcurrentSwapChaos:FrontierTableTest.*:OomUrgencyTest.*:ReferenceChainsCanaryRefillTest.*:ReferenceChainsBfsTest.CanaryStuckLimitDoublesPerRestartAndResetsOnCleanCompletion:PollWatchedTargetsTest.RestartDropsPriorRecordingsChainsAndAbandonedEvents'
+    - GTEST_DEATH_TEST_STYLE=threadsafe ./ddprof-lib/build/bin/gtest/tsan_livenessTracker_ut/livenessTracker_ut --gtest_repeat=50 --gtest_shuffle --gtest_filter='LeakTagPoolTest.*:AdmissionBoostTest.*'
+
 fuzz_infra:
   needs: []
   extends: .retry-config

build-logic/conventions/src/main/kotlin/com/datadoghq/native/util/PlatformUtils.kt

@@ -70,7 +70,11 @@ object PlatformUtils {
             val process = ProcessBuilder(compiler, "--version")
                 .redirectErrorStream(true)
                 .start()
-            process.waitFor(5, TimeUnit.SECONDS)
+            // Generous beyond the obvious: on a loaded macOS host the /usr/bin/clang++ Xcode
+            // shim can take several seconds to answer --version (Rosetta translation churn,
+            // oahd-helper at 100% CPU), and a 5s budget made this probe fail intermittently
+            // from invocations that accepted the same path minutes earlier.
+            process.waitFor(30, TimeUnit.SECONDS)
             process.exitValue() == 0
         } catch (e: Exception) {
             false

ddprof-lib/fuzz/build.gradle.kts

@@ -23,6 +23,9 @@ fuzzTargets {
   additionalIncludes.set(
     listOf(
       project(":malloc-shim").file("src/main/public").absolutePath,
+      // referenceChainsTestAccessors.h / referenceChainsMockHeap.h - the shared
+      // gtest-free harness the fuzz_referenceChainHeap target drives.
+      project(":ddprof-lib").file("src/test/cpp").absolutePath,
     ),
   )
 }

ddprof-lib/src/main/cpp/arch.h

@@ -52,6 +52,12 @@ static inline long long atomicIncRelaxed(volatile T &var,
     return __atomic_fetch_add(&var, increment, __ATOMIC_RELAXED);
 }
 
+// Atomically replaces var with value and returns the previous value (relaxed).
+template <typename T>
+static inline T atomicExchangeRelaxed(volatile T &var, T value) {
+    return __atomic_exchange_n(&var, value, __ATOMIC_RELAXED);
+}
+
 // Atomic load/store (unordered)
 template <typename T>
 static inline T load(volatile T& var) {

ddprof-lib/src/main/cpp/callTraceHashTable.h

@@ -104,7 +104,7 @@ class CallTraceHashTable {
   //   - ACQUIRE loads in collect(), put(), and putWithExistingId()
   // Required for correct visibility on weakly-ordered architectures (aarch64).
   LongHashTable* _table;
-  
+
   volatile u64 _overflow;
 
   u64 calcHash(int num_frames, ASGCT_CallFrame *frames, bool truncated);

ddprof-lib/src/main/cpp/classTagAllocator.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2026, Datadog, Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef _CLASS_TAG_ALLOCATOR_H
+#define _CLASS_TAG_ALLOCATOR_H
+
+#include "arch.h"
+#include "mutex.h"
+#include <jvmti.h>
+
+// Process-wide, negative JVMTI class-object tag allocator, shared by
+// ReferenceChainTracker (which tags every loaded class's own jclass object
+// via SetTag - see resolveLoadedClasses(), referenceChains.cpp) and
+// LivenessTracker (which needs a stable per-class identifier independent of
+// Profiler::classMap()'s dictionary id - see KlassPopulationEntry::
+// stable_class_tag's own comment, livenessTracker.h, for why: that
+// dictionary can be compacted/regenerated, silently reassigning the same
+// class a different id at different points in the process's life, breaking
+// any attempt to correlate a klass_id LivenessTracker reports as growing
+// against ReferenceChainTracker::FrontierEntry::referrer_klass values
+// recorded at a different time).
+//
+// A single shared counter, not one independently owned by each subsystem,
+// for two reasons, both load-bearing:
+// 1. Two independent counters could otherwise hand out the SAME numeric
+//    value to TWO DIFFERENT classes (one minted by each subsystem for a
+//    class the other has not seen yet), making any cross-subsystem
+//    comparison meaningless.
+// 2. Class tags must stay strictly NEGATIVE:
+//    ReferenceChainTracker::heapReferenceCallback() (referenceChains.cpp)
+//    uses `*tag_ptr < 0` to distinguish "this heap-walk-visited object is a
+//    pre-tagged class object" from an ordinary admitted instance (always
+//    tagged with a positive value via nextTag()). A class tagged by a
+//    counter that does not preserve this sign convention would be
+//    misidentified as an ordinary object and incorrectly admitted into the
+//    frontier table - a real correctness bug, not just a matching
+//    inconvenience.
+//
+// Deliberately a plain header-only function (Meyer's-singleton pattern,
+// exactly like LivenessTracker::instance()/ReferenceChainTracker::
+// instance()'s own lazy-static singletons) rather than a member of either
+// singleton class: ReferenceChainTracker already depends on LivenessTracker
+// (referenceChains.cpp includes livenessTracker.h and calls into it), so
+// putting this counter inside either one and having the other call into it
+// would introduce a circular dependency between the two headers.
+namespace ClassTagAllocator {
+
+inline volatile jlong &magnitude() {
+  static volatile jlong m = 1;
+  return m;
+}
+
+// Hands out a fresh negative class tag - see this file's own header comment
+// for why negative, and why this must be the only place in the process that
+// mints one.
+inline jlong next() { return -atomicIncRelaxed(magnitude(), (jlong)1); }
+
+// Returns the class tag klass carries, first installing a fresh next() tag if
+// it carries none. Returns 0 if GetTag or SetTag fails, or if klass carries a
+// positive tag: that is never a class tag (heapReferenceCallback() admits a
+// not-yet-class-tagged class object reached over a non-CLASS edge as an
+// ordinary frontier object), and adopting it would break the sign convention
+// above. JVMTI has no compare-and-set for tags, so two unserialized GetTag == 0
+// -> SetTag sequences on one class would both install a tag and the caller
+// whose SetTag landed first would keep a tag the class no longer carries. Every
+// class-tag install goes through here, so this leaf mutex (no other lock is
+// taken while it is held) closes that window. A blocking mutex rather than a
+// SpinLock: it is held across JVMTI calls, and callers include application
+// threads.
+inline jlong getOrMint(jvmtiEnv *jvmti, jclass klass) {
+  static Mutex mint_lock;
+  MutexLocker locker(mint_lock);
+  jlong tag = 0;
+  if (jvmti->GetTag(klass, &tag) != JVMTI_ERROR_NONE) {
+    return 0;
+  }
+  if (tag != 0) {
+    return tag < 0 ? tag : 0;
+  }
+  tag = next();
+  return jvmti->SetTag(klass, tag) == JVMTI_ERROR_NONE ? tag : 0;
+}
+
+// Test-only: resets the shared counter back to its starting value. Without
+// this, gtest cases that assert on exact tag values (e.g. "the first class
+// tagged gets -1") would see values keep climbing across every TEST_F in the
+// same gtest binary, since this counter is genuinely process-wide (shared
+// with LivenessTracker) rather than per-ReferenceChainTracker-instance.
+inline void resetForTest() {
+  // Atomic exchange, matching next()'s atomicIncRelaxed RMW on the same
+  // variable: a plain volatile store can tear or be lost against a concurrent
+  // RMW (e.g. a tracker thread from a prior TEST_F not fully quiesced), which
+  // would mint duplicate negative tags - the cross-subsystem collision this
+  // shared allocator exists to prevent. Callers must still ensure no tracker
+  // thread is live (reset in TearDown after tracker->stop()).
+  atomicExchangeRelaxed(magnitude(), (jlong)1);
+}
+
+} // namespace ClassTagAllocator
+
+#endif

ddprof-lib/src/main/cpp/common.h

@@ -62,6 +62,15 @@ constexpr size_t KNUTH_MULTIPLICATIVE_CONSTANT = 0x9e3779b97f4a7c15ULL;
     #define TEST_LOG(fmt, ...) // No-op in non-debug mode
 #endif
 
+// Same gate as assert(): use for state that only assert() reads. Keying it on
+// DEBUG instead would break builds that keep asserts but do not define DEBUG
+// (the gtest release build strips -DNDEBUG without adding -DDEBUG).
+#ifndef NDEBUG
+    #define ASSERT_ONLY(s) s
+#else
+    #define ASSERT_ONLY(s)
+#endif
+
 #ifdef __FAULT_INJECTION__
     #define FAULT_INJECTION_ONLY(s) s
 #else

ddprof-lib/src/main/cpp/counters.h

@@ -178,6 +178,45 @@
    * signal for spotting a recurrence. */                                     \
   X(METADATA_TREE_NULL_CHILD, "metadata_tree_null_child")                     \
   X(METADATA_TREE_DEPTH_EXCEEDED, "metadata_tree_depth_exceeded")             \
+  /* A resolved datadog.ReferenceChain could not be cached in                 \
+   * ReferenceChainTracker::_resolved_chains (referenceChains.h): a brand-new \
+   * leak-candidate klass arrived with the cache already at                   \
+   * MAX_RESOLVED_CHAINS, so its chain is dropped rather than evicting some   \
+   * other still-live sample's chain. See that constant's own comment. */     \
+  X(REFERENCE_CHAIN_EVENTS_DROPPED, "reference_chain_events_dropped")         \
+  /* ReferenceChainTracker::releaseSearchTags() (referenceChains.cpp) failed  \
+   * to call GetObjectsWithTags() for at least one batch - the search's tag   \
+   * release is retried on a later call rather than proceeding, but this     \
+   * counts how often that retry path is taken. */                           \
+  X(REFERENCE_CHAIN_TAG_RELEASE_FAILED, "reference_chain_tag_release_failed") \
+  /* The profiler-side reference-chain writer could not acquire a            \
+   * sample-record lock within its bounded retry budget and dropped the      \
+   * already-dequeued datadog.ReferenceChain event for this dump - not       \
+   * permanently lost, since ReferenceChainTracker::_resolved_chains (see    \
+   * REFERENCE_CHAIN_EVENTS_DROPPED above) keeps the resolved chain cached   \
+   * and re-emits it on a later dump while the leak candidate is still      \
+   * live. */                                                                \
+  X(REFERENCE_CHAIN_WRITE_DROPPED, "reference_chain_write_dropped")            \
+  /* FrontierTable's own calloc/realloc-backed storage (referenceChains.cpp) -   \
+   * outside NMT's visibility since it bypasses os::malloc, so this is the only \
+   * way to attribute its native RSS contribution. */                          \
+  X(REFERENCE_CHAIN_FRONTIER_TABLE_BYTES, "reference_chain_frontier_table_bytes") \
+  X(REFERENCE_CHAIN_FRONTIER_TABLE_CAPACITY, "reference_chain_frontier_table_capacity") \
+  X(REFERENCE_CHAIN_CANDIDATE_COUNT, "reference_chain_candidate_count") \
+  X(REFERENCE_CHAIN_CANDIDATES_FOUND, "reference_chain_candidates_found") \
+  /* admitStaticFieldRoots() per-class non-static quota: non-STATIC_FIELD \
+   * edges (CONSTANT_POOL, INTERFACE, SUPERCLASS, CLASS_LOADER, ...) that \
+   * were dropped because the class already hit \
+   * STATIC_FIELD_SWEEP_NON_STATIC_CAP_PER_CLASS. Total drops across all \
+   * classes/laps — compare against kind_counts (k9 total) to gauge how \
+   * much CP pressure the quota is absorbing. */ \
+  X(REFERENCE_CHAIN_STATIC_SWEEP_NON_STATIC_DROPPED, "reference_chain_static_sweep_non_static_dropped") \
+  /* Incremented once per class that hit the non-static cap at least once \
+   * in a lap (on the first drop for that class). Distinguishes "a few fat \
+   * outlier classes dropping many edges" from "systematic drops across \
+   * almost all classes" — if this tracks the total class count per lap, \
+   * the cap is too low; if it stays near zero, the cap is fine. */ \
+  X(REFERENCE_CHAIN_STATIC_SWEEP_CLASSES_CAPPED, "reference_chain_static_sweep_classes_capped") \
   DD_COUNTER_TABLE_FAULT_INJECTION(X)                                          \
   DD_COUNTER_TABLE_FI_DEBUG(X)                                                 \
   DD_COUNTER_TABLE_SAMPLER_PERF(X)                                             \

ddprof-lib/src/main/cpp/flightRecorder.h

@@ -593,20 +593,21 @@ class FlightRecorder {
 
   // Mirrors recordHeapUsage()'s shape exactly - ReferenceChainAbandonedEvent
   // is not stack-sample-shaped (no tid/call_trace_id), same as HeapUsage.
-  // Called from Profiler::writeReferenceChainAbandoned() (profiler.cpp),
+  // Called from the profiler's dump-time abandoned-event drain,
   // wired from Profiler::dump() the same way LivenessTracker::flush() is.
   void recordReferenceChainAbandoned(int lock_index,
                                      ReferenceChainAbandonedEvent *event);
 
   // Mirrors recordReferenceChainAbandoned() above exactly, for
-  // ReferenceChainEvent instead. Called from Profiler::writeReferenceChain()
-  // (profiler.cpp), itself called from Profiler::dump()'s drain loop over
+  // ReferenceChainEvent instead. Called from the profiler's dump()-time
+  // writer, itself called from Profiler::dump()'s drain loop over
   // the engine's resolved-chain cache snapshot: the BFS
   // scheduling thread only caches resolved chains and each dump re-emits
   // the cache, so chain events
   // are written on dump()'s own thread, not from the tracker thread, and
   // unlike recordReferenceChainAbandoned() (unbounded retry budget per
-  // event) the batch shares one deadline (writeReferenceChain()'s comment).
+  // event) the batch shares one deadline (see the writer's contract in
+  // Profiler - the drain batch, not each event, owns the retry budget).
   void recordReferenceChain(int lock_index, ReferenceChainEvent *event);
 };