@sentry/react-native 8.1.0 → 8.3.0

package/scripts/eas-build-hook.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+/**
+ * EAS Build Hook
+ *
+ * Unified entry point for all EAS build hooks (on-complete, on-error, on-success).
+ * The hook name is determined from the bin command name in process.argv[1]
+ * (e.g. sentry-eas-build-on-error → on-error) or can be passed as a CLI argument.
+ *
+ * Required environment variables:
+ *   - SENTRY_DSN: Your Sentry DSN
+ *
+ * Optional environment variables:
+ *   - SENTRY_EAS_BUILD_CAPTURE_SUCCESS: Set to 'true' to also capture successful builds
+ *   - SENTRY_EAS_BUILD_TAGS: JSON string of additional tags
+ *   - SENTRY_EAS_BUILD_ERROR_MESSAGE: Custom error message for failed builds
+ *   - SENTRY_EAS_BUILD_SUCCESS_MESSAGE: Custom success message for successful builds
+ *
+ * @see https://docs.expo.dev/build-reference/npm-hooks/
+ * @see https://docs.sentry.io/platforms/react-native/
+ */
+
+/* eslint-disable no-console */
+
+const path = require('path');
+const fs = require('fs');
+
+// ─── Environment loading ─────────────────────────────────────────────────────
+
+/**
+ * Merges parsed env vars into process.env without overwriting existing values.
+ * This preserves EAS secrets and other pre-set environment variables.
+ * @param {object} parsed - Parsed environment variables from dotenv
+ */
+function mergeEnvWithoutOverwrite(parsed) {
+  for (const key of Object.keys(parsed)) {
+    if (process.env[key] === undefined) {
+      process.env[key] = parsed[key];
+    }
+  }
+}
+
+/**
+ * Loads environment variables from various sources:
+ * - @expo/env (if available)
+ * - .env file (via dotenv, if available)
+ * - .env.sentry-build-plugin file
+ *
+ * NOTE: Existing environment variables (like EAS secrets) are NOT overwritten.
+ */
+function loadEnv() {
+  // Try @expo/env first
+  try {
+    require('@expo/env').load('.');
+  } catch (_e) {
+    // Fallback to dotenv if available
+    try {
+      const dotenvPath = path.join(process.cwd(), '.env');
+      if (fs.existsSync(dotenvPath)) {
+        const dotenvFile = fs.readFileSync(dotenvPath, 'utf-8');
+        const dotenv = require('dotenv');
+        mergeEnvWithoutOverwrite(dotenv.parse(dotenvFile));
+      }
+    } catch (_e2) {
+      // No dotenv available, continue with existing env vars
+    }
+  }
+
+  // Also load .env.sentry-build-plugin if it exists
+  try {
+    const sentryEnvPath = path.join(process.cwd(), '.env.sentry-build-plugin');
+    if (fs.existsSync(sentryEnvPath)) {
+      const dotenvFile = fs.readFileSync(sentryEnvPath, 'utf-8');
+      const dotenv = require('dotenv');
+      mergeEnvWithoutOverwrite(dotenv.parse(dotenvFile));
+    }
+  } catch (_e) {
+    // Continue without .env.sentry-build-plugin
+  }
+}
+
+// ─── Hooks module & options ──────────────────────────────────────────────────
+
+/**
+ * Loads the EAS build hooks module from the compiled output.
+ * @returns {object} The hooks module exports
+ * @throws {Error} If the module cannot be loaded
+ */
+function loadHooksModule() {
+  try {
+    return require('../dist/js/tools/easBuildHooks.js');
+  } catch (_e) {
+    console.error('[Sentry] Could not load EAS build hooks module. Make sure @sentry/react-native is properly installed.');
+    process.exit(1);
+  }
+}
+
+/**
+ * Parses common options from environment variables.
+ * @returns {object} Parsed options object
+ */
+function parseBaseOptions() {
+  const options = {
+    dsn: process.env.SENTRY_DSN,
+  };
+
+  // Parse additional tags if provided
+  if (process.env.SENTRY_EAS_BUILD_TAGS) {
+    try {
+      const parsed = JSON.parse(process.env.SENTRY_EAS_BUILD_TAGS);
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        options.tags = parsed;
+      } else {
+        console.warn('[Sentry] SENTRY_EAS_BUILD_TAGS must be a JSON object (e.g., {"key":"value"}). Ignoring.');
+      }
+    } catch (_e) {
+      console.warn('[Sentry] Could not parse SENTRY_EAS_BUILD_TAGS as JSON. Ignoring.');
+    }
+  }
+
+  return options;
+}
+
+// ─── Hook configuration & execution ─────────────────────────────────────────
+
+/**
+ * Hook configuration keyed by hook name.
+ *
+ * Each entry defines which extra env vars to read and which hooks module
+ * method to call.
+ */
+const HOOK_CONFIGS = {
+  'on-complete': {
+    envKeys: {
+      errorMessage: 'SENTRY_EAS_BUILD_ERROR_MESSAGE',
+      successMessage: 'SENTRY_EAS_BUILD_SUCCESS_MESSAGE',
+      captureSuccessfulBuilds: 'SENTRY_EAS_BUILD_CAPTURE_SUCCESS',
+    },
+    method: 'captureEASBuildComplete',
+  },
+  'on-error': {
+    envKeys: {
+      errorMessage: 'SENTRY_EAS_BUILD_ERROR_MESSAGE',
+    },
+    method: 'captureEASBuildError',
+  },
+  'on-success': {
+    envKeys: {
+      successMessage: 'SENTRY_EAS_BUILD_SUCCESS_MESSAGE',
+      captureSuccessfulBuilds: 'SENTRY_EAS_BUILD_CAPTURE_SUCCESS',
+    },
+    // When a user explicitly configures the on-success hook, they intend to
+    // capture successful builds, so default captureSuccessfulBuilds to true.
+    defaults: { captureSuccessfulBuilds: true },
+    method: 'captureEASBuildSuccess',
+  },
+};
+
+/**
+ * Runs an EAS build hook by name.
+ *
+ * Loads the environment, resolves hook-specific options from env vars,
+ * and calls the corresponding hooks module method.
+ *
+ * @param {'on-complete' | 'on-error' | 'on-success'} hookName
+ */
+async function runEASBuildHook(hookName) {
+  const config = HOOK_CONFIGS[hookName];
+  if (!config) {
+    throw new Error(`Unknown EAS build hook: ${hookName}`);
+  }
+
+  loadEnv();
+
+  const hooks = loadHooksModule();
+  const options = {
+    ...parseBaseOptions(),
+    ...config.defaults,
+  };
+
+  for (const [optionKey, envKey] of Object.entries(config.envKeys)) {
+    if (optionKey === 'captureSuccessfulBuilds') {
+      // Only override the default when the env var is explicitly set
+      if (process.env[envKey] !== undefined) {
+        options[optionKey] = process.env[envKey] === 'true';
+      }
+    } else if (process.env[envKey] !== undefined) {
+      options[optionKey] = process.env[envKey];
+    }
+  }
+
+  try {
+    await hooks[config.method](options);
+    console.log(`[Sentry] EAS build ${hookName} hook completed.`);
+  } catch (error) {
+    console.error(`[Sentry] Error in eas-build-${hookName} hook:`, error);
+    // Don't fail the build hook itself
+  }
+}
+
+// ─── Hook name resolution & entry point ─────────────────────────────────────
+
+const HOOK_NAME_RE = /(?:sentry-eas-build-|build-)(on-(?:complete|error|success))/;
+
+/**
+ * Resolves which hook to run.
+ *
+ * 1. Explicit CLI argument: `node build-hook.js on-error`
+ * 2. Derived from the script path in process.argv[1]
+ */
+function resolveHookName() {
+  const arg = process.argv[2];
+  if (arg && /^on-(complete|error|success)$/.test(arg)) {
+    return arg;
+  }
+
+  const caller = path.basename(process.argv[1] || '', '.js');
+  const match = caller.match(HOOK_NAME_RE);
+  if (match) {
+    return match[1];
+  }
+
+  console.error(
+    '[Sentry] Could not determine EAS build hook name. ' +
+      'Pass one of: on-complete, on-error, on-success',
+  );
+  process.exit(1);
+}
+
+const hookName = resolveHookName();
+
+runEASBuildHook(hookName).catch(error => {
+  console.error(`[Sentry] Unexpected error in eas-build-${hookName} hook:`, error);
+  process.exit(1);
+});

