fix

Author: gagik

package-lock.json

@@ -69,7 +69,7 @@
     "mongodb-log-writer": "^2.4.1",
     "mongodb-redact": "^1.1.6",
     "mongodb-schema": "^12.6.2",
-    "native-machine-id": "^0.1.0",
+    "node-machine-id": "1.1.12",
     "openapi-fetch": "^0.13.5",
     "simple-oauth2": "^5.1.0",
     "yargs-parser": "^21.1.1",

package.json

@@ -7,6 +7,7 @@ import { config } from "./config.js";
 import { Session } from "./session.js";
 import { Server } from "./server.js";
 import { packageInfo } from "./packageInfo.js";
+import { Telemetry } from "./telemetry/telemetry.js";
 
 try {
     const session = new Session({
@@ -19,9 +20,12 @@ try {
         version: packageInfo.version,
     });
 
+    const telemetry = Telemetry.create(session);
+
     const server = new Server({
         mcpServer,
         session,
+        telemetry,
         userConfig: config,
     });
 

src/index.ts

@@ -17,6 +17,7 @@ export const LogId = {
     telemetryEmitFailure: mongoLogId(1_002_002),
     telemetryEmitStart: mongoLogId(1_002_003),
     telemetryEmitSuccess: mongoLogId(1_002_004),
+    telemetryMachineIdFailure: mongoLogId(1_002_005),
 
     toolExecute: mongoLogId(1_003_001),
     toolExecuteFailure: mongoLogId(1_003_002),

src/logger.ts

@@ -16,6 +16,7 @@ export interface ServerOptions {
     session: Session;
     userConfig: UserConfig;
     mcpServer: McpServer;
+    telemetry: Telemetry;
 }
 
 export class Server {
@@ -25,10 +26,10 @@ export class Server {
     public readonly userConfig: UserConfig;
     private readonly startTime: number;
 
-    constructor({ session, mcpServer, userConfig }: ServerOptions) {
+    constructor({ session, mcpServer, userConfig, telemetry }: ServerOptions) {
         this.startTime = Date.now();
         this.session = session;
-        this.telemetry = new Telemetry(session);
+        this.telemetry = telemetry;
         this.mcpServer = mcpServer;
         this.userConfig = userConfig;
     }

src/server.ts

@@ -1,11 +1,9 @@
-import { getMachineIdSync } from "native-machine-id";
 import { packageInfo } from "../packageInfo.js";
 import { type CommonStaticProperties } from "./types.js";
 /**
  * Machine-specific metadata formatted for telemetry
  */
 export const MACHINE_METADATA: CommonStaticProperties = {
-    device_id: getMachineIdSync(),
     mcp_server_version: packageInfo.version,
     mcp_server_name: packageInfo.mcpServerName,
     platform: process.platform,

src/telemetry/constants.ts

@@ -1,5 +1,5 @@
-import { BaseEvent } from "./types.js";
 import { LRUCache } from "lru-cache";
+import { BaseEvent } from "./types.js";
 
 /**
  * Singleton class for in-memory telemetry event caching

src/telemetry/eventCache.ts

@@ -5,22 +5,85 @@ import logger, { LogId } from "../logger.js";
 import { ApiClient } from "../common/atlas/apiClient.js";
 import { MACHINE_METADATA } from "./constants.js";
 import { EventCache } from "./eventCache.js";
+import { createHmac } from "crypto";
+import { machineId } from "node-machine-id";
 
 type EventResult = {
     success: boolean;
     error?: Error;
 };
 
 export class Telemetry {
-    private readonly commonProperties: CommonProperties;
+    private isBufferingEvents: boolean = true;
+    private resolveDeviceId: (deviceId: string) => void = () => {};
 
-    constructor(
+    private constructor(
         private readonly session: Session,
-        private readonly eventCache: EventCache = EventCache.getInstance()
-    ) {
-        this.commonProperties = {
-            ...MACHINE_METADATA,
-        };
+        private readonly commonProperties: CommonProperties,
+        private readonly eventCache: EventCache
+    ) {}
+
+    static create(
+        session: Session,
+        commonProperties: CommonProperties = MACHINE_METADATA,
+        eventCache: EventCache = EventCache.getInstance()
+    ): Telemetry {
+        const instance = new Telemetry(session, commonProperties, eventCache);
+
+        void instance.start();
+        return instance;
+    }
+
+    private async start(): Promise<void> {
+        this.commonProperties.device_id = await this.getDeviceId();
+
+        this.isBufferingEvents = false;
+        await this.emitEvents(this.eventCache.getEvents());
+    }
+
+    public async close(): Promise<void> {
+        this.resolveDeviceId("unknown");
+        this.isBufferingEvents = false;
+        await this.emitEvents(this.eventCache.getEvents());
+    }
+
+    private async machineIdWithTimeout(): Promise<string> {
+        try {
+            return Promise.race<string>([
+                machineId(true),
+                new Promise<string>((resolve, reject) => {
+                    this.resolveDeviceId = resolve;
+                    setTimeout(() => {
+                        reject(new Error("Timeout getting machine ID"));
+                    }, 3000);
+                }),
+            ]);
+        } catch (error) {
+            logger.debug(LogId.telemetryMachineIdFailure, "telemetry", `Error getting machine ID: ${String(error)}`);
+            return "unknown";
+        }
+    }
+
+    /**
+     * @returns A hashed, unique identifier for the running device or `undefined` if not known.
+     */
+    private async getDeviceId(): Promise<string> {
+        if (this.commonProperties.device_id) {
+            return this.commonProperties.device_id;
+        }
+
+        // Create a hashed format from the all uppercase version of the machine ID
+        // to match it exactly with the denisbrodbeck/machineid library that Atlas CLI uses.
+
+        const originalId = (await this.machineIdWithTimeout()).toUpperCase();
+
+        const hmac = createHmac("sha256", originalId);
+
+        /** This matches the message used to create the hashes in Atlas CLI */
+        const DEVICE_ID_HASH_MESSAGE = "atlascli";
+
+        hmac.update(DEVICE_ID_HASH_MESSAGE);
+        return hmac.digest("hex");
     }
 
     /**
@@ -84,6 +147,11 @@ export class Telemetry {
      * Falls back to caching if both attempts fail
      */
     private async emit(events: BaseEvent[]): Promise<void> {
+        if (this.isBufferingEvents) {
+            this.eventCache.appendEvents(events);
+            return;
+        }
+
         const cachedEvents = this.eventCache.getEvents();
         const allEvents = [...cachedEvents, ...events];
 

src/telemetry/telemetry.ts

@@ -53,7 +53,6 @@ export type ServerEvent = TelemetryEvent<ServerEventProperties>;
  * Interface for static properties, they can be fetched once and reused.
  */
 export type CommonStaticProperties = {
-    device_id?: string;
     mcp_server_version: string;
     mcp_server_name: string;
     platform: string;

src/telemetry/types.ts

@@ -5,6 +5,7 @@ import { UserConfig } from "../../src/config.js";
 import { McpError } from "@modelcontextprotocol/sdk/types.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Session } from "../../src/session.js";
+import { Telemetry } from "../../src/telemetry/telemetry.js";
 
 interface ParameterInfo {
     name: string;
@@ -52,9 +53,13 @@ export function setupIntegrationTest(getUserConfig: () => UserConfig): Integrati
         });
 
         userConfig.telemetry = "disabled";
+
+        const telemetry = Telemetry.create(session);
+
         mcpServer = new Server({
             session,
             userConfig,
+            telemetry,
             mcpServer: new McpServer({
                 name: "test-server",
                 version: "1.2.3",