Migrate ReferenceChainTrackingTest to the JfrEvents API

jbachorik · claude · jbachorik · commit eecff95cd0e4 · 2026-08-06T12:41:41.000+02:00
Fixes the CodeQL Autobuild failure: this test still used JMC's
IItemCollection/IItem after AbstractProfilerTest's verifyEvents() switched
to the jafar-backed JfrEvents API. Adds a JfrEvents overload of
ReferenceChainAssertions.findMatchForClass alongside the existing
IItemCollection one, which LeakingCacheScenario/ReferenceChainJfrParserTest
still use unchanged.

Co-Authored-By: Claude Sonnet 5 &lt;noreply@anthropic.com&gt;
diff --git a/ddprof-test/src/test/java/com/datadoghq/profiler/referencechains/ReferenceChainAssertions.java b/ddprof-test/src/test/java/com/datadoghq/profiler/referencechains/ReferenceChainAssertions.java
@@ -5,6 +5,8 @@
 
 package com.datadoghq.profiler.referencechains;
 
+import com.datadoghq.profiler.JfrEvent;
+import com.datadoghq.profiler.JfrEvents;
 import org.openjdk.jmc.common.IMCType;
 import org.openjdk.jmc.common.item.IAccessorKey;
 import org.openjdk.jmc.common.item.IItem;
@@ -16,13 +18,21 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Shared {@code datadog.ReferenceChain} JFR-parsing helpers, extracted out of
  * {@code ReferenceChainTrackingTest} so both that in-process JUnit test and
  * {@link LeakingCacheScenario} (run inside a genuinely separate child JVM by
  * {@code ExternalProcessReferenceChainTest}) can reuse the exact same JMC-accessor logic
  * rather than maintaining two copies.
