feat(core): Extract errors from props in unkown inputs (#11526)

This changes the handling of unknown inputs for e.g.
`captureException()`, to check if there is a property that holds an
`Error` and use this.

So e.g. this:

```js
const error = new Error('Some error');
Sentry.captureException({ message: 'something happened!', err: error });
```

Will use `Some error` as the error message, and also take the stacktrace
from the error instead of the syntethic one.

There is of course the chance that this leads to false positives, if
something is captured and contains a reference to an unrelated error
instance. But I'd say this is not so likely, and we still keep the
serialised object as `extra` on the event.

Should fix e.g.
https://peated.sentry.io/issues/5166150355/?project=4505138086019073

Author: mydea

packages/browser/src/eventbuilder.ts

@@ -48,10 +48,7 @@ export function exceptionFromError(stackParser: StackParser, ex: Error): Excepti
   return exception;
 }
 
-/**
- * @hidden
- */
-export function eventFromPlainObject(
+function eventFromPlainObject(
   stackParser: StackParser,
   exception: Record<string, unknown>,
   syntheticException?: Error,
@@ -60,35 +57,46 @@ export function eventFromPlainObject(
   const client = getClient();
   const normalizeDepth = client && client.getOptions().normalizeDepth;
 
-  const event: Event = {
+  // If we can, we extract an exception from the object properties
+  const errorFromProp = getErrorPropertyFromObject(exception);
+
+  const extra = {
+    __serialized__: normalizeToSize(exception, normalizeDepth),
+  };
+
+  if (errorFromProp) {
+    return {
+      exception: {
+        values: [exceptionFromError(stackParser, errorFromProp)],
+      },
+      extra,
+    };
+  }
+
+  const event = {
     exception: {
       values: [
         {
           type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',
           value: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }),
-        },
+        } as Exception,
       ],
     },
-    extra: {
-      __serialized__: normalizeToSize(exception, normalizeDepth),
-    },
-  };
+    extra,
+  } satisfies Event;
 
   if (syntheticException) {
     const frames = parseStackFrames(stackParser, syntheticException);
     if (frames.length) {
       // event.exception.values[0] has been set above
-      (event.exception as { values: Exception[] }).values[0].stacktrace = { frames };
+      event.exception.values[0].stacktrace = { frames };
     }
   }
 
   return event;
 }
 
