Merge branch 'gagik/esm-jest' of github.com:mongodb-js/mongodb-mcp-server into gagik/use-machine-id

Author: gagik

eslint.config.js

@@ -48,7 +48,7 @@ export default defineConfig([
         "coverage",
         "global.d.ts",
         "eslint.config.js",
-        "jest.config.js",
+        "jest.config.ts",
     ]),
     eslintPluginPrettierRecommended,
 ]);

jest.config.js renamed to jest.config.ts

@@ -12,7 +12,7 @@ export default {
             "ts-jest",
             {
                 useESM: true,
-                tsconfig: "tsconfig.jest.json", // Use specific tsconfig file for Jest
+                tsconfig: "tsconfig.jest.json",
             },
         ],
     },

package.json

@@ -29,7 +29,7 @@
     "check:types": "tsc --noEmit --project tsconfig.json",
     "reformat": "prettier --write .",
     "generate": "./scripts/generate.sh",
-    "test": "jest --coverage"
+    "test": "node --experimental-vm-modules ./node_modules/.bin/jest --coverage"
   },
   "license": "Apache-2.0",
   "devDependencies": {

src/logger.ts

@@ -17,8 +17,9 @@ export const LogId = {
     telemetryEmitFailure: mongoLogId(1_002_002),
     telemetryEmitStart: mongoLogId(1_002_003),
     telemetryEmitSuccess: mongoLogId(1_002_004),
-    telemetryDeviceIdFailure: mongoLogId(1_002_005),
-    telemetryDeviceIdTimeout: mongoLogId(1_002_006),
+    telemetryMetadataError: mongoLogId(1_002_005),
+    telemetryDeviceIdFailure: mongoLogId(1_002_006),
+    telemetryDeviceIdTimeout: mongoLogId(1_002_007),
 
     toolExecute: mongoLogId(1_003_001),
     toolExecuteFailure: mongoLogId(1_003_002),

src/telemetry/telemetry.ts

@@ -1,6 +1,6 @@
 import { Session } from "../session.js";
 import { BaseEvent, CommonProperties } from "./types.js";
-import { config } from "../config.js";
+import { UserConfig } from "../config.js";
 import logger, { LogId } from "../logger.js";
 import { ApiClient } from "../common/atlas/apiClient.js";
 import { MACHINE_METADATA } from "./constants.js";
@@ -23,23 +23,25 @@ export class Telemetry {
 
     private constructor(
         private readonly session: Session,
+        private readonly userConfig: UserConfig,
         private readonly commonProperties: CommonProperties,
         private readonly eventCache: EventCache
     ) {}
 
     static create(
         session: Session,
+        userConfig: UserConfig,
         commonProperties: CommonProperties = { ...MACHINE_METADATA },
         eventCache: EventCache = EventCache.getInstance()
     ): Telemetry {
-        const instance = new Telemetry(session, commonProperties, eventCache);
+        const instance = new Telemetry(session, userConfig, commonProperties, eventCache);
 
         void instance.start();
         return instance;
     }
 
     private async start(): Promise<void> {
-        if (!Telemetry.isTelemetryEnabled()) {
+        if (!this.isTelemetryEnabled()) {
             return;
         }
         this.deviceIdPromise = DeferredPromise.fromPromise(this.getDeviceId(), {
@@ -86,38 +88,14 @@ export class Telemetry {
         }
     }
 
-    /**
-     * Checks if telemetry is currently enabled
-     * This is a method rather than a constant to capture runtime config changes
-     *
-     * Follows the Console Do Not Track standard (https://consoledonottrack.com/)
-     * by respecting the DO_NOT_TRACK environment variable
-     */
-    private static isTelemetryEnabled(): boolean {
-        // Check if telemetry is explicitly disabled in config
-        if (config.telemetry === "disabled") {
-            return false;
-        }
-
-        const doNotTrack = process.env.DO_NOT_TRACK;
-        if (doNotTrack) {
-            const value = doNotTrack.toLowerCase();
-            // Telemetry should be disabled if DO_NOT_TRACK is "1", "true", or "yes"
-            if (value === "1" || value === "true" || value === "yes") {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
     /**
      * Emits events through the telemetry pipeline
      * @param events - The events to emit
      */
     public async emitEvents(events: BaseEvent[]): Promise<void> {
         try {
-            if (!Telemetry.isTelemetryEnabled()) {
+            if (!this.isTelemetryEnabled()) {
+                logger.info(LogId.telemetryEmitFailure, "telemetry", `Telemetry is disabled.`);
                 return;
             }
 
@@ -139,10 +117,27 @@ export class Telemetry {
             mcp_client_name: this.session.agentRunner?.name,
             session_id: this.session.sessionId,
             config_atlas_auth: this.session.apiClient.hasCredentials() ? "true" : "false",
-            config_connection_string: config.connectionString ? "true" : "false",
+            config_connection_string: this.userConfig.connectionString ? "true" : "false",
         };
     }
 
+    /**
+     * Checks if telemetry is currently enabled
+     * This is a method rather than a constant to capture runtime config changes
+     *
+     * Follows the Console Do Not Track standard (https://consoledonottrack.com/)
+     * by respecting the DO_NOT_TRACK environment variable
+     */
+    public isTelemetryEnabled(): boolean {
+        // Check if telemetry is explicitly disabled in config
+        if (this.userConfig.telemetry === "disabled") {
+            return false;
+        }
+
+        const doNotTrack = "DO_NOT_TRACK" in process.env;
+        return !doNotTrack;
+    }
+
     /**
      * Attempts to emit events through authenticated and unauthenticated clients
      * Falls back to caching if both attempts fail
@@ -165,7 +160,11 @@ export class Telemetry {
         const result = await this.sendEvents(this.session.apiClient, allEvents);
         if (result.success) {
             this.eventCache.clearEvents();
-            logger.debug(LogId.telemetryEmitSuccess, "telemetry", `Sent ${allEvents.length} events successfully`);
+            logger.debug(
+                LogId.telemetryEmitSuccess,
+                "telemetry",
+                `Sent ${allEvents.length} events successfully: ${JSON.stringify(allEvents, null, 2)}`
+            );
             return;
         }
 

src/tools/atlas/atlasTool.ts

@@ -1,4 +1,7 @@
-import { ToolBase, ToolCategory } from "../tool.js";
+import { ToolBase, ToolCategory, TelemetryToolMetadata } from "../tool.js";
+import { ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
+import logger, { LogId } from "../../logger.js";
+import { z } from "zod";
 
 export abstract class AtlasToolBase extends ToolBase {
     protected category: ToolCategory = "atlas";
@@ -9,4 +12,46 @@ export abstract class AtlasToolBase extends ToolBase {
         }
         return super.verifyAllowed();
     }
+
+    /**
+     *
+     * Resolves the tool metadata from the arguments passed to the tool
+     *
+     * @param args - The arguments passed to the tool
+     * @returns The tool metadata
+     */
+    protected resolveTelemetryMetadata(
+        ...args: Parameters<ToolCallback<typeof this.argsShape>>
+    ): TelemetryToolMetadata {
+        const toolMetadata: TelemetryToolMetadata = {};
+        if (!args.length) {
+            return toolMetadata;
+        }
+
+        // Create a typed parser for the exact shape we expect
+        const argsShape = z.object(this.argsShape);
+        const parsedResult = argsShape.safeParse(args[0]);
+
+        if (!parsedResult.success) {
+            logger.debug(
+                LogId.telemetryMetadataError,
+                "tool",
+                `Error parsing tool arguments: ${parsedResult.error.message}`
+            );
+            return toolMetadata;
+        }
+
+        const data = parsedResult.data;
+
+        // Extract projectId using type guard
+        if ("projectId" in data && typeof data.projectId === "string" && data.projectId.trim() !== "") {
+            toolMetadata.projectId = data.projectId;
+        }
+
+        // Extract orgId using type guard
+        if ("orgId" in data && typeof data.orgId === "string" && data.orgId.trim() !== "") {
+            toolMetadata.orgId = data.orgId;
+        }
+        return toolMetadata;
+    }
 }

src/tools/mongodb/mongodbTool.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ToolArgs, ToolBase, ToolCategory } from "../tool.js";
+import { ToolArgs, ToolBase, ToolCategory, TelemetryToolMetadata } from "../tool.js";
 import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { ErrorCodes, MongoDBError } from "../../errors.js";
@@ -73,4 +73,18 @@ export abstract class MongoDBToolBase extends ToolBase {
     protected connectToMongoDB(connectionString: string): Promise<void> {
         return this.session.connectToMongoDB(connectionString, this.config.connectOptions);
     }
+
+    protected resolveTelemetryMetadata(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        args: ToolArgs<typeof this.argsShape>
+    ): TelemetryToolMetadata {
+        const metadata: TelemetryToolMetadata = {};
+
+        // Add projectId to the metadata if running a MongoDB operation to an Atlas cluster
+        if (this.session.connectedAtlasCluster?.projectId) {
+            metadata.projectId = this.session.connectedAtlasCluster.projectId;
+        }
+
+        return metadata;
+    }
 }

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,28 +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: {
-                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;
@@ -64,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;
             }
         };
@@ -149,4 +131,47 @@ export abstract class ToolBase {
             ],
         };
     }
+
+    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]);
+    }
 }

tests/integration/helpers.ts

@@ -6,6 +6,7 @@ import { McpError } from "@modelcontextprotocol/sdk/types.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Session } from "../../src/session.js";
 import { Telemetry } from "../../src/telemetry/telemetry.js";
+import { config } from "../../src/config.js";
 
 interface ParameterInfo {
     name: string;
@@ -20,6 +21,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;
@@ -54,27 +59,21 @@ export function setupIntegrationTest(getUserConfig: () => UserConfig): Integrati
 
         userConfig.telemetry = "disabled";
 
-        const telemetry = Telemetry.create(session);
+        const telemetry = Telemetry.create(session, userConfig);
 
         mcpServer = new Server({
             session,
             userConfig,
             telemetry,
             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();