fixes

Author: alwx

CHANGELOG.md

@@ -13,6 +13,7 @@
 - Add `disableAutoUpload` option to Expo plugin to disable source map and debug symbol uploads ([#6195](https://github.com/getsentry/sentry-react-native/pull/6195))
 - Expose `pauseAppHangTracking` and `resumeAppHangTracking` APIs on iOS ([#6192](https://github.com/getsentry/sentry-react-native/pull/6192))
 - Better route and dynamic param extraction for Expo Router ([#6197](https://github.com/getsentry/sentry-react-native/pull/6197))
+- 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))
 
 ### Fixes
 

packages/core/src/js/turbomodule/turboModuleTracker.ts

@@ -93,6 +93,26 @@ export function pushTurboModuleCall(args: {
   return call.callId;
 }
 
+/**
+ * Updates the `kind` of a previously-pushed call (in place) and re-syncs the
+ * scope if the call is currently the active one. Used by
+ * {@link wrapTurboModule} once it discovers that a method's return value is
+ * thenable.
+ *
+ * Returns `true` if the call was found and relabelled.
+ */
+export function relabelTurboModuleCallKind(callId: number, kind: 'sync' | 'async', scope?: Scope): boolean {
+  const call = stack.find(c => c.callId === callId);
+  if (!call || call.kind === kind) {
+    return !!call;
+  }
+  call.kind = kind;
+  if (stack[stack.length - 1] === call) {
+    syncToScope(call, scope);
+  }
+  return true;
+}
+
 /**
  * Records the end of a TurboModule method invocation previously started with
  * {@link pushTurboModuleCall}. Pops the matching frame off the stack and

packages/core/src/js/turbomodule/wrapTurboModule.ts

@@ -1,15 +1,16 @@
 import { logger } from '@sentry/react';
 
-import { popTurboModuleCall, pushTurboModuleCall } from './turboModuleTracker';
-
-const WRAPPED_FLAG = '__sentryTurboModuleWrapped__';
+import { popTurboModuleCall, pushTurboModuleCall, relabelTurboModuleCallKind } from './turboModuleTracker';
 
 /**
- * Marker added to wrapped modules so we never double-wrap (which would push the
- * same call twice onto the tracker stack).
+ * Modules we've already wrapped. Tracked off-module so that even sealed proxies
+ * (which can't accept a marker property) are protected from double-wrapping.
  */
-interface MaybeWrapped {
-  [WRAPPED_FLAG]?: boolean;
+let wrappedModules = new WeakSet<object>();
+
+/** Tests only. */
+export function _resetWrappedModules(): void {
+  wrappedModules = new WeakSet<object>();
 }
 
 /**
@@ -18,8 +19,8 @@ interface MaybeWrapped {
  * `module` reference for chaining convenience.
  *
  * - Sync methods are tracked as `kind: 'sync'` and popped right after the call.
- * - Async methods (those returning a thenable) are tracked as `kind: 'async'`
- *   and popped when the returned promise settles.
+ * - Async methods (those returning a thenable) are relabelled to `kind: 'async'`
+ *   right after the call dispatches and popped when the returned promise settles.
  *
  * `skip` can be used to opt specific method names out of tracking (e.g. very
  * hot, no-op methods like RN's `addListener`/`removeListeners` event-emitter
@@ -34,15 +35,24 @@ export function wrapTurboModule<T extends object>(
     return module;
   }
 
-  const maybeWrapped = module as T & MaybeWrapped;
-  if (maybeWrapped[WRAPPED_FLAG]) {
+  if (wrappedModules.has(module)) {
     return module;
   }
+  wrappedModules.add(module);
 
   const skip = new Set(options.skip ?? []);
+  const methodNames = collectMethodNames(module);
+
+  if (methodNames.length === 0) {
+    logger.warn(
+      `[TurboModuleTracker] No methods discovered on '${name}' — TurboModule context will not be attached for this module. ` +
+        `This usually means the module is a JSI HostObject that only materialises methods on first access.`,
+    );
+    return module;
+  }
 
   const target = module as unknown as Record<string, unknown>;
-  for (const key of Object.keys(target)) {
+  for (const key of methodNames) {
     if (skip.has(key)) {
       continue;
     }
@@ -52,9 +62,9 @@ export function wrapTurboModule<T extends object>(
     }
     const originalFn = original as (...a: unknown[]) => unknown;
 
-    target[key] = function sentryTurboModuleWrapper(this: unknown, ...args: unknown[]): unknown {
+    const wrapper = function sentryTurboModuleWrapper(this: unknown, ...args: unknown[]): unknown {
       // We don't know yet whether `original` is sync or async — start optimistic
-      // as sync, upgrade the scope context if the result is thenable.
+      // as sync, relabel to 'async' if the result turns out to be thenable.
       const callId = pushTurboModuleCall({ name, method: key, kind: 'sync' });
       let result: unknown;
       try {
@@ -65,13 +75,7 @@ export function wrapTurboModule<T extends object>(
       }
 
       if (isThenable(result)) {
-        // Re-record as async — clearer in the report. We just overwrite the
-        // existing tracker frame in place by popping + re-pushing with a fresh
-        // id would lose ordering, so instead we leave the stack frame alone
-        // and only relabel for the scope on completion (it's the *active*
-        // call's `kind` that ends up in `contexts.turbo_module`, and the
-        // outer perf-logger driven users can push with `kind: 'async'`
-        // directly when they know up front).
+        relabelTurboModuleCallKind(callId, 'async');
         return (result as Promise<unknown>).then(
           value => {
             popTurboModuleCall(callId);
@@ -87,29 +91,41 @@ export function wrapTurboModule<T extends object>(
       popTurboModuleCall(callId);
       return result;
     };
-  }
 
-  try {
-    Object.defineProperty(module, WRAPPED_FLAG, {
-      value: true,
-      enumerable: false,
-      configurable: false,
-      writable: false,
-    });
-  } catch (e) {
-    // Some TurboModule proxies are sealed — that's fine, we still patched the
-    // methods, but a second wrap call would be a no-op anyway because the
-    // properties now point at our wrappers (re-wrapping would still push
-    // through to `original` which is itself a wrapper, but the per-call
-    // pushes would double up). Log so this is visible during development.
-    logger.warn(
-      `[TurboModuleTracker] Could not mark ${name} as wrapped — repeated wrapping would double-track invocations.`,
-    );
+    try {
+      target[key] = wrapper;
+    } catch {
+      // Sealed / non-writable property — can't intercept this method, but we
+      // can still wrap the rest. Skip silently; the module-level method-count
+      // check above is the cliff that catches the "wrapped nothing" case.
+    }
   }
 
   return module;
 }
 
+/**
+ * Returns the union of own + prototype-chain method names on `module`,
+ * deduplicated and skipping `Object.prototype`. Walking the prototype chain is
+ * necessary for JSI HostObject-backed TurboModule proxies under RN's New
+ * Architecture, which can expose methods via the proto chain rather than as
+ * own enumerable properties.
+ */
+function collectMethodNames(module: object): string[] {
+  const seen = new Set<string>();
+  let current: object | null = module;
+  while (current && current !== Object.prototype) {
+    for (const key of Object.getOwnPropertyNames(current)) {
+      if (key === 'constructor') {
+        continue;
+      }
+      seen.add(key);
+    }
+    current = Object.getPrototypeOf(current) as object | null;
+  }
+  return Array.from(seen);
+}
+
 function isThenable(value: unknown): value is PromiseLike<unknown> {
   if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
     return false;

packages/core/test/turbomodule/turboModuleTracker.test.ts

@@ -6,6 +6,7 @@ import {
   getTurboModuleCallStack,
   popTurboModuleCall,
   pushTurboModuleCall,
+  relabelTurboModuleCallKind,
 } from '../../src/js/turbomodule/turboModuleTracker';
 
 describe('turboModuleTracker', () => {
@@ -90,6 +91,32 @@ describe('turboModuleTracker', () => {
     expect(getActiveTurboModuleCall()?.callId).toBe(id);
   });
 
+  it('relabels the active call kind and re-syncs the scope', () => {
+    const id = pushTurboModuleCall({ name: 'RNSentry', method: 'captureEnvelope', kind: 'sync', scope });
+
+    const relabelled = relabelTurboModuleCallKind(id, 'async', scope);
+
+    expect(relabelled).toBe(true);
+    expect(getActiveTurboModuleCall()?.kind).toBe('async');
+    expect(scope.getScopeData().contexts.turbo_module).toMatchObject({ kind: 'async' });
+  });
+
+  it('relabels a non-top frame without touching the scope context', () => {
+    const outer = pushTurboModuleCall({ name: 'M', method: 'outer', kind: 'sync', scope });
+    pushTurboModuleCall({ name: 'M', method: 'inner', kind: 'sync', scope });
+
+    relabelTurboModuleCallKind(outer, 'async', scope);
+
+    // outer was relabelled
+    expect(getTurboModuleCallStack().find(c => c.callId === outer)?.kind).toBe('async');
+    // but the active scope context still describes the top of stack ('inner', sync)
+    expect(scope.getScopeData().contexts.turbo_module).toMatchObject({ method: 'inner', kind: 'sync' });
+  });
+
+  it('relabel returns false for an unknown id', () => {
+    expect(relabelTurboModuleCallKind(9999, 'async')).toBe(false);
+  });
+
   it('assigns monotonically increasing call ids', () => {
     const a = pushTurboModuleCall({ name: 'M', method: 'a', kind: 'sync', scope });
     const b = pushTurboModuleCall({ name: 'M', method: 'b', kind: 'sync', scope });

packages/core/test/turbomodule/wrapTurboModule.test.ts

@@ -2,13 +2,14 @@ import * as SentryCore from '@sentry/core';
 import { Scope } from '@sentry/core';
 
 import { _resetTurboModuleTracker, getTurboModuleCallStack } from '../../src/js/turbomodule/turboModuleTracker';
-import { wrapTurboModule } from '../../src/js/turbomodule/wrapTurboModule';
+import { _resetWrappedModules, wrapTurboModule } from '../../src/js/turbomodule/wrapTurboModule';
 
 describe('wrapTurboModule', () => {
   let scope: Scope;
 
   beforeEach(() => {
     _resetTurboModuleTracker();
+    _resetWrappedModules();
     scope = new Scope();
     jest.spyOn(SentryCore, 'getCurrentScope').mockReturnValue(scope);
   });
@@ -74,6 +75,26 @@ describe('wrapTurboModule', () => {
     expect(getTurboModuleCallStack()).toEqual([]);
   });
 
+  it('relabels async calls to kind="async" once the call returns a thenable', () => {
+    let resolveCall: (value: string) => void = () => undefined;
+    const module = {
+      asyncOp: () =>
+        new Promise<string>(resolve => {
+          resolveCall = resolve;
+        }),
+    };
+
+    wrapTurboModule('Mod', module);
+
+    const promise = module.asyncOp();
+
+    expect(getTurboModuleCallStack()[0]).toMatchObject({ method: 'asyncOp', kind: 'async' });
+    expect(scope.getScopeData().contexts.turbo_module).toMatchObject({ method: 'asyncOp', kind: 'async' });
+
+    resolveCall('done');
+    return promise;
+  });
+
   it('pops when an async method rejects', async () => {
     const module = {
       asyncFail: () => Promise.reject(new Error('nope')),
@@ -115,6 +136,54 @@ describe('wrapTurboModule', () => {
     expect(module.doStuff).toBe(wrappedOnce);
   });
 
+  it('does not double-wrap a sealed module on repeated calls', () => {
+    const module: { doStuff: () => void } = {
+      doStuff: () => undefined,
+    };
+    wrapTurboModule('Mod', module);
+    Object.seal(module);
+
+    // Repeated wrap attempts must be no-ops, otherwise every real call would
+    // push the same frame multiple times onto the tracker stack.
+    wrapTurboModule('Mod', module);
+    wrapTurboModule('Mod', module);
+
+    module.doStuff();
+    expect(getTurboModuleCallStack()).toEqual([]);
+  });
+
+  it('discovers methods exposed via the prototype chain (JSI HostObject shape)', () => {
+    let stackDuringCall: ReturnType<typeof getTurboModuleCallStack> = [];
+    class HostObjectLike {
+      public doStuff(): string {
+        stackDuringCall = getTurboModuleCallStack();
+        return 'ok';
+      }
+    }
+    const module = new HostObjectLike();
+
+    // sanity: methods are exposed via the prototype, not as own properties
+    expect(Object.keys(module)).toEqual([]);
+
+    wrapTurboModule('HostObj', module);
+
+    const result = module.doStuff();
+
+    expect(result).toBe('ok');
+    expect(stackDuringCall).toHaveLength(1);
+    expect(stackDuringCall[0]).toMatchObject({ name: 'HostObj', method: 'doStuff' });
+  });
+
+  it('warns and bails out cleanly when no methods are discoverable', () => {
+    const warnSpy = jest.spyOn(require('@sentry/react').logger, 'warn').mockImplementation(() => undefined);
+
+    const opaque = Object.create(null) as object;
+
+    wrapTurboModule('Opaque', opaque);
+
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("No methods discovered on 'Opaque'"));
+  });
+
   it('ignores non-function properties', () => {
     const module: { version: string; doStuff: () => number } = {
       version: '1.0.0',