deslop

Author: Lms24

packages/core/src/client.ts

@@ -1148,19 +1148,15 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
    * `false` otherwise
    */
   protected async _isClientDoneProcessing(timeout?: number): Promise<boolean> {
-    // Early exit if there's nothing to process
     if (!this._numProcessing) {
       return true;
     }
 
     let ticked = 0;
 
-    // if no timeout is provided, we wait "forever" until everything is processed
     while (!timeout || ticked < timeout) {
       await new Promise(resolve => {
         const timer = setTimeout(resolve, 1);
-        // Use unref() in Node.js to allow the process to exit naturally
-        // In browsers, setTimeout returns a number, so we check for that
         if (typeof timer !== 'number' && timer.unref) {
           timer.unref();
         }

packages/core/src/utils/promisebuffer.ts

@@ -81,16 +81,12 @@ export function makePromiseBuffer<T>(limit: number = 100): PromiseBuffer<T> {
       drainPromise,
       new Promise<boolean>(resolve => {
         const timer = setTimeout(() => resolve(false), timeout);
-        // Use unref() in Node.js to allow the process to exit naturally
-        // In browsers, setTimeout returns a number, so we check for that
         if (typeof timer !== 'number' && timer.unref) {
           timer.unref();
         }
       }),
     ];
 
-    // Promise.race will resolve to the first promise that resolves or rejects
-    // So if the drainPromise resolves, the timeout promise will be ignored
     return Promise.race(promises);
   }
 

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

@@ -2217,9 +2217,7 @@ describe('Client', () => {
       const result = await client.flush(1000);
       const elapsed = Date.now() - startTime;
 
-      // Should return true immediately without waiting
       expect(result).toBe(true);
-      // Should take less than 100ms (much less than the 1000ms timeout)
       expect(elapsed).toBeLessThan(100);
     });
 
@@ -2241,13 +2239,12 @@ describe('Client', () => {
       expect(getSendCalled()).toEqual(1);
 
       const startTime = Date.now();
-      // Use a large timeout but processing should complete early
       await client.flush(5000);
       const elapsed = Date.now() - startTime;
 
       expect(getSentCount()).toEqual(1);
-      // Should complete in ~50ms (the transport delay), not wait for the full 5000ms timeout
-      expect(elapsed).toBeLessThan(500);
+      // if this flakes, remove the test
+      expect(elapsed).toBeLessThan(1000);
     });
   });
 

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

@@ -262,7 +262,6 @@ describe('PromiseBuffer', () => {
     const elapsed = Date.now() - startTime;
 
     expect(result).toBe(true);
-    // Should return immediately, not wait for timeout
     expect(elapsed).toBeLessThan(100);
   });
 });

packages/node-core/test/sdk/client.test.ts

@@ -396,23 +396,15 @@ describe('NodeClient', () => {
       const result = await client.flush(1000);
       const elapsed = Date.now() - startTime;
 
-      // Should return true immediately without waiting
       expect(result).toBe(true);
-      // Should take less than 100ms (much less than the 1000ms timeout)
       expect(elapsed).toBeLessThan(100);
     });
 
-    it('flush does not block process exit when using unref timers', async () => {
-      // This test verifies that timers are properly unref'd in Node.js
-      // We create a client with no processing and a long timeout
+    it('flush does not block process exit with unref timers', async () => {
       const options = getDefaultNodeClientOptions();
       const client = new NodeClient(options);
 
-      // Flush with a long timeout - if timers are not unref'd, this would block
-      const flushPromise = client.flush(5000);
-
-      // The flush should complete immediately since there's nothing to process
-      const result = await flushPromise;
+      const result = await client.flush(5000);
       expect(result).toBe(true);
     });
   });