5
import type { TelemetryPayload } from '../../src/services/telemetry/TelemetryService.types';
6
import { TelemetryMetadata } from '../../src/types/telemetry.types';
7
8
+const flushMicrotasks = async () => {
9
+ await Promise.resolve();
10
+ await Promise.resolve();
11
+};
12
+
13
// Helper to create a mock telemetry payload
14
const createPayload = (overrides: Partial<TelemetryPayload> = {}): TelemetryPayload => ({
15
functionName: 'TestClass.testMethod',
40
vi.useRealTimers();
41
});
42
38
- it('should batch items and call callback when batch size is reached', () => {
43
+ it('should batch items and defer callback when batch size is reached', async () => {
44
const payloads = [createPayload(), createPayload(), createPayload()];
45
payloads.forEach(p => processor.pushItem(p));
46
+ expect(callback).not.toHaveBeenCalled();
47
+
48
+ await flushMicrotasks();
49
+
50
expect(callback).toHaveBeenCalledOnce();
51
expect(callback).toHaveBeenCalledWith(payloads);
52
});
57
payloads.forEach(p => processor.pushItem(p));
58
expect(callback).not.toHaveBeenCalled();
59
vi.advanceTimersByTime(60);
60
+ await flushMicrotasks();
61
+
62
expect(callback).toHaveBeenCalledOnce();
63
expect(callback).toHaveBeenCalledWith(payloads);
64
});
86
const payloads = [createPayload(), createPayload()];
87
payloads.forEach(p => asyncProcessor.pushItem(p));
88
89
+ await flushMicrotasks();
90
+
91
expect(asyncCallback).toHaveBeenCalledOnce();
92
expect(asyncCallback).toHaveBeenCalledWith(payloads);
93
111
// @ts-expect-error: private access for test
112
expect(asyncProcessor.pendingBatches.size).toBe(1);
113
114
+ await flushMicrotasks();
115
resolveCallback!();
116
await asyncProcessor.flush();
117
146
// @ts-expect-error: private access for test
147
expect(asyncProcessor.batch).toEqual([]);
148
149
+ await flushMicrotasks();
150
resolveCallback!();
151
await asyncProcessor.flush();
152
});
187
const flushPromise = asyncProcessor.flush();
188
expect(callbackCompleted).toBe(false);
189
190
+ await flushMicrotasks();
191
resolveCallback!();
192
await flushPromise;
193
247
asyncProcessor.pushItem(createPayload());
248
asyncProcessor.pushItem(createPayload());
249
250
+ await flushMicrotasks();
251
+
252
expect(asyncCallback).toHaveBeenCalledTimes(2);
253
254
// @ts-expect-error: private access for test
296
asyncProcessor.pushItem(createPayload({ functionName: 'batch2' }));
297
asyncProcessor.pushItem(createPayload({ functionName: 'batch3' }));
298
299
+ await flushMicrotasks();
300
+
301
expect(asyncCallback).toHaveBeenCalledTimes(3);
302
303
// @ts-expect-error: private access for test
328
provider: 'test',
329
};
330
311
- beforeEach(() => {
331
+ beforeEach(async () => {
332
sendMetricSpy = vi.spyOn(TelemetryService, 'sendMetric').mockResolvedValue({} as any);
333
sendErrorLogSpy = vi.spyOn(TelemetryService, 'sendErrorLog').mockResolvedValue({} as any);
334
transport = new TelemetryTransport();
335
transport.setup(metadata);
336
+ await transport.flush();
337
});
338
339
afterEach(() => {
382
const instance = new TestClass();
383
const instrumented = transport.instrument(instance);
384
await expect(instrumented.fail()).rejects.toThrow('fail!');
385
+ await transport.flush();
386
expect(sendErrorLogSpy).toHaveBeenCalled();
387
});
388
389
+ it('should not wait for deferred error telemetry before rejecting instrumented errors', async () => {
390
+ let resolveTelemetry: (() => void) | undefined;
391
+ sendErrorLogSpy.mockImplementationOnce(
392
+ () =>
393
+ new Promise(resolve => {
394
+ resolveTelemetry = () => resolve({} as any);
395
+ })
396
+ );
397
+
398
+ class TestClass {
399
+ async fail() {
400
+ throw new Error('fail!');
401
+ }
402
+ }
403
+ const instance = new TestClass();
404
+ const instrumented = transport.instrument(instance);
405
+
406
+ await expect(
407
+ Promise.race([
408
+ instrumented.fail().then(
409
+ () => 'resolved',
410
+ () => 'rejected'
411
+ ),
412
+ new Promise(resolve => setTimeout(() => resolve('timeout'), 20)),
413
+ ])
414
+ ).resolves.toBe('rejected');
415
+
416
+ await flushMicrotasks();
417
+ expect(sendErrorLogSpy).toHaveBeenCalled();
418
+
419
+ resolveTelemetry?.();
420
+ await transport.flush();
421
+ });
422
+
423
it('should flush pending telemetry when flush is called', async () => {
424
class TestClass {
425
async foo(a: number) {