@devries-cameron20 / composio-1 / commits / 22a917198
Fork 0

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

fix(core): defer telemetry sends (#3447)

## Summary - Defer telemetry batch processing via microtask scheduling so reaching the batch size no longer starts telemetry network work inline with SDK calls. - Defer SDK init/error telemetry sends and make `flush()` wait for both deferred sends and pending batches. - Remove stale blocking TODOs and add regression coverage for deferred batch/error telemetry behavior. Fixes #3442 ## Tests - `pnpm --filter @composio/json-schema-to-zod build` - `pnpm --filter @composio/core typecheck` - `pnpm --dir ts/packages/core exec vitest run test/telemetry/TelemetryService.test.ts` - `pnpm --filter @composio/core test` - `pnpm exec eslint ts/packages/core/src/telemetry/BatchProcessor.ts ts/packages/core/src/telemetry/Telemetry.ts ts/packages/core/src/services/telemetry/TelemetryService.ts` ## CI - GitHub checks are pending on PR creation; initial `gh pr checks 3447` showed required jobs queued/in progress.

Rahul Tarak committed May 26, 2026 at 03:29 UTC 22a9171981d96e573d937ac4360a1185d5682256
5 files changed +136 -35
.changeset/defer-telemetry-flushes.md new
+5
@@ -0,0 +1,5 @@
1 +---
2 +'@composio/core': patch
3 +---
4 +
5 +Defer telemetry batch and error sends so instrumentation does not wait for telemetry network requests before returning SDK results or rethrowing SDK errors.
ts/packages/core/src/services/telemetry/TelemetryService.ts
+2 -7
@@ -20,10 +20,7 @@ export class TelemetryService {
20 });
21 return result;
22 } catch (error) {
23 - // ignore error for now
24 - // @TODO in cloudflare workers and other services, there is no way to log errors without blocking the request
25 - // this is likely happening because the telemetry is batched and the request is not blocking
26 - // we should find a way to log errors without blocking the request
23 + // ignore error for now; telemetry failures should never affect SDK calls
24 logger.debug('Error sending metric telemetry', error);
25 }
26 }
@@ -44,9 +41,7 @@ export class TelemetryService {
41 });
42 return result;
43 } catch (error) {
47 - // ignore error for now
48 - // @TODO in cloudflare workers and other services, there is no way to log errors without blocking the request
49 - // we should find a way to log errors without blocking the request
44 + // ignore error for now; telemetry failures should never affect SDK calls
45 logger.debug('Error sending error telemetry', error);
46 }
47 }
ts/packages/core/src/telemetry/BatchProcessor.ts
+21 -8
@@ -8,7 +8,7 @@ export class BatchProcessor {
8 private time: number;
9 private batchSize: number;
10 private processBatchCallback: (data: TelemetryMetricPayloadBody) => Promise<void>;
11 - private timer: NodeJS.Timeout | null = null;
11 + private timer: ReturnType<typeof setTimeout> | null = null;
12 private pendingBatches: Set<Promise<void>> = new Set();
13
14 constructor(
@@ -35,15 +35,28 @@ export class BatchProcessor {
35 if (this.batch.length > 0) {
36 const batchToProcess = this.batch;
37 this.batch = [];
38 - const pending = this.processBatchCallback(batchToProcess)
39 - .catch(() => {
40 - // Silently ignore errors - they should be handled by the callback
41 - })
42 - .finally(() => {
43 - this.pendingBatches.delete(pending);
44 - });
38 +
39 + const pending = new Promise<void>(resolve => {
40 + const run = () => {
41 + Promise.resolve()
42 + .then(() => this.processBatchCallback(batchToProcess))
43 + .catch(() => {
44 + // Silently ignore errors - they should be handled by the callback
45 + })
46 + .finally(resolve);
47 + };
48 +
49 + if (typeof queueMicrotask === 'function') {
50 + queueMicrotask(run);
51 + } else {
52 + setTimeout(run, 0);
53 + }
54 + });
55
56 this.pendingBatches.add(pending);
57 + pending.finally(() => {
58 + this.pendingBatches.delete(pending);
59 + });
60 }
61 if (this.timer) {
62 clearTimeout(this.timer);
ts/packages/core/src/telemetry/Telemetry.ts
+50 -18
@@ -43,6 +43,7 @@ export class TelemetryTransport {
43 private readonly telemetryServiceName = 'sdk';
44 private readonly telemetryLanguage = 'typescript';
45 private exitHandlersRegistered = false;
46 + private pendingImmediateTelemetry: Set<Promise<void>> = new Set();
47
48 private batchProcessor = new BatchProcessor(200, 10, async (data: TelemetryMetricPayloadBody) => {
49 logger.debug('Sending batch of telemetry metrics', data);
@@ -63,20 +64,22 @@ export class TelemetryTransport {
64 // Register exit handlers to automatically flush telemetry before process exit
65 this.registerExitHandlers();
66
66 - // send telemetry event for SDK initialization
67 - this.sendMetric([
68 - {
69 - functionName: TELEMETRY_EVENTS.SDK_INITIALIZED,
70 - durationMs: 0,
71 - timestamp: Date.now() / 1000,
72 - props: {},
73 - source: this.telemetrySource,
74 - metadata: {
75 - provider: this.telemetryMetadata?.provider ?? 'openai',
67 + // send telemetry event for SDK initialization without blocking setup
68 + this.deferTelemetry(() =>
69 + this.sendMetric([
70 + {
71 + functionName: TELEMETRY_EVENTS.SDK_INITIALIZED,
72 + durationMs: 0,
73 + timestamp: Date.now() / 1000,
74 + props: {},
75 + source: this.telemetrySource,
76 + metadata: {
77 + provider: this.telemetryMetadata?.provider ?? 'openai',
78 + },
79 + error: undefined,
80 },
77 - error: undefined,
78 - },
79 - ]);
81 + ])
82 + );
83 }
84
85 /**
@@ -144,7 +147,7 @@ export class TelemetryTransport {
147 // Only send error telemetry if telemetry is enabled
148 if (telemetryEnabled && startTime !== undefined) {
149 const durationMs = Date.now() - startTime;
147 - await this.prepareAndSendErrorTelemetry(
150 + this.prepareAndSendErrorTelemetry(
151 error,
152 instrumentedClassName,
153 name,
@@ -178,15 +181,13 @@ export class TelemetryTransport {
181 /**
182 * Prepare and send the error telemetry.
183 *
181 - * @TODO This currently blocks the thread and sends the telemetry to the server.
182 - *
184 * @param {unknown} error - The error to send.
185 * @param {string} instrumentedClassName - The class name of the instrumented class.
186 * @param {string} name - The name of the method that threw the error.
187 * @param {number} startTime - The start time of the method invocation in milliseconds.
188 * @param {number} durationMs - The duration of the method invocation in milliseconds.
189 */
189 - private async prepareAndSendErrorTelemetry(
190 + private prepareAndSendErrorTelemetry(
191 error: unknown,
192 instrumentedClassName: string,
193 name: string,
@@ -231,7 +232,37 @@ export class TelemetryTransport {
232 };
233 }
234
234 - await this.sendErrorTelemetry(telemetryPayload);
235 + this.deferTelemetry(() => this.sendErrorTelemetry(telemetryPayload));
236 + }
237 +
238 + private deferTelemetry(callback: () => Promise<void>): void {
239 + const pending = new Promise<void>(resolve => {
240 + const run = () => {
241 + Promise.resolve()
242 + .then(callback)
243 + .catch(error => {
244 + logger.debug('Error sending deferred telemetry', error);
245 + })
246 + .finally(resolve);
247 + };
248 +
249 + if (typeof queueMicrotask === 'function') {
250 + queueMicrotask(run);
251 + } else {
252 + setTimeout(run, 0);
253 + }
254 + });
255 +
256 + this.pendingImmediateTelemetry.add(pending);
257 + pending.finally(() => {
258 + this.pendingImmediateTelemetry.delete(pending);
259 + });
260 + }
261 +
262 + private async flushImmediateTelemetry(): Promise<void> {
263 + while (this.pendingImmediateTelemetry.size > 0) {
264 + await Promise.all(Array.from(this.pendingImmediateTelemetry));
265 + }
266 }
267
268 /**
@@ -271,6 +302,7 @@ export class TelemetryTransport {
302 */
303 async flush(): Promise<void> {
304 await this.batchProcessor.flush();
305 + await this.flushImmediateTelemetry();
306 }
307
308 /**
ts/packages/core/test/telemetry/TelemetryService.test.ts
+58 -2
@@ -5,6 +5,11 @@ import { TelemetryService } from '../../src/services/telemetry/TelemetryService'
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',
@@ -35,9 +40,13 @@ describe('BatchProcessor', () => {
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 });
@@ -48,6 +57,8 @@ describe('BatchProcessor', () => {
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 });
@@ -75,6 +86,8 @@ describe('BatchProcessor', () => {
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
@@ -98,6 +111,7 @@ describe('BatchProcessor', () => {
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
@@ -132,6 +146,7 @@ describe('BatchProcessor', () => {
146 // @ts-expect-error: private access for test
147 expect(asyncProcessor.batch).toEqual([]);
148
149 + await flushMicrotasks();
150 resolveCallback!();
151 await asyncProcessor.flush();
152 });
@@ -172,6 +187,7 @@ describe('BatchProcessor', () => {
187 const flushPromise = asyncProcessor.flush();
188 expect(callbackCompleted).toBe(false);
189
190 + await flushMicrotasks();
191 resolveCallback!();
192 await flushPromise;
193
@@ -231,6 +247,8 @@ describe('BatchProcessor', () => {
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
@@ -278,6 +296,8 @@ describe('BatchProcessor', () => {
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
@@ -308,11 +328,12 @@ describe('TelemetryTransport', () => {
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(() => {
@@ -361,9 +382,44 @@ describe('TelemetryTransport', () => {
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) {