chore: allow logging unredacted messages

Author: nirinchev

src/common/atlas/accessListUtils.ts

@@ -30,25 +30,25 @@ export async function ensureCurrentIpInAccessList(apiClient: ApiClient, projectI
             params: { path: { groupId: projectId } },
             body: [entry],
         });
-        logger.debug(
-            LogId.atlasIpAccessListAdded,
-            "accessListUtils",
-            `IP access list created: ${JSON.stringify(entry)}`
-        );
+        logger.debug({
+            id: LogId.atlasIpAccessListAdded,
+            context: "accessListUtils",
+            message: `IP access list created: ${JSON.stringify(entry)}`,
+        });
     } catch (err) {
         if (err instanceof ApiClientError && err.response?.status === 409) {
             // 409 Conflict: entry already exists, log info
-            logger.debug(
-                LogId.atlasIpAccessListAdded,
-                "accessListUtils",
-                `IP address ${entry.ipAddress} is already present in the access list for project ${projectId}.`
-            );
+            logger.debug({
+                id: LogId.atlasIpAccessListAdded,
+                context: "accessListUtils",
+                message: `IP address ${entry.ipAddress} is already present in the access list for project ${projectId}.`,
+            });
             return;
         }
-        logger.warning(
-            LogId.atlasIpAccessListAddFailure,
-            "accessListUtils",
-            `Error adding IP access list: ${err instanceof Error ? err.message : String(err)}`
-        );
+        logger.warning({
+            id: LogId.atlasIpAccessListAddFailure,
+            context: "accessListUtils",
+            message: `Error adding IP access list: ${err instanceof Error ? err.message : String(err)}`,
+        });
     }
 }

src/common/atlas/apiClient.ts

@@ -179,7 +179,11 @@ export class ApiClient {
                 };
             } catch (error: unknown) {
                 const err = error instanceof Error ? error : new Error(String(error));
-                logger.error(LogId.atlasConnectFailure, "apiClient", `Failed to request access token: ${err.message}`);
+                logger.error({
+                    id: LogId.atlasConnectFailure,
+                    context: "apiClient",
+                    message: `Failed to request access token: ${err.message}`,
+                });
             }
             return this.accessToken;
         }
@@ -197,7 +201,11 @@ export class ApiClient {
             }
         } catch (error: unknown) {
             const err = error instanceof Error ? error : new Error(String(error));
-            logger.error(LogId.atlasApiRevokeFailure, "apiClient", `Failed to revoke access token: ${err.message}`);
+            logger.error({
+                id: LogId.atlasApiRevokeFailure,
+                context: "apiClient",
+                message: `Failed to revoke access token: ${err.message}`,
+            });
         }
         this.accessToken = undefined;
     }

src/common/atlas/cluster.ts

@@ -87,7 +87,11 @@ export async function inspectCluster(apiClient: ApiClient, projectId: string, cl
             return formatFlexCluster(cluster);
         } catch (flexError) {
             const err = flexError instanceof Error ? flexError : new Error(String(flexError));
-            logger.error(LogId.atlasInspectFailure, "inspect-cluster", `error inspecting cluster: ${err.message}`);
+            logger.error({
+                id: LogId.atlasInspectFailure,
+                context: "inspect-cluster",
+                message: `error inspecting cluster: ${err.message}`,
+            });
             throw error;
         }
     }

src/common/logger.ts

@@ -50,44 +50,95 @@ export const LogId = {
     streamableHttpTransportCloseFailure: mongoLogId(1_006_006),
 } as const;
 
