feat: update connectionString appName param - [MCP-68]

src/common/connectionManager.ts

@@ -6,6 +6,8 @@ import { packageInfo } from "./packageInfo.js";
 import ConnectionString from "mongodb-connection-string-url";
 import { MongoClientOptions } from "mongodb";
 import { ErrorCodes, MongoDBError } from "./errors.js";
+import { DeviceIdService } from "../helpers/deviceId.js";
+import { AppNameComponents } from "../helpers/connectionOptions.js";
 
 export interface AtlasClusterConnectionInfo {
     username: string;
@@ -67,11 +69,19 @@ export interface ConnectionManagerEvents {
 
 export class ConnectionManager extends EventEmitter<ConnectionManagerEvents> {
     private state: AnyConnectionState;
+    private deviceId: DeviceIdService;
+    private clientName: string;
 
     constructor() {
         super();
 
         this.state = { tag: "disconnected" };
+        this.deviceId = DeviceIdService.getInstance();
+        this.clientName = "unknown";
+    }
+
+    setClientName(clientName: string): void {
+        this.clientName = clientName;
     }
 
     async connect(settings: ConnectionSettings): Promise<AnyConnectionState> {
@@ -84,9 +94,15 @@ export class ConnectionManager extends EventEmitter<ConnectionManagerEvents> {
         let serviceProvider: NodeDriverServiceProvider;
         try {
             settings = { ...settings };
-            settings.connectionString = setAppNameParamIfMissing({
+            const appNameComponents: AppNameComponents = {
+                appName: `${packageInfo.mcpServerName} ${packageInfo.version}`,
+                deviceId: this.deviceId.getDeviceId(),
+                clientName: this.clientName,
+            };
+
+            settings.connectionString = await setAppNameParamIfMissing({
                 connectionString: settings.connectionString,
-                defaultAppName: `${packageInfo.mcpServerName} ${packageInfo.version}`,
+                components: appNameComponents,
             });
 
             serviceProvider = await NodeDriverServiceProvider.connect(settings.connectionString, {

src/common/logger.ts

@@ -14,6 +14,7 @@ export const LogId = {
     serverClosed: mongoLogId(1_000_004),
     serverCloseFailure: mongoLogId(1_000_005),
     serverDuplicateLoggers: mongoLogId(1_000_006),
+    serverMcpClientSet: mongoLogId(1_000_007),
 
     atlasCheckCredentials: mongoLogId(1_001_001),
     atlasDeleteDatabaseUserFailure: mongoLogId(1_001_002),
@@ -30,8 +31,8 @@ export const LogId = {
     telemetryEmitStart: mongoLogId(1_002_003),
     telemetryEmitSuccess: mongoLogId(1_002_004),
     telemetryMetadataError: mongoLogId(1_002_005),
-    telemetryDeviceIdFailure: mongoLogId(1_002_006),
-    telemetryDeviceIdTimeout: mongoLogId(1_002_007),
+    deviceIdResolutionError: mongoLogId(1_002_006),
+    deviceIdTimeout: mongoLogId(1_002_007),
 
     toolExecute: mongoLogId(1_003_001),
     toolExecuteFailure: mongoLogId(1_003_002),

src/common/session.ts

@@ -34,9 +34,10 @@ export class Session extends EventEmitter<SessionEvents> {
     readonly exportsManager: ExportsManager;
     readonly connectionManager: ConnectionManager;
     readonly apiClient: ApiClient;
-    agentRunner?: {
-        name: string;
-        version: string;
+    mcpClient?: {
+        name?: string;
+        version?: string;
+        title?: string;
     };
 
     public logger: CompositeLogger;
@@ -69,13 +70,24 @@ export class Session extends EventEmitter<SessionEvents> {
         this.connectionManager.on("connection-errored", (error) => this.emit("connection-error", error.errorReason));
     }
 
-    setAgentRunner(agentRunner: Implementation | undefined): void {
-        if (agentRunner?.name && agentRunner?.version) {
-            this.agentRunner = {
-                name: agentRunner.name,
-                version: agentRunner.version,
-            };
+    setMcpClient(mcpClient: Implementation | undefined): void {
+        if (!mcpClient) {
+            this.connectionManager.setClientName("unknown");
+            this.logger.debug({
+                id: LogId.serverMcpClientSet,
+                context: "session",
+                message: "MCP client info not found",
+            });
         }
+
+        this.mcpClient = {
+            name: mcpClient?.name || "unknown",
+            version: mcpClient?.version || "unknown",
+            title: mcpClient?.title || "unknown",
+        };
+
+        // Set the client name on the connection manager for appName generation
+        this.connectionManager.setClientName(this.mcpClient.name || "unknown");
     }
 
     async disconnect(): Promise<void> {

src/helpers/connectionOptions.ts

@@ -1,20 +1,59 @@
 import { MongoClientOptions } from "mongodb";
 import ConnectionString from "mongodb-connection-string-url";
 
-export function setAppNameParamIfMissing({
+export interface AppNameComponents {
+    appName: string;
+    deviceId?: Promise<string>;
+    clientName?: string;
+}
+
+/**
+ * Sets the appName parameter with the extended format: appName--deviceId--clientName
+ * Only sets the appName if it's not already present in the connection string
+ * @param connectionString - The connection string to modify
+ * @param components - The components to build the appName from
+ * @returns The modified connection string
+ */
+export async function setAppNameParamIfMissing({
     connectionString,
-    defaultAppName,
+    components,
 }: {
     connectionString: string;
-    defaultAppName?: string;
-}): string {
+    components: AppNameComponents;
+}): Promise<string> {
     const connectionStringUrl = new ConnectionString(connectionString);
-
     const searchParams = connectionStringUrl.typedSearchParams<MongoClientOptions>();
 
-    if (!searchParams.has("appName") && defaultAppName !== undefined) {
-        searchParams.set("appName", defaultAppName);
+    // Only set appName if it's not already present
+    if (searchParams.has("appName")) {
+        return connectionStringUrl.toString();
     }
 
+    const appName = components.appName || "unknown";
+    const deviceId = components.deviceId ? await components.deviceId : "unknown";
+    const clientName = components.clientName || "unknown";
+
+    // Build the extended appName format: appName--deviceId--clientName
+    const extendedAppName = `${appName}--${deviceId}--${clientName}`;
+
+    searchParams.set("appName", extendedAppName);
+
     return connectionStringUrl.toString();
 }
+
+/**
+ * Validates the connection string
+ * @param connectionString - The connection string to validate
+ * @param looseValidation - Whether to allow loose validation
+ * @returns void
+ * @throws Error if the connection string is invalid
+ */
+export function validateConnectionString(connectionString: string, looseValidation: boolean): void {
+    try {
+        new ConnectionString(connectionString, { looseValidation });
+    } catch (error) {
+        throw new Error(
+            `Invalid connection string with error: ${error instanceof Error ? error.message : String(error)}`
+        );
+    }
+}

src/helpers/deviceId.ts

@@ -0,0 +1,170 @@
+import { getDeviceId } from "@mongodb-js/device-id";
+import nodeMachineId from "node-machine-id";
+import { LogId, LoggerBase } from "../common/logger.js";
+
+export const DEVICE_ID_TIMEOUT = 3000;
+
+/**
+ * Singleton class for managing device ID retrieval and caching.
+ * Starts device ID calculation early and is shared across all services.
+ */
+export class DeviceIdService {
+    private static instance: DeviceIdService | undefined = undefined;
+    private deviceId: string | undefined = undefined;
+    private deviceIdPromise: Promise<string> | undefined = undefined;
+    private abortController: AbortController | undefined = undefined;
+    private logger: LoggerBase;
+    private readonly getMachineId: () => Promise<string>;
+    private timeout: number;
+
+    private constructor(logger: LoggerBase, timeout: number) {
+        this.logger = logger;
+        this.timeout = timeout;
+        this.getMachineId = (): Promise<string> => nodeMachineId.machineId(true);
+        // Start device ID calculation immediately
+        this.startDeviceIdCalculation();
+    }
+
+    /**
+     * Initializes the DeviceIdService singleton with a logger.
+     * A separated init method is used to use a single instance of the logger.
+     * @param logger - The logger instance to use
+     * @returns The DeviceIdService instance
+     */
+    public static init(logger: LoggerBase, timeout?: number): DeviceIdService {
+        if (DeviceIdService.instance) {
+            return DeviceIdService.instance;
+        }
+        DeviceIdService.instance = new DeviceIdService(logger, timeout ?? DEVICE_ID_TIMEOUT);
+        return DeviceIdService.instance;
+    }
+
+    /**
+     * Checks if the DeviceIdService is initialized.
+     * @returns True if the DeviceIdService is initialized, false otherwise
+     */
+    public static isInitialized(): boolean {
+        return DeviceIdService.instance !== undefined;
+    }
+
+    /**
+     * Gets the singleton instance of DeviceIdService.
+     * @returns The DeviceIdService instance
+     */
+    public static getInstance(): DeviceIdService {
+        if (!DeviceIdService.instance) {
+            throw new Error("DeviceIdService not initialized");
+        }
+        return DeviceIdService.instance;
+    }
+
+    /**
+     * Starts the device ID calculation process.
+     * This method is called automatically in the constructor.
+     */
+    private startDeviceIdCalculation(): void {
+        if (this.deviceIdPromise) {
+            return;
+        }
+
+        this.abortController = new AbortController();
+        this.deviceIdPromise = this.calculateDeviceId();
+    }
+
+    /**
+     * Gets the device ID, waiting for the calculation to complete if necessary.
+     * @returns Promise that resolves to the device ID string
+     */
+    public async getDeviceId(): Promise<string> {
+        if (this.deviceId !== undefined) {
+            return this.deviceId;
+        }
+
+        if (!this.deviceIdPromise) {
+            throw new Error("DeviceIdService calculation not started");
+        }
+
+        return this.deviceIdPromise;
+    }
+    /**
+     * Aborts any ongoing device ID calculation.
+     */
+    public close(): void {
+        if (this.abortController) {
+            this.abortController.abort();
+            this.abortController = undefined;
+        }
+        this.deviceId = undefined;
+        this.deviceIdPromise = undefined;
+        DeviceIdService.instance = undefined;
+    }
+
+    /**
+     * Internal method that performs the actual device ID calculation.
+     */
+    private async calculateDeviceId(): Promise<string> {
+        if (!this.abortController) {
+            throw new Error("Device ID calculation not started");
+        }
+
+        try {
+            const deviceId = await getDeviceId({
+                getMachineId: this.getMachineId,
+                onError: (reason, error) => {
+                    this.handleDeviceIdError(reason, String(error));
+                },
+                timeout: this.timeout,
+                abortSignal: this.abortController.signal,
+            });
+
+            // Cache the result
+            this.deviceId = deviceId;
+            return deviceId;
+        } catch (error) {
+            // Check if this was an abort error
+            if (error instanceof Error && error.name === "AbortError") {
+                throw error; // Re-throw abort errors
+            }
+
+            this.logger.debug({
+                id: LogId.deviceIdResolutionError,
+                context: "deviceId",
+                message: `Failed to get device ID: ${String(error)}`,
+            });
+
+            // Cache the fallback value
+            this.deviceId = "unknown";
+            return "unknown";
+        } finally {
+            this.abortController = undefined;
+        }
+    }
+
+    /**
+     * Handles device ID error.
+     * @param reason - The reason for the error
+     * @param error - The error object
+     */
+    private handleDeviceIdError(reason: string, error: string): void {
+        switch (reason) {
+            case "resolutionError":
+                this.logger.debug({
+                    id: LogId.deviceIdResolutionError,
+                    context: "deviceId",
+                    message: `Resolution error: ${String(error)}`,
+                });
+                break;
+            case "timeout":
+                this.logger.debug({
+                    id: LogId.deviceIdTimeout,
+                    context: "deviceId",
+                    message: "Device ID retrieval timed out",
+                    noRedaction: true,
+                });
+                break;
+            case "abort":
+                // No need to log in the case of aborts
+                break;
+        }
+    }
+}

src/index.ts

@@ -42,6 +42,7 @@ import { packageInfo } from "./common/packageInfo.js";
 import { StdioRunner } from "./transports/stdio.js";
 import { StreamableHttpRunner } from "./transports/streamableHttp.js";
 import { systemCA } from "@mongodb-js/devtools-proxy-support";
+import { DeviceIdService } from "./helpers/deviceId.js";
 
 async function main(): Promise<void> {
     systemCA().catch(() => undefined); // load system CA asynchronously as in mongosh
@@ -50,6 +51,7 @@ async function main(): Promise<void> {
     assertVersionMode();
 
     const transportRunner = config.transport === "stdio" ? new StdioRunner(config) : new StreamableHttpRunner(config);
+    const deviceId = DeviceIdService.init(transportRunner.logger);
 
     const shutdown = (): void => {
         transportRunner.logger.info({
@@ -61,6 +63,7 @@ async function main(): Promise<void> {
         transportRunner
             .close()
             .then(() => {
+                deviceId.close();
                 transportRunner.logger.info({
                     id: LogId.serverClosed,
                     context: "server",
@@ -69,6 +72,7 @@ async function main(): Promise<void> {
                 process.exit(0);
             })
             .catch((error: unknown) => {
+                deviceId.close();
                 transportRunner.logger.error({
                     id: LogId.serverCloseFailure,
                     context: "server",