[v7] Remove SyncPromise in favor of native Promise

Author: kamilogorek

packages/core/src/baseclient.ts

@@ -16,7 +16,6 @@ import {
   logger,
   normalize,
   SentryError,
-  SyncPromise,
   truncate,
   uuid4,
 } from '@sentry/utils';
@@ -276,7 +275,7 @@ export abstract class BaseClient<O extends OptionsV7> implements ClientLike<O> {
 
   /** Waits for the client to be done with processing. */
   protected _isClientProcessing(timeout?: number): PromiseLike<boolean> {
-    return new SyncPromise(resolve => {
+    return new Promise(resolve => {
       let ticked: number = 0;
       const tick: number = 1;
 
@@ -484,22 +483,22 @@ export abstract class BaseClient<O extends OptionsV7> implements ClientLike<O> {
    * @param event The event to send to Sentry.
    * @param hint May contain additional information about the original exception.
    * @param scope A scope containing event metadata.
-   * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.
+   * @returns A Promise that resolves with the event or rejects in case event was/will not be send.
    */
   protected _processEvent(event: SentryEvent, captureContext: CaptureContext): PromiseLike<SentryEvent> {
     // eslint-disable-next-line @typescript-eslint/unbound-method
     const { beforeSend, sampleRate } = this.options;
 
     if (this.options.enabled === false) {
-      return SyncPromise.reject(new SentryError('SDK not enabled, will not send event.'));
+      return Promise.reject(new SentryError('SDK not enabled, will not send event.'));
     }
 
     const isTransaction = event.type === 'transaction';
     // 1.0 === 100% events are sent
     // 0.0 === 0% events are sent
     // Sampling for transaction happens somewhere else
     if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {
-      return SyncPromise.reject(
+      return Promise.reject(
         new SentryError(
           `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,
         ),

packages/eventbuilder-browser/src/index.ts

@@ -10,7 +10,6 @@ import {
   isErrorEvent,
   isEvent,
   isPlainObject,
-  SyncPromise,
 } from '@sentry/utils';
 
 import { eventFromPlainObject, eventFromStacktrace, prepareFramesForEvent } from './parsers';
@@ -42,7 +41,7 @@ export function eventFromException(
   }
   event.level = Severity.Error;
   event.platform = 'javascript';
-  return SyncPromise.resolve(event);
+  return Promise.resolve(event);
 }
 
 /**
@@ -63,7 +62,7 @@ export function eventFromMessage(
   }
   event.level = captureContext.scope?.level ?? Severity.Info;
   event.platform = 'javascript';
-  return SyncPromise.resolve(event);
+  return Promise.resolve(event);
 }
 
 /**

packages/eventbuilder-node/src/index.ts

@@ -8,7 +8,6 @@ import {
   isError,
   isPlainObject,
   normalizeToSize,
-  SyncPromise,
 } from '@sentry/utils';
 
 import { extractStackFromError, parseError, parseStack, prepareFramesForEvent } from './parsers';
@@ -44,7 +43,7 @@ export function eventFromException(
     mechanism.synthetic = true;
   }
 
-  return new SyncPromise<SentryEvent>((resolve, reject) =>
+  return new Promise((resolve, reject) =>
     parseError(ex as Error)
       .then(event => {
         addExceptionTypeValue(event, undefined, undefined);
@@ -82,7 +81,7 @@ export function eventFromMessage(
     event.event_id = captureContext.hint?.event_id;
   }
 
-  return new SyncPromise<SentryEvent>(resolve => {
+  return new Promise(resolve => {
     if (options.attachStacktrace && captureContext.hint?.syntheticException) {
       const stack = extractStackFromError(captureContext.hint?.syntheticException);
       parseStack(stack)

packages/eventbuilder-node/src/parsers.ts

@@ -1,5 +1,5 @@
 import { SentryEvent, Exception, ExtendedError, StackFrame } from '@sentry/types';
-import { basename, dirname, SyncPromise } from '@sentry/utils';
+import { basename, dirname } from '@sentry/utils';
 
 import * as stacktrace from './stacktrace';
 
@@ -90,7 +90,7 @@ export function parseStack(stack: stacktrace.StackFrame[]): PromiseLike<StackFra
     return parsedFrame;
   });
 
-  return SyncPromise.resolve(frames);
+  return Promise.resolve(frames);
 }
 
 /**
@@ -99,7 +99,7 @@ export function parseStack(stack: stacktrace.StackFrame[]): PromiseLike<StackFra
 export function getExceptionFromError(error: Error): PromiseLike<Exception> {
   const name = error.name || error.constructor.name;
   const stack = extractStackFromError(error);
-  return new SyncPromise<Exception>(resolve =>
+  return new Promise(resolve =>
     parseStack(stack).then(frames => {
       const result = {
         stacktrace: {
@@ -117,7 +117,7 @@ export function getExceptionFromError(error: Error): PromiseLike<Exception> {
  * @hidden
  */
 export function parseError(error: ExtendedError): PromiseLike<SentryEvent> {
-  return new SyncPromise<SentryEvent>(resolve =>
+  return new Promise(resolve =>
     getExceptionFromError(error).then((exception: Exception) => {
       resolve({
         exception: {

packages/integration-node-contextlines/src/index.ts

@@ -1,12 +1,14 @@
 import { readFile } from 'fs';
 
 import { ClientLike, Integration, StackFrame } from '@sentry/types';
-import { snipLine, SyncPromise } from '@sentry/utils';
+import { snipLine } from '@sentry/utils';
 import { LRUMap } from 'lru_map';
 
 const DEFAULT_LINES_OF_CONTEXT: number = 7;
 const FILE_CONTENT_CACHE = new LRUMap<string, string | null>(100);
 
+// TODO: Write some performance tests for LRU/Promise memory issue.
+
 /**
  * Resets the file cache. Exists for testing purposes.
  * @hidden
@@ -91,12 +93,10 @@ function addContextToFrame(lines: string[], frame: StackFrame, linesOfContext: n
 function readSourceFiles(filenames: string[]): PromiseLike<{ [key: string]: string | null }> {
   // we're relying on filenames being de-duped already
   if (filenames.length === 0) {
-    return SyncPromise.resolve({});
+    return Promise.resolve({});
   }
 
-  return new SyncPromise<{
-    [key: string]: string | null;
-  }>(resolve => {
+  return new Promise(resolve => {
     const sourceFiles: {
       [key: string]: string | null;
     } = {};

packages/integration-node-linkederrors/src/index.ts

@@ -1,5 +1,5 @@
 import { ClientLike, EventHint, Exception, ExtendedError, Integration, SentryEvent } from '@sentry/types';
-import { isInstanceOf, SyncPromise } from '@sentry/utils';
+import { isInstanceOf } from '@sentry/utils';
 import { getExceptionFromError } from '@sentry/eventbuilder-node';
 
 const DEFAULT_KEY = 'cause';
@@ -19,10 +19,10 @@ export class LinkedErrors implements Integration {
   public install(client: ClientLike): void {
     client.addEventProcessor((event: SentryEvent, hint?: EventHint) => {
       if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {
-        return SyncPromise.resolve(event);
+        return Promise.resolve(event);
       }
 
-      return new SyncPromise<SentryEvent>(resolve => {
+      return new Promise(resolve => {
         this._walkErrorTree(hint.originalException as Error, this._key)
           .then((linkedErrors: Exception[]) => {
             if (event && event.exception && event.exception.values) {
@@ -39,9 +39,9 @@ export class LinkedErrors implements Integration {
 
   private _walkErrorTree(error: ExtendedError, key: string, stack: Exception[] = []): PromiseLike<Exception[]> {
     if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {
-      return SyncPromise.resolve(stack);
+      return Promise.resolve(stack);
     }
-    return new SyncPromise<Exception[]>((resolve, reject) => {
+    return new Promise((resolve, reject) => {
       getExceptionFromError(error[key])
         .then((exception: Exception) => {
           this._walkErrorTree(error[key], key, [exception, ...stack])

packages/scope/src/scope.ts

@@ -16,7 +16,7 @@ import {
   User,
   BreadcrumbHint,
 } from '@sentry/types';
-import { dateTimestampInSeconds, isPlainObject, isThenable, SyncPromise } from '@sentry/utils';
+import { dateTimestampInSeconds, isPlainObject, isThenable } from '@sentry/utils';
 
 import { Session } from './session';
 
@@ -441,7 +441,7 @@ export class Scope implements ScopeLike {
     hint?: EventHint,
     index: number = 0,
   ): PromiseLike<SentryEvent | null> {
-    return new SyncPromise<SentryEvent | null>((resolve, reject) => {
+    return new Promise((resolve, reject) => {
       const processor = processors[index];
       if (event === null || typeof processor !== 'function') {
         resolve(event);

packages/utils/src/index.ts

@@ -13,5 +13,4 @@ export * from './promisebuffer';
 export * from './stacktrace';
 export * from './string';
 export * from './supports';
-export * from './syncpromise';
 export * from './time';

packages/utils/src/promisebuffer.ts

@@ -1,5 +1,4 @@
 import { SentryError } from './error';
-import { SyncPromise } from './syncpromise';
 
 /** A simple queue that holds promises. */
 export class PromiseBuffer<T> {
@@ -23,7 +22,7 @@ export class PromiseBuffer<T> {
    */
   public add(task: PromiseLike<T>): PromiseLike<T> {
     if (!this.isReady()) {
-      return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));
+      return Promise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));
     }
     if (this._buffer.indexOf(task) === -1) {
       this._buffer.push(task);
@@ -64,13 +63,14 @@ export class PromiseBuffer<T> {
    * @param timeout Number in ms to wait until it resolves with false.
    */
   public drain(timeout?: number): PromiseLike<boolean> {
-    return new SyncPromise<boolean>(resolve => {
+    return new Promise(resolve => {
       const capturedSetTimeout = setTimeout(() => {
         if (timeout && timeout > 0) {
           resolve(false);
         }
       }, timeout);
-      SyncPromise.all(this._buffer)
+
+      Promise.all(this._buffer)
         .then(() => {
           clearTimeout(capturedSetTimeout);
           resolve(true);