provide a better hint when the connection string is misconfigured

nirinchev · nirinchev · commit 8f1d6baecc4a · 2025-04-25T01:51:20.000+02:00
diff --git a/src/common/atlas/apiClient.ts b/src/common/atlas/apiClient.ts
@@ -4,8 +4,7 @@ import { AccessToken, ClientCredentials } from "simple-oauth2";
 import { ApiClientError } from "./apiClientError.js";
 import { paths, operations } from "./openapi.js";
 import { BaseEvent } from "../../telemetry/types.js";
-import { mongoLogId } from "mongodb-log-writer";
-import logger from "../../logger.js";
+import logger, { LogId } from "../../logger.js";
 import { packageInfo } from "../../packageInfo.js";
 
 const ATLAS_API_VERSION = "2025-03-12";
@@ -99,7 +98,7 @@ export class ApiClient {
 
     public hasCredentials(): boolean {
         logger.info(
-            mongoLogId(1_000_000),
+            LogId.atlasCheckCredentials,
             "api-client",
             `Checking if API client has credentials: ${!!(this.oauth2Client && this.accessToken)}`
         );
diff --git a/src/errors.ts b/src/errors.ts
@@ -1,6 +1,6 @@
 export enum ErrorCodes {
     NotConnectedToMongoDB = 1_000_000,
-    InvalidParams = 1_000_001,
+    MisconfiguredConnectionString = 1_000_001,
 }
 
 export class MongoDBError extends Error {
diff --git a/src/index.ts b/src/index.ts
@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import logger from "./logger.js";
-import { mongoLogId } from "mongodb-log-writer";
+import logger, { LogId } from "./logger.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { config } from "./config.js";
 import { Session } from "./session.js";
@@ -29,6 +28,6 @@ try {
 
     await server.connect(transport);
 } catch (error: unknown) {
-    logger.emergency(mongoLogId(1_000_004), "server", `Fatal error running server: ${error as string}`);
+    logger.emergency(LogId.serverStartFailure, "server", `Fatal error running server: ${error as string}`);
     process.exit(1);
 }
diff --git a/src/logger.ts b/src/logger.ts
@@ -1,11 +1,29 @@
 import fs from "fs/promises";
-import { MongoLogId, MongoLogManager, MongoLogWriter } from "mongodb-log-writer";
+import { mongoLogId, MongoLogId, MongoLogManager, MongoLogWriter } from "mongodb-log-writer";
 import redact from "mongodb-redact";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { LoggingMessageNotification } from "@modelcontextprotocol/sdk/types.js";
 
 export type LogLevel = LoggingMessageNotification["params"]["level"];
 
+export const LogId = {
+    serverStartFailure: mongoLogId(1_000_001),
+    serverInitialized: mongoLogId(1_000_002),
+
+    atlasCheckCredentials: mongoLogId(1_001_001),
+
+    telemetryDisabled: mongoLogId(1_002_001),
+    telemetryEmitFailure: mongoLogId(1_002_002),
+    telemetryEmitStart: mongoLogId(1_002_003),
+    telemetryEmitSuccess: mongoLogId(1_002_004),
+
+    toolExecute: mongoLogId(1_003_001),
+    toolExecuteFailure: mongoLogId(1_003_002),
+    toolDisabled: mongoLogId(1_003_003),
+
+    mongodbConnectFailure: mongoLogId(1_004_001),
+} as const;
+
 abstract class LoggerBase {
     abstract log(level: LogLevel, id: MongoLogId, context: string, message: string): void;
     info(id: MongoLogId, context: string, message: string): void {
diff --git a/src/server.ts b/src/server.ts
@@ -3,8 +3,7 @@ import { Session } from "./session.js";
 import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { AtlasTools } from "./tools/atlas/tools.js";
 import { MongoDbTools } from "./tools/mongodb/tools.js";
-import logger, { initializeLogger } from "./logger.js";
-import { mongoLogId } from "mongodb-log-writer";
+import logger, { initializeLogger, LogId } from "./logger.js";
 import { ObjectId } from "mongodb";
 import { Telemetry } from "./telemetry/telemetry.js";
 import { UserConfig } from "./config.js";
@@ -67,7 +66,7 @@ export class Server {
             this.session.sessionId = new ObjectId().toString();
 
             logger.info(
-                mongoLogId(1_000_004),
+                LogId.serverInitialized,
                 "server",
                 `Server started with transport ${transport.constructor.name} and agent runner ${this.session.agentRunner?.name}`
             );
diff --git a/src/telemetry/telemetry.ts b/src/telemetry/telemetry.ts
@@ -1,8 +1,7 @@
 import { Session } from "../session.js";
 import { BaseEvent } from "./types.js";
 import { config } from "../config.js";
-import logger from "../logger.js";
-import { mongoLogId } from "mongodb-log-writer";
+import logger, { LogId } from "../logger.js";
 import { ApiClient } from "../common/atlas/apiClient.js";
 import { MACHINE_METADATA } from "./constants.js";
 import { EventCache } from "./eventCache.js";
@@ -69,13 +68,13 @@ export class Telemetry {
     public async emitEvents(events: BaseEvent[]): Promise<void> {
         try {
             if (!Telemetry.isTelemetryEnabled()) {
-                logger.debug(mongoLogId(1_000_000), "telemetry", "Telemetry is disabled, skipping events.");
+                logger.debug(LogId.telemetryDisabled, "telemetry", "Telemetry is disabled, skipping events.");
                 return;
             }
 
             await this.emit(events);
         } catch {
-            logger.debug(mongoLogId(1_000_002), "telemetry", `Error emitting telemetry events.`);
+            logger.debug(LogId.telemetryEmitFailure, "telemetry", `Error emitting telemetry events.`);
         }
     }
 
@@ -101,20 +100,20 @@ export class Telemetry {
         const allEvents = [...cachedEvents, ...events];
 
         logger.debug(
-            mongoLogId(1_000_003),
+            LogId.telemetryEmitStart,
             "telemetry",
             `Attempting to send ${allEvents.length} events (${cachedEvents.length} cached)`
         );
 
         const result = await this.sendEvents(this.session.apiClient, allEvents);
         if (result.success) {
             this.eventCache.clearEvents();
-            logger.debug(mongoLogId(1_000_004), "telemetry", `Sent ${allEvents.length} events successfully`);
+            logger.debug(LogId.telemetryEmitSuccess, "telemetry", `Sent ${allEvents.length} events successfully`);
             return;
         }
 
-        logger.warning(
-            mongoLogId(1_000_005),
+        logger.debug(
+            LogId.telemetryEmitFailure,
             "telemetry",
             `Error sending event to client: ${result.error instanceof Error ? result.error.message : String(result.error)}`
         );
diff --git a/src/tools/mongodb/mongodbTool.ts b/src/tools/mongodb/mongodbTool.ts
@@ -3,6 +3,7 @@ import { ToolArgs, ToolBase, ToolCategory } from "../tool.js";
 import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { ErrorCodes, MongoDBError } from "../../errors.js";
+import logger, { LogId } from "../../logger.js";
 
 export const DbOperationArgs = {
     database: z.string().describe("Database name"),
@@ -14,7 +15,16 @@ export abstract class MongoDBToolBase extends ToolBase {
 
     protected async ensureConnected(): Promise<NodeDriverServiceProvider> {
         if (!this.session.serviceProvider && this.config.connectionString) {
-            await this.connectToMongoDB(this.config.connectionString);
+            try {
+                await this.connectToMongoDB(this.config.connectionString);
+            } catch (error) {
+                logger.error(
+                    LogId.mongodbConnectFailure,
+                    "mongodbTool",
+                    `Failed to connect to MongoDB instance using the connection string from the config: ${error as string}`
+                );
+                throw new MongoDBError(ErrorCodes.MisconfiguredConnectionString, "Not connected to MongoDB.");
+            }
         }
 
         if (!this.session.serviceProvider) {
@@ -28,20 +38,33 @@ export abstract class MongoDBToolBase extends ToolBase {
         error: unknown,
         args: ToolArgs<typeof this.argsShape>
     ): Promise<CallToolResult> | CallToolResult {
-        if (error instanceof MongoDBError && error.code === ErrorCodes.NotConnectedToMongoDB) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "You need to connect to a MongoDB instance before you can access its data.",
-                    },
-                    {
-                        type: "text",
-                        text: "Please use the 'connect' tool to connect to a MongoDB instance.",
-                    },
-                ],
-                isError: true,
-            };
+        if (error instanceof MongoDBError) {
+            switch (error.code) {
+                case ErrorCodes.NotConnectedToMongoDB:
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "You need to connect to a MongoDB instance before you can access its data.",
+                            },
+                            {
+                                type: "text",
+                                text: "Please use the 'connect' or 'switch-connection' tool to connect to a MongoDB instance.",
+                            },
+                        ],
+                        isError: true,
+                    };
+                case ErrorCodes.MisconfiguredConnectionString:
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "The configured connection string is not valid. Please check the connection string and confirm it points to a valid MongoDB instance. Alternatively, use the 'switch-connection' tool to connect to a different instance.",
+                            },
+                        ],
+                        isError: true,
+                    };
+            }
         }
 
         return super.handleError(error, args);
diff --git a/src/tools/tool.ts b/src/tools/tool.ts
@@ -2,8 +2,7 @@ import { z, type ZodRawShape, type ZodNever, AnyZodObject } from "zod";
 import type { McpServer, RegisteredTool, ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { Session } from "../session.js";
-import logger from "../logger.js";
-import { mongoLogId } from "mongodb-log-writer";
+import logger, { LogId } from "../logger.js";
 import { Telemetry } from "../telemetry/telemetry.js";
 import { type ToolEvent } from "../telemetry/types.js";
 import { UserConfig } from "../config.js";
@@ -63,17 +62,13 @@ export abstract class ToolBase {
         const callback: ToolCallback<typeof this.argsShape> = async (...args) => {
             const startTime = Date.now();
             try {
-                logger.debug(
-                    mongoLogId(1_000_006),
-                    "tool",
-                    `Executing ${this.name} with args: ${JSON.stringify(args)}`
-                );
+                logger.debug(LogId.toolExecute, "tool", `Executing ${this.name} with args: ${JSON.stringify(args)}`);
 
                 const result = await this.execute(...args);
                 await this.emitToolEvent(startTime, result);
                 return result;
             } catch (error: unknown) {
-                logger.error(mongoLogId(1_000_000), "tool", `Error executing ${this.name}: ${error as string}`);
+                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(() => {});
                 return toolResult;
@@ -124,7 +119,7 @@ export abstract class ToolBase {
 
         if (errorClarification) {
             logger.debug(
-                mongoLogId(1_000_010),
+                LogId.toolDisabled,
                 "tool",
                 `Prevented registration of ${this.name} because ${errorClarification} is disabled in the config`
             );

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`export enum ErrorCodes {`
`2`	`2`	`NotConnectedToMongoDB = 1_000_000,`
`3`		`- InvalidParams = 1_000_001,`
	`3`	`+ MisconfiguredConnectionString = 1_000_001,`
`4`	`4`	`}`
`5`	`5`
`6`	`6`	`export class MongoDBError extends Error {`