@sentry/react-native 8.2.0 → 8.4.0

package/ios/RNSentryNativeLogsForwarder.m

@@ -0,0 +1,145 @@
+#import "RNSentryNativeLogsForwarder.h"
+#import "RNSentryEvents.h"
+
+@import Sentry;
+
+@interface RNSentryNativeLogsForwarder ()
+
+@property (nonatomic, weak) RCTEventEmitter *eventEmitter;
+
+@end
+
+@implementation RNSentryNativeLogsForwarder
+
++ (instancetype)shared
+{
+    static RNSentryNativeLogsForwarder *instance = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{ instance = [[RNSentryNativeLogsForwarder alloc] init]; });
+    return instance;
+}
+
+- (void)configureWithEventEmitter:(RCTEventEmitter *)emitter
+{
+    self.eventEmitter = emitter;
+
+    __weak RNSentryNativeLogsForwarder *weakSelf = self;
+
+    // Set up the Sentry SDK log output to forward logs to JS
+    [SentrySDKLog setOutput:^(NSString *_Nonnull message) {
+        // Always print to console (default behavior)
+        NSLog(@"%@", message);
+
+        // Forward to JS if we have an emitter
+        RNSentryNativeLogsForwarder *strongSelf = weakSelf;
+        if (strongSelf) {
+            [strongSelf forwardLogMessage:message];
+        }
+    }];
+
+    // Send a log to notify user the forwarding works
+    [self forwardLogMessage:
+            @"[Sentry] [info] [0] [RNSentryNativeLogsForwarder] Native log forwarding "
+            @"configured successfully"];
+}
+
+- (void)stopForwarding
+{
+    self.eventEmitter = nil;
+
+    // TODO: Ideally we should save the previous output block in configureWithEventEmitter:
+    // and restore it here instead of hardcoding NSLog.
+    // Reset to default print behavior
+    [SentrySDKLog setOutput:^(NSString *_Nonnull message) { NSLog(@"%@", message); }];
+}
+
+- (void)forwardLogMessage:(NSString *)message
+{
+    RCTEventEmitter *emitter = self.eventEmitter;
+    if (emitter == nil) {
+        return;
+    }
+
+    // Only forward messages that look like Sentry SDK logs
+    if (![message hasPrefix:@"[Sentry]"]) {
+        return;
+    }
+
+    // Parse the log message to extract level and component
+    // Format: "[Sentry] [level] [timestamp] [Component:line] message"
+    // or: "[Sentry] [level] [timestamp] message"
+    NSString *level = [self extractLevelFromMessage:message];
+    NSString *component = [self extractComponentFromMessage:message];
+    NSString *cleanMessage = [self extractCleanMessageFromMessage:message];
+
+    NSDictionary *body = @{
+        @"level" : level,
+        @"component" : component,
+        @"message" : cleanMessage,
+    };
+
+    // Dispatch async to avoid blocking the calling thread and potential deadlocks
+    dispatch_async(dispatch_get_main_queue(), ^{
+        RCTEventEmitter *currentEmitter = self.eventEmitter;
+        if (currentEmitter != nil) {
+            [currentEmitter sendEventWithName:RNSentryNativeLogEvent body:body];
+        }
+    });
+}
+
+- (NSString *)extractLevelFromMessage:(NSString *)message
+{
+    // Look for patterns like [debug], [info], [warning], [error], [fatal]
+    NSRegularExpression *regex =
+        [NSRegularExpression regularExpressionWithPattern:@"\\[(debug|info|warning|error|fatal)\\]"
+                                                  options:NSRegularExpressionCaseInsensitive
+                                                    error:nil];
+
+    NSTextCheckingResult *match = [regex firstMatchInString:message
+                                                    options:0
+                                                      range:NSMakeRange(0, message.length)];
+
+    if (match && match.numberOfRanges > 1) {
+        return [[message substringWithRange:[match rangeAtIndex:1]] lowercaseString];
+    }
+
+    return @"info";
+}
+
+- (NSString *)extractComponentFromMessage:(NSString *)message
+{
+    // Look for pattern like [ComponentName:123]
+    NSRegularExpression *regex =
+        [NSRegularExpression regularExpressionWithPattern:@"\\[([A-Za-z]+):\\d+\\]"
+                                                  options:0
+                                                    error:nil];
+
+    NSTextCheckingResult *match = [regex firstMatchInString:message
+                                                    options:0
+                                                      range:NSMakeRange(0, message.length)];
+
+    if (match && match.numberOfRanges > 1) {
+        return [message substringWithRange:[match rangeAtIndex:1]];
+    }
+
+    return @"Sentry";
+}
+
+- (NSString *)extractCleanMessageFromMessage:(NSString *)message
+{
+    // Remove the prefix parts: [Sentry] [level] [timestamp] [Component:line]
+    // and return just the actual message content
+    NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:
+            @"^\\[Sentry\\]\\s*\\[[^\\]]+\\]\\s*\\[[^\\]]+\\]\\s*(?:\\[[^\\]]+\\]\\s*)?"
+                                                                           options:0
+                                                                             error:nil];
+
+    NSString *cleanMessage = [regex stringByReplacingMatchesInString:message
+                                                             options:0
+                                                               range:NSMakeRange(0, message.length)
+                                                        withTemplate:@""];
+
+    return [cleanMessage stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];
+}
+
+@end

