extract safeUnref

Author: Lms24

packages/core/src/client.ts

@@ -49,6 +49,7 @@ import { safeMathRandom } from './utils/randomSafeContext';
 import { reparentChildSpans, shouldIgnoreSpan } from './utils/should-ignore-span';
 import { showSpanDropWarning } from './utils/spanUtils';
 import { rejectedSyncPromise } from './utils/syncpromise';
+import { safeUnref } from './utils/timer';
 import { convertSpanJsonToTransactionEvent, convertTransactionEventToSpanJson } from './utils/transactionEvent';
 
 const ALREADY_SEEN_ERROR = "Not capturing exception because it's already been captured.";
@@ -1155,12 +1156,7 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
     let ticked = 0;
 
     while (!timeout || ticked < timeout) {
-      await new Promise(resolve => {
-        const timer = setTimeout(resolve, 1);
-        if (typeof timer !== 'number' && timer.unref) {
-          timer.unref();
-        }
-      });
+      await new Promise(resolve => safeUnref(setTimeout(resolve, 1)));
 
       if (!this._numProcessing) {
         return true;

packages/core/src/utils/promisebuffer.ts

@@ -1,4 +1,5 @@
 import { rejectedSyncPromise, resolvedSyncPromise } from './syncpromise';
+import { safeUnref } from './timer';
 
 export interface PromiseBuffer<T> {
   // exposes the internal array so tests can assert on the state of it.
@@ -79,12 +80,7 @@ export function makePromiseBuffer<T>(limit: number = 100): PromiseBuffer<T> {
 
     const promises = [
       drainPromise,
-      new Promise<boolean>(resolve => {
-        const timer = setTimeout(() => resolve(false), timeout);
-        if (typeof timer !== 'number' && timer.unref) {
-          timer.unref();
-        }
-      }),
+      new Promise<boolean>(resolve => safeUnref(setTimeout(() => resolve(false), timeout))),
     ];
 
     return Promise.race(promises);

packages/core/src/utils/timer.ts

@@ -0,0 +1,15 @@
+/**
+ * Calls `unref` on a timer, if the method is available on @param timer.
+ *
+ * `unred()` is used to allow processes to exit immediately, even if the timer
+ * is still running and hasn't resolved yet.
+ *
+ * Use this in places where code can run on browser or server, since browsers
+ * do not support `unref`.
+ */
+export function safeUnref(timer: ReturnType<typeof setTimeout>): ReturnType<typeof setTimeout> {
+  if (typeof timer === 'object' && typeof timer.unref === 'function') {
+    timer.unref();
+  }
+  return timer;
+}

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

@@ -0,0 +1,32 @@
+import { describe, expect, it, vi } from 'vitest';
+import { safeUnref } from '../../../src/utils/timer';
+
+describe('safeUnref', () => {
+  it('calls unref on a NodeJS timer', () => {
+    const timeout = setTimeout(() => {}, 1000);
+    const unrefSpy = vi.spyOn(timeout, 'unref');
+    safeUnref(timeout);
+    expect(unrefSpy).toHaveBeenCalledOnce();
+  });
+
+  it('returns the timer', () => {
+    const timeout = setTimeout(() => {}, 1000);
+    const result = safeUnref(timeout);
+    expect(result).toBe(timeout);
+  });
+
+  it('handles multiple unref calls', () => {
+    const timeout = setTimeout(() => {}, 1000);
+    const unrefSpy = vi.spyOn(timeout, 'unref');
+
+    const result = safeUnref(timeout);
+    result.unref();
+
+    expect(unrefSpy).toHaveBeenCalledTimes(2);
+  });
+
+  it("doesn't throw for a browser timer", () => {
+    const timer = safeUnref(385 as unknown as ReturnType<typeof setTimeout>);
+    expect(timer).toBe(385);
+  });
+});