fix: Prevent iterating over SyntheticEvents (#1900)

Author: kamilogorek

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+## 4.6.3
+
+- [utils] fix: Normalize value before recursively walking down the tree
+
 ## 4.6.2
 
 - [utils] fix: Preserve function prototype when filling

packages/utils/src/is.ts

@@ -138,3 +138,15 @@ export function isRegExp(wat: any): boolean {
 export function isNaN(wat: any): boolean {
   return wat !== wat;
 }
+
+/**
+ * Checks whether given value's type is a SyntheticEvent
+ * {@link isSyntheticEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+export function isSyntheticEvent(wat: any): boolean {
+  // tslint:disable-next-line:no-unsafe-any
+  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;
+}

packages/utils/src/object.ts

@@ -1,5 +1,5 @@
 import { SentryWrappedFunction } from '@sentry/types';
-import { isArray, isNaN, isPlainObject, isPrimitive, isUndefined } from './is';
+import { isArray, isNaN, isPlainObject, isPrimitive, isSyntheticEvent, isUndefined } from './is';
 import { Memo } from './memo';
 import { truncate } from './string';
 
@@ -291,10 +291,6 @@ function normalizeValue(value: any, key?: any): any {
     return '[Document]';
   }
 
-  if (value instanceof Date) {
-    return `[Date] ${value}`;
-  }
-
   if (value instanceof Error) {
     return objectifyError(value);
   }
@@ -304,6 +300,11 @@ function normalizeValue(value: any, key?: any): any {
     return Object.getPrototypeOf(value) ? value.constructor.name : 'Event';
   }
 
+  // React's SyntheticEvent thingy
+  if (isSyntheticEvent(value)) {
+    return '[SyntheticEvent]';
+  }
+
   if (isNaN(value)) {
     return '[NaN]';
   }
@@ -328,6 +329,12 @@ function normalizeValue(value: any, key?: any): any {
 export function decycle(obj: any, memo: Memo = new Memo()): any {
   // tslint:disable-next-line:no-unsafe-any
   const copy = isArray(obj) ? obj.slice() : isPlainObject(obj) ? assign({}, obj) : obj;
+  const normalized = normalizeValue(obj);
+
+  // If an object was normalized to its string form, we should just bail out as theres no point in going down that branch
+  if (typeof normalized === 'string') {
+    return normalized;
+  }
 
   if (!isPrimitive(obj)) {
     if (memo.memoize(obj)) {

packages/utils/test/object.test.ts

@@ -587,4 +587,24 @@ describe('safeNormalize()', () => {
       reason: '[Circular ~]',
     });
   });
+
+  test('normalizes value on every iteration of decycle and takes care of things like Reacts SyntheticEvents', () => {
+    const obj = {
+      foo: {
+        nativeEvent: 'wat',
+        preventDefault: 'wat',
+        stopPropagation: 'wat',
+      },
+      baz: NaN,
+      qux: function qux(): void {
+        /*no-empty*/
+      },
+    };
+    const result = safeNormalize(obj);
+    expect(result).toEqual({
+      foo: '[SyntheticEvent]',
+      baz: '[NaN]',
+      qux: '[Function: qux]',
+    });
+  });
 });