mongodb-mcp-server 0.1.2 → 0.1.3

package/src/telemetry/telemetry.ts

@@ -7,152 +7,114 @@ import { MACHINE_METADATA } from "./constants.js";
 import { EventCache } from "./eventCache.js";
 import nodeMachineId from "node-machine-id";
 import { getDeviceId } from "@mongodb-js/device-id";
-import fs from "fs/promises";
-
-async function fileExists(filePath: string): Promise<boolean> {
-    try {
-        await fs.access(filePath, fs.constants.F_OK);
-        return true; // File exists
-    } catch (e: unknown) {
-        if (
-            e instanceof Error &&
-            (
-                e as Error & {
-                    code: string;
-                }
-            ).code === "ENOENT"
-        ) {
-            return false; // File does not exist
-        }
-        throw e; // Re-throw unexpected errors
-    }
-}
 
-async function isContainerized(): Promise<boolean> {
-    if (process.env.container) {
-        return true;
-    }
-
-    const exists = await Promise.all(["/.dockerenv", "/run/.containerenv", "/var/run/.containerenv"].map(fileExists));
+type EventResult = {
+    success: boolean;
+    error?: Error;
+};
 
-    return exists.includes(true);
-}
+export const DEVICE_ID_TIMEOUT = 3000;
 
 export class Telemetry {
+    private isBufferingEvents: boolean = true;
+    /** Resolves when the device ID is retrieved or timeout occurs */
+    public deviceIdPromise: Promise<string> | undefined;
     private deviceIdAbortController = new AbortController();
     private eventCache: EventCache;
     private getRawMachineId: () => Promise<string>;
-    private getContainerEnv: () => Promise<boolean>;
-    private cachedCommonProperties?: CommonProperties;
-    private flushing: boolean = false;
 
     private constructor(
         private readonly session: Session,
         private readonly userConfig: UserConfig,
-        {
-            eventCache,
-            getRawMachineId,
-            getContainerEnv,
-        }: {
-            eventCache: EventCache;
-            getRawMachineId: () => Promise<string>;
-            getContainerEnv: () => Promise<boolean>;
-        }
+        private readonly commonProperties: CommonProperties,
+        { eventCache, getRawMachineId }: { eventCache: EventCache; getRawMachineId: () => Promise<string> }
     ) {
         this.eventCache = eventCache;
         this.getRawMachineId = getRawMachineId;
-        this.getContainerEnv = getContainerEnv;
     }
 
     static create(
         session: Session,
         userConfig: UserConfig,
         {
+            commonProperties = { ...MACHINE_METADATA },
             eventCache = EventCache.getInstance(),
             getRawMachineId = () => nodeMachineId.machineId(true),
-            getContainerEnv = isContainerized,
         }: {
             eventCache?: EventCache;
             getRawMachineId?: () => Promise<string>;
-            getContainerEnv?: () => Promise<boolean>;
+            commonProperties?: CommonProperties;
         } = {}
     ): Telemetry {
-        const instance = new Telemetry(session, userConfig, {
-            eventCache,
-            getRawMachineId,
-            getContainerEnv,
-        });
+        const instance = new Telemetry(session, userConfig, commonProperties, { eventCache, getRawMachineId });
 
+        void instance.start();
         return instance;
     }
 
+    private async start(): Promise<void> {
+        if (!this.isTelemetryEnabled()) {
+            return;
+        }
+        this.deviceIdPromise = getDeviceId({
+            getMachineId: () => this.getRawMachineId(),
+            onError: (reason, error) => {
+                switch (reason) {
+                    case "resolutionError":
+                        logger.debug(LogId.telemetryDeviceIdFailure, "telemetry", String(error));
+                        break;
+                    case "timeout":
+                        logger.debug(LogId.telemetryDeviceIdTimeout, "telemetry", "Device ID retrieval timed out");
+                        break;
+                    case "abort":
+                        // No need to log in the case of aborts
+                        break;
+                }
+            },
+            abortSignal: this.deviceIdAbortController.signal,
+        });
+
+        this.commonProperties.device_id = await this.deviceIdPromise;
+
+        this.isBufferingEvents = false;
+    }
+
     public async close(): Promise<void> {
         this.deviceIdAbortController.abort();
-        await this.flush();
+        this.isBufferingEvents = false;
+        await this.emitEvents(this.eventCache.getEvents());
     }
 
     /**
      * Emits events through the telemetry pipeline
      * @param events - The events to emit
      */
-    public emitEvents(events: BaseEvent[]): void {
-        void this.flush(events);
+    public async emitEvents(events: BaseEvent[]): Promise<void> {
+        try {
+            if (!this.isTelemetryEnabled()) {
+                logger.info(LogId.telemetryEmitFailure, "telemetry", `Telemetry is disabled.`);
+                return;
+            }
+
+            await this.emit(events);
+        } catch {
+            logger.debug(LogId.telemetryEmitFailure, "telemetry", `Error emitting telemetry events.`);
+        }
     }
 
     /**
      * Gets the common properties for events
      * @returns Object containing common properties for all events
      */
-    private async getCommonProperties(): Promise<CommonProperties> {
-        if (!this.cachedCommonProperties) {
-            let deviceId: string | undefined;
-            let containerEnv: boolean | undefined;
-            try {
-                await Promise.all([
-                    getDeviceId({
-                        getMachineId: () => this.getRawMachineId(),
-                        onError: (reason, error) => {
-                            switch (reason) {
-                                case "resolutionError":
-                                    logger.debug(LogId.telemetryDeviceIdFailure, "telemetry", String(error));
-                                    break;
-                                case "timeout":
-                                    logger.debug(
-                                        LogId.telemetryDeviceIdTimeout,
-                                        "telemetry",
-                                        "Device ID retrieval timed out"
-                                    );
-                                    break;
-                                case "abort":
-                                    // No need to log in the case of aborts
-                                    break;
-                            }
-                        },
-                        abortSignal: this.deviceIdAbortController.signal,
-                    }).then((id) => {
-                        deviceId = id;
-                    }),
-                    this.getContainerEnv().then((env) => {
-                        containerEnv = env;
-                    }),
-                ]);
-            } catch (error: unknown) {
-                const err = error instanceof Error ? error : new Error(String(error));
-                logger.debug(LogId.telemetryDeviceIdFailure, "telemetry", err.message);
-            }
-            this.cachedCommonProperties = {
-                ...MACHINE_METADATA,
-                mcp_client_version: this.session.agentRunner?.version,
-                mcp_client_name: this.session.agentRunner?.name,
-                session_id: this.session.sessionId,
-                config_atlas_auth: this.session.apiClient.hasCredentials() ? "true" : "false",
-                config_connection_string: this.userConfig.connectionString ? "true" : "false",
-                is_container_env: containerEnv ? "true" : "false",
-                device_id: deviceId,
-            };
-        }
-
-        return this.cachedCommonProperties;
+    public getCommonProperties(): CommonProperties {
+        return {
+            ...this.commonProperties,
+            mcp_client_version: this.session.agentRunner?.version,
+            mcp_client_name: this.session.agentRunner?.name,
+            session_id: this.session.sessionId,
+            config_atlas_auth: this.session.apiClient.hasCredentials() ? "true" : "false",
+            config_connection_string: this.userConfig.connectionString ? "true" : "false",
+        };
     }
 
     /**
@@ -173,74 +135,60 @@ export class Telemetry {
     }
 
     /**
-     * Attempts to flush events through authenticated and unauthenticated clients
+     * Attempts to emit events through authenticated and unauthenticated clients
      * Falls back to caching if both attempts fail
      */
-    public async flush(events?: BaseEvent[]): Promise<void> {
-        if (!this.isTelemetryEnabled()) {
-            logger.info(LogId.telemetryEmitFailure, "telemetry", `Telemetry is disabled.`);
-            return;
-        }
-
-        if (this.flushing) {
-            this.eventCache.appendEvents(events ?? []);
-            process.nextTick(async () => {
-                // try again if in the middle of a flush
-                await this.flush();
-            });
+    private async emit(events: BaseEvent[]): Promise<void> {
+        if (this.isBufferingEvents) {
+            this.eventCache.appendEvents(events);
             return;
         }
 
-        this.flushing = true;
+        const cachedEvents = this.eventCache.getEvents();
+        const allEvents = [...cachedEvents, ...events];
 
-        try {
-            const cachedEvents = this.eventCache.getEvents();
-            const allEvents = [...cachedEvents, ...(events ?? [])];
-            if (allEvents.length <= 0) {
-                this.flushing = false;
-                return;
-            }
-
-            logger.debug(
-                LogId.telemetryEmitStart,
-                "telemetry",
-                `Attempting to send ${allEvents.length} events (${cachedEvents.length} cached)`
-            );
+        logger.debug(
+            LogId.telemetryEmitStart,
+            "telemetry",
+            `Attempting to send ${allEvents.length} events (${cachedEvents.length} cached)`
+        );
 
-            await this.sendEvents(this.session.apiClient, allEvents);
+        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: ${JSON.stringify(allEvents, null, 2)}`
             );
-        } catch (error: unknown) {
-            logger.debug(
-                LogId.telemetryEmitFailure,
-                "telemetry",
-                `Error sending event to client: ${error instanceof Error ? error.message : String(error)}`
-            );
-            this.eventCache.appendEvents(events ?? []);
-            process.nextTick(async () => {
-                // try again
-                await this.flush();
-            });
+            return;
         }
 
-        this.flushing = false;
+        logger.debug(
+            LogId.telemetryEmitFailure,
+            "telemetry",
+            `Error sending event to client: ${result.error instanceof Error ? result.error.message : String(result.error)}`
+        );
+        this.eventCache.appendEvents(events);
     }
 
     /**
      * Attempts to send events through the provided API client
      */
-    private async sendEvents(client: ApiClient, events: BaseEvent[]): Promise<void> {
-        const commonProperties = await this.getCommonProperties();
-
-        await client.sendEvents(
-            events.map((event) => ({
-                ...event,
-                properties: { ...commonProperties, ...event.properties },
-            }))
-        );
+    private async sendEvents(client: ApiClient, events: BaseEvent[]): Promise<EventResult> {
+        try {
+            await client.sendEvents(
+                events.map((event) => ({
+                    ...event,
+                    properties: { ...this.getCommonProperties(), ...event.properties },
+                }))
+            );
+            return { success: true };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+            };
+        }
     }
 }

package/src/telemetry/types.ts

@@ -71,5 +71,4 @@ export type CommonProperties = {
     config_atlas_auth?: TelemetryBoolSet;
     config_connection_string?: TelemetryBoolSet;
     session_id?: string;
-    is_container_env?: TelemetryBoolSet;
 } & CommonStaticProperties;

package/src/tools/mongodb/delete/deleteMany.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
+import { checkIndexUsage } from "../../../helpers/indexCheck.js";
 
 export class DeleteManyTool extends MongoDBToolBase {
     protected name = "delete-many";
@@ -23,6 +24,25 @@ export class DeleteManyTool extends MongoDBToolBase {
         filter,
     }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
         const provider = await this.ensureConnected();
+
+        // Check if delete operation uses an index if enabled
+        if (this.config.indexCheck) {
+            await checkIndexUsage(provider, database, collection, "deleteMany", async () => {
+                return provider.runCommandWithCheck(database, {
+                    explain: {
+                        delete: collection,
+                        deletes: [
+                            {
+                                q: filter || {},
+                                limit: 0, // 0 means delete all matching documents
+                            },
+                        ],
+                    },
+                    verbosity: "queryPlanner",
+                });
+            });
+        }
+
         const result = await provider.deleteMany(database, collection, filter);
 
         return {

package/src/tools/mongodb/metadata/explain.ts

@@ -76,7 +76,7 @@ export class ExplainTool extends MongoDBToolBase {
             }
             case "count": {
                 const { query } = method.arguments;
-                result = await provider.mongoClient.db(database).command({
+                result = await provider.runCommandWithCheck(database, {
                     explain: {
                         count: collection,
                         query,

package/src/tools/mongodb/mongodbTool.ts

@@ -64,6 +64,16 @@ export abstract class MongoDBToolBase extends ToolBase {
                         ],
                         isError: true,
                     };
+                case ErrorCodes.ForbiddenCollscan:
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: error.message,
+                            },
+                        ],
+                        isError: true,
+                    };
             }
         }
 

package/src/tools/mongodb/read/aggregate.ts

@@ -3,6 +3,7 @@ import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 import { EJSON } from "bson";
+import { checkIndexUsage } from "../../../helpers/indexCheck.js";
 
 export const AggregateArgs = {
     pipeline: z.array(z.record(z.string(), z.unknown())).describe("An array of aggregation stages to execute"),
@@ -23,6 +24,16 @@ export class AggregateTool extends MongoDBToolBase {
         pipeline,
     }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
         const provider = await this.ensureConnected();
+
+        // Check if aggregate operation uses an index if enabled
+        if (this.config.indexCheck) {
+            await checkIndexUsage(provider, database, collection, "aggregate", async () => {
+                return provider
+                    .aggregate(database, collection, pipeline, {}, { writeConcern: undefined })
+                    .explain("queryPlanner");
+            });
+        }
+
         const documents = await provider.aggregate(database, collection, pipeline).toArray();
 
         const content: Array<{ text: string; type: "text" }> = [

package/src/tools/mongodb/read/count.ts

@@ -2,6 +2,7 @@ import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 import { z } from "zod";
+import { checkIndexUsage } from "../../../helpers/indexCheck.js";
 
 export const CountArgs = {
     query: z
@@ -25,6 +26,20 @@ export class CountTool extends MongoDBToolBase {
 
     protected async execute({ database, collection, query }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
         const provider = await this.ensureConnected();
+
+        // Check if count operation uses an index if enabled
+        if (this.config.indexCheck) {
+            await checkIndexUsage(provider, database, collection, "count", async () => {
+                return provider.runCommandWithCheck(database, {
+                    explain: {
+                        count: collection,
+                        query,
+                    },
+                    verbosity: "queryPlanner",
+                });
+            });
+        }
+
         const count = await provider.count(database, collection, query);
 
         return {

package/src/tools/mongodb/read/find.ts

@@ -4,6 +4,7 @@ import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 import { SortDirection } from "mongodb";
 import { EJSON } from "bson";
+import { checkIndexUsage } from "../../../helpers/indexCheck.js";
 
 export const FindArgs = {
     filter: z
@@ -39,6 +40,14 @@ export class FindTool extends MongoDBToolBase {
         sort,
     }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
         const provider = await this.ensureConnected();
+
+        // Check if find operation uses an index if enabled
+        if (this.config.indexCheck) {
+            await checkIndexUsage(provider, database, collection, "find", async () => {
+                return provider.find(database, collection, filter, { projection, limit, sort }).explain("queryPlanner");
+            });
+        }
+
         const documents = await provider.find(database, collection, filter, { projection, limit, sort }).toArray();
 
         const content: Array<{ text: string; type: "text" }> = [

package/src/tools/mongodb/update/updateMany.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
+import { checkIndexUsage } from "../../../helpers/indexCheck.js";
 
 export class UpdateManyTool extends MongoDBToolBase {
     protected name = "update-many";
@@ -32,6 +33,27 @@ export class UpdateManyTool extends MongoDBToolBase {
         upsert,
     }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
         const provider = await this.ensureConnected();
+
+        // Check if update operation uses an index if enabled
+        if (this.config.indexCheck) {
+            await checkIndexUsage(provider, database, collection, "updateMany", async () => {
+                return provider.runCommandWithCheck(database, {
+                    explain: {
+                        update: collection,
+                        updates: [
+                            {
+                                q: filter || {},
+                                u: update,
+                                upsert: upsert || false,
+                                multi: true,
+                            },
+                        ],
+                    },
+                    verbosity: "queryPlanner",
+                });
+            });
+        }
+
         const result = await provider.updateMany(database, collection, filter, update, {
             upsert,
         });

package/src/tools/tool.ts

@@ -74,12 +74,12 @@ export abstract class ToolBase {
                 logger.debug(LogId.toolExecute, "tool", `Executing tool ${this.name}`);
 
                 const result = await this.execute(...args);
-                this.emitToolEvent(startTime, result, ...args);
+                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>);
-                this.emitToolEvent(startTime, toolResult, ...args);
+                await this.emitToolEvent(startTime, toolResult, ...args).catch(() => {});
                 return toolResult;
             }
         };
@@ -179,11 +179,11 @@ export abstract class ToolBase {
      * @param result - Whether the command succeeded or failed
      * @param args - The arguments passed to the tool
      */
-    private emitToolEvent(
+    private async emitToolEvent(
         startTime: number,
         result: CallToolResult,
         ...args: Parameters<ToolCallback<typeof this.argsShape>>
-    ): void {
+    ): Promise<void> {
         if (!this.telemetry.isTelemetryEnabled()) {
             return;
         }
@@ -209,6 +209,6 @@ export abstract class ToolBase {
             event.properties.project_id = metadata.projectId;
         }
 
-        this.telemetry.emitEvents([event]);
+        await this.telemetry.emitEvents([event]);
     }
 }