mongodb-mcp-server 0.0.7 → 0.0.8

package/src/tools/tool.ts

@@ -11,6 +11,10 @@ export type ToolArgs<Args extends ZodRawShape> = z.objectOutputType<Args, ZodNev
 
 export type OperationType = "metadata" | "read" | "create" | "delete" | "update";
 export type ToolCategory = "mongodb" | "atlas";
+export type TelemetryToolMetadata = {
+    projectId?: string;
+    orgId?: string;
+};
 
 export abstract class ToolBase {
     protected abstract name: string;
@@ -31,29 +35,6 @@ export abstract class ToolBase {
         protected readonly telemetry: Telemetry
     ) {}
 
-    /**
-     * Creates and emits a tool telemetry event
-     * @param startTime - Start time in milliseconds
-     * @param result - Whether the command succeeded or failed
-     * @param error - Optional error if the command failed
-     */
-    private async emitToolEvent(startTime: number, result: CallToolResult): Promise<void> {
-        const duration = Date.now() - startTime;
-        const event: ToolEvent = {
-            timestamp: new Date().toISOString(),
-            source: "mdbmcp",
-            properties: {
-                ...this.telemetry.getCommonProperties(),
-                command: this.name,
-                category: this.category,
-                component: "tool",
-                duration_ms: duration,
-                result: result.isError ? "failure" : "success",
-            },
-        };
-        await this.telemetry.emitEvents([event]);
-    }
-
     public register(server: McpServer): void {
         if (!this.verifyAllowed()) {
             return;
@@ -65,12 +46,12 @@ export abstract class ToolBase {
                 logger.debug(LogId.toolExecute, "tool", `Executing ${this.name} with args: ${JSON.stringify(args)}`);
 
                 const result = await this.execute(...args);
-                await this.emitToolEvent(startTime, result);
+                await this.emitToolEvent(startTime, result, ...args).catch(() => {});
                 return result;
             } catch (error: unknown) {
                 logger.error(LogId.toolExecuteFailure, "tool", `Error executing ${this.name}: ${error as string}`);
                 const toolResult = await this.handleError(error, args[0] as ToolArgs<typeof this.argsShape>);
-                await this.emitToolEvent(startTime, toolResult).catch(() => {});
+                await this.emitToolEvent(startTime, toolResult, ...args).catch(() => {});
                 return toolResult;
             }
         };
@@ -145,9 +126,52 @@ export abstract class ToolBase {
                 {
                     type: "text",
                     text: `Error running ${this.name}: ${error instanceof Error ? error.message : String(error)}`,
-                    isError: true,
                 },
             ],
+            isError: true,
+        };
+    }
+
+    protected abstract resolveTelemetryMetadata(
+        ...args: Parameters<ToolCallback<typeof this.argsShape>>
+    ): TelemetryToolMetadata;
+
+    /**
+     * Creates and emits a tool telemetry event
+     * @param startTime - Start time in milliseconds
+     * @param result - Whether the command succeeded or failed
+     * @param args - The arguments passed to the tool
+     */
+    private async emitToolEvent(
+        startTime: number,
+        result: CallToolResult,
+        ...args: Parameters<ToolCallback<typeof this.argsShape>>
+    ): Promise<void> {
+        if (!this.telemetry.isTelemetryEnabled()) {
+            return;
+        }
+        const duration = Date.now() - startTime;
+        const metadata = this.resolveTelemetryMetadata(...args);
+        const event: ToolEvent = {
+            timestamp: new Date().toISOString(),
+            source: "mdbmcp",
+            properties: {
+                command: this.name,
+                category: this.category,
+                component: "tool",
+                duration_ms: duration,
+                result: result.isError ? "failure" : "success",
+            },
         };
+
+        if (metadata?.orgId) {
+            event.properties.org_id = metadata.orgId;
+        }
+
+        if (metadata?.projectId) {
+            event.properties.project_id = metadata.projectId;
+        }
+
+        await this.telemetry.emitEvents([event]);
     }
 }

package/tests/integration/helpers.ts

