support PrettyMethod with_signature formatted java frames

supervacuus · supervacuus · commit 35e101078e4d · 2026-02-25T13:43:17.000+01:00
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/tombstone/TombstoneParser.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/tombstone/TombstoneParser.java
@@ -135,31 +135,27 @@ private SentryStackTrace createStackTrace(@NonNull final TombstoneProtos.Thread
       final SentryStackFrame stackFrame = new SentryStackFrame();
       if (isJavaFrame(frame)) {
         stackFrame.setPlatform("java");
+        final String module = extractJavaModuleName(frame.getFunctionName());
         stackFrame.setFunction(extractJavaFunctionName(frame.getFunctionName()));
-        stackFrame.setModule(extractJavaModuleName(frame.getFunctionName()));
+        stackFrame.setModule(module);
+
+        // For Java frames, check in-app against the module (package name), which is what
+        // inAppIncludes/inAppExcludes are designed to match against.
+        @Nullable
+        Boolean inApp =
+            (module == null || module.isEmpty())
+                ? Boolean.FALSE
+                : SentryStackTraceFactory.isInApp(module, inAppIncludes, inAppExcludes);
+        stackFrame.setInApp(inApp != null && inApp);
       } else {
         stackFrame.setPackage(frame.getFileName());
         stackFrame.setFunction(frame.getFunctionName());
         stackFrame.setInstructionAddr(formatHex(frame.getPc()));
-      }
 
-      // inAppIncludes/inAppExcludes filter by Java/Kotlin package names, which don't overlap
-      // with native C/C++ function names (e.g., "crash", "__libc_init"). For native frames,
-      // isInApp() returns null, making nativeLibraryDir the effective in-app check.
-      // Protobuf returns "" for unset function names, which would incorrectly return true
-      // from isInApp(), so we treat empty as false to let nativeLibraryDir decide.
-      final String functionName = frame.getFunctionName();
-      @Nullable
-      Boolean inApp =
-          functionName.isEmpty()
-              ? Boolean.FALSE
-              : SentryStackTraceFactory.isInApp(functionName, inAppIncludes, inAppExcludes);
-
-      final boolean isInNativeLibraryDir =
-          nativeLibraryDir != null && frame.getFileName().startsWith(nativeLibraryDir);
-      inApp = (inApp != null && inApp) || isInNativeLibraryDir;
-
-      stackFrame.setInApp(inApp);
+        final boolean isInNativeLibraryDir =
+            nativeLibraryDir != null && frame.getFileName().startsWith(nativeLibraryDir);
+        stackFrame.setInApp(isInNativeLibraryDir);
+      }
       frames.add(0, stackFrame);
     }
 
@@ -180,19 +176,50 @@ private SentryStackTrace createStackTrace(@NonNull final TombstoneProtos.Thread
     return stacktrace;
   }
 
