feat: add logging

Author: nirinchev

package-lock.json

@@ -55,6 +55,8 @@
     "@types/express": "^5.0.1",
     "bson": "^6.10.3",
     "mongodb": "^6.15.0",
+    "mongodb-log-writer": "^2.4.1",
+    "mongodb-redact": "^1.1.6",
     "mongodb-schema": "^12.6.2",
     "zod": "^3.24.2"
   },

package.json

@@ -1,6 +1,7 @@
 import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
+import os from "os";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -15,6 +16,19 @@ export const config = {
     stateFile: process.env.STATE_FILE || path.resolve("./state.json"),
     projectID: process.env.PROJECT_ID,
     userAgent: `AtlasMCP/${packageJson.version} (${process.platform}; ${process.arch}; ${process.env.HOSTNAME || "unknown"})`,
+    localDataPath: getLocalDataPath(),
 };
 
 export default config;
+
+function getLocalDataPath() {
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA;
+        const localAppData = process.env.LOCALAPPDATA ?? process.env.APPDATA;
+        if (localAppData && appData) {
+            return path.join(localAppData, "mongodb", "mongodb-mcp");
+        }
+    }
+
+    return path.join(os.homedir(), ".mongodb", "mongodb-mcp");
+}

src/config.ts

@@ -1,5 +1,7 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { Server } from "./server.js";
+import log from "./logger.js";
+import { mongoLogId } from "mongodb-log-writer";
 
 async function runServer() {
     const server = new Server();
@@ -9,6 +11,7 @@ async function runServer() {
 }
 
 runServer().catch((error) => {
-    console.error(`Fatal error running server:`, error);
+    log.fatal(mongoLogId(1_000_004), "server", `Fatal error running server: ${error}`);
+
     process.exit(1);
 });

src/index.ts

@@ -1,4 +1,57 @@
-// TODO: use a proper logger here
-export function log(level: string, message: string) {
-    console.error(`[${level.toUpperCase()}] ${message}`);
+import { MongoLogId, MongoLogManager, MongoLogWriter } from "mongodb-log-writer";
+import path from "path";
+import config from "./config.js";
+import redact from "mongodb-redact";
+import fs from "fs/promises";
+
+let logWriter: MongoLogWriter | undefined = undefined;
+
+export async function initializeLogger(): Promise<void> {
+    const logDir = path.join(config.localDataPath, ".app-logs");
+    await fs.mkdir(logDir, { recursive: true });
+
+    const manager = new MongoLogManager({
+        directory: path.join(config.localDataPath, ".app-logs"),
+        retentionDays: 30,
+        onwarn: console.warn,
+        onerror: console.error,
+        gzip: false,
+        retentionGB: 1,
+    });
+
+    await manager.cleanupOldLogFiles();
+
+    logWriter = await manager.createLogWriter();
 }
+
+const log = {
+    log(level: "info" | "warn" | "error" | "debug" | "fatal", id: MongoLogId, context: string, message: string): void {
+        message = redact(message);
+        if (logWriter) {
+            logWriter[level]("MONGODB-MCP", id, context, message);
+        } else {
+            console.error(
+                `[${level.toUpperCase()}] Logger not initialized, dropping message: ${message}, context: ${context}, id: ${id}`
+            );
+        }
+    },
+
+    info(id: MongoLogId, context: string, message: string): void {
+        this.log("info", id, context, message);
+    },
+
+    warn(id: MongoLogId, context: string, message: string): void {
+        this.log("warn", id, context, message);
+    },
+    error(id: MongoLogId, context: string, message: string): void {
+        this.log("error", id, context, message);
+    },
+    debug(id: MongoLogId, context: string, message: string): void {
+        this.log("debug", id, context, message);
+    },
+    fatal(id: MongoLogId, context: string, message: string): void {
+        this.log("fatal", id, context, message);
+    },
+};
+
+export default log;

src/logger.ts

@@ -5,6 +5,8 @@ import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { registerAtlasTools } from "./tools/atlas/tools.js";
 import { registerMongoDBTools } from "./tools/mongodb/index.js";
 import { config } from "./config.js";
+import log, { initializeLogger } from "./logger.js";
+import { mongoLogId } from "mongodb-log-writer";
 
 export class Server {
     state: State | undefined = undefined;
@@ -30,6 +32,8 @@ export class Server {
             },
         });
 
+        await initializeLogger();
+
         this.initialized = true;
     }
 
@@ -49,5 +53,7 @@ export class Server {
         await this.init();
         const server = this.createMcpServer();
         await server.connect(transport);
+
+        log.info(mongoLogId(1_000_004), "server", `Server started with transport ${transport.constructor.name}`);
     }
 }

src/server.ts

@@ -11,8 +11,12 @@ export interface State {
 }
 
 export async function saveState(state: State): Promise<void> {
+    const stateCopy: State = {
+        auth: state.auth,
+    };
+
     return new Promise((resolve, reject) => {
-        fs.writeFile(config.stateFile, JSON.stringify(state), function (err) {
+        fs.writeFile(config.stateFile, JSON.stringify(stateCopy), function (err) {
             if (err) {
                 return reject(err);
             }

src/state.ts

@@ -1,8 +1,9 @@
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { log } from "../../logger.js";
 import { saveState } from "../../state.js";
 import { AtlasToolBase } from "./atlasTool.js";
 import { isAuthenticated } from "../../common/atlas/auth.js";
+import log from "../../logger.js";
+import { mongoLogId } from "mongodb-log-writer";
 
 export class AuthTool extends AtlasToolBase {
     protected name = "atlas-auth";
@@ -15,7 +16,7 @@ export class AuthTool extends AtlasToolBase {
 
     async execute(): Promise<CallToolResult> {
         if (await this.isAuthenticated()) {
-            log("INFO", "Already authenticated!");
+            log.debug(mongoLogId(1_000_001), "auth", "Already authenticated!");
             return {
                 content: [{ type: "text", text: "You are already authenticated!" }],
             };
@@ -40,13 +41,13 @@ export class AuthTool extends AtlasToolBase {
             };
         } catch (error: unknown) {
             if (error instanceof Error) {
-                log("error", `Authentication error: ${error}`);
+                log.error(mongoLogId(1_000_002), "auth", `Authentication error: ${error}`);
                 return {
                     content: [{ type: "text", text: `Authentication failed: ${error.message}` }],
                 };
             }
 
-            log("error", `Unknown authentication error: ${error}`);
+            log.error(mongoLogId(1_000_003), "auth", `Unknown authentication error: ${error}`);
             return {
                 content: [{ type: "text", text: "Authentication failed due to an unknown error." }],
             };

src/tools/atlas/auth.ts

@@ -1,8 +1,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z, ZodNever, ZodRawShape } from "zod";
-import { log } from "../logger.js";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { State } from "../state.js";
+import log from "../logger.js";
+import { mongoLogId } from "mongodb-log-writer";
 
 export type ToolArgs<Args extends ZodRawShape> = z.objectOutputType<Args, ZodNever>;
 
@@ -21,10 +22,11 @@ export abstract class ToolBase {
         const callback = async (args: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> => {
             try {
                 // TODO: add telemetry here
+                log.debug(mongoLogId(1_000_006), "tool", `Executing ${this.name} with args: ${JSON.stringify(args)}`);
 
                 return await this.execute(args);
             } catch (error) {
-                log("error", `Error executing ${this.name}: ${error}`);
+                log.error(mongoLogId(1_000_000), "tool", `Error executing ${this.name}: ${error}`);
 
                 // If the error is authentication related, suggest using auth tool
                 if (error instanceof Error && error.message.includes("Not authenticated")) {