prevent initialization inside a browser extension

Author: s1gr1d

dev-packages/browser-integration-tests/suites/manual-client/skip-init-browser-extension/init.js

@@ -0,0 +1,8 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+window.browser = { runtime: { id: 'mock-extension-id' } };
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+});

dev-packages/browser-integration-tests/suites/manual-client/skip-init-browser-extension/test.ts

@@ -0,0 +1,31 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../utils/fixtures';
+
+sentryTest('should not initialize when inside a Chrome browser extension', async ({ getLocalTestUrl, page }) => {
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
+  const errorLogs: string[] = [];
+
+  page.on('console', message => {
+    if (message.type() === 'error') errorLogs.push(message.text());
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.goto(url);
+
+  const isInitialized = await page.evaluate(() => {
+    return !!(window as any).Sentry.isInitialized();
+  });
+
+  expect(isInitialized).toEqual(false);
+  expect(errorLogs.length).toEqual(1);
+  expect(errorLogs[0]).toEqual(
+    '[Sentry] You cannot run Sentry this way in an extension, check: https://docs.sentry.io/platforms/javascript/troubleshooting/#setting-up-sentry-in-shared-environments-eg-browser-extensions',
+  );
+});

dev-packages/browser-integration-tests/suites/manual-client/skip-init-chrome-extension/init.js

@@ -0,0 +1,8 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+window.chrome = { runtime: { id: 'mock-extension-id' } };
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+});

dev-packages/browser-integration-tests/suites/manual-client/skip-init-chrome-extension/test.ts

@@ -0,0 +1,31 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../utils/fixtures';
+
+sentryTest('should not initialize when inside a Chrome browser extension', async ({ getLocalTestUrl, page }) => {
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
+  const errorLogs: string[] = [];
+
+  page.on('console', message => {
+    if (message.type() === 'error') errorLogs.push(message.text());
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.goto(url);
+
+  const isInitialized = await page.evaluate(() => {
+    return !!(window as any).Sentry.isInitialized();
+  });
+
+  expect(isInitialized).toEqual(false);
+  expect(errorLogs.length).toEqual(1);
+  expect(errorLogs[0]).toEqual(
+    '[Sentry] You cannot run Sentry this way in an extension, check: https://docs.sentry.io/platforms/javascript/troubleshooting/#setting-up-sentry-in-shared-environments-eg-browser-extensions',
+  );
+});

packages/browser/src/sdk.ts

@@ -11,6 +11,7 @@ import {
 import type { DsnLike, Integration, Options, UserFeedback } from '@sentry/types';
 import {
   addHistoryInstrumentationHandler,
+  consoleSandbox,
   logger,
   stackParserFromStackParserOptions,
   supportsFetch,
@@ -116,6 +117,31 @@ export function init(options: BrowserOptions = {}): void {
     options.sendClientReports = true;
   }
 
+  // inside Chrome extension (chrome.* API)
+  const windowWithMaybeChrome = WINDOW as typeof WINDOW & { chrome?: { runtime?: { id?: string } } };
+
+  // inside Firefox/Safari extension (browser.* API)
+  const windowWithMaybeBrowser = WINDOW as typeof WINDOW & { browser?: { runtime?: { id?: string } } };
+
+  if (
+    (windowWithMaybeBrowser &&
+      windowWithMaybeBrowser.browser &&
+      windowWithMaybeBrowser.browser.runtime &&
+      windowWithMaybeBrowser.browser.runtime.id) ||
+    (windowWithMaybeChrome &&
+      windowWithMaybeChrome.chrome &&
+      windowWithMaybeChrome.chrome.runtime &&
+      windowWithMaybeChrome.chrome.runtime.id)
+  ) {
+    consoleSandbox(() => {
+      // eslint-disable-next-line no-console
+      console.error(
+        '[Sentry] You cannot run Sentry this way in an extension, check: https://docs.sentry.io/platforms/javascript/troubleshooting/#setting-up-sentry-in-shared-environments-eg-browser-extensions',
+      );
+    });
+    return;
+  }
+
   if (DEBUG_BUILD) {
     if (!supportsFetch()) {
       logger.warn(

packages/browser/test/unit/sdk.test.ts

@@ -4,6 +4,7 @@ import type { Client, Integration } from '@sentry/types';
 import { resolvedSyncPromise } from '@sentry/utils';
 
 import type { BrowserOptions } from '../../src';
+import { WINDOW } from '../../src';
 import { init } from '../../src/sdk';
 
 const PUBLIC_DSN = 'https://username@domain/123';
@@ -127,4 +128,63 @@ describe('init', () => {
     expect(newIntegration.setupOnce as jest.Mock).toHaveBeenCalledTimes(1);
     expect(DEFAULT_INTEGRATIONS[1].setupOnce as jest.Mock).toHaveBeenCalledTimes(0);
   });
+
+  describe('initialization error in browser extension', () => {
+    const DEFAULT_INTEGRATIONS: Integration[] = [
+      new MockIntegration('MockIntegration 0.1'),
+      new MockIntegration('MockIntegration 0.2'),
+    ];
+
+    const options = getDefaultBrowserOptions({ dsn: PUBLIC_DSN, defaultIntegrations: DEFAULT_INTEGRATIONS });
+
+    it('should not log a browser extension error if executed inside regular browser environment', () => {
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+      init(options);
+
+      expect(consoleErrorSpy).toBeCalledTimes(0);
+
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should log a browser extension error if executed inside a Chrome extension', () => {
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+      Object.defineProperty(WINDOW, 'chrome', {
+        value: { runtime: { id: 'mock-extension-id' } },
+        writable: true,
+      });
+
+      init(options);
+
+      expect(consoleErrorSpy).toBeCalledTimes(1);
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        '[Sentry] You cannot run Sentry this way in an extension, check: https://docs.sentry.io/platforms/javascript/troubleshooting/#setting-up-sentry-in-shared-environments-eg-browser-extensions',
+      );
+
+      consoleErrorSpy.mockRestore();
+
+      Object.defineProperty(WINDOW, 'chrome', {
+        value: null,
+        writable: true,
+      });
+    });
+
+    it('should log a browser extension error if executed inside a Firefox/Safari extension', () => {
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+      Object.defineProperty(WINDOW, 'browser', { value: { runtime: { id: 'mock-extension-id' } }, writable: true });
+
+      init(options);
+
+      expect(consoleErrorSpy).toBeCalledTimes(1);
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        '[Sentry] You cannot run Sentry this way in an extension, check: https://docs.sentry.io/platforms/javascript/troubleshooting/#setting-up-sentry-in-shared-environments-eg-browser-extensions',
+      );
+
+      consoleErrorSpy.mockRestore();
+
+      Object.defineProperty(WINDOW, 'browser', { value: null, writable: true });
+    });
+  });
 });