refactor: split loggers

Author: fmenezes

src/logger.ts

@@ -7,7 +7,12 @@ import { LoggingMessageNotification } from "@modelcontextprotocol/sdk/types.js";
 export type LogLevel = LoggingMessageNotification["params"]["level"];
 
 abstract class LoggerBase {
+    async initialize(): Promise<void> {
+        return Promise.resolve();
+    }
+
     abstract log(level: LogLevel, id: MongoLogId, context: string, message: string): void;
+
     info(id: MongoLogId, context: string, message: string): void {
         this.log("info", id, context, message);
     }
@@ -47,22 +52,41 @@ class ConsoleLogger extends LoggerBase {
     }
 }
 
-class Logger extends LoggerBase {
+class DiskLogger extends LoggerBase {
+    private logWriter?: MongoLogWriter;
+    
     constructor(
-        private logWriter: MongoLogWriter,
-        private server: McpServer
+        private logPath: string
     ) {
         super();
     }
 
+async initialize(): Promise<void> {
+    await fs.mkdir(this.logPath, { recursive: true });
+
+    const manager = new MongoLogManager({
+        directory: this.logPath,
+        retentionDays: 30,
+        onwarn: console.warn,
+        onerror: console.error,
+        gzip: false,
+        retentionGB: 1,
+    });
+
+    await manager.cleanupOldLogFiles();
+
+    this.logWriter = await manager.createLogWriter();
+}
+
     log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
         message = redact(message);
         const mongoDBLevel = this.mapToMongoDBLogLevel(level);
+        
+        if (!this.logWriter) {
+            throw new Error("DiskLogger is not initialized");
+        }
+        
         this.logWriter[mongoDBLevel]("MONGODB-MCP", id, context, message);
-        void this.server.server.sendLoggingMessage({
-            level,
-            data: `[${context}]: ${message}`,
-        });
     }
 
     private mapToMongoDBLogLevel(level: LogLevel): "info" | "warn" | "error" | "debug" | "fatal" {
@@ -86,31 +110,57 @@ class Logger extends LoggerBase {
     }
 }
 
-class ProxyingLogger extends LoggerBase {
-    private internalLogger: LoggerBase = new ConsoleLogger();
 
-    log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
-        this.internalLogger.log(level, id, context, message);
+class McpLogger extends LoggerBase {
+    constructor(
+        private server: McpServer
+    ) {
+        super();
+    }
+
+    log(level: LogLevel, _: MongoLogId, context: string, message: string): void {
+        void this.server.server.sendLoggingMessage({
+            level,
+            data: `[${context}]: ${message}`,
+        });
     }
 }
 
-const logger = new ProxyingLogger();
-export default logger;
+class CompositeLogger extends LoggerBase {
+    private loggers: LoggerBase[];
 
-export async function initializeLogger(server: McpServer, logPath: string): Promise<void> {
-    await fs.mkdir(logPath, { recursive: true });
+    constructor(...loggers: LoggerBase[]) {
+        super();
+        if (loggers.length === 0) { // default to ConsoleLogger
+            loggers.push(new ConsoleLogger());
+        }
+        this.loggers = [...loggers];
+    }
 
-    const manager = new MongoLogManager({
-        directory: logPath,
-        retentionDays: 30,
-        onwarn: console.warn,
-        onerror: console.error,
-        gzip: false,
-        retentionGB: 1,
-    });
+    async initialize(): Promise<void> {
+        for(const logger of this.loggers) {
+            await logger.initialize();
+        }
+    }
 
-    await manager.cleanupOldLogFiles();
+    setLoggers(...loggers: LoggerBase[]): void {
+        this.loggers = [...loggers];
+    }
+
+    log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
+        for(const logger of this.loggers) {
+            logger.log(level, id, context, message);
+        }
+    }
+}
 
-    const logWriter = await manager.createLogWriter();
-    logger["internalLogger"] = new Logger(logWriter, server);
+const logger = new CompositeLogger();
+export default logger;
+
+export async function initializeLogger(server: McpServer, logPath: string): Promise<void> {
+    logger.setLoggers(
+        new McpLogger(server),
+        new DiskLogger(logPath),
+    )
+    await logger.initialize();
 }