+  /**
+   * Normalizes a PrettyMethod-formatted function name by stripping the return type prefix and
+   * parameter list suffix that dex2oat may include when compiling AOT frames into the symtab.
+   *
+   * <p>e.g. "void com.example.MyClass.myMethod(int, java.lang.String)" ->
+   * "com.example.MyClass.myMethod"
+   */
+  private static String normalizeFunctionName(String fqFunctionName) {
+    String normalized = fqFunctionName.trim();
+
+    // When dex2oat compiles AOT frames, PrettyMethod with_signature format may be used:
+    // "void com.example.MyClass.myMethod(int, java.lang.String)"
+    // A space is never part of a normal fully-qualified method name, so its presence
+    // reliably indicates the with_signature format.
+    final int spaceIndex = normalized.indexOf(' ');
+    if (spaceIndex >= 0) {
+      // Strip return type prefix
+      normalized = normalized.substring(spaceIndex + 1).trim();
+
+      // Strip parameter list suffix
+      final int parenIndex = normalized.indexOf('(');
+      if (parenIndex >= 0) {
+        normalized = normalized.substring(0, parenIndex);
+      }
+    }
+
+    return normalized;
+  }
+
   private static @Nullable String extractJavaModuleName(String fqFunctionName) {
-    if (fqFunctionName.contains(".")) {
-      return fqFunctionName.substring(0, fqFunctionName.lastIndexOf("."));
+    final String normalized = normalizeFunctionName(fqFunctionName);
+    if (normalized.contains(".")) {
+      return normalized.substring(0, normalized.lastIndexOf("."));
     } else {
       return "";
     }
   }
 
   private static @Nullable String extractJavaFunctionName(String fqFunctionName) {
-    if (fqFunctionName.contains(".")) {
-      return fqFunctionName.substring(fqFunctionName.lastIndexOf(".") + 1);
+    final String normalized = normalizeFunctionName(fqFunctionName);
+    if (normalized.contains(".")) {
+      return normalized.substring(normalized.lastIndexOf(".") + 1);
     } else {
-      return fqFunctionName;
+      return normalized;
     }
   }
 
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/tombstone/TombstoneParserTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/tombstone/TombstoneParserTest.kt
@@ -464,6 +464,119 @@ class TombstoneParserTest {
     assertEquals(expectedJson, actualJson)
   }
 
+  @Test
+  fun `extracts java function and module from plain PrettyMethod format`() {
+    val event = parseTombstoneWithJavaFunctionName("com.example.MyClass.myMethod")
+    val frame = event.threads!![0].stacktrace!!.frames!![0]
+    assertEquals("java", frame.platform)
+    assertEquals("myMethod", frame.function)
+    assertEquals("com.example.MyClass", frame.module)
+  }
+
+  @Test
+  fun `extracts java function and module from PrettyMethod with_signature format`() {
+    val event =
+      parseTombstoneWithJavaFunctionName("void com.example.MyClass.myMethod(int, java.lang.String)")
+    val frame = event.threads!![0].stacktrace!!.frames!![0]
+    assertEquals("java", frame.platform)
+    assertEquals("myMethod", frame.function)
+    assertEquals("com.example.MyClass", frame.module)
+  }
+
+  @Test
+  fun `extracts java function and module from PrettyMethod with_signature with object return type`() {
+    val event =
+      parseTombstoneWithJavaFunctionName("java.lang.String com.example.MyClass.myMethod(int)")
+    val frame = event.threads!![0].stacktrace!!.frames!![0]
+    assertEquals("java", frame.platform)
+    assertEquals("myMethod", frame.function)
+    assertEquals("com.example.MyClass", frame.module)
+  }
+
+  @Test
+  fun `extracts java function and module from PrettyMethod with_signature with no params`() {
+    val event = parseTombstoneWithJavaFunctionName("void com.example.MyClass.myMethod()")
+    val frame = event.threads!![0].stacktrace!!.frames!![0]
+    assertEquals("java", frame.platform)
+    assertEquals("myMethod", frame.function)
+    assertEquals("com.example.MyClass", frame.module)
+  }
+
+  @Test
+  fun `handles bare function name without package`() {
+    val event = parseTombstoneWithJavaFunctionName("myMethod")
+    val frame = event.threads!![0].stacktrace!!.frames!![0]
+    assertEquals("java", frame.platform)
+    assertEquals("myMethod", frame.function)
+    assertEquals("", frame.module)
+  }
+
+  @Test
+  fun `handles PrettyMethod with_signature bare function name`() {
+    val event = parseTombstoneWithJavaFunctionName("void myMethod()")
+    val frame = event.threads!![0].stacktrace!!.frames!![0]
+    assertEquals("java", frame.platform)
+    assertEquals("myMethod", frame.function)
+    assertEquals("", frame.module)
+  }
+
+  @Test
+  fun `java frame with_signature format is correctly detected as inApp`() {
+    val event =
+      parseTombstoneWithJavaFunctionName("void io.sentry.samples.android.MyClass.myMethod(int)")
+    val frame = event.threads!![0].stacktrace!!.frames!![0]
+    assertEquals("java", frame.platform)
+    assertEquals(true, frame.isInApp)
+  }
+
+  @Test
+  fun `java frame with_signature format is correctly detected as not inApp`() {
+    val event =
+      parseTombstoneWithJavaFunctionName(
+        "void android.os.Handler.handleCallback(android.os.Message)"
+      )
+    val frame = event.threads!![0].stacktrace!!.frames!![0]
+    assertEquals("java", frame.platform)
+    assertEquals(false, frame.isInApp)
+  }
+
+  private fun parseTombstoneWithJavaFunctionName(functionName: String): io.sentry.SentryEvent {
+    val tombstone =
+      TombstoneProtos.Tombstone.newBuilder()
+        .setPid(1234)
+        .setTid(1234)
+        .setSignalInfo(
+          TombstoneProtos.Signal.newBuilder()
+            .setNumber(11)
+            .setName("SIGSEGV")
+            .setCode(1)
+            .setCodeName("SEGV_MAPERR")
+        )
+        .putThreads(
+          1234,
+          TombstoneProtos.Thread.newBuilder()
+            .setId(1234)
+            .setName("main")
+            .addCurrentBacktrace(
+              TombstoneProtos.BacktraceFrame.newBuilder()
+                .setPc(0x1000)
+                .setFunctionName(functionName)
+                .setFileName("/data/app/base.apk!classes.oat")
+            )
+            .build(),
+        )
+        .build()
+
+    val parser =
+      TombstoneParser(
+        ByteArrayInputStream(tombstone.toByteArray()),
+        inAppIncludes,
+        inAppExcludes,
+        nativeLibraryDir,
+      )
+    return parser.parse()
+  }
+
   private fun serializeDebugMeta(debugMeta: DebugMeta): String {
     val logger = mock<ILogger>()
     val writer = StringWriter()