@@ -5,6 +5,7 @@ import { UserConfig } from "../../src/config.js";
 import { McpError } from "@modelcontextprotocol/sdk/types.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Session } from "../../src/session.js";
+import { config } from "../../src/config.js";
 
 interface ParameterInfo {
     name: string;
@@ -19,6 +20,10 @@ export interface IntegrationTest {
     mcpClient: () => Client;
     mcpServer: () => Server;
 }
+export const defaultTestConfig: UserConfig = {
+    ...config,
+    telemetry: "disabled",
+};
 
 export function setupIntegrationTest(getUserConfig: () => UserConfig): IntegrationTest {
     let mcpClient: Client | undefined;
@@ -51,25 +56,18 @@ export function setupIntegrationTest(getUserConfig: () => UserConfig): Integrati
             apiClientSecret: userConfig.apiClientSecret,
         });
 
-        userConfig.telemetry = "disabled";
         mcpServer = new Server({
             session,
             userConfig,
             mcpServer: new McpServer({
                 name: "test-server",
-                version: "1.2.3",
+                version: "5.2.3",
             }),
         });
         await mcpServer.connect(serverTransport);
         await mcpClient.connect(clientTransport);
     });
 
-    beforeEach(() => {
-        if (mcpServer) {
-            mcpServer.userConfig.telemetry = "disabled";
-        }
-    });
-
     afterEach(async () => {
         if (mcpServer) {
             await mcpServer.session.close();

package/tests/integration/inMemoryTransport.ts

@@ -2,7 +2,7 @@ import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
 
 export class InMemoryTransport implements Transport {
-    private outputController: ReadableStreamDefaultController<JSONRPCMessage>;
+    private outputController: ReadableStreamDefaultController<JSONRPCMessage> | undefined;
 
     private startPromise: Promise<unknown>;
 
@@ -35,13 +35,13 @@ export class InMemoryTransport implements Transport {
     }
 
     send(message: JSONRPCMessage): Promise<void> {
-        this.outputController.enqueue(message);
+        this.outputController?.enqueue(message);
         return Promise.resolve();
     }
 
     // eslint-disable-next-line @typescript-eslint/require-await
     async close(): Promise<void> {
-        this.outputController.close();
+        this.outputController?.close();
         this.onclose?.();
     }
     onclose?: (() => void) | undefined;

package/tests/integration/server.test.ts

@@ -1,5 +1,4 @@
-import { expectDefined, setupIntegrationTest } from "./helpers.js";
-import { config } from "../../src/config.js";
+import { defaultTestConfig, expectDefined, setupIntegrationTest } from "./helpers.js";
 import { describeWithMongoDB } from "./tools/mongodb/mongodbHelpers.js";
 
 describe("Server integration test", () => {
@@ -16,7 +15,7 @@ describe("Server integration test", () => {
             });
         },
         () => ({
-            ...config,
+            ...defaultTestConfig,
             apiClientId: undefined,
             apiClientSecret: undefined,
         })
@@ -24,7 +23,7 @@ describe("Server integration test", () => {
 
     describe("with atlas", () => {
         const integration = setupIntegrationTest(() => ({
-            ...config,
+            ...defaultTestConfig,
             apiClientId: "test",
             apiClientSecret: "test",
         }));
@@ -59,7 +58,7 @@ describe("Server integration test", () => {
 
     describe("with read-only mode", () => {
         const integration = setupIntegrationTest(() => ({
-            ...config,
+            ...defaultTestConfig,
             readOnly: true,
             apiClientId: "test",
             apiClientSecret: "test",

package/tests/integration/tools/atlas/atlasHelpers.ts

@@ -1,15 +1,14 @@
 import { ObjectId } from "mongodb";
 import { Group } from "../../../../src/common/atlas/openapi.js";
 import { ApiClient } from "../../../../src/common/atlas/apiClient.js";
-import { setupIntegrationTest, IntegrationTest } from "../../helpers.js";
-import { config } from "../../../../src/config.js";
+import { setupIntegrationTest, IntegrationTest, defaultTestConfig } from "../../helpers.js";
 
 export type IntegrationTestFunction = (integration: IntegrationTest) => void;
 
 export function describeWithAtlas(name: string, fn: IntegrationTestFunction) {
     const testDefinition = () => {
         const integration = setupIntegrationTest(() => ({
-            ...config,
+            ...defaultTestConfig,
             apiClientId: process.env.MDB_MCP_API_CLIENT_ID,
             apiClientSecret: process.env.MDB_MCP_API_CLIENT_SECRET,
         }));
@@ -74,7 +73,7 @@ export function parseTable(text: string): Record<string, string>[] {
     return data
         .filter((_, index) => index >= 2)
         .map((cells) => {
-            const row = {};
+            const row: Record<string, string> = {};
             cells.forEach((cell, index) => {
                 row[headers[index]] = cell;
             });

package/tests/integration/tools/mongodb/mongodbHelpers.ts

@@ -1,9 +1,12 @@
 import { MongoCluster } from "mongodb-runner";
 import path from "path";
+import { fileURLToPath } from "url";
 import fs from "fs/promises";
 import { MongoClient, ObjectId } from "mongodb";
-import { getResponseContent, IntegrationTest, setupIntegrationTest } from "../../helpers.js";
-import { config, UserConfig } from "../../../../src/config.js";
+import { getResponseContent, IntegrationTest, setupIntegrationTest, defaultTestConfig } from "../../helpers.js";
+import { UserConfig } from "../../../../src/config.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 interface MongoDBIntegrationTest {
     mongoClient: () => MongoClient;
@@ -14,7 +17,7 @@ interface MongoDBIntegrationTest {
 export function describeWithMongoDB(
     name: string,
     fn: (integration: IntegrationTest & MongoDBIntegrationTest & { connectMcpClient: () => Promise<void> }) => void,
-    getUserConfig: (mdbIntegration: MongoDBIntegrationTest) => UserConfig = () => config,
+    getUserConfig: (mdbIntegration: MongoDBIntegrationTest) => UserConfig = () => defaultTestConfig,
     describeFn = describe
 ) {
     describeFn(name, () => {

package/tests/unit/telemetry.test.ts

@@ -4,6 +4,7 @@ import { Telemetry } from "../../src/telemetry/telemetry.js";
 import { BaseEvent, TelemetryResult } from "../../src/telemetry/types.js";
 import { EventCache } from "../../src/telemetry/eventCache.js";
 import { config } from "../../src/config.js";
+import { jest } from "@jest/globals";
 
 // Mock the ApiClient to avoid real API calls
 jest.mock("../../src/common/atlas/apiClient.js");
@@ -21,16 +22,23 @@ describe("Telemetry", () => {
 
     // Helper function to create properly typed test events
     function createTestEvent(options?: {
-        source?: string;
         result?: TelemetryResult;
         component?: string;
         category?: string;
         command?: string;
         duration_ms?: number;
-    }): BaseEvent {
+    }): Omit<BaseEvent, "properties"> & {
+        properties: {
+            component: string;
+            duration_ms: number;
+            result: TelemetryResult;
+            category: string;
+            command: string;
+        };
+    } {
         return {
             timestamp: new Date().toISOString(),
-            source: options?.source || "mdbmcp",
+            source: "mdbmcp",
             properties: {
                 component: options?.component || "test-component",
                 duration_ms: options?.duration_ms || 100,
@@ -48,6 +56,12 @@ describe("Telemetry", () => {
         appendEventsCalls = 0,
         sendEventsCalledWith = undefined,
         appendEventsCalledWith = undefined,
+    }: {
+        sendEventsCalls?: number;
+        clearEventsCalls?: number;
+        appendEventsCalls?: number;
+        sendEventsCalledWith?: BaseEvent[] | undefined;
+        appendEventsCalledWith?: BaseEvent[] | undefined;
     } = {}) {
         const { calls: sendEvents } = mockApiClient.sendEvents.mock;
         const { calls: clearEvents } = mockEventCache.clearEvents.mock;
@@ -58,7 +72,15 @@ describe("Telemetry", () => {
         expect(appendEvents.length).toBe(appendEventsCalls);
 
         if (sendEventsCalledWith) {
-            expect(sendEvents[0]?.[0]).toEqual(sendEventsCalledWith);
+            expect(sendEvents[0]?.[0]).toEqual(
+                sendEventsCalledWith.map((event) => ({
+                    ...event,
+                    properties: {
+                        ...telemetry.getCommonProperties(),
+                        ...event.properties,
+                    },
+                }))
+            );
         }
 
         if (appendEventsCalledWith) {
@@ -71,15 +93,20 @@ describe("Telemetry", () => {
         jest.clearAllMocks();
 
         // Setup mocked API client
-        mockApiClient = new MockApiClient() as jest.Mocked<ApiClient>;
-        mockApiClient.sendEvents = jest.fn().mockResolvedValue(undefined);
-        mockApiClient.hasCredentials = jest.fn().mockReturnValue(true);
+        mockApiClient = new MockApiClient({ baseUrl: "" }) as jest.Mocked<ApiClient>;
+        //@ts-expect-error This is a workaround
+        mockApiClient.sendEvents = jest.fn<() => undefined>().mockResolvedValue(undefined);
+        mockApiClient.hasCredentials = jest.fn<() => boolean>().mockReturnValue(true);
 
         // Setup mocked EventCache
         mockEventCache = new MockEventCache() as jest.Mocked<EventCache>;
+        //@ts-expect-error This is a workaround
         mockEventCache.getEvents = jest.fn().mockReturnValue([]);
+        //@ts-expect-error This is a workaround
         mockEventCache.clearEvents = jest.fn().mockResolvedValue(undefined);
+        //@ts-expect-error This is a workaround
         mockEventCache.appendEvents = jest.fn().mockResolvedValue(undefined);
+        //@ts-expect-error This is a workaround
         MockEventCache.getInstance = jest.fn().mockReturnValue(mockEventCache);
 
         // Create a simplified session with our mocked API client
@@ -87,13 +114,14 @@ describe("Telemetry", () => {
             apiClient: mockApiClient,
             sessionId: "test-session-id",
             agentRunner: { name: "test-agent", version: "1.0.0" } as const,
+            //@ts-expect-error This is a workaround
             close: jest.fn().mockResolvedValue(undefined),
+            //@ts-expect-error This is a workaround
             setAgentRunner: jest.fn().mockResolvedValue(undefined),
         } as unknown as Session;
 
         // Create the telemetry instance with mocked dependencies
-        telemetry = new Telemetry(session, mockEventCache);
-
+        telemetry = new Telemetry(session, config, mockEventCache);
         config.telemetry = "enabled";
     });
 

package/tsconfig.build.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "strictNullChecks": true,
+    "esModuleInterop": true,
+    "types": ["node", "jest"],
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "typeRoots": ["./node_modules/@types", "./src/types"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.jest.json

@@ -1,8 +1,6 @@
 {
-  "extends": "./tsconfig.json",
+  "extends": "./tsconfig.build.json",
   "compilerOptions": {
-    "module": "esnext",
-    "target": "esnext",
     "isolatedModules": true,
     "allowSyntheticDefaultImports": true,
     "types": ["jest", "jest-extended"]

package/tsconfig.json

@@ -1,19 +1,9 @@
 {
+  "extends": "./tsconfig.build.json",
   "compilerOptions": {
-    "target": "es2020",
-    "module": "nodenext",
-    "moduleResolution": "nodenext",
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "strict": true,
-    "strictNullChecks": true,
-    "esModuleInterop": true,
-    "types": ["node", "jest"],
-    "sourceMap": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true,
-    "typeRoots": ["./node_modules/@types", "./src/types"]
+    "rootDir": ".",
+    "types": ["jest"],
+    "skipLibCheck": true
   },
-  "include": ["src/**/*.ts"]
+  "include": ["**/*"]
 }

package/tsconfig.lint.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "rootDir": ".",
-    "types": ["jest"]
-  },
-  "include": ["**/*"]
-}