Add J9/OpenJ9 crash tracking support (#10496)

Author: jbachorik

dd-java-agent/agent-bootstrap/src/main/java/datadog/trace/bootstrap/Agent.java

@@ -1278,10 +1278,6 @@ private static boolean isCrashTrackingAutoconfigEnabled() {
   }
 
   private static void initializeCrashTracking(boolean delayed, boolean checkNative) {
-    if (JavaVirtualMachine.isJ9()) {
-      // TODO currently crash tracking is supported only for HotSpot based JVMs
-      return;
-    }
     log.debug("Initializing crashtracking");
     try {
       Class<?> clz = AGENT_CLASSLOADER.loadClass("datadog.crashtracking.Initializer");

dd-java-agent/agent-crashtracking/src/main/java/datadog/crashtracking/CrashLogParser.java

@@ -2,9 +2,49 @@
 
 import datadog.crashtracking.dto.CrashLog;
 import datadog.crashtracking.parsers.HotspotCrashLogParser;
+import datadog.crashtracking.parsers.J9JavacoreParser;
 
 public final class CrashLogParser {
+
+  /** J9 javacore files start with section markers like "0SECTION" */
+  private static final String J9_SECTION_MARKER = "0SECTION";
+
+  /** J9 javacore TITLE section identifier */
+  private static final String J9_TITLE_MARKER = "TITLE";
+
+  /** Parse a HotSpot crash log (hs_err_pidXXX.log format). */
   public static CrashLog fromHotspotCrashLog(String uuid, String logText) {
     return new HotspotCrashLogParser().parse(uuid, logText);
   }
+
+  /** Parse a J9/OpenJ9 javacore dump file. */
+  public static CrashLog fromJ9Javacore(String uuid, String javacoreContent) {
+    return new J9JavacoreParser().parse(uuid, javacoreContent);
+  }
+
+  /**
+   * Auto-detect crash log format and parse accordingly.
+   *
+   * <p>Detection is based on format-specific markers:
+   *
+   * <ul>
+   *   <li>J9 javacore: Contains "0SECTION" and "TITLE" markers
+   *   <li>HotSpot hs_err: Default fallback
+   * </ul>
+   */
+  public static CrashLog parse(String uuid, String content) {
+    if (isJ9Javacore(content)) {
+      return fromJ9Javacore(uuid, content);
+    }
+    return fromHotspotCrashLog(uuid, content);
+  }
+
+  /** Check if the content appears to be a J9 javacore file. */
+  static boolean isJ9Javacore(String content) {
+    if (content == null || content.isEmpty()) {
+      return false;
+    }
+    // J9 javacores have a distinctive format with 0SECTION markers
+    return content.contains(J9_SECTION_MARKER) && content.contains(J9_TITLE_MARKER);
+  }
 }

dd-java-agent/agent-crashtracking/src/main/java/datadog/crashtracking/CrashUploader.java

@@ -256,7 +256,8 @@ void remoteUpload(
       @Nonnull String fileContent, boolean sendToTelemetry, boolean sendToErrorTracking) {
     final String uuid = storedConfig.reportUUID;
     try {
-      CrashLog crashLog = CrashLogParser.fromHotspotCrashLog(uuid, fileContent);
+      // Auto-detect crash log format (HotSpot hs_err or J9 javacore)
+      CrashLog crashLog = CrashLogParser.parse(uuid, fileContent);
       if (sendToTelemetry) {
         uploadToTelemetry(crashLog);
       }

dd-java-agent/agent-crashtracking/src/main/java/datadog/crashtracking/CrashUploaderScriptInitializer.java

@@ -31,6 +31,11 @@ private CrashUploaderScriptInitializer() {}
 
   // @VisibleForTests
   static void initialize(String onErrorVal, String onErrorFile) {
+    initialize(onErrorVal, onErrorFile, null);
+  }
+
+  // @VisibleForTests
+  static void initialize(String onErrorVal, String onErrorFile, String javacorePath) {
     if (onErrorVal == null || onErrorVal.isEmpty()) {
       LOG.debug(
           SEND_TELEMETRY, "'-XX:OnError' argument was not provided. Crash tracking is disabled.");
@@ -56,7 +61,11 @@ static void initialize(String onErrorVal, String onErrorFile) {
       return;
     }
 
-    writeConfigToPath(scriptPath, "agent", agentJar, "hs_err", onErrorFile);
+    if (javacorePath != null && !javacorePath.isEmpty()) {
+      writeConfigToPath(scriptPath, "agent", agentJar, "javacore_path", javacorePath);
+    } else {
+      writeConfigToPath(scriptPath, "agent", agentJar, "hs_err", onErrorFile);
+    }
   }
 
   private static boolean copyCrashUploaderScript(

dd-java-agent/agent-crashtracking/src/main/java/datadog/crashtracking/Initializer.java

@@ -6,6 +6,7 @@
 
 import com.datadoghq.profiler.JVMAccess;
 import com.sun.management.HotSpotDiagnosticMXBean;
+import datadog.environment.JavaVirtualMachine;
 import datadog.environment.OperatingSystem;
 import datadog.libs.ddprof.DdprofLibraryLoader;
 import datadog.trace.api.Platform;
@@ -17,6 +18,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.List;
 import java.util.StringTokenizer;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
@@ -75,6 +77,11 @@ public boolean setValue(String flagName, String value) {
   }
 
   public static boolean initialize(boolean forceJmx) {
+    // J9/OpenJ9 requires different initialization path
+    if (JavaVirtualMachine.isJ9()) {
+      return initializeJ9();
+    }
+
     try {
       FlagAccess access = null;
       // Native images don't support the native ddprof library, use JMX instead
@@ -105,6 +112,105 @@ public static boolean initialize(boolean forceJmx) {
     return false;
   }
 
+  /**
+   * Initialize crash tracking for J9/OpenJ9 JVMs.
+   *
+   * <p>Unlike HotSpot, J9's -Xdump option cannot be modified at runtime. This method:
+   *
+   * <ol>
+   *   <li>Checks if -Xdump:tool is already configured
+   *   <li>Deploys the crash uploader script if configured
+   *   <li>Logs instructions for manual configuration if not configured
+   * </ol>
+   *
+   * @return true if -Xdump is properly configured, false otherwise
+   */
+  private static boolean initializeJ9() {
+    try {
+      String scriptPath = getJ9CrashUploaderScriptPath();
+
+      // Check if -Xdump:tool is already configured via JVM arguments
+      boolean xdumpConfigured = isXdumpToolConfigured();
+      // Get custom javacore path if configured
+      String javacorePath = getJ9JavacorePath();
+
+      if (xdumpConfigured) {
+        LOG.debug("J9 crash tracking: -Xdump:tool already configured, crash uploads enabled");
+        // Initialize the crash uploader script and config manager
+        CrashUploaderScriptInitializer.initialize(scriptPath, null, javacorePath);
+        // Also set up OOME notifier script
+        String oomeScript = getScript("dd_oome_notifier");
+        OOMENotifierScriptInitializer.initialize(oomeScript);
+        return true;
+      } else {
+        // Log instructions for manual configuration
+        LOG.info("J9 JVM detected. To enable crash tracking, add this JVM argument at startup:");
+        LOG.info("  -Xdump:tool:events=gpf+abort,exec={}\\ %pid", scriptPath);
+        LOG.info(
+            "Crash tracking will not be active until this argument is added and JVM is restarted.");
+        return false;
+      }
+    } catch (Throwable t) {
+      logInitializationError(
+          "Unexpected exception while initializing J9 crash tracking. Crash tracking will not work.",
+          t);
+    }
+    return false;
+  }
+
+  /**
+   * Get the custom javacore file path from -Xdump:java:file=... JVM argument.
+   *
+   * @return the custom javacore path, or null if not configured
+   */
+  private static String getJ9JavacorePath() {
+    List<String> vmArgs = JavaVirtualMachine.getVmOptions();
+    for (String arg : vmArgs) {
+      if (arg.startsWith("-Xdump:java:file=") || arg.startsWith("-Xdump:java+heap:file=")) {
+        int fileIdx = arg.indexOf("file=");
+        if (fileIdx >= 0) {
+          String path = arg.substring(fileIdx + 5);
+          // Handle comma-separated options: -Xdump:java:file=/path,request=exclusive
+          int commaIdx = path.indexOf(',');
+          if (commaIdx > 0) {
+            path = path.substring(0, commaIdx);
+          }
+          return path;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Check if -Xdump:tool is configured with our crash uploader script.
+   *
+   * <p>Looks for JVM arguments matching: -Xdump:tool:events=...,exec=...dd_crash_uploader...
+   */
+  private static boolean isXdumpToolConfigured() {
+    List<String> vmArgs = JavaVirtualMachine.getVmOptions();
+    for (String arg : vmArgs) {
+      if (arg.startsWith("-Xdump:tool") && arg.contains("dd_crash_uploader")) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Get the path where the crash uploader script should be deployed for J9.
+   *
+   * <p>Note: The actual script deployment is handled by {@link CrashUploaderScriptInitializer} when
+   * initialize() is called with this path.
+   *
+   * @return the full path for the crash uploader script
+   */
+  private static String getJ9CrashUploaderScriptPath() {
+    String scriptFileName = getScriptFileName("dd_crash_uploader");
+    Path scriptPath = TempLocationManager.getInstance().getTempDir().resolve(scriptFileName);
+    return scriptPath.toString();
+  }
+
   static InputStream getCrashUploaderTemplate() {
     String name = OperatingSystem.isWindows() ? "upload_crash.bat" : "upload_crash.sh";
     return CrashUploader.class.getResourceAsStream(name);