feat(crashtracking): Report registry to memory mapping

bric3 · bric3 · commit 8f173335dcac · 2026-04-01T16:59:07.000+02:00
diff --git a/dd-java-agent/agent-crashtracking/src/main/java/datadog/crashtracking/CrashUploader.java b/dd-java-agent/agent-crashtracking/src/main/java/datadog/crashtracking/CrashUploader.java
@@ -577,6 +577,7 @@ private RequestBody makeErrorTrackingRequestBody(@Nonnull CrashLog payload, bool
         // experimental
         if (payload.experimental != null
             && (payload.experimental.ucontext != null
+                || payload.experimental.registerToMemoryMapping != null
                 || payload.experimental.runtimeArgs != null)) {
           writer.name("experimental");
           writer.beginObject();
@@ -588,6 +589,15 @@ private RequestBody makeErrorTrackingRequestBody(@Nonnull CrashLog payload, bool
             }
             writer.endObject();
           }
+          if (payload.experimental.registerToMemoryMapping != null) {
+            writer.name("register_to_memory_mapping");
+            writer.beginObject();
+            for (Map.Entry<String, String> entry :
+                payload.experimental.registerToMemoryMapping.entrySet()) {
+              writer.name(entry.getKey()).value(entry.getValue());
+            }
+            writer.endObject();
+          }
           if (payload.experimental.runtimeArgs != null) {
             writer.name("runtime_args");
             writer.beginArray();
diff --git a/dd-java-agent/agent-crashtracking/src/main/java/datadog/crashtracking/dto/Experimental.java b/dd-java-agent/agent-crashtracking/src/main/java/datadog/crashtracking/dto/Experimental.java
@@ -8,27 +8,40 @@
 public final class Experimental {
   public final Map<String, String> ucontext;
 
+  @Json(name = "register_to_memory_mapping")
+  public final Map<String, String> registerToMemoryMapping;
+
   @Json(name = "runtime_args")
   public final List<String> runtimeArgs;
 
   public Experimental(Map<String, String> ucontext) {
-    this(ucontext, null);
+    this(ucontext, null, null);
   }
 
   public Experimental(Map<String, String> ucontext, List<String> runtimeArgs) {
+    this(ucontext, null, runtimeArgs);
+  }
+
+  public Experimental(
+      Map<String, String> ucontext,
+      Map<String, String> registerToMemoryMapping,
+      List<String> runtimeArgs) {
     this.ucontext = ucontext;
+    this.registerToMemoryMapping = registerToMemoryMapping;
     this.runtimeArgs = runtimeArgs;
   }
 
   @Override
   public boolean equals(Object o) {
     if (!(o instanceof Experimental)) return false;
     Experimental that = (Experimental) o;
-    return Objects.equals(ucontext, that.ucontext) && Objects.equals(runtimeArgs, that.runtimeArgs);
+    return Objects.equals(ucontext, that.ucontext)
+        && Objects.equals(registerToMemoryMapping, that.registerToMemoryMapping)
+        && Objects.equals(runtimeArgs, that.runtimeArgs);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(ucontext, runtimeArgs);
+    return Objects.hash(ucontext, registerToMemoryMapping, runtimeArgs);
   }
 }
diff --git a/dd-java-agent/agent-crashtracking/src/main/java/datadog/crashtracking/parsers/HotspotCrashLogParser.java b/dd-java-agent/agent-crashtracking/src/main/java/datadog/crashtracking/parsers/HotspotCrashLogParser.java
@@ -62,6 +62,7 @@ enum State {
     SUMMARY,
     THREAD,
     STACKTRACE,
+    REGISTER_TO_MEMORY_MAPPING,
     REGISTERS,
     PROCESS,
     VM_ARGUMENTS,
@@ -95,12 +96,16 @@ public HotspotCrashLogParser() {
   // per line.
   private static final Pattern REGISTER_ENTRY_PARSER =
       Pattern.compile("([A-Za-z][A-Za-z0-9]*)\\s*=\\s*(0x[0-9a-fA-F]+)");
+  private static final Pattern REGISTER_TO_MEMORY_MAPPING_PARSER =
+      Pattern.compile("^\\s*([A-Za-z][A-Za-z0-9]*)\\s*=");
   // Used for the REGISTERS-state exit condition only: the register name must start the line
   // (after optional whitespace). This prevents lines like "Top of Stack: (sp=0x...)" and
   // "Instructions: (pc=0x...)" from being mistaken for register entries by REGISTER_ENTRY_PARSER's
   // find(), which would otherwise match the lowercase "sp"/"pc" tokens embedded in those lines.
   private static final Pattern REGISTER_LINE_START =
       Pattern.compile("^\\s*[A-Za-z][A-Za-z0-9]*\\s*=\\s*0x");
+  private static final Pattern SUBSECTION_TITLE =
+      Pattern.compile("^\\s*[A-Za-z][\\w ]*:.+$");
   private static final Pattern COMPILED_JAVA_ADDRESS_PARSER =
       Pattern.compile("@\\s+(0x[0-9a-fA-F]+)\\s+\\[(0x[0-9a-fA-F]+)\\+(0x[0-9a-fA-F]+)\\]");
 
@@ -350,10 +355,14 @@ public CrashLog parse(String uuid, String crashLog) {
     String datetimeRaw = null;
     boolean incomplete = false;
     String oomMessage = null;
-    Map<String, String> registers = null;
+    Map<String, String> registers = new LinkedHashMap<>();
+    Map<String, String> registerToMemoryMapping = new LinkedHashMap<>();
+    String currentRegisterToMemoryMapping = "";
     List<String> runtimeArgs = null;
     List<String> dynamicLibraryLines = null;
     String dynamicLibraryKey = null;
+    boolean previousLineBlank = false;
+    State nextThreadSectionState = null;
 
     String[] lines = NEWLINE_SPLITTER.split(crashLog);
     outer:
@@ -410,7 +419,10 @@ public CrashLog parse(String uuid, String crashLog) {
           }
           break;
         case STACKTRACE:
-          if (line.startsWith("siginfo:")) {
+          nextThreadSectionState = nextThreadSectionState(line, previousLineBlank);
+          if (nextThreadSectionState != null) {
+            state = nextThreadSectionState;
+          } else if (line.startsWith("siginfo:")) {
             // spotless:off
             // siginfo: si_signo: 11 (SIGSEGV), si_code: 1 (SEGV_MAPERR), si_addr: 0x70
             // siginfo: si_signo: 11 (SIGSEGV), si_code: 0 (SI_USER), si_pid: 554848, si_uid: 1000
@@ -426,11 +438,6 @@ public CrashLog parse(String uuid, String crashLog) {
               Integer siUid = safelyParseInt(siginfoMatcher.group(7));
               sigInfo = new SigInfo(number, name, siCode, sigAction, address, siPid, siUid);
             }
-          } else if (line.startsWith("Registers:")) {
-            registers = new LinkedHashMap<>();
-            state = State.REGISTERS;
-          } else if (line.contains("P R O C E S S")) {
-            state = State.PROCESS;
           } else {
             // Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)
             final StackFrame frame = parseLine(line);
@@ -439,8 +446,28 @@ public CrashLog parse(String uuid, String crashLog) {
             }
           }
           break;
+        case REGISTER_TO_MEMORY_MAPPING:
+          nextThreadSectionState = nextThreadSectionState(line, previousLineBlank);
+          if (nextThreadSectionState != null) {
+            currentRegisterToMemoryMapping = "";
+            state = nextThreadSectionState;
+          } else if (!line.isEmpty()) {
+            final Matcher m = REGISTER_TO_MEMORY_MAPPING_PARSER.matcher(line);
+            if (m.lookingAt()) {
+              currentRegisterToMemoryMapping = m.group(1);
+              registerToMemoryMapping.put(
+                  currentRegisterToMemoryMapping, line.substring(line.indexOf('=') + 1));
+            } else if (!currentRegisterToMemoryMapping.isEmpty()) {
+              registerToMemoryMapping.computeIfPresent(
+                  currentRegisterToMemoryMapping, (key, value) -> value + "\n" + line);
+            }
+          }
+          break;
         case REGISTERS:
-          if (!line.isEmpty() && !REGISTER_LINE_START.matcher(line).find()) {
+          nextThreadSectionState = nextThreadSectionState(line, previousLineBlank);
+          if (nextThreadSectionState != null) {
+            state = nextThreadSectionState;
+          } else if (!line.isEmpty() && !REGISTER_LINE_START.matcher(line).find()) {
             // non-empty line that does not start with a register entry signals end of section
             state = State.STACKTRACE;
           } else {
@@ -508,6 +535,7 @@ public CrashLog parse(String uuid, String crashLog) {
           // unexpected parser state; bail out
           break outer;
       }
+      previousLineBlank = line.isEmpty();
     }
 
     // PROCESS and SYSTEM sections are late enough that all critical data is captured
@@ -572,9 +600,10 @@ public CrashLog parse(String uuid, String crashLog) {
     Integer parsedPid = safelyParseInt(pid);
     ProcInfo procInfo = parsedPid != null ? new ProcInfo(parsedPid) : null;
     Experimental experimental =
-        (registers != null && !registers.isEmpty())
+        !registers.isEmpty()
+                || !registerToMemoryMapping.isEmpty()
                 || (runtimeArgs != null && !runtimeArgs.isEmpty())
-            ? new Experimental(registers, runtimeArgs)
+            ? new Experimental(registers, registerToMemoryMapping, runtimeArgs)
             : null;
     DynamicLibs files =
         (dynamicLibraryLines != null && !dynamicLibraryLines.isEmpty())
@@ -608,6 +637,27 @@ static String dateTimeToISO(String datetime) {
     }
   }
 
+  private static State nextThreadSectionState(String line, boolean previousLineBlank) {
+    if (line.startsWith("Register to memory mapping:")) {
+      return State.REGISTER_TO_MEMORY_MAPPING;
+    }
+    if (line.startsWith("Registers:")) {
+      return State.REGISTERS;
+    }
+    if (line.startsWith("siginfo:")) {
+      return null;
+    }
+    if (line.contains("P R O C E S S")) {
+      return State.PROCESS;
+    }
+    if (previousLineBlank
+        && !line.contains("=")
+        && SUBSECTION_TITLE.matcher(line).matches()) {
+      return State.STACKTRACE;
+    }
+    return null;
+  }
+
   /**
    * Detects whether the Dynamic libraries section comes from Linux {@code /proc/self/maps} (address
    * range format {@code addr-addr perms ...}) or from the BSD/macOS dyld callback (format {@code
diff --git a/dd-java-agent/agent-crashtracking/src/test/java/datadog/crashtracking/CrashUploaderTest.java b/dd-java-agent/agent-crashtracking/src/test/java/datadog/crashtracking/CrashUploaderTest.java
@@ -4,6 +4,7 @@
 import static datadog.crashtracking.CrashUploader.HEADER_DD_TELEMETRY_API_VERSION;
 import static datadog.crashtracking.CrashUploader.TELEMETRY_API_VERSION;
 import static net.javacrumbs.jsonunit.assertj.JsonAssertions.assertThatJson;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -392,6 +393,33 @@ public void testErrorTrackingSerializesRuntimeArgs() throws Exception {
     assertTrue(found);
   }
 
+  @Test
+  public void testErrorTrackingSerializesRegisterToMemoryMapping()
+      throws Exception {
+    ConfigManager.StoredConfig crashConfig =
+        new ConfigManager.StoredConfig.Builder(config)
+            .reportUUID(SAMPLE_UUID)
+            .processTags("a:b")
+            .runtimeId("1234")
+            .tags(ConfigManager.getMergedTagsForSerialization(Config.get()))
+            .build();
+
+    uploader = new CrashUploader(config, crashConfig);
+    server.enqueue(new MockResponse().setResponseCode(200));
+    uploader.remoteUpload(readFileAsString("sample-crash.txt"), false, true);
+
+    final RecordedRequest recordedRequest = server.takeRequest(5, TimeUnit.SECONDS);
+    final ObjectMapper mapper = new ObjectMapper();
+    final JsonNode event = mapper.readTree(recordedRequest.getBody().readUtf8());
+
+    final JsonNode mapping = event.at("/experimental/register_to_memory_mapping");
+    assertThat(mapping.isObject()).isTrue();
+    assertThat(mapping.get("RSP").asText())
+        .isEqualTo(
+            "0x00007f35e6253190 is pointing into the stack for thread: 0x00007f36cd96cc80");
+    assertThat(mapping.get("RDI").asText()).isEqualTo("0x0 is NULL");
+  }
+
   private void assertCommonHeader(JsonNode event) {
     assertEquals(TELEMETRY_API_VERSION, event.get("api_version").asText());
     assertEquals("logs", event.get("request_type").asText());
diff --git a/dd-java-agent/agent-crashtracking/src/test/java/datadog/crashtracking/parsers/HotspotCrashLogParserTest.java b/dd-java-agent/agent-crashtracking/src/test/java/datadog/crashtracking/parsers/HotspotCrashLogParserTest.java
@@ -1,5 +1,7 @@
 package datadog.crashtracking.parsers;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.InstanceOfAssertFactories.STRING;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -87,11 +89,47 @@ public void testRegisterParsingLinuxAarch64() throws Exception {
     assertEquals("0x0000000000000000", crashLog.experimental.ucontext.get("R0"));
     assertEquals("0x0000000000000001", crashLog.experimental.ucontext.get("R1"));
     assertEquals("0x0000ffff9efa168c", crashLog.experimental.ucontext.get("R30"));
-    // "Register to memory mapping:" section must NOT be included
     assertEquals(31, crashLog.experimental.ucontext.size(), "R0-R30 = 31 registers");
+  }
 
-    assertNotNull(crashLog.experimental.runtimeArgs);
-    assertTrue(crashLog.experimental.runtimeArgs.contains("--add-modules=ALL-DEFAULT"));
+  @Test
+  public void testRegisterToMemoryMapping() throws Exception {
+    CrashLog crashLog =
+        new HotspotCrashLogParser()
+            .parse(UUID.randomUUID().toString(), readFileAsString("sample-crash.txt"));
+
+    assertThat(crashLog.experimental).isNotNull();
+    assertThat(crashLog.experimental.registerToMemoryMapping)
+        .isNotNull()
+        .containsEntry(
+            "RAX",
+            "0x00007f36ccfbf170 points into unknown readable memory: 0x00007f3600000758 | 58 07 00 00 36 7f 00 00")
+        .containsEntry(
+            "RSP", "0x00007f35e6253190 is pointing into the stack for thread: 0x00007f36cd96cc80")
+        .containsEntry("RDI", "0x0 is NULL")
+        .containsEntry(
+            "R11",
+            "{method} {0x00007f3744198b70} 'resize' '()[Ljava/util/HashMap$Node;' in 'java/util/HashMap'");
+  }
+
+  @Test
+  public void testRegisterToMultilineMemoryMapping() throws Exception {
+    CrashLog crashLog =
+        new HotspotCrashLogParser()
+            .parse(
+                UUID.randomUUID().toString(), readFileAsString("sample-crash-linux-aarch64.txt"));
+
+    assertThat(crashLog.experimental).isNotNull();
+    assertThat(crashLog.experimental.registerToMemoryMapping)
+        .isNotNull()
+        .containsKey("R10");
+    assertThat(crashLog.experimental.registerToMemoryMapping)
+        .extractingByKey("R10", STRING)
+        .startsWith("0x00000007ffe85850 is an oop: java.lang.Class ")
+        .contains("\n{0x00000007ffe85850} - klass: 'java/lang/Class'")
+        .contains("\n - ---- fields (total size 25 words):")
+        .contains(
+            "\n - private transient 'name' 'Ljava/lang/String;' @44  \"jdk.internal.misc.Unsafe\"");
   }
 
   @Test