package/ios/RNSentryVersion.m

@@ -3,4 +3,4 @@
 NSString *const NATIVE_SDK_NAME = @"sentry.cocoa.react-native";
 NSString *const REACT_NATIVE_SDK_NAME = @"sentry.javascript.react-native";
 NSString *const REACT_NATIVE_SDK_PACKAGE_NAME = @"npm:@sentry/react-native";
-NSString *const REACT_NATIVE_SDK_PACKAGE_VERSION = @"8.2.0";
+NSString *const REACT_NATIVE_SDK_PACKAGE_VERSION = @"8.4.0";

package/package.json

@@ -2,7 +2,7 @@
   "name": "@sentry/react-native",
   "homepage": "https://github.com/getsentry/sentry-react-native",
   "repository": "https://github.com/getsentry/sentry-react-native",
-  "version": "8.2.0",
+  "version": "8.4.0",
   "description": "Official Sentry SDK for react-native",
   "typings": "dist/js/index.d.ts",
   "types": "dist/js/index.d.ts",
@@ -45,6 +45,9 @@
     "lint:prettier": "prettier  --config ../../.prettierrc.json --ignore-path ../../.prettierignore --check \"{src,test,scripts,plugin/src}/**/**.ts\""
   },
   "bin": {
+    "sentry-eas-build-on-complete": "scripts/eas-build-hook.js",
+    "sentry-eas-build-on-error": "scripts/eas-build-hook.js",
+    "sentry-eas-build-on-success": "scripts/eas-build-hook.js",
     "sentry-expo-upload-sourcemaps": "scripts/expo-upload-sourcemaps.js"
   },
   "keywords": [
@@ -68,22 +71,22 @@
     "react-native": ">=0.65.0"
   },
   "dependencies": {
-    "@sentry/babel-plugin-component-annotate": "4.9.1",
-    "@sentry/browser": "10.39.0",
-    "@sentry/cli": "3.2.2",
-    "@sentry/core": "10.39.0",
-    "@sentry/react": "10.39.0",
-    "@sentry/types": "10.39.0"
+    "@sentry/babel-plugin-component-annotate": "5.1.1",
+    "@sentry/browser": "10.43.0",
+    "@sentry/cli": "3.3.3",
+    "@sentry/core": "10.43.0",
+    "@sentry/react": "10.43.0",
+    "@sentry/types": "10.43.0"
   },
   "devDependencies": {
     "@babel/core": "^7.26.7",
     "@expo/metro-config": "~0.20.0",
     "@mswjs/interceptors": "^0.25.15",
     "@react-native/babel-preset": "0.80.0",
-    "@sentry-internal/eslint-config-sdk": "10.39.0",
-    "@sentry-internal/eslint-plugin-sdk": "10.39.0",
-    "@sentry-internal/typescript": "10.39.0",
-    "@sentry/wizard": "6.11.0",
+    "@sentry-internal/eslint-config-sdk": "10.43.0",
+    "@sentry-internal/eslint-plugin-sdk": "10.43.0",
+    "@sentry-internal/typescript": "10.43.0",
+    "@sentry/wizard": "6.12.0",
     "@testing-library/react-native": "^13.2.2",
     "@types/jest": "^29.5.13",
     "@types/node": "^20.9.3",

package/plugin/build/utils.d.ts

@@ -1 +1,2 @@
 export declare function writeSentryPropertiesTo(filepath: string, sentryProperties: string): void;
+export declare function writeSentryOptions(projectRoot: string, pluginOptions: Record<string, unknown>): void;

package/plugin/build/utils.js

@@ -23,9 +23,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeSentryPropertiesTo = void 0;
+exports.writeSentryOptions = exports.writeSentryPropertiesTo = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const logger_1 = require("./logger");
 function writeSentryPropertiesTo(filepath, sentryProperties) {
     if (!fs.existsSync(filepath)) {
         throw new Error(`Directory '${filepath}' does not exist.`);
@@ -33,3 +34,20 @@ function writeSentryPropertiesTo(filepath, sentryProperties) {
     fs.writeFileSync(path.resolve(filepath, 'sentry.properties'), sentryProperties);
 }
 exports.writeSentryPropertiesTo = writeSentryPropertiesTo;
+const SENTRY_OPTIONS_FILE_NAME = 'sentry.options.json';
+function writeSentryOptions(projectRoot, pluginOptions) {
+    const optionsFilePath = path.resolve(projectRoot, SENTRY_OPTIONS_FILE_NAME);
+    let existingOptions = {};
+    if (fs.existsSync(optionsFilePath)) {
+        try {
+            existingOptions = JSON.parse(fs.readFileSync(optionsFilePath, 'utf8'));
+        }
+        catch (e) {
+            (0, logger_1.warnOnce)(`Failed to parse ${SENTRY_OPTIONS_FILE_NAME}: ${e}. These options will not be set.`);
+            return;
+        }
+    }
+    const mergedOptions = { ...existingOptions, ...pluginOptions };
+    fs.writeFileSync(optionsFilePath, `${JSON.stringify(mergedOptions, null, 2)}\n`);
+}
+exports.writeSentryOptions = writeSentryOptions;

package/plugin/build/withSentry.d.ts

@@ -6,6 +6,7 @@ interface PluginProps {
     authToken?: string;
     url?: string;
     useNativeInit?: boolean;
+    options?: Record<string, unknown>;
     experimental_android?: SentryAndroidGradlePluginOptions;
 }
 export declare function getSentryProperties(props: PluginProps | void): string | null;

package/plugin/build/withSentry.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.withSentry = exports.getSentryProperties = void 0;
 const config_plugins_1 = require("expo/config-plugins");
 const logger_1 = require("./logger");
+const utils_1 = require("./utils");
 const version_1 = require("./version");
 const withSentryAndroid_1 = require("./withSentryAndroid");
 const withSentryAndroidGradlePlugin_1 = require("./withSentryAndroidGradlePlugin");
@@ -14,6 +15,14 @@ const withSentryPlugin = (config, props) => {
         delete props.authToken;
     }
     let cfg = config;
+    const pluginOptions = props?.options ? { ...props.options } : {};
+    const environment = process.env.SENTRY_ENVIRONMENT;
+    if (environment) {
+        pluginOptions.environment = environment;
+    }
+    if (Object.keys(pluginOptions).length > 0) {
+        cfg = withSentryOptionsFile(cfg, pluginOptions);
+    }
     if (sentryProperties !== null) {
         try {
             cfg = (0, withSentryAndroid_1.withSentryAndroid)(cfg, { sentryProperties, useNativeInit: props?.useNativeInit });
@@ -61,6 +70,25 @@ ${project ? `defaults.project=${project}` : missingProjectMessage}
 ${authToken ? `${existingAuthTokenMessage}\nauth.token=${authToken}` : missingAuthTokenMessage}`;
 }
 exports.getSentryProperties = getSentryProperties;
+function withSentryOptionsFile(config, pluginOptions) {
+    // withDangerousMod requires a platform key, but sentry.options.json is at the project root.
+    // We apply to both platforms so it works with `expo prebuild --platform ios` or `--platform android`.
+    let cfg = (0, config_plugins_1.withDangerousMod)(config, [
+        'android',
+        mod => {
+            (0, utils_1.writeSentryOptions)(mod.modRequest.projectRoot, pluginOptions);
+            return mod;
+        },
+    ]);
+    cfg = (0, config_plugins_1.withDangerousMod)(cfg, [
+        'ios',
+        mod => {
+            (0, utils_1.writeSentryOptions)(mod.modRequest.projectRoot, pluginOptions);
+            return mod;
+        },
+    ]);
+    return cfg;
+}
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const withSentry = (0, config_plugins_1.createRunOncePlugin)(withSentryPlugin, version_1.PLUGIN_NAME, version_1.PLUGIN_VERSION);
 exports.withSentry = withSentry;

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

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,16 +1,16 @@
 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';
-export { reactNativeTracingIntegration, getCurrentReactNativeTracingIntegration, getReactNativeTracingIntegration, reactNavigationIntegration, reactNativeNavigationIntegration, sentryTraceGesture, TimeToInitialDisplay, TimeToFullDisplay, startTimeToInitialDisplaySpan, startTimeToFullDisplaySpan, startIdleNavigationSpan, startIdleSpan, getDefaultIdleNavigationSpanOptions, createTimeToFullDisplay, createTimeToInitialDisplay, wrapExpoRouter, } from './tracing';
-export type { TimeToDisplayProps, ExpoRouter } from './tracing';
+export { reactNativeTracingIntegration, getCurrentReactNativeTracingIntegration, getReactNativeTracingIntegration, reactNavigationIntegration, reactNativeNavigationIntegration, sentryTraceGesture, TimeToInitialDisplay, TimeToFullDisplay, startTimeToInitialDisplaySpan, startTimeToFullDisplaySpan, startIdleNavigationSpan, startIdleSpan, getDefaultIdleNavigationSpanOptions, createTimeToFullDisplay, createTimeToInitialDisplay, wrapExpoRouter, wrapExpoImage, wrapExpoAsset, } from './tracing';
+export type { TimeToDisplayProps, ExpoRouter, ExpoImage, ExpoAsset } from './tracing';
 export { Mask, Unmask } from './replay/CustomMask';
 export { FeedbackButton } from './feedback/FeedbackButton';
 export { FeedbackWidget } from './feedback/FeedbackWidget';

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';
 /**