Revert promise changes

Author: timfish

packages/node/src/backend.ts

@@ -16,14 +16,14 @@ export class NodeBackend extends BaseBackend<NodeOptions> {
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
   public eventFromException(exception: any, hint?: EventHint): PromiseLike<Event> {
-    return Promise.resolve(eventFromException(exception, hint));
+    return eventFromException(exception, hint);
   }
 
   /**
    * @inheritDoc
    */
   public eventFromMessage(message: string, level: Severity = Severity.Info, hint?: EventHint): PromiseLike<Event> {
-    return Promise.resolve(eventFromMessage(this._options, message, level, hint));
+    return eventFromMessage(this._options, message, level, hint);
   }
 
   /**

packages/node/src/eventbuilder.ts

@@ -7,6 +7,7 @@ import {
   isError,
   isPlainObject,
   normalizeToSize,
+  SyncPromise,
 } from '@sentry/utils';
 
 import { extractStackFromError, parseError, parseStack, prepareFramesForEvent } from './parsers';
@@ -15,7 +16,7 @@ import { extractStackFromError, parseError, parseStack, prepareFramesForEvent }
  * Builds and Event from a Exception
  * @hidden
  */
-export function eventFromException(exception: unknown, hint?: EventHint): Event {
+export function eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event> {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   let ex: any = exception;
   const providedMechanism: Mechanism | undefined =
@@ -46,14 +47,19 @@ export function eventFromException(exception: unknown, hint?: EventHint): Event
     mechanism.synthetic = true;
   }
 
-  const event = parseError(ex as Error);
-  addExceptionTypeValue(event, undefined, undefined);
-  addExceptionMechanism(event, mechanism);
+  return new SyncPromise<Event>((resolve, reject) =>
+    parseError(ex as Error)
+      .then(event => {
+        addExceptionTypeValue(event, undefined, undefined);
+        addExceptionMechanism(event, mechanism);
 
-  return {
-    ...event,
-    event_id: hint && hint.event_id,
-  };
+        resolve({
+          ...event,
+          event_id: hint && hint.event_id,
+        });
+      })
+      .then(null, reject),
+  );
 }
 
 /**
@@ -65,21 +71,23 @@ export function eventFromMessage(
   message: string,
   level: Severity = Severity.Info,
   hint?: EventHint,
-): Event {
+): PromiseLike<Event> {
   const event: Event = {
     event_id: hint && hint.event_id,
     level,
     message,
   };
 
-  if (options.attachStacktrace && hint && hint.syntheticException) {
-    const stack = hint.syntheticException ? extractStackFromError(hint.syntheticException) : [];
-    const frames = parseStack(stack);
-
-    event.stacktrace = {
-      frames: prepareFramesForEvent(frames),
-    };
-  }
-
-  return event;
+  return new SyncPromise<Event>(resolve => {
+    if (options.attachStacktrace && hint && hint.syntheticException) {
+      const stack = hint.syntheticException ? extractStackFromError(hint.syntheticException) : [];
+      const frames = parseStack(stack);
+      event.stacktrace = {
+        frames: prepareFramesForEvent(frames),
+      };
+      resolve(event);
+    } else {
+      resolve(event);
+    }
+  });
 }

packages/node/src/integrations/linkederrors.ts

@@ -81,9 +81,14 @@ export class LinkedErrors implements Integration {
       return resolvedSyncPromise(stack);
     }
     return new SyncPromise<Exception[]>((resolve, reject) => {
-      const exception = getExceptionFromError(error[key]);
-      void this._walkErrorTree(error[key], key, [exception, ...stack])
-        .then(resolve)
+      void getExceptionFromError(error[key])
+        .then((exception: Exception) => {
+          void this._walkErrorTree(error[key], key, [exception, ...stack])
+            .then(resolve)
+            .then(null, () => {
+              reject();
+            });
+        })
         .then(null, () => {
           reject();
         });

packages/node/src/parsers.ts

@@ -1,5 +1,5 @@
 import { Event, Exception, ExtendedError, StackFrame } from '@sentry/types';
-import { basename, dirname } from '@sentry/utils';
+import { basename, dirname, SyncPromise } from '@sentry/utils';
 
 import * as stacktrace from './stacktrace';
 
@@ -97,31 +97,35 @@ export function parseStack(stack: stacktrace.StackFrame[]): StackFrame[] {
 /**
  * @hidden
  */
-export function getExceptionFromError(error: Error): Exception {
+export function getExceptionFromError(error: Error): PromiseLike<Exception> {
   const name = error.name || error.constructor.name;
   const stack = extractStackFromError(error);
-  const frames = parseStack(stack);
-
-  return {
-    stacktrace: {
-      frames: prepareFramesForEvent(frames),
-    },
-    type: name,
-    value: error.message,
-  };
+  return new SyncPromise<Exception>(resolve => {
+    const frames = parseStack(stack);
+    const result = {
+      stacktrace: {
+        frames: prepareFramesForEvent(frames),
+      },
+      type: name,
+      value: error.message,
+    };
+    resolve(result);
+  });
 }
 
 /**
  * @hidden
  */
-export function parseError(error: ExtendedError): Event {
-  const exception = getExceptionFromError(error);
-
-  return {
-    exception: {
-      values: [exception],
-    },
-  };
+export function parseError(error: ExtendedError): PromiseLike<Event> {
+  return new SyncPromise<Event>(resolve =>
+    getExceptionFromError(error).then((exception: Exception) => {
+      resolve({
+        exception: {
+          values: [exception],
+        },
+      });
+    }),
+  );
 }
 
 /**