feat(core): Add includeFeedback Metro option to exclude feedback widget from bundle (#6025)

* feat(core): Add includeFeedback Metro option to exclude feedback widget from bundle

Mirrors the existing `includeWebReplay` option. When set to `false`,
`@sentry-internal/feedback` (and related subpackages) are resolved to an
empty module, removing the web user-feedback widget from the bundle.

Refactored the shared resolver logic into `buildSentryPackageExcludeResolver`
so `withSentryResolver` and the new `withSentryFeedbackResolver` both call
into it instead of duplicating the resolver body.

Closes #5629

* Fix changelog

* refactor(core): Rename include to includePackage in buildSentryPackageExcludeResolver

Addresses review feedback: bare `include` is ambiguous in the helper —
`includePackage` makes the intent obvious alongside `moduleRegex`.

* refactor(core): Rename includeFeedback to includeWebFeedback

Addresses review feedback from @lucas-zimerman: mirror the
`includeWebReplay` naming to make it obvious the option only affects
the web feedback package, not the native feedback integration.

Also moves the changelog entry from 8.9.1 (where it landed during the
merge with main) to Unreleased since this change hasn't shipped yet.

Author: antonis

CHANGELOG.md

@@ -8,6 +8,10 @@
 
 ## Unreleased
 
+### Features
+
+- Add `includeWebFeedback` Metro config option to exclude `@sentry-internal/feedback` from the bundle ([#6025](https://github.com/getsentry/sentry-react-native/pull/6025))
+
 ### Fixes
 
 - Stop the Hermes sampling profiler on React instance teardown to prevent `pthread_kill` SIGABRT when the JS thread is torn down with profiling active ([#6035](https://github.com/getsentry/sentry-react-native/pull/6035))

packages/core/src/js/tools/metroconfig.ts

@@ -1,3 +1,4 @@
+/* oxlint-disable eslint(max-lines) */
 import type { MetroConfig, MixedOutput, Module, ReadOnlyGraph } from 'metro';
 import type { CustomResolutionContext, CustomResolver, Resolution } from 'metro-resolver';
 
@@ -38,6 +39,11 @@ export interface SentryMetroConfigOptions {
    * @default true
    */
   includeWebReplay?: boolean;
+  /**
+   * Adds the Sentry user feedback widget package.
+   * @default true
+   */
+  includeWebFeedback?: boolean;
   /**
    * Add Sentry Metro Server Middleware which
    * enables the app to fetch stack frames source context.
@@ -79,6 +85,7 @@ export function withSentryConfig(
   {
     annotateReactComponents = false,
     includeWebReplay = true,
+    includeWebFeedback = true,
     enableSourceContextInDevelopment = true,
     optionsFile = true,
   }: SentryMetroConfigOptions = {},
@@ -95,6 +102,9 @@ export function withSentryConfig(
   if (includeWebReplay === false) {
     newConfig = withSentryResolver(newConfig, includeWebReplay);
   }
+  if (includeWebFeedback === false) {
+    newConfig = withSentryFeedbackResolver(newConfig, includeWebFeedback);
+  }
   newConfig = withSentryExcludeServerOnlyResolver(newConfig);
   if (enableSourceContextInDevelopment) {
     newConfig = withSentryMiddleware(newConfig);
@@ -135,6 +145,9 @@ export function getSentryExpoConfig(
   if (options.includeWebReplay === false) {
     newConfig = withSentryResolver(newConfig, options.includeWebReplay);
   }
+  if (options.includeWebFeedback === false) {
+    newConfig = withSentryFeedbackResolver(newConfig, options.includeWebFeedback);
+  }
   newConfig = withSentryExcludeServerOnlyResolver(newConfig);
 
   if (options.enableSourceContextInDevelopment ?? true) {
@@ -230,21 +243,26 @@ type CustomResolverBeforeMetro068 = (
 ) => Resolution;
 
 /**
- * Includes `@sentry/replay` packages based on the `includeWebReplay` flag and current bundle `platform`.
+ * Builds a Metro resolver that returns `{ type: 'empty' }` for Sentry sub-packages
+ * matching `moduleRegex` when the user opts out on web or the platform is native.
  */
-export function withSentryResolver(config: MetroConfig, includeWebReplay: boolean | undefined): MetroConfig {
+function buildSentryPackageExcludeResolver(
+  config: MetroConfig,
+  includePackage: boolean | undefined,
+  moduleRegex: RegExp,
+  optionName: string,
+): MetroConfig {
   const originalResolver = config.resolver?.resolveRequest as CustomResolver | CustomResolverBeforeMetro068 | undefined;
 
-  const sentryResolverRequest: CustomResolver = (
+  const resolverRequest: CustomResolver = (
     context: CustomResolutionContext,
     moduleName: string,
     platform: string | null,
     oldMetroModuleName?: string,
   ) => {
     if (
-      (includeWebReplay === false ||
-        (includeWebReplay === undefined && (platform === 'android' || platform === 'ios'))) &&
-      !!(oldMetroModuleName ?? moduleName).match(/@sentry(?:-internal)?\/replay/)
+      (includePackage === false || (includePackage === undefined && (platform === 'android' || platform === 'ios'))) &&
+      !!(oldMetroModuleName ?? moduleName).match(moduleRegex)
     ) {
       return { type: 'empty' } as Resolution;
     }
@@ -254,15 +272,15 @@ export function withSentryResolver(config: MetroConfig, includeWebReplay: boolea
         : originalResolver(context, moduleName, platform);
     }
 
-    // Prior 0.68, resolve context.resolveRequest is sentryResolver itself, where on later version it is the default resolver.
-    if (context.resolveRequest === sentryResolverRequest) {
+    // Prior 0.68, context.resolveRequest is resolverRequest itself, where on later version it is the default resolver.
+    if (context.resolveRequest === resolverRequest) {
       // oxlint-disable-next-line eslint(no-console)
       console.error(
         `Error: [@sentry/react-native/metro] Can not resolve the defaultResolver on Metro older than 0.68.
 Please follow one of the following options:
 - Include your resolverRequest on your metroconfig.
 - Update your Metro version to 0.68 or higher.
-- Set includeWebReplay as true on your metro config.
+- Set ${optionName} as true on your metro config.
 - If you are still facing issues, report the issue at http://www.github.com/getsentry/sentry-react-native/issues`,
       );
       // Return required for test.
@@ -276,11 +294,35 @@ Please follow one of the following options:
     ...config,
     resolver: {
       ...config.resolver,
-      resolveRequest: sentryResolverRequest,
+      resolveRequest: resolverRequest,
     },
   };
 }
 
+/**
+ * Includes `@sentry/replay` packages based on the `includeWebReplay` flag and current bundle `platform`.
+ */
+export function withSentryResolver(config: MetroConfig, includeWebReplay: boolean | undefined): MetroConfig {
+  return buildSentryPackageExcludeResolver(
+    config,
+    includeWebReplay,
+    /@sentry(?:-internal)?\/replay/,
+    'includeWebReplay',
+  );
+}
+
+/**
+ * Includes `@sentry-internal/feedback` packages based on the `includeWebFeedback` flag and current bundle `platform`.
+ */
+export function withSentryFeedbackResolver(config: MetroConfig, includeWebFeedback: boolean | undefined): MetroConfig {
+  return buildSentryPackageExcludeResolver(
+    config,
+    includeWebFeedback,
+    /@sentry(?:-internal)?\/feedback/,
+    'includeWebFeedback',
+  );
+}
+
 /**
  * Matches relative import paths to server-only AI/MCP modules within `@sentry/core`.
  *

packages/core/test/tools/metroconfig.test.ts

@@ -9,6 +9,7 @@ import {
   getSentryExpoConfig,
   withSentryBabelTransformer,
   withSentryExcludeServerOnlyResolver,
+  withSentryFeedbackResolver,
   withSentryFramesCollapsed,
   withSentryResolver,
 } from '../../src/js/tools/metroconfig';
@@ -364,6 +365,190 @@ describe('metroconfig', () => {
       }
     });
   });
+  describe('withSentryFeedbackResolver', () => {
+    let originalResolverMock: any;
+
+    // @ts-expect-error Can't see type CustomResolutionContext
+    let contextMock: CustomResolutionContext;
+    let config: MetroConfig = {};
+
+    beforeEach(() => {
+      originalResolverMock = jest.fn();
+      contextMock = {
+        resolveRequest: jest.fn(),
+      };
+
+      config = {
+        resolver: {
+          resolveRequest: originalResolverMock,
+        },
+      };
+    });
+
+    describe.each([
+      ['new Metro', false, '0.70.0'],
+      ['old Metro', true, '0.67.0'],
+    ])('on %s', (_description, oldMetro, metroVersion) => {
+      beforeEach(() => {
+        jest.resetModules();
+        // Mock metro/package.json
+        jest.mock('metro/package.json', () => ({
+          version: metroVersion,
+        }));
+      });
+
+      describe.each([['@sentry-internal/feedback'], ['@sentry/feedback']])('with %s', feedbackPackage => {
+        test('keep Feedback when platform is web and includeWebFeedback is true', () => {
+          const modifiedConfig = withSentryFeedbackResolver(config, true);
+          resolveRequest(modifiedConfig, contextMock, feedbackPackage, 'web');
+
+          ExpectToBeCalledWithMetroParameters(originalResolverMock, contextMock, feedbackPackage, 'web');
+        });
+
+        test('removes Feedback when platform is web and includeWebFeedback is false', () => {
+          const modifiedConfig = withSentryFeedbackResolver(config, false);
+          const result = resolveRequest(modifiedConfig, contextMock, feedbackPackage, 'web');
+
+          expect(result).toEqual({ type: 'empty' });
+          expect(originalResolverMock).not.toHaveBeenCalled();
+        });
+
+        test('keep Feedback when platform is android and includeWebFeedback is true', () => {
+          const modifiedConfig = withSentryFeedbackResolver(config, true);
+          resolveRequest(modifiedConfig, contextMock, feedbackPackage, 'android');
+
+          ExpectToBeCalledWithMetroParameters(originalResolverMock, contextMock, feedbackPackage, 'android');
+        });
+
+        test('removes Feedback when platform is android and includeWebFeedback is false', () => {
+          const modifiedConfig = withSentryFeedbackResolver(config, false);
+          const result = resolveRequest(modifiedConfig, contextMock, feedbackPackage, 'android');
+
+          expect(result).toEqual({ type: 'empty' });
+          expect(originalResolverMock).not.toHaveBeenCalled();
+        });
+
+        test('removes Feedback when platform is android and includeWebFeedback is undefined', () => {
+          const modifiedConfig = withSentryFeedbackResolver(config, undefined);
+          const result = resolveRequest(modifiedConfig, contextMock, feedbackPackage, 'android');
+
+          expect(result).toEqual({ type: 'empty' });
+          expect(originalResolverMock).not.toHaveBeenCalled();
+        });
+
+        test('keep Feedback when platform is undefined and includeWebFeedback is null', () => {
+          const modifiedConfig = withSentryFeedbackResolver(config, undefined);
+          resolveRequest(modifiedConfig, contextMock, feedbackPackage, null);
+
+          ExpectToBeCalledWithMetroParameters(originalResolverMock, contextMock, feedbackPackage, null);
+        });
+
+        test('keep Feedback when platform is ios and includeWebFeedback is true', () => {
+          const modifiedConfig = withSentryFeedbackResolver(config, true);
+          resolveRequest(modifiedConfig, contextMock, feedbackPackage, 'ios');
+
+          ExpectToBeCalledWithMetroParameters(originalResolverMock, contextMock, feedbackPackage, 'ios');
+        });
+
+        test('removes Feedback when platform is ios and includeWebFeedback is false', () => {
+          const modifiedConfig = withSentryFeedbackResolver(config, false);
+          const result = resolveRequest(modifiedConfig, contextMock, feedbackPackage, 'ios');
+
+          expect(result).toEqual({ type: 'empty' });
+          expect(originalResolverMock).not.toHaveBeenCalled();
+        });
+
+        test('removes Feedback when platform is ios and includeWebFeedback is undefined', () => {
+          const modifiedConfig = withSentryFeedbackResolver(config, undefined);
+          const result = resolveRequest(modifiedConfig, contextMock, feedbackPackage, 'ios');
+
+          expect(result).toEqual({ type: 'empty' });
+          expect(originalResolverMock).not.toHaveBeenCalled();
+        });
+      });
+
+      test('calls originalResolver when moduleName is not @sentry-internal/feedback', () => {
+        const modifiedConfig = withSentryFeedbackResolver(config, true);
+        const moduleName = 'some/other/module';
+        resolveRequest(modifiedConfig, contextMock, moduleName, 'web');
+
+        ExpectToBeCalledWithMetroParameters(originalResolverMock, contextMock, moduleName, 'web');
+      });
+
+      test('calls originalResolver when moduleName is not @sentry-internal/feedback and includeWebFeedback set to false', () => {
+        const modifiedConfig = withSentryFeedbackResolver(config, false);
+        const moduleName = 'some/other/module';
+        resolveRequest(modifiedConfig, contextMock, moduleName, 'web');
+
+        ExpectToBeCalledWithMetroParameters(originalResolverMock, contextMock, moduleName, 'web');
+      });
+
+      test('calls default resolver on new metro resolver when originalResolver is not provided', () => {
+        if (oldMetro) {
+          return;
+        }
+
+        const modifiedConfig = withSentryFeedbackResolver({ resolver: {} }, true);
+        const moduleName = 'some/other/module';
+        const platform = 'web';
+        resolveRequest(modifiedConfig, contextMock, moduleName, platform);
+
+        ExpectToBeCalledWithMetroParameters(contextMock.resolveRequest, contextMock, moduleName, platform);
+      });
+
+      test('throws error when running on old metro and includeWebFeedback is set to false', () => {
+        if (!oldMetro) {
+          return;
+        }
+
+        // @ts-expect-error mock.
+        const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+        const modifiedConfig = withSentryFeedbackResolver({ resolver: {} }, true);
+        const moduleName = 'some/other/module';
+        resolveRequest(modifiedConfig, contextMock, moduleName, 'web');
+
+        expect(mockExit).toHaveBeenCalledWith(-1);
+      });
+
+      type CustomResolverBeforeMetro067 = (
+        // @ts-expect-error Can't see type CustomResolutionContext
+        context: CustomResolutionContext,
+        realModuleName: string,
+        platform: string | null,
+        moduleName?: string,
+        // @ts-expect-error Can't see type CustomResolutionContext
+      ) => Resolution;
+
+      function resolveRequest(
+        metroConfig: MetroConfig,
+        context: any,
+        moduleName: string,
+        platform: string | null,
+        // @ts-expect-error Can't see type Resolution.
+      ): Resolution {
+        if (oldMetro) {
+          const resolver = metroConfig.resolver?.resolveRequest as CustomResolverBeforeMetro067;
+          // On older Metro the resolveRequest is the creater resolver.
+          context.resolveRequest = resolver;
+          return resolver(context, `real${moduleName}`, platform, moduleName);
+        }
+        return metroConfig.resolver?.resolveRequest?.(context, moduleName, platform);
+      }
+
+      function ExpectToBeCalledWithMetroParameters(
+        received: CustomResolverBeforeMetro067,
+        contextMock: CustomResolverBeforeMetro067,
+        moduleName: string,
+        platform: string | null,
+      ) {
+        if (oldMetro) {
+          expect(received).toHaveBeenCalledWith(contextMock, `real${moduleName}`, platform, moduleName);
+        } else {
+          expect(received).toHaveBeenCalledWith(contextMock, moduleName, platform);
+        }
+      }
+    });
+  });
   describe('withSentryExcludeServerOnlyResolver', () => {
     const SENTRY_CORE_ORIGIN = '/project/node_modules/@sentry/core/build/esm/index.js';