Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
TypeScript agentic-aiagentsaiai-agentsaiagentsdeveloper-toolsfunction-callinggpt-4javascriptjsllmllmopsmcppythonremote-mcp-serverssetypescript
Add telemetry tests
haxzie37591a0b9c81
diff --git a/examples/telemetry/.env.example b/examples/telemetry/.env.examplenew file mode 100644index 000000000..ad0f7ed62--- /dev/null+++ b/examples/telemetry/.env.example@@ -0,0 +1,2 @@+COMPOSIO_API_KEY=+OPENAI_API_KEY=\ No newline at end of filediff --git a/examples/telemetry/README.md b/examples/telemetry/README.mdnew file mode 100644index 000000000..08e1ab65a--- /dev/null+++ b/examples/telemetry/README.md@@ -0,0 +1,75 @@+# Vercel Example with Composio SDK++This example demonstrates how to use the Composio SDK with Vercel's AI SDK to create an AI-powered application that can interact with HackerNews data.++## Features++- Integration with Composio SDK and Vercel AI SDK+- HackerNews front page summarization using GPT-4+- Streaming AI responses+- TypeScript support++## Prerequisites++- [Node.js](https://nodejs.org/) (Latest LTS version recommended)+- [pnpm](https://pnpm.io/) (v10.8.0 or later)+- Composio API Key+- OpenAI API Key++## Getting Started++1. Clone the repository and navigate to the example directory:++```bash+cd examples/vercel+```++2. Install dependencies:++```bash+pnpm install+```++3. Copy the `.env.example` file to `.env` and fill in your API keys:++```bash+cp .env.example .env+```++4. Update the `.env` file with your credentials:++```env+COMPOSIO_API_KEY=your_composio_api_key+OPENAI_API_KEY=your_openai_api_key+```++5. Start the development server:++```bash+pnpm start+```++## How It Works++This example showcases how to:++1. Initialize the Composio SDK with the Vercel provider+2. Use the HackerNews tool to fetch front page data+3. Generate AI responses using OpenAI's GPT-4+4. Handle tool calls and results in a chat-like interface++## Dependencies++- `@composio/core`: Core Composio SDK+- `@composio/vercel`: Vercel integration for Composio+- `@ai-sdk/openai`: OpenAI integration+- `ai`: Vercel's AI SDK+- TypeScript for type safety++## License++ISC++## Support++For questions and support, please refer to the [Composio documentation](https://docs.composio.dev) or open an issue in the repository.diff --git a/examples/telemetry/package.json b/examples/telemetry/package.jsonnew file mode 100644index 000000000..f9a0cd7b6--- /dev/null+++ b/examples/telemetry/package.json@@ -0,0 +1,25 @@+{+ "name": "telemetry-example",+ "private": true,+ "version": "0.1.10-alpha.0",+ "description": "",+ "main": "src/index.ts",+ "scripts": {+ "start": "COMPOSIO_LOG_LEVEL=debug bun src/index.ts",+ "test": "echo \"Error: no test specified\" && exit 1"+ },+ "keywords": [],+ "author": "",+ "license": "ISC",+ "packageManager": "[email protected]",+ "dependencies": {+ "@ai-sdk/openai": "^1.3.16",+ "@composio/core": "workspace:*",+ "@composio/vercel": "workspace:*",+ "ai": "^4.3.8"+ },+ "devDependencies": {+ "@types/bun": "^1.2.9",+ "typescript": "^5.8.3"+ }+}diff --git a/examples/telemetry/src/index.ts b/examples/telemetry/src/index.tsnew file mode 100644index 000000000..6ced3874a--- /dev/null+++ b/examples/telemetry/src/index.ts@@ -0,0 +1,12 @@+import { Composio, ConsoleTelemetryTransport } from '@composio/core';++/**+ * Non agentic provider+ */+const composio = new Composio({+ apiKey: process.env.COMPOSIO_API_KEY,+});++const tools = await composio.tools.get('default', 'HACKERNEWS_GET_USER');++console.log(tools);diff --git a/examples/telemetry/tsconfig.json b/examples/telemetry/tsconfig.jsonnew file mode 100644index 000000000..ad82940d5--- /dev/null+++ b/examples/telemetry/tsconfig.json@@ -0,0 +1,15 @@+{+ "compilerOptions": {+ "target": "ESNext",+ "module": "ESNext",+ "declaration": true,+ "declarationDir": "./dist",+ "outDir": "./dist",+ "rootDir": "./src",+ "strict": true,+ "esModuleInterop": true,+ "moduleResolution": "node",+ "skipLibCheck": true+ },+ "include": ["src"]+}diff --git a/packages/core/package.json b/packages/core/package.jsonindex 9053c581a..35e761877 100644--- a/packages/core/package.json+++ b/packages/core/package.json@@ -37,6 +37,7 @@},"dependencies": {"@composio/client": "^0.1.0-alpha.10",+ "chalk": "^5.4.1","openai": "^4.94.0","pusher-js": "^8.4.0","semver": "^7.7.2",diff --git a/packages/core/src/composio.ts b/packages/core/src/composio.tsindex 1960bce79..cea095649 100644--- a/packages/core/src/composio.ts+++ b/packages/core/src/composio.ts@@ -90,6 +90,7 @@ export class Composio<TProvider extends BaseComposioProvider<unknown, unknown> =this.config = {...config,allowTracking: config.allowTracking ?? true,+ allowTracing: config.allowTracing ?? true,};/**@@ -108,17 +109,20 @@ export class Composio<TProvider extends BaseComposioProvider<unknown, unknown> =/*** Initialize the client telemetry.*/- if (this.config.allowTracking ?? true) {+ if (this.config.allowTracking) {telemetry.setup({apiKey: apiKeyParsed ?? '',baseUrl: baseURLParsed ?? '',framework: this.provider?.name || 'unknown',isAgentic: this.provider?._isAgentic || false,- source: 'node', // @TODO: get the source+ source: 'javascript',version: version,+ sdkType: 'Typescript-V3',isBrowser: typeof window !== 'undefined',- sessionId: getRandomUUID(), // @TODO: get the session id+ // @TODO: Users might want to pass their own session id+ // @TODO: We shouldn't be doing this as people might always have one session id throughout the process in server+ sessionId: this.config.allowTracing ? getRandomUUID() : undefined, // @TODO: get the session id},config.telemetryTransport);diff --git a/packages/core/src/index.ts b/packages/core/src/index.tsindex 0ac839f59..f750ad3b9 100644--- a/packages/core/src/index.ts+++ b/packages/core/src/index.ts@@ -4,7 +4,7 @@ export { ComposioProvider } from './provider/ComposioProvider';export { BaseAgenticProvider, BaseNonAgenticProvider } from './provider/BaseProvider';export type { BaseComposioProvider } from './provider/BaseProvider';export { OpenAIProvider } from './provider/OpenAIProvider';-export { BaseTelemetryTransport } from './telemetry/TelemetryTransport';+export { BaseTelemetryTransport, ConsoleTelemetryTransport } from './telemetry/TelemetryTransport';export { jsonSchemaToModel } from './utils/jsonSchema';export { ToolListParamsSchema } from './types/tool.types';export type { Tool, ToolListParams, ToolExecuteParams } from './types/tool.types';diff --git a/packages/core/src/telemetry/Telemetry.ts b/packages/core/src/telemetry/Telemetry.tsindex ea271ee90..71ebdbfee 100644--- a/packages/core/src/telemetry/Telemetry.ts+++ b/packages/core/src/telemetry/Telemetry.ts@@ -1,4 +1,9 @@-import { TELEMETRY_EVENTS, TelemetryMetadata, TelemetryPayload } from '../types/telemetry.types';+import {+ TELEMETRY_EVENTS,+ TELEMETRY_TYPES,+ TelemetryMetadata,+ TelemetryPayload,+} from '../types/telemetry.types';import { TELEMETRY_URL } from '../utils/constants';import { getEnvVariable } from '../utils/env';import { BatchProcessor } from './BatchProcessor';@@ -25,6 +30,7 @@ import { ProcessTelemetryTransport } from './transports/ProcessTransport';export class TelemetryService {private telemetryMetadata!: TelemetryMetadata;private transport!: BaseTelemetryTransport;+ private isTelemetryDisabled: boolean = true;private batchProcessor = new BatchProcessor(100, 10, async data => {await this.sendTelemetry(data as TelemetryPayload[]);@@ -32,14 +38,17 @@ export class TelemetryService {setup(metadata: TelemetryMetadata, transport?: BaseTelemetryTransport) {this.telemetryMetadata = metadata;+ this.isTelemetryDisabled = false;const isBrowser = typeof window !== 'undefined';if (transport) {this.transport = transport;} else if (isBrowser) {this.transport = new BrowserTelemetryTransport();+ this.telemetryMetadata.transport = 'browser';} else {this.transport = new ProcessTelemetryTransport();+ this.telemetryMetadata.transport = 'process';}// send telemetry event for SDK initialization@@ -121,13 +130,10 @@ export class TelemetryService {* @returns*/async sendTelemetry(payload: TelemetryPayload[]) {- if (!this.transport) {- return;- }-- const isTelemetryDisabled = getEnvVariable('TELEMETRY_DISABLED', 'false') === 'true';+ const isTelemetryDisabled =+ this.isTelemetryDisabled || getEnvVariable('TELEMETRY_DISABLED', 'false') === 'true';- if (isTelemetryDisabled) {+ if (!this.transport || isTelemetryDisabled) {return;}diff --git a/packages/core/src/telemetry/TelemetryTransport.ts b/packages/core/src/telemetry/TelemetryTransport.tsindex 507818559..73c964228 100644--- a/packages/core/src/telemetry/TelemetryTransport.ts+++ b/packages/core/src/telemetry/TelemetryTransport.ts@@ -1,3 +1,4 @@+import chalk from 'chalk';import { TelemetryTransportParams } from '../types/telemetry.types';import logger from '../utils/logger';@@ -15,7 +16,7 @@ export abstract class BaseTelemetryTransport {*/export class ConsoleTelemetryTransport implements BaseTelemetryTransport {send(payload: TelemetryTransportParams): Promise<void> {- logger.info('payload', payload);+ logger.debug(chalk.yellow('telemetry'), JSON.stringify(payload, null, 2));return Promise.resolve();}}diff --git a/packages/core/src/telemetry/transports/BrowserTransport.ts b/packages/core/src/telemetry/transports/BrowserTransport.tsindex d528054c6..9131ed77f 100644--- a/packages/core/src/telemetry/transports/BrowserTransport.ts+++ b/packages/core/src/telemetry/transports/BrowserTransport.ts@@ -1,11 +1,7 @@import { TelemetryTransportParams } from '../../types/telemetry.types';import logger from '../../utils/logger';import { BaseTelemetryTransport } from '../TelemetryTransport';-import { telemetry } from '../Telemetry';export class BrowserTelemetryTransport implements BaseTelemetryTransport {- constructor() {- telemetry.instrument(this);- }send(payload: TelemetryTransportParams): Promise<void> {if (typeof window === 'undefined') {return Promise.reject(diff --git a/packages/core/src/telemetry/transports/ProcessTransport.ts b/packages/core/src/telemetry/transports/ProcessTransport.tsindex 037257d7c..c0d76468b 100644--- a/packages/core/src/telemetry/transports/ProcessTransport.ts+++ b/packages/core/src/telemetry/transports/ProcessTransport.ts@@ -1,12 +1,8 @@+import chalk from 'chalk';import { TelemetryTransportParams } from '../../types/telemetry.types';import logger from '../../utils/logger';import { BaseTelemetryTransport } from '../TelemetryTransport';-import { telemetry } from '../Telemetry';export class ProcessTelemetryTransport implements BaseTelemetryTransport {- constructor() {- telemetry.instrument(this);- }-send(payload: TelemetryTransportParams): Promise<void> {if (typeof window !== 'undefined') {return Promise.reject(@@ -60,6 +56,7 @@ export class ProcessTelemetryTransport implements BaseTelemetryTransport {.catch(() => {resolve();});+ logger.debug(chalk.yellow('Process telemetry'), JSON.stringify(payload, null, 2));} catch (error) {logger.error('Error sending telemetry', error);resolve();diff --git a/packages/core/src/types/telemetry.types.ts b/packages/core/src/types/telemetry.types.tsindex 8334d2173..9831ce7d9 100644--- a/packages/core/src/types/telemetry.types.ts+++ b/packages/core/src/types/telemetry.types.ts@@ -17,7 +17,9 @@ export type TelemetryMetadata = {framework: string;isAgentic: boolean;source: string;- sessionId: string;+ transport?: string;+ sdkType?: string;+ sessionId?: string;isBrowser?: boolean;};@@ -36,6 +38,13 @@ type AcceptableJSONValue =| null| undefined;+export const TELEMETRY_TYPES = {+ SDK_USAGE: 'SDK_USAGE',+ SDK_ERROR: 'SDK_ERROR',+} as const;++export type TelemetryType = (typeof TELEMETRY_TYPES)[keyof typeof TELEMETRY_TYPES];+export interface TelemetryTransportParams {url: string;method: string;diff --git a/packages/core/src/utils/env.ts b/packages/core/src/utils/env.tsindex e4c11fb46..470b4fca5 100644--- a/packages/core/src/utils/env.ts+++ b/packages/core/src/utils/env.ts@@ -1,5 +1,3 @@-import logger from './logger';-export const getEnvVariable = (name: string,defaultValue: string | undefined = undefined@@ -7,7 +5,6 @@ export const getEnvVariable = (try {return process.env[name] || defaultValue;} catch (_e) {- logger.error(`Error getting environment variable ${name}:`, _e);return defaultValue;}};diff --git a/packages/core/src/utils/logger.ts b/packages/core/src/utils/logger.tsindex 0e2d106f6..4b0a7fb87 100644--- a/packages/core/src/utils/logger.ts+++ b/packages/core/src/utils/logger.ts@@ -1,3 +1,4 @@+import chalk from 'chalk';import { getEnvVariable } from './env';// Define log levels with corresponding priorities@@ -47,7 +48,7 @@ class Logger {}const timestamp = new Date().toISOString();- return `${timestamp} - ${formattedArgs}`;+ return `${chalk.gray(timestamp)} - ${formattedArgs}`;}private shouldLog(level: LogLevel): boolean {diff --git a/packages/core/test/telemetry/BatchProcessor.test.ts b/packages/core/test/telemetry/BatchProcessor.test.tsnew file mode 100644index 000000000..012a24c8d--- /dev/null+++ b/packages/core/test/telemetry/BatchProcessor.test.ts@@ -0,0 +1,119 @@+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';+import { BatchProcessor } from '../../src/telemetry/BatchProcessor';++describe('BatchProcessor', () => {+ // Mock timer functions+ vi.useFakeTimers();++ let batchProcessor: BatchProcessor;+ let processBatchCallback: ReturnType<typeof vi.fn>;++ beforeEach(() => {+ processBatchCallback = vi.fn().mockResolvedValue(undefined);+ batchProcessor = new BatchProcessor(1000, 3, processBatchCallback);+ });++ afterEach(() => {+ vi.clearAllTimers();+ vi.clearAllMocks();+ });++ it('should create an instance with default parameters', () => {+ const defaultProcessor = new BatchProcessor(undefined, undefined, processBatchCallback);+ expect(defaultProcessor).toBeInstanceOf(BatchProcessor);+ });++ it('should batch items and not process until batch size is reached', () => {+ batchProcessor.pushItem('item1');+ batchProcessor.pushItem('item2');++ expect(processBatchCallback).not.toHaveBeenCalled();+ });++ it('should process batch when the batch size is reached', () => {+ batchProcessor.pushItem('item1');+ batchProcessor.pushItem('item2');+ batchProcessor.pushItem('item3');++ expect(processBatchCallback).toHaveBeenCalledWith(['item1', 'item2', 'item3']);+ expect(processBatchCallback).toHaveBeenCalledTimes(1);+ });++ it('should process batch after the specified time', () => {+ batchProcessor.pushItem('item1');+ batchProcessor.pushItem('item2');++ expect(processBatchCallback).not.toHaveBeenCalled();++ // Fast-forward time by 1 second+ vi.advanceTimersByTime(1000);++ expect(processBatchCallback).toHaveBeenCalledWith(['item1', 'item2']);+ expect(processBatchCallback).toHaveBeenCalledTimes(1);+ });++ it('should reset the timer after processing batch due to size limit', () => {+ batchProcessor.pushItem('item1');+ batchProcessor.pushItem('item2');+ batchProcessor.pushItem('item3');++ expect(processBatchCallback).toHaveBeenCalledTimes(1);+ processBatchCallback.mockClear();++ // Add a new item, which should start a new timer+ batchProcessor.pushItem('item4');++ // Fast-forward time by 1 second+ vi.advanceTimersByTime(1000);++ expect(processBatchCallback).toHaveBeenCalledWith(['item4']);+ expect(processBatchCallback).toHaveBeenCalledTimes(1);+ });++ it('should not process an empty batch', () => {+ // No items added+ batchProcessor.processBatch();++ expect(processBatchCallback).not.toHaveBeenCalled();+ });++ it('should clear timer after manual processBatch call', () => {+ // Spy on setTimeout+ const setTimeoutSpy = vi.spyOn(global, 'setTimeout');++ batchProcessor.pushItem('item1');++ // A timer should be set+ expect(setTimeoutSpy).toHaveBeenCalled();++ // Clear the spy call history+ setTimeoutSpy.mockClear();++ // Process the batch manually+ batchProcessor.processBatch();++ // Add a new item, which should start a new timer+ batchProcessor.pushItem('item2');++ // setTimeout should be called again+ expect(setTimeoutSpy).toHaveBeenCalled();+ });++ it('should handle batches efficiently', () => {+ // Create a batch processor with a moderate batch size+ const processor = new BatchProcessor(1000, 20, processBatchCallback);++ // Add 19 items+ for (let i = 0; i < 19; i++) {+ processor.pushItem(`item${i}`);+ }++ expect(processBatchCallback).not.toHaveBeenCalled();++ // Add the 20th item to trigger batch processing+ processor.pushItem('item-last');++ expect(processBatchCallback).toHaveBeenCalledTimes(1);+ expect(processBatchCallback.mock.calls[0][0].length).toBe(20);+ });+});diff --git a/packages/core/test/telemetry/BrowserTransport.test.ts b/packages/core/test/telemetry/BrowserTransport.test.tsnew file mode 100644index 000000000..0023b3748--- /dev/null+++ b/packages/core/test/telemetry/BrowserTransport.test.ts@@ -0,0 +1,117 @@+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';+import { BrowserTelemetryTransport } from '../../src/telemetry/transports/BrowserTransport';+import { TelemetryTransportParams } from '../../src/types/telemetry.types';++describe('BrowserTelemetryTransport', () => {+ let transport: BrowserTelemetryTransport;++ // Define the mock XHR class+ const mockXHR = {+ open: vi.fn(),+ send: vi.fn(),+ setRequestHeader: vi.fn(),+ onload: null as Function | null,+ };++ // Save original globals+ const originalWindow = global.window;+ const originalXMLHttpRequest = global.XMLHttpRequest;++ beforeEach(() => {+ // Setup mock window and XMLHttpRequest+ global.window = global.window || ({} as any);+ global.XMLHttpRequest = vi.fn(() => mockXHR) as any;++ // Reset mock functions and state+ mockXHR.open.mockReset();+ mockXHR.send.mockReset();+ mockXHR.setRequestHeader.mockReset();+ mockXHR.onload = null;++ // Create new transport instance+ transport = new BrowserTelemetryTransport();+ });++ afterEach(() => {+ // Restore globals+ global.window = originalWindow;+ global.XMLHttpRequest = originalXMLHttpRequest;+ });++ it('should create an instance successfully', () => {+ expect(transport).toBeInstanceOf(BrowserTelemetryTransport);+ });++ it('should send telemetry data via XMLHttpRequest', async () => {+ const payload: TelemetryTransportParams = {+ url: 'https://example.com/telemetry',+ method: 'POST',+ headers: {+ 'Content-Type': 'application/json',+ 'X-Custom-Header': 'test-value',+ },+ data: { key: 'value' },+ };++ // Start sending the data+ const promise = transport.send(payload);++ // Verify XHR was configured correctly+ expect(mockXHR.open).toHaveBeenCalledWith('POST', 'https://example.com/telemetry', true);+ expect(mockXHR.setRequestHeader).toHaveBeenCalledWith('Content-Type', 'application/json');+ expect(mockXHR.setRequestHeader).toHaveBeenCalledWith('X-Custom-Header', 'test-value');+ expect(mockXHR.send).toHaveBeenCalledWith(JSON.stringify({ key: 'value' }));++ // Trigger the onload callback if it was set+ if (mockXHR.onload) {+ (mockXHR.onload as Function)();+ }++ // Verify promise resolves+ await expect(promise).resolves.toBeUndefined();+ });++ it('should reject if not running in a browser environment', async () => {+ // Temporarily remove window to simulate non-browser environment+ const tempWindow = global.window;+ global.window = undefined as any;++ // Expect rejection when sending in non-browser env+ await expect(+ transport.send({+ url: 'https://example.com/telemetry',+ method: 'POST',+ headers: {},+ data: {},+ })+ ).rejects.toThrow('BrowserTelemetryTransport can only be used in browser environments');++ // Restore window for other tests+ global.window = tempWindow;+ });++ it('should handle errors gracefully', async () => {+ const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});++ const payload: TelemetryTransportParams = {+ url: 'https://example.com/telemetry',+ method: 'POST',+ headers: {},+ data: {},+ };++ // Make the send method throw an error+ mockXHR.send.mockImplementation(() => {+ throw new Error('Network error');+ });++ // Should resolve despite the error+ const promise = transport.send(payload);+ await expect(promise).resolves.toBeUndefined();++ // Should log the error+ expect(consoleSpy).toHaveBeenCalled();++ consoleSpy.mockRestore();+ });+});diff --git a/packages/core/test/telemetry/ProcessTransport.test.ts b/packages/core/test/telemetry/ProcessTransport.test.tsnew file mode 100644index 000000000..fe9cd0a6c--- /dev/null+++ b/packages/core/test/telemetry/ProcessTransport.test.ts@@ -0,0 +1,91 @@+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';+import { ProcessTelemetryTransport } from '../../src/telemetry/transports/ProcessTransport';+import { TelemetryTransportParams } from '../../src/types/telemetry.types';++describe('ProcessTelemetryTransport', () => {+ let transport: ProcessTelemetryTransport;+ const originalWindow = global.window;++ // Spy on console.error to validate error handling+ const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});++ beforeEach(() => {+ // Reset window to simulate Node.js environment+ delete (global as any).window;++ // Reset mocks and spies+ vi.clearAllMocks();++ // Create transport instance+ transport = new ProcessTelemetryTransport();+ });++ afterEach(() => {+ // Restore window+ global.window = originalWindow;+ });++ it('should create an instance successfully', () => {+ expect(transport).toBeInstanceOf(ProcessTelemetryTransport);+ });++ it('should reject if running in a browser environment', async () => {+ // Set window to simulate browser environment+ global.window = {} as any;++ await expect(+ transport.send({+ url: 'https://example.com/telemetry',+ method: 'POST',+ headers: {},+ data: {},+ })+ ).rejects.toThrow('ProcessTelemetryTransport can only be used in Node.js environments');+ });++ // Since we're running in a test environment and can't easily mock dynamic imports,+ // we'll focus on testing the URL handling and error handling aspects++ it('should handle errors gracefully', async () => {+ // Force an error by making URL constructor throw+ const originalURL = global.URL;+ global.URL = vi.fn().mockImplementation(() => {+ throw new Error('Invalid URL');+ }) as any;++ const payload: TelemetryTransportParams = {+ url: 'invalid:///url',+ method: 'POST',+ headers: {},+ data: {},+ };++ // Test that the promise still resolves despite the error+ await expect(transport.send(payload)).resolves.toBeUndefined();++ // Verify error was logged+ expect(consoleErrorSpy).toHaveBeenCalled();++ // Restore URL+ global.URL = originalURL;+ });++ // For these tests, we can't easily verify the spawn call since it's dynamically imported+ // and would require more complex mocking. Instead, we'll focus on ensuring the method+ // runs without throwing errors.++ it('should handle telemetry requests without throwing errors', async () => {+ const payload: TelemetryTransportParams = {+ url: 'https://example.com/telemetry',+ method: 'POST',+ headers: {+ 'Content-Type': 'application/json',+ 'X-Custom-Header': 'test-value',+ },+ data: { key: 'value' },+ };++ // The test passes if no exception is thrown+ await expect(transport.send(payload)).resolves.toBeUndefined();+ });+});diff --git a/packages/core/test/telemetry/TelemetryService.test.ts b/packages/core/test/telemetry/TelemetryService.test.tsnew file mode 100644index 000000000..ebd9e49e7--- /dev/null+++ b/packages/core/test/telemetry/TelemetryService.test.ts@@ -0,0 +1,294 @@+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';+import { TelemetryService } from '../../src/telemetry/Telemetry';+import { BaseTelemetryTransport } from '../../src/telemetry/TelemetryTransport';+import { BrowserTelemetryTransport } from '../../src/telemetry/transports/BrowserTransport';+import { ProcessTelemetryTransport } from '../../src/telemetry/transports/ProcessTransport';+import { TELEMETRY_EVENTS, TelemetryMetadata } from '../../src/types/telemetry.types';+import * as envUtils from '../../src/utils/env';++describe('TelemetryService', () => {+ let telemetryService: TelemetryService;+ let mockTransport: BaseTelemetryTransport;+ let testMetadata: TelemetryMetadata;++ // Save original window+ const originalWindow = global.window;++ beforeEach(() => {+ // Create a new instance for each test+ telemetryService = new TelemetryService();++ // Create mock transport+ mockTransport = {+ send: vi.fn().mockResolvedValue(undefined),+ };++ // Test metadata+ testMetadata = {+ apiKey: 'test-api-key',+ baseUrl: 'https://api.test.com',+ version: '1.0.0',+ framework: 'test-framework',+ isAgentic: false,+ source: 'test',+ sessionId: 'test-session-id',+ isBrowser: false,+ };++ // Reset window to simulate Node.js environment by default+ delete (global as any).window;++ // Mock environment variable+ vi.spyOn(envUtils, 'getEnvVariable').mockImplementation((key, defaultValue) =>+ key === 'TELEMETRY_DISABLED' ? 'false' : defaultValue || ''+ );+ });++ afterEach(() => {+ vi.clearAllMocks();++ // Restore window+ if (originalWindow !== undefined) {+ global.window = originalWindow;+ }+ });++ describe('setup', () => {+ it('should set up telemetry metadata', () => {+ telemetryService.setup(testMetadata, mockTransport);++ expect(mockTransport.send).toHaveBeenCalledWith(+ expect.objectContaining({+ data: expect.arrayContaining([+ expect.objectContaining({+ eventName: TELEMETRY_EVENTS.SDK_INITIALIZED,+ sdk_meta: testMetadata,+ }),+ ]),+ })+ );+ });++ it('should use BrowserTelemetryTransport in browser environment', () => {+ // Mock window to simulate browser environment+ global.window = {} as any;++ // Mock BrowserTelemetryTransport constructor+ const browserTransportSpy = vi+ .spyOn(BrowserTelemetryTransport.prototype, 'send')+ .mockImplementation(() => Promise.resolve());++ telemetryService.setup(testMetadata);++ // Send a test event to verify the transport+ telemetryService['sendTelemetry']([+ {+ eventName: TELEMETRY_EVENTS.SDK_METHOD_INVOKED,+ data: {},+ sdk_meta: testMetadata,+ },+ ]);++ expect(browserTransportSpy).toHaveBeenCalled();+ });++ it('should use ProcessTelemetryTransport in Node.js environment', () => {+ // Mock ProcessTelemetryTransport constructor+ const processTransportSpy = vi+ .spyOn(ProcessTelemetryTransport.prototype, 'send')+ .mockImplementation(() => Promise.resolve());++ telemetryService.setup(testMetadata);++ // Send a test event to verify the transport+ telemetryService['sendTelemetry']([+ {+ eventName: TELEMETRY_EVENTS.SDK_METHOD_INVOKED,+ data: {},+ sdk_meta: testMetadata,+ },+ ]);++ expect(processTransportSpy).toHaveBeenCalled();+ });++ it('should use custom transport when provided', () => {+ telemetryService.setup(testMetadata, mockTransport);++ // Send a test event to verify the transport+ telemetryService['sendTelemetry']([+ {+ eventName: TELEMETRY_EVENTS.SDK_METHOD_INVOKED,+ data: {},+ sdk_meta: testMetadata,+ },+ ]);++ expect(mockTransport.send).toHaveBeenCalledTimes(2); // Once during setup and once for the test+ });+ });++ describe('instrument', () => {+ class TestClass {+ constructor() {}++ async testMethod(param1: string, param2: number) {+ return { result: `${param1}-${param2}` };+ }++ async failingMethod() {+ throw new Error('Test error');+ }++ synchronousMethod() {+ return 'sync result';+ }+ }++ beforeEach(() => {+ telemetryService.setup(testMetadata, mockTransport);+ });++ it('should instrument async methods of an object', async () => {+ const testInstance = new TestClass();+ telemetryService.instrument(testInstance);++ // Reset the mock to clear the SDK_INITIALIZED call+ vi.clearAllMocks();++ await testInstance.testMethod('test', 123);++ // Manually process the batch+ (telemetryService as any).batchProcessor.processBatch();++ expect(mockTransport.send).toHaveBeenCalledWith(+ expect.objectContaining({+ data: expect.arrayContaining([+ expect.objectContaining({+ eventName: TELEMETRY_EVENTS.SDK_METHOD_INVOKED,+ data: expect.objectContaining({+ fileName: 'TestClass',+ method: 'testMethod',+ params: ['test', 123],+ }),+ sdk_meta: testMetadata,+ }),+ ]),+ })+ );+ });++ it('should not instrument synchronous methods', () => {+ const testInstance = new TestClass();+ const instrumentedInstance = telemetryService.instrument(testInstance);++ // The synchronous method should remain unchanged+ const originalMethod = TestClass.prototype.synchronousMethod;+ expect(instrumentedInstance.synchronousMethod).toBe(originalMethod);+ });++ it('should capture errors from instrumented methods', async () => {+ const testInstance = new TestClass();+ telemetryService.instrument(testInstance);++ // Reset the mock to clear the SDK_INITIALIZED call+ vi.clearAllMocks();++ await expect(testInstance.failingMethod()).rejects.toThrow('Test error');++ // Manually process the batch+ (telemetryService as any).batchProcessor.processBatch();++ expect(mockTransport.send).toHaveBeenCalledWith(+ expect.objectContaining({+ data: expect.arrayContaining([+ expect.objectContaining({+ eventName: TELEMETRY_EVENTS.SDK_METHOD_ERROR,+ data: expect.objectContaining({+ fileName: 'TestClass',+ method: 'failingMethod',+ error: expect.objectContaining({+ message: 'Test error',+ }),+ }),+ sdk_meta: testMetadata,+ }),+ ]),+ })+ );+ });++ it('should use the filename if constructor name is not available', () => {+ const anonymousObject = {+ async testMethod() {+ return 'result';+ },+ };++ telemetryService.instrument(anonymousObject, 'custom-filename');++ // Verify the instrumentation works with the custom filename+ expect(anonymousObject.testMethod).not.toBe(undefined);+ expect(typeof anonymousObject.testMethod).toBe('function');+ });+ });++ describe('sendTelemetry', () => {+ beforeEach(() => {+ telemetryService.setup(testMetadata, mockTransport);+ });++ it('should not send telemetry if transport is not set', async () => {+ // Create a new instance without setting up transport+ const newTelemetryService = new TelemetryService();++ // Reset the mock to clear any previous calls+ vi.clearAllMocks();++ await newTelemetryService['sendTelemetry']([+ {+ eventName: TELEMETRY_EVENTS.SDK_METHOD_INVOKED,+ data: {},+ sdk_meta: testMetadata,+ },+ ]);++ expect(mockTransport.send).not.toHaveBeenCalled();+ });++ it('should not send telemetry if telemetry is disabled', async () => {+ // Mock environment variable to disable telemetry+ vi.spyOn(envUtils, 'getEnvVariable').mockImplementation(() => 'true');++ await telemetryService['sendTelemetry']([+ {+ eventName: TELEMETRY_EVENTS.SDK_METHOD_INVOKED,+ data: {},+ sdk_meta: testMetadata,+ },+ ]);++ // We expect only the SDK_INITIALIZED call during setup+ expect(mockTransport.send).toHaveBeenCalledTimes(1);+ });++ it('should send telemetry with correct payload format', async () => {+ const testPayload = [+ {+ eventName: TELEMETRY_EVENTS.SDK_METHOD_INVOKED,+ data: { test: 'data' },+ sdk_meta: testMetadata,+ },+ ];++ await telemetryService['sendTelemetry'](testPayload);++ expect(mockTransport.send).toHaveBeenLastCalledWith({+ data: testPayload,+ url: expect.stringContaining('/api/sdk_metrics/telemetry'),+ method: 'POST',+ headers: { 'Content-Type': 'application/json' },+ });+ });+ });+});diff --git a/pnpm-lock.yaml b/pnpm-lock.yamlindex 0641c7da6..645ad56b9 100644--- a/pnpm-lock.yaml+++ b/pnpm-lock.yaml@@ -136,6 +136,28 @@ importers:specifier: ^5.8.3version: 5.8.3+ examples/telemetry:+ dependencies:+ '@ai-sdk/openai':+ specifier: ^1.3.16+ version: 1.3.22([email protected])+ '@composio/core':+ specifier: workspace:*+ version: link:../../packages/core+ '@composio/vercel':+ specifier: workspace:*+ version: link:../../packages/providers/vercel+ ai:+ specifier: ^4.3.8+ version: 4.3.15([email protected])([email protected])+ devDependencies:+ '@types/bun':+ specifier: ^1.2.9+ version: 1.2.13+ typescript:+ specifier: ^5.8.3+ version: 5.8.3+examples/toolkits:dependencies:'@ai-sdk/openai':@@ -188,6 +210,9 @@ importers:'@composio/client':specifier: ^0.1.0-alpha.10version: 0.1.0-alpha.10+ chalk:+ specifier: ^5.4.1+ version: 5.4.1openai:specifier: ^4.94.0version: 4.98.0([email protected])([email protected])