ref: Attach autoloaded integrations to defaultIntegrations

Author: HazAT

packages/core/src/integration.ts

@@ -1,4 +1,4 @@
-import { addGlobalEventProcessor, getCurrentHub, getMainCarrier } from '@sentry/hub';
+import { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';
 import { Integration, Options } from '@sentry/types';
 import { logger } from '@sentry/utils';
 
@@ -23,12 +23,10 @@ function filterDuplicates(integrations: Integration[]): Integration[] {
 
 /** Gets integration to install */
 export function getIntegrationsToSetup(options: Options): Integration[] {
-  const carrier = getMainCarrier();
-  const autoloadedIntegrations = carrier.__SENTRY__?.integrations || [];
   const defaultIntegrations = (options.defaultIntegrations && [...options.defaultIntegrations]) || [];
   const userIntegrations = options.integrations;
 
-  let integrations: Integration[] = [...filterDuplicates(defaultIntegrations), ...autoloadedIntegrations];
+  let integrations: Integration[] = [...filterDuplicates(defaultIntegrations)];
 
   if (Array.isArray(userIntegrations)) {
     // Filter out integrations that are also included in user options

packages/core/test/lib/integration.test.ts

@@ -15,13 +15,6 @@ class MockIntegration implements Integration {
   }
 }
 
-function withAutoloadedIntegrations(integrations: Integration[], callback: () => void) {
-  (global as any).__SENTRY__ = { integrations };
-  callback();
-  (global as any).__SENTRY__ = undefined;
-  delete (global as any).__SENTRY__;
-}
-
 describe('getIntegrationsToSetup', () => {
   it('works with empty array', () => {
     const integrations = getIntegrationsToSetup({
@@ -131,40 +124,6 @@ describe('getIntegrationsToSetup', () => {
     expect((integrations[1] as any).order).toEqual('secondUser');
   });
 
-  it('work with single autoloaded integration', () => {
-    withAutoloadedIntegrations([new MockIntegration('foo')], () => {
-      const integrations = getIntegrationsToSetup({});
-      expect(integrations.map(i => i.name)).toEqual(['foo']);
-    });
-  });
-
-  it('work with multiple autoloaded integrations', () => {
-    withAutoloadedIntegrations([new MockIntegration('foo'), new MockIntegration('bar')], () => {
-      const integrations = getIntegrationsToSetup({});
-      expect(integrations.map(i => i.name)).toEqual(['foo', 'bar']);
-    });
-  });
-
-  it('user integrations override autoloaded', () => {
-    const firstAutoloaded = new MockIntegration('foo');
-    (firstAutoloaded as any).order = 'firstAutoloaded';
-    const secondAutoloaded = new MockIntegration('bar');
-    (secondAutoloaded as any).order = 'secondAutoloaded';
-    const firstUser = new MockIntegration('foo');
-    (firstUser as any).order = 'firstUser';
-    const secondUser = new MockIntegration('bar');
-    (secondUser as any).order = 'secondUser';
-
-    withAutoloadedIntegrations([firstAutoloaded, secondAutoloaded], () => {
-      const integrations = getIntegrationsToSetup({
-        integrations: [firstUser, secondUser],
-      });
-      expect(integrations.map(i => i.name)).toEqual(['foo', 'bar']);
-      expect((integrations[0] as any).order).toEqual('firstUser');
-      expect((integrations[1] as any).order).toEqual('secondUser');
-    });
-  });
-
   it('always moves Debug integration to the end of the list', () => {
     let integrations = getIntegrationsToSetup({
       defaultIntegrations: [new MockIntegration('Debug'), new MockIntegration('foo')],

packages/hub/src/hub.ts

@@ -35,7 +35,7 @@ import { Session } from './session';
  *
  * @hidden
  */
-export const API_VERSION = 3;
+export const API_VERSION = 4;
 
 /**
  * Default maximum number of breadcrumbs added to an event. Can be overwritten

packages/node/src/sdk.ts

@@ -77,9 +77,16 @@ export const defaultIntegrations = [
  * @see {@link NodeOptions} for documentation on configuration options.
  */
 export function init(options: NodeOptions = {}): void {
-  if (options.defaultIntegrations === undefined) {
-    options.defaultIntegrations = defaultIntegrations;
-  }
+  const carrier = getMainCarrier();
+  const autoloadedIntegrations = carrier.__SENTRY__?.integrations || [];
+
+  options.defaultIntegrations =
+    options.defaultIntegrations === false
+      ? []
+      : [
+          ...(Array.isArray(options.defaultIntegrations) ? options.defaultIntegrations : defaultIntegrations),
+          ...autoloadedIntegrations,
+        ];
 
   if (options.dsn === undefined && process.env.SENTRY_DSN) {
     options.dsn = process.env.SENTRY_DSN;
@@ -105,7 +112,7 @@ export function init(options: NodeOptions = {}): void {
 
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
   if ((domain as any).active) {
-    setHubOnCarrier(getMainCarrier(), getCurrentHub());
+    setHubOnCarrier(carrier, getCurrentHub());
   }
 
   initAndBind(NodeClient, options);

packages/node/test/index.test.ts

@@ -1,4 +1,6 @@
-import { SDK_VERSION } from '@sentry/core';
+import { initAndBind, SDK_VERSION } from '@sentry/core';
+import { getMainCarrier } from '@sentry/hub';
+import { Integration } from '@sentry/types';
 import * as domain from 'domain';
 
 import {
@@ -15,6 +17,14 @@ import {
 } from '../src';
 import { NodeBackend } from '../src/backend';
 
+jest.mock('@sentry/core', () => {
+  const original = jest.requireActual('@sentry/core');
+  return {
+    ...original,
+    initAndBind: jest.fn().mockImplementation(original.initAndBind),
+  };
+});
+
 const dsn = 'https://[email protected]/4291';
 
 // eslint-disable-next-line no-var
@@ -26,6 +36,7 @@ describe('SentryNode', () => {
   });
 
   beforeEach(() => {
+    jest.clearAllMocks();
     getCurrentHub().pushScope();
   });
 
@@ -270,7 +281,32 @@ describe('SentryNode', () => {
   });
 });
 
+function withAutoloadedIntegrations(integrations: Integration[], callback: () => void) {
+  const carrier = getMainCarrier();
+  carrier.__SENTRY__!.integrations = integrations;
+  callback();
+  carrier.__SENTRY__!.integrations = undefined;
+  delete carrier.__SENTRY__!.integrations;
+}
+
+/** JSDoc */
+class MockIntegration implements Integration {
+  public name: string;
+
+  public constructor(name: string) {
+    this.name = name;
+  }
+
+  public setupOnce(): void {
+    // noop
+  }
+}
+
 describe('SentryNode initialization', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
   test('global.SENTRY_RELEASE is used to set release on initialization if available', () => {
     global.SENTRY_RELEASE = { id: 'foobar' };
     init({ dsn });
@@ -333,4 +369,36 @@ describe('SentryNode initialization', () => {
       expect(sdkData.version).toEqual(SDK_VERSION);
     });
   });
+
+  describe('autoloaded integrations', () => {
+    it('should attach single integration to default integrations', () => {
+      withAutoloadedIntegrations([new MockIntegration('foo')], () => {
+        init({
+          defaultIntegrations: [new MockIntegration('bar')],
+        });
+        const integrations = (initAndBind as jest.Mock).mock.calls[0][1].defaultIntegrations;
+        expect(integrations.map(i => i.name)).toEqual(['bar', 'foo']);
+      });
+    });
+
+    it('should attach multiple integrations to default integrations', () => {
+      withAutoloadedIntegrations([new MockIntegration('foo'), new MockIntegration('bar')], () => {
+        init({
+          defaultIntegrations: [new MockIntegration('baz'), new MockIntegration('qux')],
+        });
+        const integrations = (initAndBind as jest.Mock).mock.calls[0][1].defaultIntegrations;
+        expect(integrations.map(i => i.name)).toEqual(['baz', 'qux', 'foo', 'bar']);
+      });
+    });
+
+    it('should ignore autoloaded integrations when defaultIntegrations:false', () => {
+      withAutoloadedIntegrations([new MockIntegration('foo')], () => {
+        init({
+          defaultIntegrations: false,
+        });
+        const integrations = (initAndBind as jest.Mock).mock.calls[0][1].defaultIntegrations;
+        expect(integrations).toEqual([]);
+      });
+    });
+  });
 });