feat(core): Use Promise.try where available

We use this instead of our own `SyncPromise` implementation where available.  See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/try for details.

Author: mydea

packages/core/src/client.ts

@@ -1079,7 +1079,7 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
    * @param event The event to send to Sentry.
    * @param hint May contain additional information about the original exception.
    * @param currentScope 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 PromiseLike that resolves with the event or rejects in case event was/will not be send.
    */
   protected _processEvent(
     event: Event,

packages/core/src/index.ts

@@ -242,7 +242,13 @@ export {
   supportsReferrerPolicy,
   supportsReportingObserver,
 } from './utils/supports';
-export { SyncPromise, rejectedSyncPromise, resolvedSyncPromise } from './utils/syncpromise';
+export {
+  // eslint-disable-next-line deprecation/deprecation
+  SyncPromise,
+  rejectedSyncPromise,
+  resolvedSyncPromise,
+  makeSyncPromise,
+} from './utils/syncpromise';
 export { browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds } from './utils/time';
 export {
   TRACEPARENT_REGEXP,

packages/core/src/utils/promisebuffer.ts

@@ -1,4 +1,4 @@
-import { rejectedSyncPromise, resolvedSyncPromise, SyncPromise } from './syncpromise';
+import { makeSyncPromise, rejectedSyncPromise, resolvedSyncPromise } from './syncpromise';
 
 export interface PromiseBuffer<T> {
   // exposes the internal array so tests can assert on the state of it.
@@ -74,28 +74,30 @@ export function makePromiseBuffer<T>(limit?: number): PromiseBuffer<T> {
    * `false` otherwise
    */
   function drain(timeout?: number): PromiseLike<boolean> {
-    return new SyncPromise<boolean>((resolve, reject) => {
+    return makeSyncPromise<boolean>(() => {
       let counter = buffer.length;
 
       if (!counter) {
-        return resolve(true);
+        return true;
       }
 
-      // wait for `timeout` ms and then resolve to `false` (if not cancelled first)
-      const capturedSetTimeout = setTimeout(() => {
-        if (timeout && timeout > 0) {
-          resolve(false);
-        }
-      }, timeout);
-
-      // if all promises resolve in time, cancel the timer and resolve to `true`
-      buffer.forEach(item => {
-        void resolvedSyncPromise(item).then(() => {
-          if (!--counter) {
-            clearTimeout(capturedSetTimeout);
-            resolve(true);
+      return new Promise<boolean>((resolve, reject) => {
+        // wait for `timeout` ms and then resolve to `false` (if not cancelled first)
+        const capturedSetTimeout = setTimeout(() => {
+          if (timeout && timeout > 0) {
+            resolve(false);
           }
-        }, reject);
+        }, timeout);
+
+        // if all promises resolve in time, cancel the timer and resolve to `true`
+        buffer.forEach(item => {
+          void resolvedSyncPromise(item).then(() => {
+            if (!--counter) {
+              clearTimeout(capturedSetTimeout);
+              resolve(true);
+            }
+          }, reject);
+        });
       });
     });
   }

packages/core/src/utils/syncpromise.ts

@@ -7,6 +7,28 @@ const STATE_RESOLVED = 1;
 const STATE_REJECTED = 2;
 
 type State = typeof STATE_PENDING | typeof STATE_RESOLVED | typeof STATE_REJECTED;
+type Executor<T> = (resolve: (value?: T | PromiseLike<T> | null) => void, reject: (reason?: any) => void) => void;
+type PromiseTry = <T>(executor: Executor<T>) => PromiseLike<T>;
+type PromiseWithTry = PromiseConstructor & { try: PromiseTry };
+
+/**
+ * Takes an executor and returns a promise that is executed synchronously (if the executor is synchronous) or else asynchronously.
+ * It always returns a promise.
+ *
+ * This uses the native Promise.try, if it exists, else our SyncPromise implementation.
+ */
+export function makeSyncPromise<T>(executor: Executor<T>): PromiseLike<T> {
+  if (hasPromiseTry(Promise)) {
+    return Promise.try(executor);
+  }
+
+  // eslint-disable-next-line deprecation/deprecation
+  return new SyncPromise(executor);
+}
+
+function hasPromiseTry(Promise: typeof globalThis.Promise): Promise is PromiseWithTry {
+  return 'try' in Promise && typeof Promise.try === 'function';
+}
 
 // Overloads so we can call resolvedSyncPromise without arguments and generic argument
 export function resolvedSyncPromise(): PromiseLike<void>;
@@ -19,9 +41,7 @@ export function resolvedSyncPromise<T>(value: T | PromiseLike<T>): PromiseLike<T
  * @returns the resolved sync promise
  */
 export function resolvedSyncPromise<T>(value?: T | PromiseLike<T>): PromiseLike<T> {
-  return new SyncPromise(resolve => {
-    resolve(value);
-  });
+  return makeSyncPromise(() => value);
 }
 
 /**
@@ -31,16 +51,16 @@ export function resolvedSyncPromise<T>(value?: T | PromiseLike<T>): PromiseLike<
  * @returns the rejected sync promise
  */
 export function rejectedSyncPromise<T = never>(reason?: any): PromiseLike<T> {
-  return new SyncPromise((_, reject) => {
-    reject(reason);
+  return makeSyncPromise(() => {
+    throw reason;
   });
 }
 
-type Executor<T> = (resolve: (value?: T | PromiseLike<T> | null) => void, reject: (reason?: any) => void) => void;
-
 /**
  * Thenable class that behaves like a Promise and follows it's interface
  * but is not async internally
+ *
+ * @deprecated Use makeSyncPromise instead.
  */
 export class SyncPromise<T> implements PromiseLike<T> {
   private _state: State;
@@ -59,6 +79,7 @@ export class SyncPromise<T> implements PromiseLike<T> {
     onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
     onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
   ): PromiseLike<TResult1 | TResult2> {
+    // eslint-disable-next-line deprecation/deprecation
     return new SyncPromise((resolve, reject) => {
       this._handlers.push([
         false,
@@ -100,6 +121,7 @@ export class SyncPromise<T> implements PromiseLike<T> {
 
   /** @inheritdoc */
   public finally<TResult>(onfinally?: (() => void) | null): PromiseLike<TResult> {
+    // eslint-disable-next-line deprecation/deprecation
     return new SyncPromise<TResult>((resolve, reject) => {
       let val: TResult | any;
       let isRejected: boolean;

packages/core/test/lib/client.test.ts

@@ -8,7 +8,6 @@ import {
   makeSession,
   Scope,
   setCurrentClient,
-  SyncPromise,
   withMonitor,
 } from '../../src';
 import * as integrationModule from '../../src/integration';
@@ -2111,7 +2110,7 @@ describe('Client', () => {
       const spy = vi.spyOn(TestClient.instance!, 'eventFromMessage');
       spy.mockImplementationOnce(
         (message, level) =>
-          new SyncPromise(resolve => {
+          new Promise(resolve => {
             setTimeout(() => resolve({ message, level }), 150);
           }),
       );

packages/core/test/lib/utils/promisebuffer.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect, test, vi } from 'vitest';
 import { makePromiseBuffer } from '../../../src/utils/promisebuffer';
-import { SyncPromise } from '../../../src/utils/syncpromise';
+import { makeSyncPromise } from '../../../src/utils/syncpromise';
 
 describe('PromiseBuffer', () => {
   describe('add()', () => {
     test('no limit', () => {
       const buffer = makePromiseBuffer();
-      const p = vi.fn(() => new SyncPromise(resolve => setTimeout(resolve)));
+      const p = vi.fn(() => makeSyncPromise(() => {}));
       void buffer.add(p);
       expect(buffer.$.length).toEqual(1);
     });
@@ -15,10 +15,10 @@ describe('PromiseBuffer', () => {
       const buffer = makePromiseBuffer(1);
       let task1;
       const producer1 = vi.fn(() => {
-        task1 = new SyncPromise(resolve => setTimeout(resolve));
+        task1 = makeSyncPromise(() => {});
         return task1;
       });
-      const producer2 = vi.fn(() => new SyncPromise(resolve => setTimeout(resolve)));
+      const producer2 = vi.fn(() => makeSyncPromise(() => {}));
       expect(buffer.add(producer1)).toEqual(task1);
       void expect(buffer.add(producer2)).rejects.toThrowError();
       expect(buffer.$.length).toEqual(1);
@@ -31,7 +31,7 @@ describe('PromiseBuffer', () => {
     test('without timeout', async () => {
       const buffer = makePromiseBuffer();
       for (let i = 0; i < 5; i++) {
-        void buffer.add(() => new SyncPromise(resolve => setTimeout(resolve)));
+        void buffer.add(() => makeSyncPromise(() => {}));
       }
       expect(buffer.$.length).toEqual(5);
       const result = await buffer.drain();
@@ -42,7 +42,7 @@ describe('PromiseBuffer', () => {
     test('with timeout', async () => {
       const buffer = makePromiseBuffer();
       for (let i = 0; i < 5; i++) {
-        void buffer.add(() => new SyncPromise(resolve => setTimeout(resolve, 100)));
+        void buffer.add(() => new Promise(resolve => setTimeout(resolve, 100)));
       }
       expect(buffer.$.length).toEqual(5);
       const result = await buffer.drain(50);
@@ -60,7 +60,7 @@ describe('PromiseBuffer', () => {
 
   test('resolved promises should not show up in buffer length', async () => {
     const buffer = makePromiseBuffer();
-    const producer = () => new SyncPromise(resolve => setTimeout(resolve));
+    const producer = () => makeSyncPromise(() => {});
     const task = buffer.add(producer);
     expect(buffer.$.length).toEqual(1);
     await task;
@@ -69,7 +69,10 @@ describe('PromiseBuffer', () => {
 
   test('rejected promises should not show up in buffer length', async () => {
     const buffer = makePromiseBuffer();
-    const producer = () => new SyncPromise((_, reject) => setTimeout(reject));
+    const producer = () =>
+      makeSyncPromise(() => {
+        throw new Error('whoops');
+      });
     const task = buffer.add(producer);
     expect(buffer.$.length).toEqual(1);
     try {
@@ -82,7 +85,7 @@ describe('PromiseBuffer', () => {
 
   test('resolved task should give an access to the return value', async () => {
     const buffer = makePromiseBuffer<string>();
-    const producer = () => new SyncPromise<string>(resolve => setTimeout(() => resolve('test')));
+    const producer = () => makeSyncPromise<string>(() => 'test');
     const task = buffer.add(producer);
     const result = await task;
     expect(result).toEqual('test');
@@ -91,7 +94,10 @@ describe('PromiseBuffer', () => {
   test('rejected task should give an access to the return value', async () => {
     expect.assertions(1);
     const buffer = makePromiseBuffer<string>();
-    const producer = () => new SyncPromise<string>((_, reject) => setTimeout(() => reject(new Error('whoops'))));
+    const producer = () =>
+      makeSyncPromise<string>(() => {
+        throw new Error('whoops');
+      });
     const task = buffer.add(producer);
     try {
       await task;

packages/core/test/lib/utils/syncpromise.test.ts

@@ -1,3 +1,4 @@
+/* eslint-disable deprecation/deprecation */
 import { describe, expect, test, vi } from 'vitest';
 import { rejectedSyncPromise, resolvedSyncPromise, SyncPromise } from '../../../src/utils/syncpromise';
 

packages/core/test/mocks/transport.ts

@@ -1,9 +1,8 @@
 import { createTransport } from '../../src/transports/base';
 import type { Transport } from '../../src/types-hoist/transport';
-import { SyncPromise } from '../../src/utils/syncpromise';
 
 async function sleep(delay: number): Promise<void> {
-  return new SyncPromise(resolve => setTimeout(resolve, delay));
+  return new Promise(resolve => setTimeout(resolve, delay));
 }
 
 export function makeFakeTransport(delay: number = 2000): {
@@ -15,13 +14,12 @@ export function makeFakeTransport(delay: number = 2000): {
   let sendCalled = 0;
   let sentCount = 0;
   const makeTransport = () =>
-    createTransport({ recordDroppedEvent: () => undefined }, () => {
+    createTransport({ recordDroppedEvent: () => undefined }, async () => {
       sendCalled++;
-      return new SyncPromise(async res => {
-        await sleep(delay);
-        sentCount++;
-        res({});
-      });
+      await sleep(delay);
+      sentCount++;
+      return {};
     });
+
   return { makeTransport, getSendCalled: () => sendCalled, getSentCount: () => sentCount, delay };
 }