-/**
- * @hidden
- */
-export function eventFromError(stackParser: StackParser, ex: Error): Event {
+function eventFromError(stackParser: StackParser, ex: Error): Event {
   return {
     exception: {
       values: [exceptionFromError(stackParser, ex)],
@@ -97,7 +105,7 @@ export function eventFromError(stackParser: StackParser, ex: Error): Event {
 }
 
 /** Parses stack frames from an error */
-export function parseStackFrames(
+function parseStackFrames(
   stackParser: StackParser,
   ex: Error & { framesToPop?: number; stacktrace?: string },
 ): StackFrame[] {
@@ -283,10 +291,7 @@ export function eventFromUnknownInput(
   return event;
 }
 
-/**
- * @hidden
- */
-export function eventFromString(
+function eventFromString(
   stackParser: StackParser,
   message: ParameterizedString,
   syntheticException?: Error,
@@ -346,3 +351,17 @@ function getObjectClassName(obj: unknown): string | undefined | void {
     // ignore errors here
   }
 }
+
+/** If a plain object has a property that is an `Error`, return this error. */
+function getErrorPropertyFromObject(obj: Record<string, unknown>): Error | undefined {
+  for (const prop in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+      const value = obj[prop];
+      if (value instanceof Error) {
+        return value;
+      }
+    }
+  }
+
+  return undefined;
+}

packages/browser/test/unit/eventbuilder.test.ts

@@ -1,5 +1,5 @@
 import { defaultStackParser } from '../../src';
-import { eventFromPlainObject } from '../../src/eventbuilder';
+import { eventFromUnknownInput } from '../../src/eventbuilder';
 
 jest.mock('@sentry/core', () => {
   const original = jest.requireActual('@sentry/core');
@@ -12,17 +12,6 @@ jest.mock('@sentry/core', () => {
         },
       };
     },
-    getCurrentHub() {
-      return {
-        getClient(): any {
-          return {
-            getOptions(): any {
-              return { normalizeDepth: 6 };
-            },
-          };
-        },
-      };
-    },
   };
 });
 
@@ -35,7 +24,7 @@ afterEach(() => {
   jest.resetAllMocks();
 });
 
-describe('eventFromPlainObject', () => {
+describe('eventFromUnknownInput', () => {
   it('should use normalizeDepth from init options', () => {
     const deepObject = {
       a: {
@@ -53,7 +42,7 @@ describe('eventFromPlainObject', () => {
       },
     };
 
-    const event = eventFromPlainObject(defaultStackParser, deepObject);
+    const event = eventFromUnknownInput(defaultStackParser, deepObject);
 
     expect(event?.extra?.__serialized__).toEqual({
       a: {
@@ -71,16 +60,107 @@ describe('eventFromPlainObject', () => {
   });
 
   it.each([
-    ['empty object', {}, 'Object captured as exception with keys: [object has no keys]'],
-    ['pojo', { prop1: 'hello', prop2: 2 }, 'Object captured as exception with keys: prop1, prop2'],
-    ['Custom Class', new MyTestClass(), 'Object captured as exception with keys: prop1, prop2'],
-    ['Event', new Event('custom'), 'Event `Event` (type=custom) captured as exception'],
-    ['MouseEvent', new MouseEvent('click'), 'Event `MouseEvent` (type=click) captured as exception'],
-  ] as [string, Record<string, unknown>, string][])(
+    ['empty object', {}, {}, 'Object captured as exception with keys: [object has no keys]'],
+    [
+      'pojo',
+      { prop1: 'hello', prop2: 2 },
+      { prop1: 'hello', prop2: 2 },
+      'Object captured as exception with keys: prop1, prop2',
+    ],
+    [
+      'Custom Class',
+      new MyTestClass(),
+      { prop1: 'hello', prop2: 2 },
+      'Object captured as exception with keys: prop1, prop2',
+    ],
+    [
+      'Event',
+      new Event('custom'),
+      {
+        currentTarget: '[object Null]',
+        isTrusted: false,
+        target: '[object Null]',
+        type: 'custom',
+      },
+      'Event `Event` (type=custom) captured as exception',
+    ],
+    [
+      'MouseEvent',
+      new MouseEvent('click'),
+      {
+        currentTarget: '[object Null]',
+        isTrusted: false,
+        target: '[object Null]',
+        type: 'click',
+      },
+      'Event `MouseEvent` (type=click) captured as exception',
+    ],
+  ] as [string, Record<string, unknown>, Record<string, unknown>, string][])(
     'has correct exception value for %s',
-    (_name, exception, expected) => {
-      const actual = eventFromPlainObject(defaultStackParser, exception);
+    (_name, exception, serializedException, expected) => {
+      const actual = eventFromUnknownInput(defaultStackParser, exception);
       expect(actual.exception?.values?.[0]?.value).toEqual(expected);
+
+      expect(actual.extra).toEqual({
+        __serialized__: serializedException,
+      });
     },
   );
+
+  it('handles object with error prop', () => {
+    const error = new Error('Some error');
+    const event = eventFromUnknownInput(defaultStackParser, {
+      foo: { bar: 'baz' },
+      name: 'BadType',
+      err: error,
+    });
+
+    expect(event.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        mechanism: { handled: true, synthetic: true, type: 'generic' },
+        type: 'Error',
+        value: 'Some error',
+      }),
+    );
+    expect(event.extra).toEqual({
+      __serialized__: {
+        foo: { bar: 'baz' },
+        name: 'BadType',
+        err: {
+          message: 'Some error',
+          name: 'Error',
+          stack: expect.stringContaining('Error: Some error'),
+        },
+      },
+    });
+  });
+
+  it('handles class with error prop', () => {
+    const error = new Error('Some error');
+
+    class MyTestClass {
+      prop1 = 'hello';
+      prop2 = error;
+    }
+
+    const event = eventFromUnknownInput(defaultStackParser, new MyTestClass());
+
+    expect(event.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        mechanism: { handled: true, synthetic: true, type: 'generic' },
+        type: 'Error',
+        value: 'Some error',
+      }),
+    );
+    expect(event.extra).toEqual({
+      __serialized__: {
+        prop1: 'hello',
+        prop2: {
+          message: 'Some error',
+          name: 'Error',
+          stack: expect.stringContaining('Error: Some error'),
+        },
+      },
+    });
+  });
 });