fix: safeNormalize and serialize for Promise rejections (#1841)

* fix: safeNormalize and serialize

* fix: Ensure max of 300 chars

Author: HazAT

packages/browser/src/integrations/globalhandlers.ts

@@ -1,6 +1,8 @@
 import { getCurrentHub } from '@sentry/core';
 import { Integration, SentryEvent } from '@sentry/types';
 import { logger } from '@sentry/utils/logger';
+import { safeNormalize, serialize } from '@sentry/utils/object';
+import { truncate } from '@sentry/utils/string';
 import { addExceptionTypeValue, eventFromStacktrace } from '../parsers';
 import {
   installGlobalHandler,
@@ -110,7 +112,10 @@ export class GlobalHandlers implements Integration {
       },
     };
 
-    const fallbackValue = typeof stacktrace.original !== 'undefined' ? `${stacktrace.original}` : '';
+    const fallbackValue =
+      typeof stacktrace.original !== 'undefined'
+        ? `${truncate(serialize(safeNormalize(stacktrace.original)), 300)}`
+        : '';
     const fallbackType = stacktrace.mechanism === 'onunhandledrejection' ? 'UnhandledRejection' : 'Error';
 
     // This makes sure we have type/value in every exception

packages/browser/test/integration/test.js

@@ -646,7 +646,7 @@ for (var idx in frames) {
           );
         });
 
-        it('should capture unhandledrejection as string', function(done) {
+        it('should capture unhandledrejection with a string', function(done) {
           var iframe = this.iframe;
 
           iframeExecute(
@@ -661,7 +661,101 @@ for (var idx in frames) {
             },
             function(sentryData) {
               if (debounceAssertEventCount(sentryData, 1, done)) {
-                assert.equal(sentryData[0].exception.values[0].value, 'test');
+                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();
+              } else {
+                // This test will be skipped if it's not Chrome Desktop
+                done();
+              }
+            }
+          );
+        });
+
+        it('should capture unhandledrejection with a monster string', function(done) {
+          var iframe = this.iframe;
+
+          iframeExecute(
+            iframe,
+            done,
+            function() {
+              if (isChrome()) {
+                Promise.reject('test'.repeat(100));
+              } else {
+                done();
+              }
+            },
+            function(sentryData) {
+              if (debounceAssertEventCount(sentryData, 1, done)) {
+                assert.isAtMost(sentryData[0].exception.values[0].value.length, 303);
+                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();
+              } else {
+                // This test will be skipped if it's not Chrome Desktop
+                done();
+              }
+            }
+          );
+        });
+
+        it('should capture unhandledrejection with an object', function(done) {
+          var iframe = this.iframe;
+
+          iframeExecute(
+            iframe,
+            done,
+            function() {
+              if (isChrome()) {
+                Promise.reject({ a: 'b' });
+              } else {
+                done();
+              }
+            },
+            function(sentryData) {
+              if (debounceAssertEventCount(sentryData, 1, done)) {
+                assert.equal(sentryData[0].exception.values[0].value, '{"a":"b"}');
+                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();
+              } else {
+                // This test will be skipped if it's not Chrome Desktop
+                done();
+              }
+            }
+          );
+        });
+
+        it('should capture unhandledrejection with an monster object', function(done) {
+          var iframe = this.iframe;
+
+          iframeExecute(
+            iframe,
+            done,
+            function() {
+              if (isChrome()) {
+                var a = {
+                  a: '1'.repeat('100'),
+                  b: '2'.repeat('100'),
+                  c: '3'.repeat('100'),
+                };
+                a.d = a.a;
+                a.e = a;
+                Promise.reject(a);
+              } else {
+                done();
+              }
+            },
+            function(sentryData) {
+              if (debounceAssertEventCount(sentryData, 1, done)) {
+                assert.isAtMost(sentryData[0].exception.values[0].value.length, 303);
                 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);

packages/utils/test/string.test.ts

@@ -4,7 +4,8 @@ describe('truncate()', () => {
   test('it works as expected', () => {
     expect(truncate('lolol', 3)).toEqual('lol...');
     expect(truncate('lolol', 10)).toEqual('lolol');
-    expect(truncate('lol', 3)).toEqual('lol');
+    expect(truncate('1'.repeat(1000), 300)).toHaveLength(303);
+    expect(truncate(new Array(1000).join('f'), 0)).toEqual(new Array(1000).join('f'));
     expect(truncate(new Array(1000).join('f'), 0)).toEqual(new Array(1000).join('f'));
   });