feat: Core integrations and new is/supports utils with tests (#1354)

Author: kamilogorek

package.json

@@ -8,7 +8,13 @@
     "test": "lerna run --stream --concurrency 1 --sort test"
   },
   "workspaces": [
-    "packages/*"
+    "packages/browser",
+    "packages/core",
+    "packages/node",
+    "packages/shim",
+    "packages/types",
+    "packages/typescript",
+    "packages/utils"
   ],
   "devDependencies": {
     "@types/chai": "^4.1.3",

packages/core/src/interfaces.ts

@@ -1,5 +1,5 @@
 import { Scope } from '@sentry/shim';
-import { Breadcrumb, SentryEvent } from '@sentry/types';
+import { Breadcrumb, Integration, SentryEvent } from '@sentry/types';
 import { DSN } from './dsn';
 import { SendStatus } from './status';
 
@@ -30,6 +30,15 @@ export interface Options {
    */
   dsn?: string;
 
+  /**
+   * List of integrations that should be installed after SDK was initialized.
+   * Accepts either a list of integrations or a function that receives
+   * default integrations and returns a new, updated list.
+   */
+  integrations?:
+    | Integration[]
+    | ((integrations: Integration[]) => Integration[]);
+
   /**
    * The release identifier used when uploading respective source maps. Specify
    * this value to allow Sentry to resolve the correct source maps when

packages/core/src/sdk.ts

@@ -2,6 +2,7 @@ import {
   bindClient as shimBindClient,
   getCurrentClient as shimGetCurrentClient,
 } from '@sentry/shim';
+import { Integration } from '@sentry/types';
 import { Client, Options } from './interfaces';
 
 /** A class object that can instanciate Client objects. */
@@ -20,12 +21,28 @@ export interface ClientClass<F extends Client, O extends Options> {
 export function initAndBind<F extends Client, O extends Options>(
   clientClass: ClientClass<F, O>,
   options: O,
+  defaultIntegrations: Integration[] = [],
 ): void {
   if (shimGetCurrentClient()) {
     return;
   }
 
   const client = new clientClass(options);
   client.install();
+
+  let integrations = [...defaultIntegrations];
+  if (Array.isArray(options.integrations)) {
+    integrations = [...integrations, ...options.integrations];
+  } else if (typeof options.integrations === 'function') {
+    integrations = options.integrations(integrations);
+  }
+
+  // Just in case someone will return non-array from a `itegrations` callback
+  if (Array.isArray(integrations)) {
+    integrations.forEach(integration => {
+      integration.install();
+    });
+  }
+
   shimBindClient(client);
 }

packages/core/test/lib/sdk.test.ts

@@ -0,0 +1,80 @@
+import { Integration } from '@sentry/types';
+import { initAndBind } from '../../src/sdk';
+import { TestClient } from '../mocks/client';
+
+declare var global: any;
+
+class MockIntegration implements Integration {
+  public name: string = 'MockIntegration';
+  public handler: () => void = jest.fn();
+  public install: () => void = () => {
+    this.handler();
+  };
+}
+
+describe('SDK', () => {
+  beforeEach(() => {
+    global.__SENTRY__ = {
+      shim: undefined,
+      stack: [],
+    };
+  });
+
+  describe('initAndBind', () => {
+    test('installs default integrations', () => {
+      const DEFAULT_INTEGRATIONS: Integration[] = [
+        new MockIntegration(),
+        new MockIntegration(),
+      ];
+      initAndBind(TestClient, {}, DEFAULT_INTEGRATIONS);
+      expect(DEFAULT_INTEGRATIONS[0].handler.mock.calls.length).toBe(1);
+      expect(DEFAULT_INTEGRATIONS[1].handler.mock.calls.length).toBe(1);
+    });
+
+    test('installs integrations provided through options', () => {
+      const integrations: Integration[] = [
+        new MockIntegration(),
+        new MockIntegration(),
+      ];
+      initAndBind(TestClient, { integrations }, []);
+      expect(integrations[0].handler.mock.calls.length).toBe(1);
+      expect(integrations[1].handler.mock.calls.length).toBe(1);
+    });
+
+    test('installs merged default integrations and one provided through options', () => {
+      const DEFAULT_INTEGRATIONS: Integration[] = [
+        new MockIntegration(),
+        new MockIntegration(),
+      ];
+      const integrations: Integration[] = [
+        new MockIntegration(),
+        new MockIntegration(),
+      ];
+      initAndBind(TestClient, { integrations }, DEFAULT_INTEGRATIONS);
+      expect(DEFAULT_INTEGRATIONS[0].handler.mock.calls.length).toBe(1);
+      expect(DEFAULT_INTEGRATIONS[1].handler.mock.calls.length).toBe(1);
+      expect(integrations[0].handler.mock.calls.length).toBe(1);
+      expect(integrations[1].handler.mock.calls.length).toBe(1);
+    });
+
+    test('installs integrations returned from a callback function', () => {
+      const DEFAULT_INTEGRATIONS: Integration[] = [
+        new MockIntegration(),
+        new MockIntegration(),
+      ];
+      const newIntegration = new MockIntegration();
+      initAndBind(
+        TestClient,
+        {
+          // Take only the first one and add a new one to it
+          integrations: (integrations: Integration[]) =>
+            integrations.slice(0, 1).concat(newIntegration),
+        },
+        DEFAULT_INTEGRATIONS,
+      );
+      expect(DEFAULT_INTEGRATIONS[0].handler.mock.calls.length).toBe(1);
+      expect(newIntegration.handler.mock.calls.length).toBe(1);
+      expect(DEFAULT_INTEGRATIONS[1].handler.mock.calls.length).toBe(0);
+    });
+  });
+});

packages/core/test/tslint.json

@@ -4,6 +4,7 @@
     "completed-docs": false,
     "no-non-null-assertion": false,
     "no-implicit-dependencies": [true, "dev"],
-    "no-unused-expression": false
+    "no-unused-expression": false,
+    "no-unsafe-any": false
   }
 }

packages/types/src/index.ts

@@ -7,6 +7,8 @@ export enum Severity {
   /** TODO */
   Warning = 'warning',
   /** TODO */
+  Log = 'log',
+  /** TODO */
   Info = 'info',
   /** TODO */
   Debug = 'debug',
@@ -116,3 +118,10 @@ export interface SentryEvent {
   extra?: { [key: string]: object };
   user?: User;
 }
+
+/** TODO */
+export interface Integration {
+  name: string;
+  handler?: any;
+  install(): void;
+}

packages/typescript/tslint.json

@@ -12,7 +12,7 @@
     "no-require-imports": false,
     "prefer-function-over-method": [false],
     "strict-boolean-expressions": false,
-
+    "no-inferrable-types": false,
     // These are too strict in tslint:all
     "comment-format": [true, "check-space"],
     "completed-docs": [

packages/utils/src/index.ts

@@ -1,4 +1,10 @@
 export { forget, filterAsync } from './async';
 export { mkdirp, mkdirpSync } from './fs';
-export { clone, deserialize, serialize } from './object';
+export { clone, deserialize, fill, serialize } from './object';
 export { Store } from './store';
+export { isError, isErrorEvent, isDOMError, isDOMException } from './is';
+export {
+  supportsErrorEvent,
+  supportsDOMError,
+  supportsDOMException,
+} from './supports';

packages/utils/src/is.ts

@@ -0,0 +1,52 @@
+/**
+ * Checks whether given value's type is one of a few Error or Error-like
+ * {@link isError}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+export function isError(wat: any): boolean {
+  switch (Object.prototype.toString.call(wat)) {
+    case '[object Error]':
+      return true;
+    case '[object Exception]':
+      return true;
+    case '[object DOMException]':
+      return true;
+    default:
+      return wat instanceof Error;
+  }
+}
+
+/**
+ * Checks whether given value's type is ErrorEvent
+ * {@link isErrorEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+export function isErrorEvent(wat: any): boolean {
+  return Object.prototype.toString.call(wat) === '[object ErrorEvent]';
+}
+
+/**
+ * Checks whether given value's type is DOMError
+ * {@link isDOMError}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+export function isDOMError(wat: any): boolean {
+  return Object.prototype.toString.call(wat) === '[object DOMError]';
+}
+
+/**
+ * Checks whether given value's type is DOMException
+ * {@link isDOMException}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+export function isDOMException(wat: any): boolean {
+  return Object.prototype.toString.call(wat) === '[object DOMException]';
+}

packages/utils/src/object.ts

@@ -39,3 +39,31 @@ export function deserialize<T>(str: string): T {
 export function clone<T>(object: T): T {
   return deserialize(serialize(object));
 }
+
+/**
+ * Wrap a given object method with a higher-order function
+ * and keep track of the original within `track` array
+ *
+ * @param source An object that contains a method to be wrapped.
+ * @param name A name of method to be wrapped.
+ * @param replacement A function that should be used to wrap a given method.
+ * @param [track] An array containing original methods that were wrapped.
+ * @returns void
+ */
+
+export function fill(
+  source: { [key: string]: any },
+  name: string,
+  replacement: (...args: any[]) => any,
+  track?: Array<[{ [key: string]: any }, string, any]>,
+): void {
+  const orig = source[name];
+  source[name] = replacement(orig);
+  // tslint:disable:no-unsafe-any
+  source[name].__raven__ = true;
+  // tslint:disable:no-unsafe-any
+  source[name].__orig__ = orig;
+  if (track) {
+    track.push([source, name, orig]);
+  }
+}