package/scripts/sentry-xcode.sh

@@ -15,6 +15,13 @@ RN_PROJECT_ROOT="${PROJECT_DIR}/.."
 [ -z "$SENTRY_PROPERTIES" ] && export SENTRY_PROPERTIES=sentry.properties
 [ -z "$SENTRY_DOTENV_PATH" ] && [ -f "$RN_PROJECT_ROOT/.env.sentry-build-plugin" ] && export SENTRY_DOTENV_PATH="$RN_PROJECT_ROOT/.env.sentry-build-plugin"
 [ -z "$SOURCEMAP_FILE" ] && export SOURCEMAP_FILE="$DERIVED_FILE_DIR/main.jsbundle.map"
+# Resolve relative SOURCEMAP_FILE to absolute. The script runs from `ios/` (Xcode's PWD),
+# but users typically specify paths relative to the project root. Without this, sentry-cli
+# would resolve relative paths against `ios/` and fail to find the file.
+# See: https://github.com/getsentry/sentry-react-native/issues/3889
+if [[ "$SOURCEMAP_FILE" != /* ]]; then
+  export SOURCEMAP_FILE="$(cd "$RN_PROJECT_ROOT" && pwd)/${SOURCEMAP_FILE#./}"
+fi
 
 if [ -z "$SENTRY_CLI_EXECUTABLE" ]; then
   # Try standard resolution safely
@@ -57,11 +64,11 @@ if [ "$SENTRY_DISABLE_AUTO_UPLOAD" != true ]; then
     echo "$SENTRY_XCODE_COMMAND_OUTPUT" | awk '{print "output: sentry-cli - " $0}'
   else
     if [ "$SENTRY_ALLOW_FAILURE" == true ]; then
+      echo "$SENTRY_XCODE_COMMAND_OUTPUT" | awk '{print "warning: sentry-cli - " $0}'
       echo "warning: sentry-cli - Source maps upload failed, but continuing build because SENTRY_ALLOW_FAILURE=true"
-      echo "warning: sentry-cli - $SENTRY_XCODE_COMMAND_OUTPUT"
     else
+      echo "$SENTRY_XCODE_COMMAND_OUTPUT" | awk '{print "error: sentry-cli - " $0}'
       echo "error: sentry-cli - To disable source maps auto upload, set SENTRY_DISABLE_AUTO_UPLOAD=true in your environment variables. Or to allow failing upload, set SENTRY_ALLOW_FAILURE=true"
-      echo "error: sentry-cli - $SENTRY_XCODE_COMMAND_OUTPUT"
       exitCode=1
     fi
   fi

package/sentry.gradle

@@ -67,11 +67,19 @@ plugins.withId('com.android.application') {
 
     androidComponents.onVariants(androidComponents.selector().all()) { v ->
         if (!v.name.toLowerCase().contains("debug")) {
-            // separately we then hook into the bundle task of react native to inject
-            // sourcemap generation parameters.  In case for whatever reason no release
-            // was found for the asset folder we just bail.
-            def bundleTasks = tasks.findAll { task -> (task.name.startsWith("createBundle") || task.name.startsWith("bundle")) && task.name.endsWith("JsAndAssets") && !task.name.contains("Debug") && task.enabled }
-            bundleTasks.each { bundleTask ->
+            // Hook into the bundle task of react native to inject sourcemap generation parameters.
+            // tasks.names.contains() checks task existence without iterating the container, avoiding
+            // eager realization of unrelated tasks (fixes #5698, Fullstory AGP Artifacts API).
+            def variantCapitalized = v.name.capitalize()
+            def sentryBundleTaskName = ["createBundle${variantCapitalized}JsAndAssets", "bundle${variantCapitalized}JsAndAssets"].find { tasks.names.contains(it) }
+            if (sentryBundleTaskName == null) {
+                project.logger.warn("[sentry] No bundle task found for variant '${v.name}'. " +
+                    "Expected 'createBundle${variantCapitalized}JsAndAssets' or " +
+                    "'bundle${variantCapitalized}JsAndAssets'. Source maps will not be uploaded.")
+                return
+            }
+            def bundleTask = tasks.named(sentryBundleTaskName).get()
+            if (bundleTask.enabled) {
                 def shouldCleanUp
                 def sourcemapOutput
                 def bundleOutput

package/ts3.8/dist/js/NativeLogListener.d.ts

@@ -0,0 +1,16 @@
+import type { NativeLogEntry } from './options';
+/**
+ * Sets up the native log listener that forwards logs from the native SDK to JS.
+ * This only works when `debug: true` is set in Sentry options.
+ *
+ * @param callback - The callback to invoke when a native log is received.
+ * @returns A function to remove the listener, or undefined if setup failed.
+ */
+export declare function setupNativeLogListener(callback: (log: NativeLogEntry) => void): (() => void) | undefined;
+/**
+ * Default handler for native logs that uses Sentry's debug logger.
+ * This avoids interference with captureConsoleIntegration which would
+ * otherwise capture these logs as breadcrumbs or events.
+ */
+export declare function defaultNativeLogHandler(log: NativeLogEntry): void;
+//# sourceMappingURL=NativeLogListener.d.ts.map

package/ts3.8/dist/js/client.d.ts

@@ -10,6 +10,7 @@ import type { ReactNativeClientOptions } from './options';
 export declare class ReactNativeClient extends Client<ReactNativeClientOptions> {
     private _outcomesBuffer;
     private _logFlushIdleTimeout;
+    private _removeNativeLogListener;
     /**
      * Creates a new React Native SDK instance.
      * @param options Configuration options for this SDK.

package/ts3.8/dist/js/index.d.ts

@@ -1,11 +1,11 @@
 export type { Breadcrumb, SdkInfo, Event, Exception, SendFeedbackParams, SeverityLevel, Span, StackFrame, Stacktrace, Thread, User, UserFeedback, ErrorEvent, TransactionEvent, Metric, } from '@sentry/core';
-export { addBreadcrumb, addIntegration, captureException, captureEvent, captureFeedback, captureMessage, Scope, setContext, setExtra, setExtras, setTag, setTags, setUser, startInactiveSpan, startSpan, startSpanManual, getActiveSpan, getRootSpan, withActiveSpan, suppressTracing, spanToJSON, spanIsSampled, setMeasurement, getCurrentScope, getGlobalScope, getIsolationScope, getClient, setCurrentClient, addEventProcessor, lastEventId, } from '@sentry/core';
+export { addBreadcrumb, addIntegration, captureException, captureEvent, captureFeedback, captureMessage, Scope, setContext, setExtra, setExtras, setTag, setTags, setUser, startInactiveSpan, startSpan, startSpanManual, getActiveSpan, getRootSpan, withActiveSpan, suppressTracing, spanToJSON, spanIsSampled, setMeasurement, getCurrentScope, getGlobalScope, getIsolationScope, getClient, setCurrentClient, addEventProcessor, lastEventId, consoleSandbox, } from '@sentry/core';
 export { ErrorBoundary, withErrorBoundary, createReduxEnhancer, Profiler, useProfiler, withProfiler, } from '@sentry/react';
 export type { FeatureFlagsIntegration } from '@sentry/browser';
 export { logger, consoleLoggingIntegration, featureFlagsIntegration, metrics } from '@sentry/browser';
 export * from './integrations/exports';
 export { SDK_NAME, SDK_VERSION } from './version';
-export type { ReactNativeOptions } from './options';
+export type { ReactNativeOptions, NativeLogEntry } from './options';
 export { ReactNativeClient } from './client';
 export { init, wrap, nativeCrash, flush, close, withScope, crashedLastRun } from './sdk';
 export { TouchEventBoundary, withTouchEventBoundary } from './touchevents';

package/ts3.8/dist/js/integrations/expoconstants.d.ts

@@ -0,0 +1,24 @@
+import type { Integration } from '@sentry/core';
+export declare const EXPO_CONSTANTS_CONTEXT_KEY = "expo_constants";
+/** Load Expo Constants as event context. */
+export declare const expoConstantsIntegration: () => Integration;
+/**
+ * @internal Exposed for testing purposes
+ */
+export declare function getExpoConstantsContext(): ExpoConstantsContext;
+type ExpoConstantsContext = Partial<{
+    execution_environment: string;
+    app_ownership: string;
+    debug_mode: boolean;
+    expo_version: string;
+    expo_runtime_version: string;
+    session_id: string;
+    status_bar_height: number;
+    app_name: string;
+    app_slug: string;
+    app_version: string;
+    expo_sdk_version?: string;
+    eas_project_id: string;
+}>;
+export {};
+//# sourceMappingURL=expoconstants.d.ts.map

package/ts3.8/dist/js/integrations/exports.d.ts

@@ -11,6 +11,7 @@ export { hermesProfilingIntegration } from '../profiling/integration';
 export { screenshotIntegration } from './screenshot';
 export { viewHierarchyIntegration } from './viewhierarchy';
 export { expoContextIntegration } from './expocontext';
+export { expoConstantsIntegration } from './expoconstants';
 export { spotlightIntegration } from './spotlight';
 export { mobileReplayIntegration } from '../replay/mobilereplay';
 export { feedbackIntegration } from '../feedback/integration';

package/ts3.8/dist/js/options.d.ts

@@ -313,6 +313,32 @@ export interface BaseReactNativeOptions {
      * @default 'all'
      */
     logsOrigin?: 'all' | 'js' | 'native';
+    /**
+     * A callback that is invoked when the native SDK emits a log message.
+     * This is useful for surfacing native SDK logs (e.g., transport errors like HTTP 413)
+     * in the JavaScript console.
+     *
+     * Only works when `debug: true` is set.
+     *
+     * @example
+     * ```typescript
+     * Sentry.init({
+     *   debug: true,
+     *   onNativeLog: ({ level, component, message }) => {
+     *     console.log(`[Sentry Native] [${level}] [${component}] ${message}`);
+     *   },
+     * });
+     * ```
+     */
+    onNativeLog?: (log: NativeLogEntry) => void;
+}
+/**
+ * Represents a log entry from the native SDK.
+ */
+export interface NativeLogEntry {
+    level: string;
+    component: string;
+    message: string;
 }
 export type SentryReplayQuality = 'low' | 'medium' | 'high';
 /**

package/ts3.8/dist/js/tracing/onSpanEndUtils.d.ts

@@ -21,6 +21,13 @@ export declare const ignoreEmptyRouteChangeTransactions: (client: Client | undef
 export declare const onlySampleIfChildSpans: (client: Client, span: Span) => void;
 /**
  * Hooks on AppState change to cancel the span if the app goes background.
+ *
+ * On iOS the JS thread can be suspended between the `inactive` and
+ * `background` transitions, which means the `background` event may never
+ * reach JS in time. To handle this we schedule a deferred cancellation when
+ * the app becomes `inactive`. If the app returns to `active` before the
+ * timeout fires, the cancellation is cleared. If it transitions to
+ * `background` first, we cancel immediately and clear the timeout.
  */
 export declare const cancelInBackground: (client: Client, span: Span) => void;
 //# sourceMappingURL=onSpanEndUtils.d.ts.map

package/ts3.8/dist/js/tracing/reactnavigation.d.ts

@@ -1,5 +1,20 @@
 import type { Client, Integration } from '@sentry/core';
 export declare const INTEGRATION_NAME = "ReactNavigation";
+/**
+ * Extracts dynamic route parameters from a route name and its params.
+ * Matches Expo Router style dynamic segments like `[id]` and `[...slug]`.
+ *
+ * Only params whose keys appear as dynamic segments in the route name are returned,
+ * filtering out non-structural params (query params, etc.) that may contain PII.
+ *
+ * Note: dynamic segment values (e.g. the `123` in `profile/[id]`) may be user-identifiable.
+ * This function only extracts params — callers are responsible for checking `sendDefaultPii`
+ * before including the result in span attributes.
+ *
+ * Previous route params are intentionally not captured — only the current route's
+ * structural params are needed for trace attribution.
+ */
+export declare function extractDynamicRouteParams(routeName: string, params?: Record<string, unknown>): Record<string, string> | undefined;
 interface ReactNavigationIntegrationOptions {
     /**
      * How long the instrumentation will wait for the route to mount after a change has been initiated,

package/ts3.8/dist/js/tracing/span.d.ts

@@ -7,14 +7,14 @@ export declare const defaultIdleOptions: {
      *
      * @default 1_000 (ms)
      */
-    finalTimeout: number;
+    idleTimeout: number;
     /**
      * The max. time an idle span may run.
      * If this time is exceeded, the idle span will finish no matter what.
      *
-     * @default 60_0000 (ms)
+     * @default 600_000 (ms)
      */
-    idleTimeout: number;
+    finalTimeout: number;
 };
 export declare const startIdleNavigationSpan: (startSpanOption: StartSpanOptions, { finalTimeout, idleTimeout, isAppRestart, }?: Partial<{
     /**
@@ -23,14 +23,14 @@ export declare const startIdleNavigationSpan: (startSpanOption: StartSpanOptions
      *
      * @default 1_000 (ms)
      */
-    finalTimeout: number;
+    idleTimeout: number;
     /**
      * The max. time an idle span may run.
      * If this time is exceeded, the idle span will finish no matter what.
      *
-     * @default 60_0000 (ms)
+     * @default 600_000 (ms)
      */
-    idleTimeout: number;
+    finalTimeout: number;
 }> & {
     isAppRestart?: boolean | undefined;
 }) => Span | undefined;

package/ts3.8/dist/js/utils/expoglobalobject.d.ts

@@ -5,15 +5,9 @@
  *
  * https://github.com/expo/expo/blob/b51b5139f2caa2a9495e4132437d7ca612276158/packages/expo-constants/src/Constants.ts
  * https://github.com/expo/expo/blob/b51b5139f2caa2a9495e4132437d7ca612276158/packages/expo-manifests/src/Manifests.ts
+ * https://github.com/expo/expo/blob/fce7f6eb2ea2611cb30e9cb20baaeee2ac0a18b6/packages/expo-constants/src/Constants.types.ts
  */
 export interface ExpoConstants {
-    /**
-     * Deprecated. But until removed we can use it as user ID to match the native SDKs.
-     */
-    installationId?: string;
-    /**
-     * Version of the Expo Go app
-     */
     expoVersion?: string | null;
     manifest?: null | {
         [key: string]: unknown;
@@ -23,6 +17,52 @@ export interface ExpoConstants {
          */
         runtimeVersion?: string;
     };
+    /**
+     * Returns the current execution environment.
+     * Values: 'bare', 'standalone', 'storeClient'
+     */
+    executionEnvironment?: string;
+    /**
+     * Deprecated. Returns 'expo' when running in Expo Go, otherwise null.
+     */
+    appOwnership?: string | null;
+    /**
+     * Identifies debug vs. production builds.
+     */
+    debugMode?: boolean;
+    /**
+     * Unique identifier per app session.
+     */
+    sessionId?: string;
+    /**
+     * Runtime version info.
+     */
+    expoRuntimeVersion?: string | null;
+    /**
+     * Device status bar height.
+     */
+    statusBarHeight?: number;
+    /**
+     * Available system fonts.
+     */
+    systemFonts?: string[];
+    /**
+     * The standard Expo config object defined in app.json and app.config.js files.
+     */
+    expoConfig?: null | {
+        [key: string]: unknown;
+        name?: string;
+        slug?: string;
+        version?: string;
+        sdkVersion?: string;
+    };
+    /**
+     * EAS configuration when applicable.
+     */
+    easConfig?: null | {
+        [key: string]: unknown;
+        projectId?: string;
+    };
 }
 /**
  * Interface from the Expo SDK defined here

package/ts3.8/dist/js/version.d.ts

@@ -1,4 +1,4 @@
 export declare const SDK_PACKAGE_NAME = "npm:@sentry/react-native";
 export declare const SDK_NAME = "sentry.javascript.react-native";
-export declare const SDK_VERSION = "8.1.0";
+export declare const SDK_VERSION = "8.3.0";
 //# sourceMappingURL=version.d.ts.map