node: raven-node port (#1418)

Author: kamilogorek

package.json

@@ -42,6 +42,6 @@
     "ts-jest": "^22.4.4",
     "tslint": "^5.9.1",
     "tslint-language-service": "^0.9.9",
-    "typescript": "^2.8.3"
+    "typescript": "^2.9.2"
   }
 }

packages/core/src/base.ts

@@ -112,14 +112,15 @@ export abstract class BaseClient<B extends Backend, O extends Options>
    */
   public install(): boolean {
     if (!this.isEnabled()) {
-      return false;
+      return (this.installed = false);
     }
 
-    if (this.installed === undefined) {
-      this.installed = this.getBackend().install();
+    const backend = this.getBackend();
+    if (!this.installed && backend.install) {
+      backend.install();
     }
 
-    return this.installed;
+    return (this.installed = true);
   }
 
   /**
@@ -275,7 +276,7 @@ export abstract class BaseClient<B extends Backend, O extends Options>
     // This should be the last thing called, since we want that
     // {@link Hub.addEventProcessor} gets the finished prepared event.
     if (scope) {
-      await scope.applyToEvent(
+      return scope.applyToEvent(
         prepared,
         Math.min(maxBreadcrumbs, MAX_BREADCRUMBS),
       );

packages/core/src/interfaces.ts

@@ -245,7 +245,7 @@ export interface Client<O extends Options = Options> {
  */
 export interface Backend {
   /** Installs the SDK into the environment. */
-  install(): boolean;
+  install?(): boolean;
 
   /** Creates a {@link SentryEvent} from an exception. */
   eventFromException(exception: any): Promise<SentryEvent>;

packages/hub/src/hub.ts

@@ -217,7 +217,7 @@ export class Hub {
    * @param callback will only be called if there is a bound client
    */
   public addEventProcessor(
-    callback: (event: SentryEvent) => Promise<void>,
+    callback: (event: SentryEvent) => Promise<SentryEvent>,
   ): void {
     const top = this.getStackTop();
     if (top.scope && top.client) {

packages/hub/src/scope.ts

@@ -12,7 +12,9 @@ export class Scope {
   protected scopeListeners: Array<(scope: Scope) => void> = [];
 
   /** Callback list that will be called after {@link applyToEvent}. */
-  protected eventProcessors: Array<(scope: SentryEvent) => Promise<void>> = [];
+  protected eventProcessors: Array<
+    (scope: SentryEvent) => Promise<SentryEvent>
+  > = [];
 
   /** Array of breadcrumbs. */
   protected breadcrumbs: Breadcrumb[] = [];
@@ -36,7 +38,7 @@ export class Scope {
 
   /** Add new event processor that will be called after {@link applyToEvent}. */
   public addEventProcessor(
-    callback: (scope: SentryEvent) => Promise<void>,
+    callback: (scope: SentryEvent) => Promise<SentryEvent>,
   ): void {
     this.eventProcessors.push(callback);
   }
@@ -59,11 +61,13 @@ export class Scope {
   /**
    * This will be called after {@link applyToEvent} is finished.
    */
-  protected async notifyEventProcessors(event: SentryEvent): Promise<void> {
+  protected async notifyEventProcessors(
+    event: SentryEvent,
+  ): Promise<SentryEvent> {
     return this.eventProcessors.reduce(async (prev, callback) => {
-      await prev;
-      return callback(event);
-    }, Promise.resolve());
+      const prevEvent = await prev;
+      return callback(prevEvent);
+    }, Promise.resolve(event));
   }
 
   /**
@@ -170,7 +174,7 @@ export class Scope {
   public async applyToEvent(
     event: SentryEvent,
     maxBreadcrumbs?: number,
-  ): Promise<void> {
+  ): Promise<SentryEvent> {
     if (this.extra && Object.keys(this.extra).length) {
       event.extra = { ...this.extra, ...event.extra };
     }
@@ -195,6 +199,6 @@ export class Scope {
           : this.breadcrumbs;
     }
 
-    await this.notifyEventProcessors(event);
+    return this.notifyEventProcessors(event);
   }
 }

packages/hub/test/lib/hub.test.ts

@@ -1,9 +1,7 @@
 import { SentryEvent } from '@sentry/types';
-import { Hub, Layer, Scope } from '../../src';
+import { Hub, Scope } from '../../src';
 
 const clientFn = jest.fn();
-// const asyncClientFn = jest.fn(async () => Promise.resolve({}));
-// const asyncClientFn = async () => jest.fn();
 const asyncClientFn = async () => Promise.reject('error');
 const scope = new Scope();
 
@@ -236,13 +234,16 @@ describe('Hub', () => {
     const hub = new Hub({ a: 'b' }, localScope);
     hub.addEventProcessor(async (processedEvent: SentryEvent) => {
       expect(processedEvent.extra).toEqual({ a: 'b', b: 3 });
+      return processedEvent;
     });
     hub.addEventProcessor(async (processedEvent: SentryEvent) => {
       processedEvent.dist = '1';
+      return processedEvent;
     });
     hub.addEventProcessor(async (processedEvent: SentryEvent) => {
       expect(processedEvent.dist).toEqual('1');
       done();
+      return processedEvent;
     });
     await localScope.applyToEvent(event);
   });
@@ -257,19 +258,21 @@ describe('Hub', () => {
     const hub = new Hub({ a: 'b' }, localScope);
     hub.addEventProcessor(async (processedEvent: SentryEvent) => {
       expect(processedEvent.extra).toEqual({ a: 'b', b: 3 });
+      return processedEvent;
     });
     hub.addEventProcessor(
       async (processedEvent: SentryEvent) =>
-        new Promise<void>(resolve => {
+        new Promise<SentryEvent>(resolve => {
           setImmediate(() => {
             processedEvent.dist = '1';
-            resolve();
+            resolve(processedEvent);
           });
         }),
     );
     hub.addEventProcessor(async (processedEvent: SentryEvent) => {
       expect(processedEvent.dist).toEqual('1');
       done();
+      return processedEvent;
     });
     await localScope.applyToEvent(event);
   });

packages/node/package.json

@@ -20,7 +20,13 @@
     "@sentry/minimal": "4.0.0-beta.6",
     "@sentry/types": "4.0.0-beta.6",
     "@sentry/utils": "4.0.0-beta.6",
-    "raven": "^2.6.0"
+    "@types/cookie": "0.3.1",
+    "@types/md5": "2.1.32",
+    "@types/stack-trace": "0.0.29",
+    "cookie": "0.3.1",
+    "lsmod": "1.0.0",
+    "md5": "2.2.1",
+    "stack-trace": "0.0.10"
   },
   "devDependencies": {
     "jest": "^22.4.3",

packages/node/src/backend.ts

@@ -1,37 +1,21 @@
 import { Backend, DSN, Options, SentryError } from '@sentry/core';
-import { addBreadcrumb, captureEvent } from '@sentry/minimal';
+import { getDefaultHub } from '@sentry/hub';
 import { SentryEvent, SentryResponse } from '@sentry/types';
-import { Raven } from './raven';
+import { isError, isPlainObject } from '@sentry/utils/is';
+import {
+  limitObjectDepthToSize,
+  serializeKeysToEventMessage,
+} from '@sentry/utils/object';
+import * as md5 from 'md5';
+import * as stacktrace from 'stack-trace';
+import { parseError, parseStack, prepareFramesForEvent } from './parsers';
 import { HTTPSTransport, HTTPTransport } from './transports';
 
-/** Extension to the Function type. */
-interface FunctionExt extends Function {
-  __SENTRY_CAPTURE__?: boolean;
-}
-
-/** Prepares an event so it can be send with raven-js. */
-function normalizeEvent(ravenEvent: any): SentryEvent {
-  const event = ravenEvent;
-  // tslint:disable-next-line:no-unsafe-any
-  if (ravenEvent.exception && !ravenEvent.exception.values) {
-    // tslint:disable-next-line:no-unsafe-any
-    event.exception = { values: ravenEvent.exception };
-  }
-  return event as SentryEvent;
-}
-
 /**
  * Configuration options for the Sentry Node SDK.
  * @see NodeClient for more information.
  */
 export interface NodeOptions extends Options {
-  /**
-   * Whether unhandled Promise rejections should be captured or not. If true,
-   * this will install an error handler and prevent the process from crashing.
-   * Defaults to false.
-   */
-  captureUnhandledRejections?: boolean;
-
   /** Callback that is executed when a fatal global error occurs. */
   onFatalError?(error: Error): void;
 }
@@ -44,77 +28,58 @@ export class NodeBackend implements Backend {
   /**
    * @inheritDoc
    */
-  public install(): boolean {
-    // We are only called by the client if the SDK is enabled and a valid DSN
-    // has been configured. If no DSN is present, this indicates a programming
-    // error.
-    const dsn = this.options.dsn;
-    if (!dsn) {
-      throw new SentryError(
-        'Invariant exception: install() must not be called when disabled',
-      );
-    }
-
-    Raven.config(dsn, this.options);
-
-    // We need to leave it here for now, as we are skipping `install` call,
-    // due to integrations migration
-    // TODO: Remove it once we fully migrate our code
-    const { onFatalError } = this.options;
-    if (onFatalError) {
-      Raven.onFatalError = onFatalError;
-    }
-    Raven.installed = true;
-
-    // Hook into Raven's breadcrumb mechanism. This allows us to intercept both
-    // breadcrumbs created internally by Raven and pass them to the Client
-    // first, before actually capturing them.
-    Raven.captureBreadcrumb = breadcrumb => {
-      addBreadcrumb(breadcrumb);
-    };
-
-    // Hook into Raven's internal event sending mechanism. This allows us to
-    // pass events to the client, before they will be sent back here for
-    // actual submission.
-    Raven.send = (event, callback) => {
-      if (callback && (callback as FunctionExt).__SENTRY_CAPTURE__) {
-        callback(normalizeEvent(event));
+  public async eventFromException(exception: any): Promise<SentryEvent> {
+    let stack: stacktrace.StackFrame[] | undefined;
+    let ex: any = exception;
+
+    if (!isError(exception)) {
+      if (isPlainObject(exception)) {
+        // This will allow us to group events based on top-level keys
+        // which is much better than creating new group when any key/value change
+        const keys = Object.keys(exception as {}).sort();
+        const message = `Non-Error exception captured with keys: ${serializeKeysToEventMessage(
+          keys,
+        )}`;
+
+        // TODO: We also set `event.message` here previously, check if it works without it as well
+        getDefaultHub().configureScope(scope => {
+          scope.setExtra(
+            '__serialized__',
+            limitObjectDepthToSize(exception as {}),
+          );
+          scope.setFingerprint([md5(keys.join(''))]);
+        });
+
+        ex = new Error(message);
       } else {
-        // This "if" needs to be here in order for raven-node to propergate
-        // internal callbacks like in makeErrorHandler -> captureException
-        // correctly. Also the setTimeout is a dirty hack because in case of a
-        // fatal error, raven-node exits the process and our consturct of
-        // hub -> client doesn't have enough time to send the event.
-        if (callback) {
-          setTimeout(() => {
-            callback(event);
-          }, 1000);
-        }
-        captureEvent(normalizeEvent(event));
+        // This handles when someone does: `throw "something awesome";`
+        // We synthesize an Error here so we can extract a (rough) stack trace.
+        ex = new Error(exception as string);
       }
-    };
 
-    return true;
-  }
+      stack = stacktrace.get();
+    }
 
-  /**
-   * @inheritDoc
-   */
-  public async eventFromException(exception: any): Promise<SentryEvent> {
-    return new Promise<SentryEvent>(resolve => {
-      (resolve as FunctionExt).__SENTRY_CAPTURE__ = true;
-      Raven.captureException(exception, resolve);
-    });
+    const event: SentryEvent = stack
+      ? await parseError(ex as Error, stack)
+      : await parseError(ex as Error);
+
+    return event;
   }
 
   /**
    * @inheritDoc
    */
   public async eventFromMessage(message: string): Promise<SentryEvent> {
-    return new Promise<SentryEvent>(resolve => {
-      (resolve as FunctionExt).__SENTRY_CAPTURE__ = true;
-      Raven.captureMessage(message, resolve);
-    });
+    const stack = stacktrace.get();
+    const frames = await parseStack(stack);
+    const event: SentryEvent = {
+      message,
+      stacktrace: {
+        frames: prepareFramesForEvent(frames),
+      },
+    };
+    return event;
   }
 
   /**

packages/node/src/declarations.d.ts

@@ -0,0 +1 @@
+declare module 'lsmod';