fix: Exception type/value, Loader promise reject (#1838)

* fix: Exception type/value, Loader promise reject

* fix: Comment

* revert: Changes to utils

* fix: Code Review

Author: HazAT

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## 4.5.2
+
+- [browser] fix: <unlabeled> event for unhandledRejection
+- [loader] fix: Handle unhandledRejection the same way as it would be thrown
+
 ## 4.5.1
 
 - [utils] fix: Don't npm ignore esm for utils

packages/browser/src/integrations/globalhandlers.ts

@@ -1,7 +1,7 @@
 import { getCurrentHub } from '@sentry/core';
 import { Integration, SentryEvent } from '@sentry/types';
 import { logger } from '@sentry/utils/logger';
-import { eventFromStacktrace } from '../parsers';
+import { addExceptionTypeValue, eventFromStacktrace } from '../parsers';
 import {
   installGlobalHandler,
   installGlobalUnhandledRejectionHandler,
@@ -78,21 +78,44 @@ export class GlobalHandlers implements Integration {
     }
   }
 
-  /** JSDoc */
+  /**
+   * This function creates an SentryEvent from an TraceKitStackTrace.
+   *
+   * @param stacktrace TraceKitStackTrace to be converted to an SentryEvent.
+   */
   private eventFromGlobalHandler(stacktrace: TraceKitStackTrace): SentryEvent {
     const event = eventFromStacktrace(stacktrace);
-    return {
+
+    const data: { [key: string]: string } = {
+      mode: stacktrace.mode,
+    };
+
+    if (stacktrace.message) {
+      data.message = stacktrace.message;
+    }
+
+    if (stacktrace.name) {
+      data.name = stacktrace.name;
+    }
+
+    const newEvent: SentryEvent = {
       ...event,
       exception: {
         ...event.exception,
         mechanism: {
-          data: {
-            mode: stacktrace.mode,
-          },
+          data,
           handled: false,
           type: stacktrace.mechanism,
         },
       },
     };
+
+    const fallbackValue = typeof stacktrace.original !== 'undefined' ? `${stacktrace.original}` : '';
+    const fallbackType = stacktrace.mechanism === 'onunhandledrejection' ? 'UnhandledRejection' : 'Error';
+
+    // This makes sure we have type/value in every exception
+    addExceptionTypeValue(newEvent, fallbackValue, fallbackType);
+
+    return newEvent;
   }
 }

packages/browser/src/loader.js

@@ -128,13 +128,14 @@
       // Because we installed the SDK, at this point we have an access to TraceKit's handler,
       // which can take care of browser differences (eg. missing exception argument in onerror)
       var tracekitErrorHandler = _window[_onerror];
+      var tracekitUnhandledRejectionHandler = _window[_onunhandledrejection];
 
       // And now capture all previously caught exceptions
       for (var i = 0; i < data.length; i++) {
-        if (data[i].e) {
+        if (data[i].e && tracekitErrorHandler) {
           tracekitErrorHandler.apply(_window, data[i].e);
-        } else if (data[i].p) {
-          SDK.captureException(data[i].p);
+        } else if (data[i].p && tracekitUnhandledRejectionHandler) {
+          tracekitUnhandledRejectionHandler.apply(_window, [data[i].p]);
         }
       }
     } catch (o_O) {

packages/browser/src/parsers.ts

@@ -6,16 +6,22 @@ import { computeStackTrace, StackFrame as TraceKitStackFrame, StackTrace as Trac
 
 const STACKTRACE_LIMIT = 50;
 
-/** JSDoc */
+/**
+ * This function creates an exception from an TraceKitStackTrace
+ * @param stacktrace TraceKitStackTrace that will be converted to an exception
+ */
 export function exceptionFromStacktrace(stacktrace: TraceKitStackTrace): SentryException {
   const frames = prepareFramesForEvent(stacktrace.stack);
 
-  const exception = {
-    stacktrace: { frames },
+  const exception: SentryException = {
     type: stacktrace.name,
     value: stacktrace.message,
   };
 
+  if (frames && frames.length) {
+    exception.stacktrace = { frames };
+  }
+
   // tslint:disable-next-line:strict-type-predicates
   if (exception.type === undefined && exception.value === '') {
     exception.value = 'Unrecoverable error caught';
@@ -96,12 +102,13 @@ export function prepareFramesForEvent(stack: TraceKitStackFrame[]): StackFrame[]
 /**
  * Adds exception values, type and value to an synthetic Exception.
  * @param event The event to modify.
- * @param message Message to be added.
+ * @param value Value of the exception.
+ * @param type Type of the exception.
  */
-export function addExceptionTypeValue(event: SentryEvent, message: string): void {
+export function addExceptionTypeValue(event: SentryEvent, value?: string, type?: string): void {
   event.exception = event.exception || {};
   event.exception.values = event.exception.values || [];
   event.exception.values[0] = event.exception.values[0] || {};
-  event.exception.values[0].value = event.exception.values[0].value || message;
-  event.exception.values[0].type = event.exception.values[0].type || 'Error';
+  event.exception.values[0].value = event.exception.values[0].value || value || '';
+  event.exception.values[0].type = event.exception.values[0].type || type || 'Error';
 }

packages/browser/src/tracekit.ts

@@ -23,6 +23,7 @@ export interface StackTrace {
   url: string;
   stack: StackFrame[];
   useragent: string;
+  original?: string;
 }
 
 interface ComputeStackTrace {
@@ -1468,6 +1469,7 @@ TraceKit.computeStackTrace = (function computeStackTraceWrapper() {
     }
 
     return {
+      original: ex,
       name: ex.name,
       message: ex.message,
       mode: 'failed',

packages/browser/test/integration/test.js

@@ -466,7 +466,7 @@ for (var idx in frames) {
             function(sentryData) {
               if (debounceAssertEventCount(sentryData, 1, done)) {
                 var sentryData = sentryData[0];
-                assert.equal(sentryData.exception.values[0].type, undefined);
+                assert.equal(sentryData.exception.values[0].type, 'Error');
 
                 // #<Object> is covering default Android 4.4 and 5.1 browser
                 assert.match(sentryData.exception.values[0].value, /^(\[object Object\]|#<Object>)$/);
@@ -617,6 +617,54 @@ for (var idx in frames) {
           );
         });
 
+        it('should capture unhandledrejection with error', function(done) {
+          var iframe = this.iframe;
+
+          iframeExecute(
+            iframe,
+            done,
+            function() {
+              setTimeout(function() {
+                return Promise.reject(new Error('test2'));
+              });
+            },
+            function(sentryData) {
+              if (debounceAssertEventCount(sentryData, 1, done)) {
+                assert.equal(sentryData[0].exception.values[0].value, 'test2');
+                assert.equal(sentryData[0].exception.values[0].type, 'Error');
+                assert.isAtLeast(sentryData[0].exception.values[0].stacktrace.frames.length, 1);
+                assert.equal(sentryData[0].exception.mechanism.handled, false);
+                assert.equal(sentryData[0].exception.mechanism.type, 'onunhandledrejection');
+                done();
+              }
+            }
+          );
+        });
+
+        it('should capture unhandledrejection as string', function(done) {
+          var iframe = this.iframe;
+
+          iframeExecute(
+            iframe,
+            done,
+            function() {
+              setTimeout(function() {
+                return Promise.reject('test');
+              });
+            },
+            function(sentryData) {
+              if (debounceAssertEventCount(sentryData, 1, done)) {
+                assert.equal(sentryData[0].exception.values[0].value, 'test');
+                assert.equal(sentryData[0].exception.values[0].type, 'UnhandledRejection');
+                assert.equal(sentryData[0].exception.values[0].stacktrace, undefined);
+                assert.equal(sentryData[0].exception.mechanism.handled, false);
+                assert.equal(sentryData[0].exception.mechanism.type, 'onunhandledrejection');
+                done();
+              }
+            }
+          );
+        });
+
         it('should capture exceptions inside setTimeout', function(done) {
           var iframe = this.iframe;