+ *
+ * <p>{@link #findMatchForClass(JfrEvents, Class)} is a separate, jafar-backed counterpart to
+ * {@link #findMatchForClass(IItemCollection, Class)} for {@code ReferenceChainTrackingTest}, which
+ * loads recordings via {@code AbstractProfilerTest}'s {@code JfrEvents}-returning helpers
+ * (jb/jfr-lightweight-query-api). {@link LeakingCacheScenario} and {@code ReferenceChainJfrParserTest}
+ * load recordings directly via JMC's {@code JfrLoaderToolkit} and keep using the
+ * {@code IItemCollection} overload unchanged.
  */
 public final class ReferenceChainAssertions {
   private ReferenceChainAssertions() {}
@@ -40,6 +50,19 @@ public static final class ChainMatch {
     }
   }
 
+  /** Result of {@link #findMatchForClass(JfrEvents, Class)}: one resolved chain event's fields. */
+  public static final class JfrChainMatch {
+    public final List<String> chain;
+    public final long targetTag;
+    public final int depth;
+
+    JfrChainMatch(List<String> chain, long targetTag, int depth) {
+      this.chain = chain;
+      this.targetTag = targetTag;
+      this.depth = depth;
+    }
+  }
+
   /**
    * Scans {@code events} for a {@code datadog.ReferenceChain} item whose {@code chain[0]} is
    * {@code targetClass} specifically, ignoring any events for other klasses this same
@@ -82,6 +105,57 @@ public static ChainMatch findMatchForClass(IItemCollection events, Class<?> targ
     return null;
   }
 
+  /**
+   * jafar/{@code JfrEvents}-backed counterpart to {@link #findMatchForClass(IItemCollection, Class)} -
+   * see this class's own header comment for why these are two separate overloads rather than one.
+   */
+  public static JfrChainMatch findMatchForClass(JfrEvents events, Class<?> targetClass) {
+    if (events == null || !events.hasItems()) {
+      return null;
+    }
+    for (JfrEvent item : events) {
+      Object chainValue = item.get("chain");
+      if (!(chainValue instanceof Object[])) {
+        throw new IllegalStateException(
+            "'chain' field resolved to " + chainValue + ", expected an array");
+      }
+      Object[] rawChain = (Object[]) chainValue;
+      if (rawChain.length == 0 || !targetClass.getName().equals(classFullName(rawChain[0]))) {
+        continue;
+      }
+      List<String> chain = new ArrayList<>(rawChain.length);
+      for (Object element : rawChain) {
+        chain.add(classFullName(element));
+      }
+      long targetTag = item.getLong("targetTag", -1);
+      int depth = (int) item.getLong("depth", -1);
+      return new JfrChainMatch(chain, targetTag, depth);
+    }
+    return null;
+  }
+
+  /**
+   * The full name (e.g. {@code java.lang.String}) of a resolved {@code chain[]} array element -
+   * mirrors {@code JfrEvent.getClassName(String)}'s own class-reference-map unwrapping, applied
+   * to an array element rather than a named field.
+   */
+  @SuppressWarnings("unchecked")
+  private static String classFullName(Object element) {
+    if (!(element instanceof Map)) {
+      throw new IllegalStateException(
+          "chain[] element resolved to " + element + ", expected a class reference map");
+    }
+    Object name = ((Map<String, Object>) element).get("name");
+    String s;
+    if (name instanceof Map) {
+      Object v = ((Map<String, Object>) name).get("string");
+      s = v != null ? v.toString() : null;
+    } else {
+      s = name != null ? name.toString() : null;
+    }
+    return s != null ? s.replace('/', '.') : null;
+  }
+
   /**
    * Looks up a field's accessor by identifier rather than via {@code Attribute.attr(...)}: JMC's
    * v1 chunk parser (internal.parser.v1.ValueReaders.ArrayReader#getContentType()) registers
diff --git a/ddprof-test/src/test/java/com/datadoghq/profiler/referencechains/ReferenceChainTrackingTest.java b/ddprof-test/src/test/java/com/datadoghq/profiler/referencechains/ReferenceChainTrackingTest.java
@@ -7,19 +7,15 @@
 
 import com.datadoghq.profiler.AbstractProfilerTest;
 import com.datadoghq.profiler.JavaProfiler;
+import com.datadoghq.profiler.JfrEvent;
+import com.datadoghq.profiler.JfrEvents;
 import com.datadoghq.profiler.Platform;
 import org.junit.jupiter.api.MethodOrderer;
 import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestMethodOrder;
 import org.junitpioneer.jupiter.RetryingTest;
-import org.openjdk.jmc.common.IMCType;
-import org.openjdk.jmc.common.item.IAttribute;
-import org.openjdk.jmc.common.item.IItem;
-import org.openjdk.jmc.common.item.IItemCollection;
-import org.openjdk.jmc.common.item.IItemIterable;
-import org.openjdk.jmc.common.item.IMemberAccessor;
 
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -32,8 +28,6 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.openjdk.jmc.common.item.Attribute.attr;
-import static org.openjdk.jmc.common.unit.UnitLookup.PLAIN_TEXT;
 
 /**
  * PROF-15341 (+ lifecycle-wiring follow-up, + the Remaining Work Plan's target-selection bridging,
@@ -92,9 +86,6 @@
 @Tag("slow")
 public class ReferenceChainTrackingTest extends AbstractProfilerTest {
 
-  private static final IAttribute<String> SETTING_NAME = attr("name", "", "", PLAIN_TEXT);
-  private static final IAttribute<String> SETTING_VALUE = attr("value", "", "", PLAIN_TEXT);
-
   // Arbitrary, test-chosen klass ids for the debug-only population-seeding seams below (see
   // ReferenceChainTestSeamsTest's own comment: LivenessTracker's population table treats these as
   // opaque keys, so they need not resolve to any real class). Distinct per test/from
@@ -224,19 +215,11 @@ protected boolean isPlatformSupported() {
   @RetryingTest(5)
   public void shouldExposeReferenceChainsSettingWhenEnabled() {
     stopProfiler();
-    IItemCollection settings = verifyEvents("jdk.ActiveSetting");
+    JfrEvents settings = verifyEvents("jdk.ActiveSetting");
     boolean sawEnabledSetting = false;
-    for (IItemIterable iterable : settings) {
-      IMemberAccessor<String, IItem> nameAccessor = SETTING_NAME.getAccessor(iterable.getType());
-      IMemberAccessor<String, IItem> valueAccessor = SETTING_VALUE.getAccessor(iterable.getType());
-      if (nameAccessor == null || valueAccessor == null) {
-        continue;
-      }
-      for (IItem item : iterable) {
-        if ("enabled".equals(nameAccessor.getMember(item))
-            && "true".equals(valueAccessor.getMember(item))) {
-          sawEnabledSetting = true;
-        }
+    for (JfrEvent item : settings) {
+      if ("enabled".equals(item.getString("name")) && "true".equals(item.getString("value"))) {
+        sawEnabledSetting = true;
       }
     }
     assertTrue(sawEnabledSetting, "datadog.ReferenceChain#enabled setting was not found");
@@ -334,7 +317,7 @@ public void shouldReconstructReferrerChainToGcRoot() throws Exception {
       // flag as leak candidates - this test's own assertions below look for ChainLink specifically
       // among however many datadog.ReferenceChain events actually appear, rather than assuming it
       // is the only one.
-      ReferenceChainAssertions.ChainMatch match = null;
+      ReferenceChainAssertions.JfrChainMatch match = null;
       boolean seededTestKlassTrend = false;
       int totalRounds = 16;
       for (int round = 1; round <= totalRounds && match == null; round++) {
@@ -436,7 +419,7 @@ public void shouldReconstructReferrerChainToGcRoot() throws Exception {
       // keep as its representative. Everything above chain[0] reflects real JDK-internal
       // collection representation (e.g. ArrayList's backing array) rather than anything this test
       // controls, so it is deliberately not asserted beyond "at least one hop was reconstructed".
-      assertEquals(ChainLink.class.getName(), match.chain.get(0).getFullName());
+      assertEquals(ChainLink.class.getName(), match.chain.get(0));
       assertTrue(match.targetTag > 0, "targetTag should be a valid, non-zero JVMTI tag");
       assertTrue(match.depth >= 0, "depth should be a non-negative hop count");
       assertTrue(!gcRootHolder.isEmpty()); // keeps every allocated ChainLink reachable until here
@@ -515,7 +498,7 @@ public void shouldReconstructReferrerChainThroughUnboundedCacheLeak() throws Exc
       // floor rather than this test's own "memory=64" request, why totalRounds is capped at
       // 16 rather than a larger margin above the 10-round minimum (shared-fork heap headroom),
       // and why per-round growth itself is clamped to round 10 (Math.min(round, 10) below).
-      ReferenceChainAssertions.ChainMatch match = null;
+      ReferenceChainAssertions.JfrChainMatch match = null;
       boolean seededTestKlassTrend = false;
       int totalRounds = 16;
 
@@ -559,7 +542,7 @@ public void shouldReconstructReferrerChainThroughUnboundedCacheLeak() throws Exc
         nextKey += newEntries;
         System.gc();
         dump(scratchDumpPath);
-        IItemCollection events1 = verifyEvents(scratchDumpPath, "datadog.ReferenceChain", false);
+        JfrEvents events1 = verifyEvents(scratchDumpPath, "datadog.ReferenceChain", false);
         match = ReferenceChainAssertions.findMatchForClass(events1, CachedPayload.class);
 
         if (match == null && "debug".equals(System.getProperty("ddprof_test.config"))) {
@@ -581,7 +564,7 @@ public void shouldReconstructReferrerChainThroughUnboundedCacheLeak() throws Exc
           JavaProfiler.setKlassPopulationRepresentativeForTest0(CACHED_PAYLOAD_TEST_KLASS_ID, cache.get(keys[0]));
           JavaProfiler.pollReferenceChainTargets0();
           dump(scratchDumpPath);
-          IItemCollection events2 = verifyEvents(scratchDumpPath, "datadog.ReferenceChain", false);
+          JfrEvents events2 = verifyEvents(scratchDumpPath, "datadog.ReferenceChain", false);
           match = ReferenceChainAssertions.findMatchForClass(events2, CachedPayload.class);
         }
 
@@ -591,32 +574,32 @@ public void shouldReconstructReferrerChainThroughUnboundedCacheLeak() throws Exc
           // slot against Profiler::dump()'s own exclusive hold.
           Thread.sleep(300);
           dump(scratchDumpPath);
-          IItemCollection events3 = verifyEvents(scratchDumpPath, "datadog.ReferenceChain", false);
+          JfrEvents events3 = verifyEvents(scratchDumpPath, "datadog.ReferenceChain", false);
           match = ReferenceChainAssertions.findMatchForClass(events3, CachedPayload.class);
         }
       }
 
       for (int attempt = 0; match == null && attempt < 5; attempt++) {
         Thread.sleep(1000);
         dump(scratchDumpPath);
-        IItemCollection events4 = verifyEvents(scratchDumpPath, "datadog.ReferenceChain", false);
+        JfrEvents events4 = verifyEvents(scratchDumpPath, "datadog.ReferenceChain", false);
         match = ReferenceChainAssertions.findMatchForClass(events4, CachedPayload.class);
       }
 
       assertNotNull(match,
           "Never observed a datadog.ReferenceChain event whose chain[0] is " + CachedPayload.class
               + " after " + cache.size() + " cached entries across up to " + totalRounds
               + " population-growth rounds plus a grace period");
-      assertEquals(CachedPayload.class.getName(), match.chain.get(0).getFullName());
+      assertEquals(CachedPayload.class.getName(), match.chain.get(0));
       assertTrue(match.targetTag > 0, "targetTag should be a valid, non-zero JVMTI tag");
       assertTrue(match.depth >= 0, "depth should be a non-negative hop count");
 
       // The point of this test over shouldReconstructReferrerChainToGcRoot(): confirm the walk
       // actually passed through the cache's own internal storage, not some other, coincidental
       // retainer - cache is the only thing keeping any CachedPayload instance reachable.
       boolean sawHashMapInternals = false;
-      for (IMCType type : match.chain) {
-        if (type.getFullName().startsWith("java.util.HashMap")) {
+      for (String type : match.chain) {
+        if (type.startsWith("java.util.HashMap")) {
           sawHashMapInternals = true;
           break;
         }
@@ -685,7 +668,7 @@ public void shouldReportAbandonedSearchOnTinyFrontierCap() throws Exception {
     Path dumpPath = Paths.get("referencechains-abandoned-test.jfr");
     try {
       dump(dumpPath);
-      IItemCollection abandoned = verifyEvents(dumpPath, "datadog.ReferenceChainAbandoned", true);
+      JfrEvents abandoned = verifyEvents(dumpPath, "datadog.ReferenceChainAbandoned", true);
       assertTrue(abandoned.hasItems(), "Expected at least one datadog.ReferenceChainAbandoned event");
     } finally {
       Files.deleteIfExists(dumpPath);