+interface LogPayload {
+    id: MongoLogId;
+    context: string;
+    message: string;
+    noRedaction?: boolean | LoggerType | LoggerType[];
+}
+
+export type LoggerType = "console" | "disk" | "mcp";
+
 export abstract class LoggerBase {
-    abstract log(level: LogLevel, id: MongoLogId, context: string, message: string): void;
+    abstract log(level: LogLevel, payload: Omit<LogPayload, "noRedaction">): void;
+
+    abstract type: LoggerType | null;
+
+    private logCore(level: LogLevel, payload: LogPayload) {
+        // Default to not redacting mcp logs, redact everything else
+        const noRedaction = payload.noRedaction !== undefined ? payload.noRedaction : "mcp";
+
+        this.log(level, {
+            id: payload.id,
+            context: payload.context,
+            message: this.redactIfNecessary(payload.message, noRedaction),
+        });
+    }
+
+    private redactIfNecessary(message: string, noRedaction: LogPayload["noRedaction"]): string {
+        if (typeof noRedaction === "boolean" && noRedaction) {
+            // If the consumer has supplied noRedaction: true, we don't redact the log message
+            // regardless of the logger type
+            return message;
+        }
 
-    info(id: MongoLogId, context: string, message: string): void {
-        this.log("info", id, context, message);
+        if (typeof noRedaction === "string" && noRedaction === this.type) {
+            // If the consumer has supplied noRedaction: logger-type, we skip redacting if
+            // our logger type is the same as what the consumer requested
+            return message;
+        }
+
+        if (
+            typeof noRedaction === "object" &&
+            Array.isArray(noRedaction) &&
+            this.type !== null &&
+            noRedaction.indexOf(this.type) !== -1
+        ) {
+            // If the consumer has supplied noRedaction: array, we skip redacting if our logger
+            // type is included in that array
+            return message;
+        }
+
+        return redact(message);
+    }
+
+    info(payload: LogPayload): void {
+        this.log("info", payload);
     }
 
-    error(id: MongoLogId, context: string, message: string): void {
-        this.log("error", id, context, message);
+    error(payload: LogPayload): void {
+        this.log("error", payload);
     }
-    debug(id: MongoLogId, context: string, message: string): void {
-        this.log("debug", id, context, message);
+    debug(payload: LogPayload): void {
+        this.log("debug", payload);
     }
 
-    notice(id: MongoLogId, context: string, message: string): void {
-        this.log("notice", id, context, message);
+    notice(payload: LogPayload): void {
+        this.log("notice", payload);
     }
 
-    warning(id: MongoLogId, context: string, message: string): void {
-        this.log("warning", id, context, message);
+    warning(payload: LogPayload): void {
+        this.log("warning", payload);
     }
 
-    critical(id: MongoLogId, context: string, message: string): void {
-        this.log("critical", id, context, message);
+    critical(payload: LogPayload): void {
+        this.log("critical", payload);
     }
 
-    alert(id: MongoLogId, context: string, message: string): void {
-        this.log("alert", id, context, message);
+    alert(payload: LogPayload): void {
+        this.log("alert", payload);
     }
 
-    emergency(id: MongoLogId, context: string, message: string): void {
-        this.log("emergency", id, context, message);
+    emergency(payload: LogPayload): void {
+        this.log("emergency", payload);
     }
 }
 
 export class ConsoleLogger extends LoggerBase {
-    log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
-        message = redact(message);
+    type: LoggerType = "console";
+
+    log(level: LogLevel, payload: LogPayload): void {
+        const { id, context, message } = payload;
         console.error(`[${level.toUpperCase()}] ${id.__value} - ${context}: ${message} (${process.pid})`);
     }
 }
@@ -97,6 +148,8 @@ export class DiskLogger extends LoggerBase {
         super();
     }
 
+    type: LoggerType = "disk";
+
     static async fromPath(logPath: string): Promise<DiskLogger> {
         await fs.mkdir(logPath, { recursive: true });
 
@@ -116,8 +169,8 @@ export class DiskLogger extends LoggerBase {
         return new DiskLogger(logWriter);
     }
 
-    log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
-        message = redact(message);
+    log(level: LogLevel, payload: LogPayload): void {
+        const { id, context, message } = payload;
         const mongoDBLevel = this.mapToMongoDBLogLevel(level);
 
         this.logWriter[mongoDBLevel]("MONGODB-MCP", id, context, message);
@@ -149,20 +202,24 @@ export class McpLogger extends LoggerBase {
         super();
     }
 
-    log(level: LogLevel, _: MongoLogId, context: string, message: string): void {
+    type: LoggerType = "mcp";
+
+    log(level: LogLevel, payload: LogPayload): void {
         // Only log if the server is connected
         if (!this.server?.isConnected()) {
             return;
         }
 
         void this.server.server.sendLoggingMessage({
             level,
-            data: `[${context}]: ${message}`,
+            data: `[${payload.context}]: ${payload.message}`,
         });
     }
 }
 
 class CompositeLogger extends LoggerBase {
+    type: LoggerType | null = null;
+
     private loggers: LoggerBase[] = [];
 
     constructor(...loggers: LoggerBase[]) {
@@ -178,9 +235,9 @@ class CompositeLogger extends LoggerBase {
         this.loggers = [...loggers];
     }
 
-    log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
+    log(level: LogLevel, payload: LogPayload): void {
         for (const logger of this.loggers) {
-            logger.log(level, id, context, message);
+            logger.log(level, payload);
         }
     }
 }

src/common/session.ts

@@ -67,7 +67,11 @@ export class Session extends EventEmitter<SessionEvents> {
                 await this.serviceProvider.close(true);
             } catch (err: unknown) {
                 const error = err instanceof Error ? err : new Error(String(err));
-                logger.error(LogId.mongodbDisconnectFailure, "Error closing service provider:", error.message);
+                logger.error({
+                    id: LogId.mongodbDisconnectFailure,
+                    context: "session",
+                    message: `Error closing service provider: ${error.message}`,
+                });
             }
             this.serviceProvider = undefined;
         }
@@ -84,11 +88,11 @@ export class Session extends EventEmitter<SessionEvents> {
                 })
                 .catch((err: unknown) => {
                     const error = err instanceof Error ? err : new Error(String(err));
-                    logger.error(
-                        LogId.atlasDeleteDatabaseUserFailure,
-                        "atlas-connect-cluster",
-                        `Error deleting previous database user: ${error.message}`
-                    );
+                    logger.error({
+                        id: LogId.atlasDeleteDatabaseUserFailure,
+                        context: "session",
+                        message: `Error deleting previous database user: ${error.message}`,
+                    });
                 });
             this.connectedAtlasCluster = undefined;
         }

src/common/sessionStore.ts

@@ -47,18 +47,18 @@ export class SessionStore {
     private sendNotification(sessionId: string): void {
         const session = this.sessions[sessionId];
         if (!session) {
-            logger.warning(
-                LogId.streamableHttpTransportSessionCloseNotificationFailure,
-                "sessionStore",
-                `session ${sessionId} not found, no notification delivered`
-            );
+            logger.warning({
+                id: LogId.streamableHttpTransportSessionCloseNotificationFailure,
+                context: "sessionStore",
+                message: `session ${sessionId} not found, no notification delivered`,
+            });
             return;
         }
-        session.logger.info(
-            LogId.streamableHttpTransportSessionCloseNotification,
-            "sessionStore",
-            "Session is about to be closed due to inactivity"
-        );
+        session.logger.info({
+            id: LogId.streamableHttpTransportSessionCloseNotification,
+            context: "sessionStore",
+            message: "Session is about to be closed due to inactivity",
+        });
     }
 
     setSession(sessionId: string, transport: StreamableHTTPServerTransport, mcpServer: McpServer): void {
@@ -68,11 +68,11 @@ export class SessionStore {
         }
         const abortTimeout = setManagedTimeout(async () => {
             if (this.sessions[sessionId]) {
-                this.sessions[sessionId].logger.info(
-                    LogId.streamableHttpTransportSessionCloseNotification,
-                    "sessionStore",
-                    "Session closed due to inactivity"
-                );
+                this.sessions[sessionId].logger.info({
+                    id: LogId.streamableHttpTransportSessionCloseNotification,
+                    context: "sessionStore",
+                    message: "Session closed due to inactivity",
+                });
 
                 await this.closeSession(sessionId);
             }
@@ -95,11 +95,11 @@ export class SessionStore {
             try {
                 await session.transport.close();
             } catch (error) {
-                logger.error(
-                    LogId.streamableHttpTransportSessionCloseFailure,
-                    "streamableHttpTransport",
-                    `Error closing transport ${sessionId}: ${error instanceof Error ? error.message : String(error)}`
-                );
+                logger.error({
+                    id: LogId.streamableHttpTransportSessionCloseFailure,
+                    context: "streamableHttpTransport",
+                    message: `Error closing transport ${sessionId}: ${error instanceof Error ? error.message : String(error)}`,
+                });
             }
         }
         delete this.sessions[sessionId];