Merge branch 'main' into gagik/eslint-type

Author: gagik

package-lock.json

@@ -49,7 +49,7 @@
     "jest-environment-node": "^29.7.0",
     "jest-extended": "^4.0.2",
     "mongodb-runner": "^5.8.2",
-    "native-machine-id": "^0.0.8",
+    "native-machine-id": "^0.1.0",
     "openapi-types": "^12.1.3",
     "openapi-typescript": "^7.6.1",
     "prettier": "^3.5.3",

package.json

@@ -31,6 +31,7 @@ const defaults: UserConfig = {
         timeoutMS: 30_000,
     },
     disabledTools: [],
+    telemetry: "disabled",
 };
 
 export const config = {

src/config.ts

@@ -8,6 +8,7 @@ export type LogLevel = LoggingMessageNotification["params"]["level"];
 
 abstract class LoggerBase {
     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 +48,35 @@ class ConsoleLogger extends LoggerBase {
     }
 }
 
-class Logger extends LoggerBase {
-    constructor(
-        private logWriter: MongoLogWriter,
-        private server: McpServer
-    ) {
+class DiskLogger extends LoggerBase {
+    private constructor(private logWriter: MongoLogWriter) {
         super();
     }
 
+    static async fromPath(logPath: string): Promise<DiskLogger> {
+        await fs.mkdir(logPath, { recursive: true });
+
+        const manager = new MongoLogManager({
+            directory: logPath,
+            retentionDays: 30,
+            onwarn: console.warn,
+            onerror: console.error,
+            gzip: false,
+            retentionGB: 1,
+        });
+
+        await manager.cleanupOldLogFiles();
+
+        const logWriter = await manager.createLogWriter();
+
+        return new DiskLogger(logWriter);
+    }
+
     log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
         message = redact(message);
         const mongoDBLevel = this.mapToMongoDBLogLevel(level);
+
         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 +100,56 @@ class Logger extends LoggerBase {
     }
 }
 
-class ProxyingLogger extends LoggerBase {
-    private internalLogger: LoggerBase = new ConsoleLogger();
+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}`,
+        });
+    }
+}
+
+class CompositeLogger extends LoggerBase {
+    private loggers: LoggerBase[];
+
+    constructor(...loggers: LoggerBase[]) {
+        super();
+
+        if (loggers.length === 0) {
+            // default to ConsoleLogger
+            this.loggers = [new ConsoleLogger()];
+            return;
+        }
+
+        this.loggers = [...loggers];
+    }
+
+    setLoggers(...loggers: LoggerBase[]): void {
+        if (loggers.length === 0) {
+            throw new Error("At least one logger must be provided");
+        }
+        this.loggers = [...loggers];
+    }
 
     log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
-        this.internalLogger.log(level, id, context, message);
+        for (const logger of this.loggers) {
+            logger.log(level, id, context, message);
+        }
     }
 }
 
-const logger = new ProxyingLogger();
+const logger = new CompositeLogger();
 export default logger;
 
-export async function initializeLogger(server: McpServer, logPath: string): Promise<void> {
-    await fs.mkdir(logPath, { recursive: true });
-
-    const manager = new MongoLogManager({
-        directory: logPath,
-        retentionDays: 30,
-        onwarn: console.warn,
-        onerror: console.error,
-        gzip: false,
-        retentionGB: 1,
-    });
+export async function initializeLogger(server: McpServer, logPath: string): Promise<LoggerBase> {
+    const diskLogger = await DiskLogger.fromPath(logPath);
+    const mcpLogger = new McpLogger(server);
 
-    await manager.cleanupOldLogFiles();
+    logger.setLoggers(mcpLogger, diskLogger);
 
-    const logWriter = await manager.createLogWriter();
-    logger["internalLogger"] = new Logger(logWriter, server);
+    return logger;
 }

src/logger.ts

@@ -13,7 +13,7 @@ type EventResult = {
 };
 
 type CommonProperties = {
-    device_id: string;
+    device_id?: string;
     mcp_server_version: string;
     mcp_server_name: string;
     mcp_client_version?: string;

src/telemetry/telemetry.ts

@@ -14,7 +14,7 @@ export interface Event {
 
 export interface BaseEvent extends Event {
     properties: {
-        device_id: string;
+        device_id?: string;
         mcp_server_version: string;
         mcp_server_name: string;
         mcp_client_version?: string;

src/telemetry/types.ts

@@ -13,6 +13,16 @@ export class ListProjectsTool extends AtlasToolBase {
     };
 
     protected async execute({ orgId }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
+        const orgData = await this.session.apiClient.listOrganizations();
+
+        if (!orgData?.results?.length) {
+            throw new Error("No organizations found in your MongoDB Atlas account.");
+        }
+
+        const orgs: Record<string, string> = orgData.results
+            .map((org) => [org.id || "", org.name])
+            .reduce((acc, [id, name]) => ({ ...acc, [id]: name }), {});
+
         const data = orgId
             ? await this.session.apiClient.listOrganizationProjects({
                   params: {
@@ -31,11 +41,11 @@ export class ListProjectsTool extends AtlasToolBase {
         const rows = data.results
             .map((project) => {
                 const createdAt = project.created ? new Date(project.created).toLocaleString() : "N/A";
-                return `${project.name} | ${project.id} | ${createdAt}`;
+                return `${project.name} | ${project.id} | ${orgs[project.orgId]} | ${project.orgId} | ${createdAt}`;
             })
             .join("\n");
-        const formattedProjects = `Project Name | Project ID | Created At
-----------------| ----------------| ----------------
+        const formattedProjects = `Project Name | Project ID | Organization Name | Organization ID | Created At
+----------------| ----------------| ----------------| ----------------| ----------------
 ${rows}`;
         return {
             content: [{ type: "text", text: formattedProjects }],