feat(android): Add nativeStackAndroid support to NativeLinkedErrors

Captures the JVM stack trace attached to rejected native module promises
as a linked exception, so the Java cause of a rejected promise is reported
alongside the JS error.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: lucas-zimerman

CHANGELOG.md

@@ -16,6 +16,7 @@
   - Note: Expo Router span/breadcrumb attributes that may contain user identifiers (`route.href`, `route.params`, and concrete pathnames derived from string hrefs such as `/users/42`) are now gated behind `sendDefaultPii`. When `sendDefaultPii` is off (the default), prefetch spans for string hrefs use `route.name: 'unknown'` and omit `route.href`. Templated object hrefs (e.g. `{ pathname: '/users/[id]' }`) are unaffected.
 - Warn when Gradle resolves `sentry-android` to a version incompatible with the SDK ([#6238](https://github.com/getsentry/sentry-react-native/pull/6238))
 - Attach the active TurboModule method to native crash reports as `contexts.turbo_module` + `turbo_module.name` / `turbo_module.method` tags ([#6227](https://github.com/getsentry/sentry-react-native/pull/6227))
+- Add `nativeStackAndroid` support to `NativeLinkedErrors`, capturing the JVM stack trace of rejected native module promises as a linked exception ([#3257](https://github.com/getsentry/sentry-react-native/issues/3257))
 
 ### Fixes
 

packages/core/src/js/integrations/nativelinkederrors.ts

@@ -50,13 +50,15 @@ function preprocessEvent(event: Event, hint: EventHint | undefined, client: Clie
   }
 
   const parser = client.getOptions().stackParser;
+  const originalException = hint.originalException as ExtendedError;
+
+  const { exceptions: linkedErrors, debugImages } = walkErrorTree(parser, limit, originalException, key);
+
+  const nativeStackAndroidException = exceptionFromNativeStackAndroid(originalException);
+  if (nativeStackAndroidException && linkedErrors.length + 1 < limit) {
+    linkedErrors.push(nativeStackAndroidException);
+  }
 
-  const { exceptions: linkedErrors, debugImages } = walkErrorTree(
-    parser,
-    limit,
-    hint.originalException as ExtendedError,
-    key,
-  );
   event.exception.values = [...event.exception.values, ...linkedErrors];
 
   event.debug_meta = event.debug_meta || {};
@@ -146,22 +148,70 @@ function exceptionFromJavaStackElements(javaThrowable: {
     value: javaThrowable.message,
     stacktrace: {
       frames: javaThrowable.stackElements
-        .map(
-          stackElement =>
-            <StackFrame>{
-              platform: 'java',
-              module: stackElement.className,
-              filename: stackElement.fileName,
-              lineno: stackElement.lineNumber >= 0 ? stackElement.lineNumber : undefined,
-              function: stackElement.methodName,
-              in_app: nativePackage !== null && stackElement.className.startsWith(nativePackage) ? true : undefined,
-            },
+        .map(stackElement =>
+          javaStackFrame(
+            stackElement.className,
+            stackElement.fileName,
+            stackElement.methodName,
+            stackElement.lineNumber,
+            nativePackage,
+          ),
         )
         .reverse(),
     },
   };
 }
 
+/**
+ * Converts the `nativeStackAndroid` frames attached to errors from rejected promises
+ * (`Promise.reject(code, message, throwable, userInfo)`, see Android's `PromiseImpl.java`) to a SentryException.
+ */
+function exceptionFromNativeStackAndroid(error: ExtendedError): Exception | undefined {
+  const nativeStackAndroid = error.nativeStackAndroid as
+    | {
+        class: string;
+        file: string;
+        lineNumber: number;
+        methodName: string;
+      }[]
+    | undefined;
+
+  if (!Array.isArray(nativeStackAndroid) || nativeStackAndroid.length === 0) {
+    return undefined;
+  }
+
+  const nativePackage = fetchNativePackage();
+  return {
+    type: error.name,
+    value: error.message,
+    stacktrace: {
+      frames: nativeStackAndroid
+        .map(frame => javaStackFrame(frame.class, frame.file, frame.methodName, frame.lineNumber, nativePackage))
+        .reverse(),
+    },
+  };
+}
+
+/**
+ * Converts a Java stack trace element to a Sentry stack frame.
+ */
+function javaStackFrame(
+  className: string,
+  fileName: string,
+  methodName: string,
+  lineNumber: number,
+  nativePackage: string | null,
+): StackFrame {
+  return {
+    platform: 'java',
+    module: className,
+    filename: fileName,
+    lineno: lineNumber >= 0 ? lineNumber : undefined,
+    function: methodName,
+    in_app: nativePackage !== null && className.startsWith(nativePackage) ? true : undefined,
+  };
+}
+
 /**
  * Converts StackAddresses to a SentryException with DebugMetaImages
  */

packages/core/test/integrations/nativelinkederrors.test.ts

@@ -340,6 +340,107 @@ describe('NativeLinkedErrors', () => {
     );
   });
 
+  it('adds android nativeStackAndroid from a rejected promise to the event', async () => {
+    const actualEvent = await executeIntegrationFor(
+      {
+        exception: {
+          values: [
+            {
+              type: 'Error',
+              value: 'Captured exception',
+              stacktrace: {
+                frames: [
+                  {
+                    colno: 17,
+                    filename: 'app:///Pressability.js',
+                    function: '_performTransitionSideEffects',
+                  },
+                ],
+              },
+              mechanism: {
+                type: 'generic',
+                handled: true,
+              },
+            },
+          ],
+        },
+      },
+      {
+        originalException: createNewError({
+          message: 'Java error message.',
+          name: 'java.lang.RuntimeException',
+          stack:
+            'java.lang.RuntimeException: Java error message.\n' +
+            'at onPress (index.bundle:75:33)\n' +
+            'at _performTransitionSideEffects (index.bundle:65919:22)',
+          nativeStackAndroid: [
+            {
+              class: 'mock.native.bundle.id.Crash',
+              file: 'Crash.kt',
+              lineNumber: 10,
+              methodName: 'getDataCrash',
+            },
+            {
+              class: 'com.facebook.jni.NativeRunnable',
+              file: 'NativeRunnable.java',
+              lineNumber: 2,
+              methodName: 'run',
+            },
+          ],
+        }),
+      },
+    );
+
+    expect(actualEvent).toEqual(
+      expect.objectContaining(<Partial<Event>>{
+        exception: {
+          values: [
+            {
+              type: 'Error',
+              value: 'Captured exception',
+              stacktrace: {
+                frames: [
+                  {
+                    colno: 17,
+                    filename: 'app:///Pressability.js',
+                    function: '_performTransitionSideEffects',
+                  },
+                ],
+              },
+              mechanism: {
+                type: 'generic',
+                handled: true,
+              },
+            },
+            {
+              type: 'java.lang.RuntimeException',
+              value: 'Java error message.',
+              stacktrace: {
+                frames: [
+                  expect.objectContaining({
+                    platform: 'java',
+                    module: 'com.facebook.jni.NativeRunnable',
+                    filename: 'NativeRunnable.java',
+                    lineno: 2,
+                    function: 'run',
+                  }),
+                  expect.objectContaining({
+                    platform: 'java',
+                    module: 'mock.native.bundle.id.Crash',
+                    filename: 'Crash.kt',
+                    lineno: 10,
+                    function: 'getDataCrash',
+                    in_app: true,
+                  }),
+                ],
+              },
+            },
+          ],
+        },
+      }),
+    );
+  });
+
   it('handles events with a string cause', async () => {
     const actualEvent = await executeIntegrationFor(
       {
@@ -390,12 +491,21 @@ function executeIntegrationFor(mockedEvent: Event, mockedHint: EventHint): Event
   return mockedEvent;
 }
 
-function createNewError(from: { message: string; name?: string; stack?: string; cause?: unknown }): ExtendedError {
+function createNewError(from: {
+  message: string;
+  name?: string;
+  stack?: string;
+  cause?: unknown;
+  nativeStackAndroid?: unknown;
+}): ExtendedError {
   const error: ExtendedError = new Error(from.message);
   if (from.name) {
     error.name = from.name;
   }
   error.stack = from.stack;
   error.cause = from.cause;
+  if (from.nativeStackAndroid) {
+    error.nativeStackAndroid = from.nativeStackAndroid;
+  }
   return error;
 }

samples/react-native/android/app/src/main/java/io/sentry/reactnative/sample/SamplePackage.java

@@ -72,6 +72,14 @@ public void crashOrNumber(Promise promise) {
             promise.resolve(42);
           }
 
+          @ReactMethod
+          public void rejectWithNativeStack(Promise promise) {
+            promise.reject(
+                "ERROR",
+                "Rejected with native stack",
+                new RuntimeException("CrashModule.rejectWithNativeStack()"));
+          }
+
           private void crashNow() {
             throw new RuntimeException("CrashModule.crashNow()");
           }

samples/react-native/src/Screens/ErrorsScreen.tsx

@@ -207,6 +207,14 @@ const ErrorsScreen = (_props: Props) => {
                 });
               }}
             />
+            <Button
+              title="Reject Promise with Native Stack"
+              onPress={() => {
+                CrashModule.rejectWithNativeStack().catch((e: Error) => {
+                  Sentry.captureException(e);
+                });
+              }}
+            />
             <Button
               title="Enable Crash on Start"
               onPress={() => {