CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## 4.2.4
+
+- [browser]: Use `withScope` in `Ember` integration instead of manual `pushPop/popScope` calls
+- [browser] fix: rethrow errors in testing mode with `Ember` integration (#1696)
+- [browser/node]: Fix `LinkedErrors` integration to send exceptions in correct order and take main exception into the
+  `limit` count
+- [browser/node] ref: Re-export `addGlobalEventProcessor`
+- [core]: Fix `InboundFilters` integration so that it reads and merge configuration from the `init` call as well
+
 ## 4.2.3
 
 - [utils]: `bundlerSafeRequire` renamed to `dynamicRequire` now takes two arguments, first is should be `module`, second

lerna.json

@@ -1,6 +1,6 @@
 {
   "lerna": "3.4.0",
-  "version": "4.2.3",
+  "version": "4.2.4",
   "packages": "packages/*",
   "ignore": "raven-*",
   "npmClient": "yarn",

packages/browser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/browser",
-  "version": "4.2.3",
+  "version": "4.2.4",
   "description": "Offical Sentry SDK for browsers",
   "repository": "git://github.com/getsentry/raven-js.git",
   "homepage": "https://github.com/getsentry/raven-js/tree/master/packages/browser",
@@ -15,9 +15,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@sentry/core": "4.2.3",
-    "@sentry/types": "4.2.3",
-    "@sentry/utils": "4.2.3"
+    "@sentry/core": "4.2.4",
+    "@sentry/types": "4.2.4",
+    "@sentry/utils": "4.2.4"
   },
   "devDependencies": {
     "@types/md5": "2.1.32",

packages/browser/src/index.ts

@@ -14,6 +14,7 @@ export {
 } from '@sentry/types';
 
 export {
+  addGlobalEventProcessor,
   addBreadcrumb,
   captureException,
   captureEvent,

packages/browser/src/integrations/linkederrors.ts

@@ -64,19 +64,19 @@ export class LinkedErrors implements Integration {
       return event;
     }
     const linkedErrors = this.walkErrorTree(hint.originalException, this.key);
-    event.exception.values = [...event.exception.values, ...linkedErrors];
+    event.exception.values = [...linkedErrors, ...event.exception.values];
     return event;
   }
 
   /**
    * @inheritDoc
    */
   public walkErrorTree(error: ExtendedError, key: string, stack: SentryException[] = []): SentryException[] {
-    if (!(error[key] instanceof Error) || stack.length >= this.limit) {
+    if (!(error[key] instanceof Error) || stack.length + 1 >= this.limit) {
       return stack;
     }
     const stacktrace = computeStackTrace(error[key]);
     const exception = exceptionFromStacktrace(stacktrace);
-    return this.walkErrorTree(error[key], key, [...stack, exception]);
+    return this.walkErrorTree(error[key], key, [exception, ...stack]);
   }
 }

packages/browser/src/integrations/pluggable/ember.ts

@@ -49,24 +49,26 @@ export class Ember implements Integration {
 
       if (typeof oldOnError === 'function') {
         oldOnError.call(this.Ember, error);
+      } else if (this.Ember.testing) {
+        throw error;
       }
     };
 
     this.Ember.RSVP.on(
       'error',
       (reason: any): void => {
         if (getCurrentHub().getIntegration(Ember)) {
-          const scope = getCurrentHub().pushScope();
-          if (reason instanceof Error) {
-            scope.setExtra('context', 'Unhandled Promise error detected');
-            this.addIntegrationToSdkInfo(scope);
-            getCurrentHub().captureException(reason, { originalException: reason });
-          } else {
-            scope.setExtra('reason', reason);
-            this.addIntegrationToSdkInfo(scope);
-            captureMessage('Unhandled Promise error detected');
-          }
-          getCurrentHub().popScope();
+          withScope(scope => {
+            if (reason instanceof Error) {
+              scope.setExtra('context', 'Unhandled Promise error detected');
+              this.addIntegrationToSdkInfo(scope);
+              getCurrentHub().captureException(reason, { originalException: reason });
+            } else {
+              scope.setExtra('reason', reason);
+              this.addIntegrationToSdkInfo(scope);
+              captureMessage('Unhandled Promise error detected');
+            }
+          });
         }
       },
     );

packages/browser/src/version.ts

@@ -1,2 +1,2 @@
 export const SDK_NAME = 'sentry.javascript.browser';
-export const SDK_VERSION = '4.2.3';
+export const SDK_VERSION = '4.2.4';

packages/browser/test/integration/init.js

@@ -36,6 +36,7 @@ Sentry.init({
   // debug: true,
   attachStacktrace: true,
   transport: DummyTransport,
+  ignoreErrors: ['ignoreErrorTest'],
   // integrations: function(old) {
   //   return [new Sentry.Integrations.Debug({ stringify: true })].concat(old);
   // },

packages/browser/test/integration/test.js

@@ -78,6 +78,31 @@ for (var idx in frames) {
         document.body.removeChild(this.iframe);
       });
 
+      describe('config', function() {
+        it('should allow to ignore specific errors', function(done) {
+          var iframe = this.iframe;
+
+          iframeExecute(
+            iframe,
+            done,
+            function() {
+              Sentry.captureException(new Error('foo'));
+              Sentry.captureException(new Error('ignoreErrorTest'));
+              Sentry.captureException(new Error('bar'));
+            },
+            function(sentryData) {
+              if (debounceAssertEventCount(sentryData, 2, done)) {
+                assert.equal(sentryData[0].exception.values[0].type, 'Error');
+                assert.equal(sentryData[0].exception.values[0].value, 'foo');
+                assert.equal(sentryData[1].exception.values[0].type, 'Error');
+                assert.equal(sentryData[1].exception.values[0].value, 'bar');
+                done();
+              }
+            }
+          );
+        });
+      });
+
       describe('API', function() {
         it('should capture Sentry.captureMessage', function(done) {
           var iframe = this.iframe;

packages/browser/test/integrations/linkederrors.test.ts

@@ -1,5 +1,6 @@
 import { expect } from 'chai';
 import { stub } from 'sinon';
+import { BrowserBackend } from '../../src/backend';
 import { LinkedErrors } from '../../src/integrations/linkederrors';
 
 let linkedErrors: LinkedErrors;
@@ -52,66 +53,90 @@ describe('LinkedErrors', () => {
       expect(spy.calledOnce).equal(true);
     });
 
-    it('should recursively walk error to find linked exceptions and assign them to the event', () => {
-      const event = {
-        exception: {
-          values: [],
-        },
-        message: 'foo',
-      };
+    it('should recursively walk error to find linked exceptions and assign them to the event', async () => {
+      const three: ExtendedError = new SyntaxError('three');
 
-      const one: ExtendedError = new Error('one');
       const two: ExtendedError = new TypeError('two');
-      const three: ExtendedError = new SyntaxError('three');
+      two.cause = three;
 
-      const originalException = one;
+      const one: ExtendedError = new Error('one');
       one.cause = two;
-      two.cause = three;
 
+      const originalException = one;
+      const backend = new BrowserBackend({});
+      const event = await backend.eventFromException(originalException);
       const result = linkedErrors.handler(event, {
         originalException,
       });
 
       // It shouldn't include root exception, as it's already processed in the event by the main error handler
-      expect(result!.exception!.values!.length).equal(2);
-      expect(result!.exception!.values![0].type).equal('TypeError');
-      expect(result!.exception!.values![0].value).equal('two');
+      expect(result!.exception!.values!.length).equal(3);
+      expect(result!.exception!.values![0].type).equal('SyntaxError');
+      expect(result!.exception!.values![0].value).equal('three');
       expect(result!.exception!.values![0].stacktrace).to.have.property('frames');
-      expect(result!.exception!.values![1].type).equal('SyntaxError');
-      expect(result!.exception!.values![1].value).equal('three');
+      expect(result!.exception!.values![1].type).equal('TypeError');
+      expect(result!.exception!.values![1].value).equal('two');
       expect(result!.exception!.values![1].stacktrace).to.have.property('frames');
+      expect(result!.exception!.values![2].type).equal('Error');
+      expect(result!.exception!.values![2].value).equal('one');
+      expect(result!.exception!.values![2].stacktrace).to.have.property('frames');
     });
 
-    it('should allow to change walk key', () => {
+    it('should allow to change walk key', async () => {
       linkedErrors = new LinkedErrors({
         key: 'reason',
       });
-      const event = {
-        exception: {
-          values: [],
-        },
-        message: 'foo',
-      };
 
-      const one: ExtendedError = new Error('one');
-      const two: ExtendedError = new TypeError('two');
       const three: ExtendedError = new SyntaxError('three');
 
-      const originalException = one;
-      one.reason = two;
+      const two: ExtendedError = new TypeError('two');
       two.reason = three;
 
+      const one: ExtendedError = new Error('one');
+      one.reason = two;
+
+      const originalException = one;
+      const backend = new BrowserBackend({});
+      const event = await backend.eventFromException(originalException);
       const result = linkedErrors.handler(event, {
         originalException,
       });
 
-      // It shouldn't include root exception, as it's already processed in the event by the main error handler
+      expect(result!.exception!.values!.length).equal(3);
+      expect(result!.exception!.values![0].type).equal('SyntaxError');
+      expect(result!.exception!.values![0].value).equal('three');
+      expect(result!.exception!.values![0].stacktrace).to.have.property('frames');
+      expect(result!.exception!.values![1].type).equal('TypeError');
+      expect(result!.exception!.values![1].value).equal('two');
+      expect(result!.exception!.values![1].stacktrace).to.have.property('frames');
+      expect(result!.exception!.values![2].type).equal('Error');
+      expect(result!.exception!.values![2].value).equal('one');
+      expect(result!.exception!.values![2].stacktrace).to.have.property('frames');
+    });
+
+    it('should allow to change stack size limit', async () => {
+      linkedErrors = new LinkedErrors({
+        limit: 2,
+      });
+
+      const one: ExtendedError = new Error('one');
+      const two: ExtendedError = new TypeError('two');
+      const three: ExtendedError = new SyntaxError('three');
+      one.cause = two;
+      two.cause = three;
+
+      const backend = new BrowserBackend({});
+      const event = await backend.eventFromException(one);
+      const result = linkedErrors.handler(event, {
+        originalException: one,
+      });
+
       expect(result!.exception!.values!.length).equal(2);
       expect(result!.exception!.values![0].type).equal('TypeError');
       expect(result!.exception!.values![0].value).equal('two');
       expect(result!.exception!.values![0].stacktrace).to.have.property('frames');
-      expect(result!.exception!.values![1].type).equal('SyntaxError');
-      expect(result!.exception!.values![1].value).equal('three');
+      expect(result!.exception!.values![1].type).equal('Error');
+      expect(result!.exception!.values![1].value).equal('one');
       expect(result!.exception!.values![1].stacktrace).to.have.property('frames');
     });
   });

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/core",
-  "version": "4.2.3",
+  "version": "4.2.4",
   "description": "Base implementation for all Sentry JavaScript SDKs",
   "repository": "git://github.com/getsentry/raven-js.git",
   "homepage": "https://github.com/getsentry/raven-js/tree/master/packages/core",
@@ -15,10 +15,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@sentry/hub": "4.2.3",
-    "@sentry/minimal": "4.2.3",
-    "@sentry/types": "4.2.3",
-    "@sentry/utils": "4.2.3"
+    "@sentry/hub": "4.2.4",
+    "@sentry/minimal": "4.2.4",
+    "@sentry/types": "4.2.4",
+    "@sentry/utils": "4.2.4"
   },
   "devDependencies": {
     "jest": "^22.4.3",

packages/core/src/integrations/inboundfilters.ts

@@ -4,6 +4,7 @@ import { isRegExp } from '@sentry/utils/is';
 import { logger } from '@sentry/utils/logger';
 import { getEventDescription } from '@sentry/utils/misc';
 import { includes } from '@sentry/utils/string';
+import { Client } from '../interfaces';
 
 // "Script error." is hard coded into browsers for errors that it can't read.
 // this is the result of a script being pulled in from an external domain and CORS.
@@ -18,13 +19,6 @@ interface InboundFiltersOptions {
 
 /** Inbound filters configurable by the user */
 export class InboundFilters implements Integration {
-  /** JSDoc */
-  private ignoreErrors?: Array<string | RegExp> = DEFAULT_IGNORE_ERRORS;
-  /** JSDoc */
-  private blacklistUrls?: Array<string | RegExp>;
-  /** JSDoc */
-  private whitelistUrls?: Array<string | RegExp>;
-
   /**
    * @inheritDoc
    */
@@ -34,19 +28,23 @@ export class InboundFilters implements Integration {
    */
   public static id: string = 'InboundFilters';
 
-  public constructor(private readonly options: InboundFiltersOptions = {}) {
-    this.configureOptions();
-  }
+  public constructor(private readonly options: InboundFiltersOptions = {}) {}
 
   /**
    * @inheritDoc
    */
   public setupOnce(): void {
     addGlobalEventProcessor(async (event: SentryEvent) => {
-      const self = getCurrentHub().getIntegration(InboundFilters);
+      const hub = getCurrentHub();
+      if (!hub) {
+        return event;
+      }
+      const self = hub.getIntegration(InboundFilters);
       if (self) {
-        self.configureOptions();
-        if (self.shouldDropEvent(event)) {
+        const client = hub.getClient() as Client;
+        const clientOptions = client ? client.getOptions() : {};
+        const options = self.mergeOptions(clientOptions);
+        if (self.shouldDropEvent(event, options)) {
           return null;
         }
       }
@@ -55,22 +53,22 @@ export class InboundFilters implements Integration {
   }
 
   /** JSDoc */
-  public shouldDropEvent(event: SentryEvent): boolean {
-    if (this.isIgnoredError(event)) {
+  public shouldDropEvent(event: SentryEvent, options: InboundFiltersOptions): boolean {
+    if (this.isIgnoredError(event, options)) {
       logger.warn(
         `Event dropped due to being matched by \`ignoreErrors\` option.\nEvent: ${getEventDescription(event)}`,
       );
       return true;
     }
-    if (this.isBlacklistedUrl(event)) {
+    if (this.isBlacklistedUrl(event, options)) {
       logger.warn(
         `Event dropped due to being matched by \`blacklistUrls\` option.\nEvent: ${getEventDescription(
           event,
         )}.\nUrl: ${this.getEventFilterUrl(event)}`,
       );
       return true;
     }
-    if (!this.isWhitelistedUrl(event)) {
+    if (!this.isWhitelistedUrl(event, options)) {
       logger.warn(
         `Event dropped due to not being matched by \`whitelistUrls\` option.\nEvent: ${getEventDescription(
           event,
@@ -82,35 +80,48 @@ export class InboundFilters implements Integration {
   }
 
   /** JSDoc */
-  public isIgnoredError(event: SentryEvent): boolean {
-    if (!this.ignoreErrors) {
+  public isIgnoredError(event: SentryEvent, options: InboundFiltersOptions = {}): boolean {
+    if (!options.ignoreErrors || !options.ignoreErrors.length) {
       return false;
     }
 
     return this.getPossibleEventMessages(event).some(message =>
       // Not sure why TypeScript complains here...
-      (this.ignoreErrors as Array<RegExp | string>).some(pattern => this.isMatchingPattern(message, pattern)),
+      (options.ignoreErrors as Array<RegExp | string>).some(pattern => this.isMatchingPattern(message, pattern)),
     );
   }
 
   /** JSDoc */
-  public isBlacklistedUrl(event: SentryEvent): boolean {
+  public isBlacklistedUrl(event: SentryEvent, options: InboundFiltersOptions = {}): boolean {
     // TODO: Use Glob instead?
-    if (!this.blacklistUrls) {
+    if (!options.blacklistUrls || !options.blacklistUrls.length) {
       return false;
     }
     const url = this.getEventFilterUrl(event);
-    return !url ? false : this.blacklistUrls.some(pattern => this.isMatchingPattern(url, pattern));
+    return !url ? false : options.blacklistUrls.some(pattern => this.isMatchingPattern(url, pattern));
   }
 
   /** JSDoc */
-  public isWhitelistedUrl(event: SentryEvent): boolean {
+  public isWhitelistedUrl(event: SentryEvent, options: InboundFiltersOptions = {}): boolean {
     // TODO: Use Glob instead?
-    if (!this.whitelistUrls) {
+    if (!options.whitelistUrls || !options.whitelistUrls.length) {
       return true;
     }
     const url = this.getEventFilterUrl(event);
-    return !url ? true : this.whitelistUrls.some(pattern => this.isMatchingPattern(url, pattern));
+    return !url ? true : options.whitelistUrls.some(pattern => this.isMatchingPattern(url, pattern));
+  }
+
+  /** JSDoc */
+  public mergeOptions(clientOptions: InboundFiltersOptions = {}): InboundFiltersOptions {
+    return {
+      blacklistUrls: [...(this.options.blacklistUrls || []), ...(clientOptions.blacklistUrls || [])],
+      ignoreErrors: [
+        ...(this.options.ignoreErrors || []),
+        ...(clientOptions.ignoreErrors || []),
+        ...DEFAULT_IGNORE_ERRORS,
+      ],
+      whitelistUrls: [...(this.options.whitelistUrls || []), ...(clientOptions.whitelistUrls || [])],
+    };
   }
 
   /** JSDoc */
@@ -124,19 +135,6 @@ export class InboundFilters implements Integration {
     }
   }
 
-  /** JSDoc */
-  private configureOptions(): void {
-    if (this.options.ignoreErrors) {
-      this.ignoreErrors = [...DEFAULT_IGNORE_ERRORS, ...this.options.ignoreErrors];
-    }
-    if (this.options.blacklistUrls) {
-      this.blacklistUrls = [...this.options.blacklistUrls];
-    }
-    if (this.options.whitelistUrls) {
-      this.whitelistUrls = [...this.options.whitelistUrls];
-    }
-  }
-
   /** JSDoc */
   private getPossibleEventMessages(event: SentryEvent): string[] {
     if (event.message) {

packages/hub/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/hub",
-  "version": "4.2.3",
+  "version": "4.2.4",
   "description": "Sentry hub which handles global state managment.",
   "repository": "git://github.com/getsentry/raven-js.git",
   "homepage": "https://github.com/getsentry/raven-js/tree/master/packages/hub",
@@ -15,8 +15,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@sentry/types": "4.2.3",
-    "@sentry/utils": "4.2.3"
+    "@sentry/types": "4.2.4",
+    "@sentry/utils": "4.2.4"
   },
   "devDependencies": {
     "jest": "^22.4.3",

packages/minimal/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/minimal",
-  "version": "4.2.3",
+  "version": "4.2.4",
   "description": "Sentry minimal library that can be used in other packages",
   "repository": "git://github.com/getsentry/raven-js.git",
   "homepage": "https://github.com/getsentry/raven-js/tree/master/packages/types",
@@ -15,8 +15,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@sentry/hub": "4.2.3",
-    "@sentry/types": "4.2.3"
+    "@sentry/hub": "4.2.4",
+    "@sentry/types": "4.2.4"
   },
   "devDependencies": {
     "jest": "^22.4.3",

packages/node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/node",
-  "version": "4.2.3",
+  "version": "4.2.4",
   "description": "Offical Sentry SDK for Node.js",
   "repository": "git://github.com/getsentry/raven-js.git",
   "homepage": "https://github.com/getsentry/raven-js/tree/master/packages/node",
@@ -15,10 +15,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@sentry/core": "4.2.3",
-    "@sentry/hub": "4.2.3",
-    "@sentry/types": "4.2.3",
-    "@sentry/utils": "4.2.3",
+    "@sentry/core": "4.2.4",
+    "@sentry/hub": "4.2.4",
+    "@sentry/types": "4.2.4",
+    "@sentry/utils": "4.2.4",
     "cookie": "0.3.1",
     "lsmod": "1.0.0",
     "md5": "2.2.1",

packages/node/src/handlers.ts

@@ -82,7 +82,7 @@ function extractRequestData(req: { [key: string]: any }): { [key: string]: strin
   // query string:
   //   node: req.url (raw)
   //   express, koa: req.query
-  const query = req.query || url.parse(originalUrl || '', true).query;
+  const query = url.parse(originalUrl || '', false).query;
   // cookies:
   //   node, express, koa: req.headers.cookie
   const cookies = cookie.parse(headers.cookie || '');

packages/node/src/index.ts

@@ -14,6 +14,7 @@ export {
 } from '@sentry/types';
 
 export {
+  addGlobalEventProcessor,
   addBreadcrumb,
   captureException,
   captureEvent,

packages/node/src/integrations/linkederrors.ts

@@ -62,7 +62,7 @@ export class LinkedErrors implements Integration {
       return event;
     }
     const linkedErrors = await this.walkErrorTree(hint.originalException, this.key);
-    event.exception.values = [...event.exception.values, ...linkedErrors];
+    event.exception.values = [...linkedErrors, ...event.exception.values];
     return event;
   }
 
@@ -74,10 +74,10 @@ export class LinkedErrors implements Integration {
     key: string,
     stack: SentryException[] = [],
   ): Promise<SentryException[]> {
-    if (!(error[key] instanceof Error) || stack.length >= this.limit) {
+    if (!(error[key] instanceof Error) || stack.length + 1 >= this.limit) {
       return stack;
     }
     const exception = await getExceptionFromError(error[key]);
-    return this.walkErrorTree(error[key], key, [...stack, exception]);
+    return this.walkErrorTree(error[key], key, [exception, ...stack]);
   }
 }

packages/node/src/version.ts

@@ -1,2 +1,2 @@
 export const SDK_NAME = 'sentry.javascript.node';
-export const SDK_VERSION = '4.2.3';
+export const SDK_VERSION = '4.2.4';

packages/node/test/integrations/linkederrors.test.ts

@@ -1,3 +1,4 @@
+import { NodeBackend } from '../../src';
 import { LinkedErrors } from '../../src/integrations/linkederrors';
 
 let linkedErrors: LinkedErrors;
@@ -24,12 +25,9 @@ describe('LinkedErrors', () => {
 
     it('should bail out if event contains exception, but no hint', async () => {
       const spy = jest.spyOn(linkedErrors, 'walkErrorTree');
-      const event = {
-        exception: {
-          values: [],
-        },
-        message: 'foo',
-      };
+      const one = new Error('originalException');
+      const backend = new NodeBackend({});
+      const event = await backend.eventFromException(one);
       const result = await linkedErrors.handler(event);
       expect(spy.mock.calls.length).toEqual(0);
       expect(result).toEqual(event);
@@ -42,79 +40,92 @@ describe('LinkedErrors', () => {
             resolve([]);
           }),
       );
-      const event = {
-        exception: {
-          values: [],
-        },
-        message: 'foo',
-      };
-      const hint = {
-        originalException: new Error('originalException'),
-      };
-      await linkedErrors.handler(event, hint);
+      const one = new Error('originalException');
+      const backend = new NodeBackend({});
+      const event = await backend.eventFromException(one);
+      await linkedErrors.handler(event, {
+        originalException: one,
+      });
       expect(spy.mock.calls.length).toEqual(1);
     });
 
     it('should recursively walk error to find linked exceptions and assign them to the event', async () => {
-      const event = {
-        exception: {
-          values: [],
-        },
-        message: 'foo',
-      };
-
       const one: ExtendedError = new Error('one');
       const two: ExtendedError = new TypeError('two');
       const three: ExtendedError = new SyntaxError('three');
-
-      const originalException = one;
       one.cause = two;
       two.cause = three;
 
+      const backend = new NodeBackend({});
+      const event = await backend.eventFromException(one);
       const result = await linkedErrors.handler(event, {
-        originalException,
+        originalException: one,
       });
 
-      // It shouldn't include root exception, as it's already processed in the event by the main error handler
-      expect(result!.exception!.values!.length).toEqual(2);
-      expect(result!.exception!.values![0].type).toEqual('TypeError');
-      expect(result!.exception!.values![0].value).toEqual('two');
+      expect(result!.exception!.values!.length).toEqual(3);
+      expect(result!.exception!.values![0].type).toEqual('SyntaxError');
+      expect(result!.exception!.values![0].value).toEqual('three');
       expect(result!.exception!.values![0].stacktrace).toHaveProperty('frames');
-      expect(result!.exception!.values![1].type).toEqual('SyntaxError');
-      expect(result!.exception!.values![1].value).toEqual('three');
+      expect(result!.exception!.values![1].type).toEqual('TypeError');
+      expect(result!.exception!.values![1].value).toEqual('two');
       expect(result!.exception!.values![1].stacktrace).toHaveProperty('frames');
+      expect(result!.exception!.values![2].type).toEqual('Error');
+      expect(result!.exception!.values![2].value).toEqual('one');
+      expect(result!.exception!.values![2].stacktrace).toHaveProperty('frames');
     });
 
     it('should allow to change walk key', async () => {
       linkedErrors = new LinkedErrors({
         key: 'reason',
       });
-      const event = {
-        exception: {
-          values: [],
-        },
-        message: 'foo',
-      };
 
       const one: ExtendedError = new Error('one');
       const two: ExtendedError = new TypeError('two');
       const three: ExtendedError = new SyntaxError('three');
-
-      const originalException = one;
       one.reason = two;
       two.reason = three;
 
+      const backend = new NodeBackend({});
+      const event = await backend.eventFromException(one);
+      const result = await linkedErrors.handler(event, {
+        originalException: one,
+      });
+
+      expect(result!.exception!.values!.length).toEqual(3);
+      expect(result!.exception!.values![0].type).toEqual('SyntaxError');
+      expect(result!.exception!.values![0].value).toEqual('three');
+      expect(result!.exception!.values![0].stacktrace).toHaveProperty('frames');
+      expect(result!.exception!.values![1].type).toEqual('TypeError');
+      expect(result!.exception!.values![1].value).toEqual('two');
+      expect(result!.exception!.values![1].stacktrace).toHaveProperty('frames');
+      expect(result!.exception!.values![2].type).toEqual('Error');
+      expect(result!.exception!.values![2].value).toEqual('one');
+      expect(result!.exception!.values![2].stacktrace).toHaveProperty('frames');
+    });
+
+    it('should allow to change stack size limit', async () => {
+      linkedErrors = new LinkedErrors({
+        limit: 2,
+      });
+
+      const one: ExtendedError = new Error('one');
+      const two: ExtendedError = new TypeError('two');
+      const three: ExtendedError = new SyntaxError('three');
+      one.cause = two;
+      two.cause = three;
+
+      const backend = new NodeBackend({});
+      const event = await backend.eventFromException(one);
       const result = await linkedErrors.handler(event, {
-        originalException,
+        originalException: one,
       });
 
-      // It shouldn't include root exception, as it's already processed in the event by the main error handler
       expect(result!.exception!.values!.length).toEqual(2);
       expect(result!.exception!.values![0].type).toEqual('TypeError');
       expect(result!.exception!.values![0].value).toEqual('two');
       expect(result!.exception!.values![0].stacktrace).toHaveProperty('frames');
-      expect(result!.exception!.values![1].type).toEqual('SyntaxError');
-      expect(result!.exception!.values![1].value).toEqual('three');
+      expect(result!.exception!.values![1].type).toEqual('Error');
+      expect(result!.exception!.values![1].value).toEqual('one');
       expect(result!.exception!.values![1].stacktrace).toHaveProperty('frames');
     });
   });

packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/types",
-  "version": "4.2.3",
+  "version": "4.2.4",
   "description": "Types for all Sentry JavaScript SDKs",
   "repository": "git://github.com/getsentry/raven-js.git",
   "homepage": "https://github.com/getsentry/raven-js/tree/master/packages/types",

packages/utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/utils",
-  "version": "4.2.3",
+  "version": "4.2.4",
   "description": "Utilities for all Sentry JavaScript SDKs",
   "repository": "git://github.com/getsentry/raven-js.git",
   "homepage": "https://github.com/getsentry/raven-js/tree/master/packages/utils",
@@ -13,7 +13,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@sentry/types": "4.2.3"
+    "@sentry/types": "4.2.4"
   },
   "devDependencies": {
     "chai": "^4.1.2",