feat: Autoload Database Integrations in Node environment

Author: kamilogorek

packages/core/src/integration.ts

@@ -1,4 +1,4 @@
-import { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';
+import { addGlobalEventProcessor, getCurrentHub, getMainCarrier } from '@sentry/hub';
 import { Integration, Options } from '@sentry/types';
 import { logger } from '@sentry/utils';
 
@@ -9,38 +9,39 @@ export interface IntegrationIndex {
   [key: string]: Integration;
 }
 
+/**
+ * @private
+ */
+function filterDuplicates(integrations: Integration[]): Integration[] {
+  return integrations.reduce((acc, integrations) => {
+    if (acc.every(accIntegration => integrations.name !== accIntegration.name)) {
+      acc.push(integrations);
+    }
+    return acc;
+  }, [] as 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[] = [];
-  if (Array.isArray(userIntegrations)) {
-    const userIntegrationsNames = userIntegrations.map(i => i.name);
-    const pickedIntegrationsNames: string[] = [];
 
-    // Leave only unique default integrations, that were not overridden with provided user integrations
-    defaultIntegrations.forEach(defaultIntegration => {
-      if (
-        userIntegrationsNames.indexOf(defaultIntegration.name) === -1 &&
-        pickedIntegrationsNames.indexOf(defaultIntegration.name) === -1
-      ) {
-        integrations.push(defaultIntegration);
-        pickedIntegrationsNames.push(defaultIntegration.name);
-      }
-    });
+  let integrations: Integration[] = [...filterDuplicates(defaultIntegrations), ...autoloadedIntegrations];
 
-    // Don't add same user integration twice
-    userIntegrations.forEach(userIntegration => {
-      if (pickedIntegrationsNames.indexOf(userIntegration.name) === -1) {
-        integrations.push(userIntegration);
-        pickedIntegrationsNames.push(userIntegration.name);
-      }
-    });
+  if (Array.isArray(userIntegrations)) {
+    // Filter out integrations that are also included in user options
+    integrations = [
+      ...integrations.filter(integrations =>
+        userIntegrations.every(userIntegration => userIntegration.name !== integrations.name),
+      ),
+      // And filter out duplicated user options integrations
+      ...filterDuplicates(userIntegrations),
+    ];
   } else if (typeof userIntegrations === 'function') {
-    integrations = userIntegrations(defaultIntegrations);
+    integrations = userIntegrations(integrations);
     integrations = Array.isArray(integrations) ? integrations : [integrations];
-  } else {
-    integrations = [...defaultIntegrations];
   }
 
   // Make sure that if present, `Debug` integration will always run last

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

@@ -15,6 +15,12 @@ class MockIntegration implements Integration {
   }
 }
 
+function withAutoloadedIntegrations(integrations: Integration[], callback: () => void) {
+  (global as any).__SENTRY__ = { integrations };
+  callback();
+  delete (global as any).__SENTRY__;
+}
+
 describe('getIntegrationsToSetup', () => {
   it('works with empty array', () => {
     const integrations = getIntegrationsToSetup({
@@ -124,6 +130,40 @@ 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/core/test/lib/sdk.test.ts

@@ -9,22 +9,26 @@ declare var global: any;
 
 const PUBLIC_DSN = 'https://username@domain/123';
 
-jest.mock('@sentry/hub', () => ({
-  getCurrentHub(): {
-    bindClient(client: Client): boolean;
-    getClient(): boolean;
-  } {
-    return {
-      getClient(): boolean {
-        return false;
-      },
-      bindClient(client: Client): boolean {
-        client.setupIntegrations();
-        return true;
-      },
-    };
-  },
-}));
+jest.mock('@sentry/hub', () => {
+  const original = jest.requireActual('@sentry/hub');
+  return {
+    ...original,
+    getCurrentHub(): {
+      bindClient(client: Client): boolean;
+      getClient(): boolean;
+    } {
+      return {
+        getClient(): boolean {
+          return false;
+        },
+        bindClient(client: Client): boolean {
+          client.setupIntegrations();
+          return true;
+        },
+      };
+    },
+  };
+});
 
 class MockIntegration implements Integration {
   public name: string;

packages/hub/src/interfaces.ts

@@ -1,4 +1,4 @@
-import { Client } from '@sentry/types';
+import { Client, Integration } from '@sentry/types';
 
 import { Hub } from './hub';
 import { Scope } from './scope';
@@ -22,6 +22,7 @@ export interface Carrier {
     /**
      * Extra Hub properties injected by various SDKs
      */
+    integrations?: Integration[];
     extensions?: {
       /** Hack to prevent bundlers from breaking our usage of the domain package in the cross-platform Hub package */
       // eslint-disable-next-line @typescript-eslint/no-explicit-any

packages/tracing/src/hubextensions.ts

@@ -1,12 +1,14 @@
 import { getMainCarrier, Hub } from '@sentry/hub';
 import {
   CustomSamplingContext,
+  Integration,
+  IntegrationClass,
   Options,
   SamplingContext,
   TransactionContext,
   TransactionSamplingMethod,
 } from '@sentry/types';
-import { logger } from '@sentry/utils';
+import { dynamicRequire, isNodeEnv, loadModule, logger } from '@sentry/utils';
 
 import { registerErrorInstrumentation } from './errors';
 import { IdleTransaction } from './idletransaction';
@@ -206,15 +208,67 @@ export function startIdleTransaction(
  * @private
  */
 export function _addTracingExtensions(): void {
+  // FIXME: This is problematic, because `getMainCarrier` always return a valid Carrier, but because
+  // of how we set the types, we need to perform an unnecessary check here.
   const carrier = getMainCarrier();
-  if (carrier.__SENTRY__) {
-    carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};
-    if (!carrier.__SENTRY__.extensions.startTransaction) {
-      carrier.__SENTRY__.extensions.startTransaction = _startTransaction;
-    }
-    if (!carrier.__SENTRY__.extensions.traceHeaders) {
-      carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;
-    }
+  if (!carrier.__SENTRY__) {
+    return;
+  }
+  carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};
+  if (!carrier.__SENTRY__.extensions.startTransaction) {
+    carrier.__SENTRY__.extensions.startTransaction = _startTransaction;
+  }
+  if (!carrier.__SENTRY__.extensions.traceHeaders) {
+    carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;
+  }
+}
+
+/**
+ * @private
+ */
+function _autoloadDatabaseIntegrations(): void {
+  const carrier = getMainCarrier();
+  if (!carrier.__SENTRY__) {
+    return;
+  }
+
+  const supportedPackages = ['mongodb', 'mongoose', 'pg', 'mysql'];
+
+  const packageToIntegrationMapping: Record<string, () => Integration> = {
+    mongodb() {
+      const integration = dynamicRequire(module, './integrations/mongo') as { Mongo: IntegrationClass<Integration> };
+      return new integration.Mongo();
+    },
+    mongoose() {
+      const integration = dynamicRequire(module, './integrations/mongo') as { Mongo: IntegrationClass<Integration> };
+      return new integration.Mongo({ mongoose: true });
+    },
+    mysql() {
+      const integration = dynamicRequire(module, './integrations/mysql') as { Mysql: IntegrationClass<Integration> };
+      return new integration.Mysql();
+    },
+    pg() {
+      const integration = dynamicRequire(module, './integrations/postgres') as {
+        Postgres: IntegrationClass<Integration>;
+      };
+      return new integration.Postgres();
+    },
+  };
+
+  const mappedPackages = supportedPackages
+    .filter(moduleName => !!loadModule(moduleName))
+    .map(pkg => {
+      try {
+        return packageToIntegrationMapping[pkg]();
+      } catch (e) {
+        return undefined;
+      }
+    })
+    .filter(p => p) as Integration[];
+
+  if (mappedPackages.length > 0) {
+    carrier.__SENTRY__.integrations = carrier.__SENTRY__.integrations || [];
+    carrier.__SENTRY__.integrations.concat(mappedPackages);
   }
 }
 
@@ -224,6 +278,12 @@ export function _addTracingExtensions(): void {
 export function addExtensionMethods(): void {
   _addTracingExtensions();
 
+  // TODO: Option to disable this (but how, if it's a side-effect and there's no access to client options?)
+  // Detect and automatically load specified integrations.
+  if (isNodeEnv()) {
+    _autoloadDatabaseIntegrations();
+  }
+
   // If an error happens globally, we should make sure transaction status is set to error.
   registerErrorInstrumentation();
 }

packages/tracing/src/integrations/mongo.ts

@@ -1,6 +1,6 @@
 import { Hub } from '@sentry/hub';
 import { EventProcessor, Integration, SpanContext } from '@sentry/types';
-import { dynamicRequire, fill, isThenable, logger } from '@sentry/utils';
+import { fill, isThenable, loadModule, logger } from '@sentry/utils';
 
 // This allows us to use the same array for both defaults options and the type itself.
 // (note `as const` at the end to make it a union of string literal types (i.e. "a" | "b" | ... )
@@ -119,17 +119,15 @@ export class Mongo implements Integration {
    * @inheritDoc
    */
   public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {
-    let collection: MongoCollection;
     const moduleName = this._useMongoose ? 'mongoose' : 'mongodb';
-    try {
-      const mongodbModule = dynamicRequire(module, moduleName) as { Collection: MongoCollection };
-      collection = mongodbModule.Collection;
-    } catch (e) {
+    const pkg = loadModule<{ Collection: MongoCollection }>(moduleName);
+
+    if (!pkg) {
       logger.error(`Mongo Integration was unable to require \`${moduleName}\` package.`);
       return;
     }
 
-    this._instrumentOperations(collection, this._operations, getCurrentHub);
+    this._instrumentOperations(pkg.Collection, this._operations, getCurrentHub);
   }
 
   /**

packages/tracing/src/integrations/mysql.ts

@@ -1,6 +1,6 @@
 import { Hub } from '@sentry/hub';
 import { EventProcessor, Integration } from '@sentry/types';
-import { dynamicRequire, fill, logger } from '@sentry/utils';
+import { fill, loadModule, logger } from '@sentry/utils';
 
 interface MysqlConnection {
   createQuery: () => void;
@@ -22,12 +22,9 @@ export class Mysql implements Integration {
    * @inheritDoc
    */
   public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {
-    let connection: MysqlConnection;
+    const pkg = loadModule<MysqlConnection>('mysql/lib/Connection.js');
 
-    try {
-      // Unfortunatelly mysql is using some custom loading system and `Connection` is not exported directly.
-      connection = dynamicRequire(module, 'mysql/lib/Connection.js');
-    } catch (e) {
+    if (!pkg) {
       logger.error('Mysql Integration was unable to require `mysql` package.');
       return;
     }
@@ -36,7 +33,7 @@ export class Mysql implements Integration {
     //    function (callback) => void
     //    function (options, callback) => void
     //    function (options, values, callback) => void
-    fill(connection, 'createQuery', function(orig: () => void) {
+    fill(pkg, 'createQuery', function(orig: () => void) {
       return function(this: unknown, options: unknown, values: unknown, callback: unknown) {
         const scope = getCurrentHub().getScope();
         const parentSpan = scope?.getSpan();

packages/tracing/src/integrations/postgres.ts

@@ -1,6 +1,6 @@
 import { Hub } from '@sentry/hub';
 import { EventProcessor, Integration } from '@sentry/types';
-import { dynamicRequire, fill, logger } from '@sentry/utils';
+import { fill, loadModule, logger } from '@sentry/utils';
 
 interface PgClient {
   prototype: {
@@ -24,12 +24,9 @@ export class Postgres implements Integration {
    * @inheritDoc
    */
   public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {
-    let client: PgClient;
+    const pkg = loadModule<{ Client: PgClient }>('pg');
 
-    try {
-      const pgModule = dynamicRequire(module, 'pg') as { Client: PgClient };
-      client = pgModule.Client;
-    } catch (e) {
+    if (!pkg) {
       logger.error('Postgres Integration was unable to require `pg` package.');
       return;
     }
@@ -40,7 +37,7 @@ export class Postgres implements Integration {
      * function (query) => Promise
      * function (query, params) => Promise
      */
-    fill(client.prototype, 'query', function(orig: () => void | Promise<unknown>) {
+    fill(pkg.Client.prototype, 'query', function(orig: () => void | Promise<unknown>) {
       return function(this: unknown, config: unknown, values: unknown, callback: unknown) {
         const scope = getCurrentHub().getScope();
         const parentSpan = scope?.getSpan();

packages/tracing/test/integrations/mongo.test.ts

@@ -27,7 +27,7 @@ jest.mock('@sentry/utils', () => {
   const actual = jest.requireActual('@sentry/utils');
   return {
     ...actual,
-    dynamicRequire() {
+    loadModule() {
       return {
         Collection,
       };