Skip to content

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

Add telemetry tests

haxzie37591a0b9c81
diff --git a/examples/telemetry/.env.example b/examples/telemetry/.env.example
new file mode 100644
index 000000000..ad0f7ed62
--- /dev/null
+++ b/examples/telemetry/.env.example
@@ -0,0 +1,2 @@
+COMPOSIO_API_KEY=
+OPENAI_API_KEY=
\ No newline at end of file
diff --git a/examples/telemetry/README.md b/examples/telemetry/README.md
new file mode 100644
index 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.json
new file mode 100644
index 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.ts
new file mode 100644
index 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.json
new file mode 100644
index 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.json
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.yaml
index 0641c7da6..645ad56b9 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -136,6 +136,28 @@ importers:
specifier: ^5.8.3
version: 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
+ 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.10
version: 0.1.0-alpha.10
+ chalk:
+ specifier: ^5.4.1
+ version: 5.4.1
openai:
specifier: ^4.94.0