chore: [MCP-2] add is_container_env to telemetry

src/telemetry/telemetry.ts

@@ -7,55 +7,91 @@ import { MACHINE_METADATA } from "./constants.js";
 import { EventCache } from "./eventCache.js";
 import nodeMachineId from "node-machine-id";
 import { getDeviceId } from "@mongodb-js/device-id";
+import fs from "fs/promises";
+
+async function fileExists(filePath: string): Promise<boolean> {
+    try {
+        await fs.stat(filePath);
+        return true; // File exists
+    } catch (e: unknown) {
+        if (
+            e instanceof Error &&
+            (
+                e as Error & {
+                    code: string;
+                }
+            ).code === "ENOENT"
+        ) {
+            return false; // File does not exist
+        }
+        throw e; // Re-throw unexpected errors
+    }
+}
 
-type EventResult = {
-    success: boolean;
-    error?: Error;
-};
+async function isContainerized(): Promise<boolean> {
+    if (process.env.container) {
+        return true;
+    }
+
+    const exists = await Promise.all(["/.dockerenv", "/run/.containerenv", "/var/run/.containerenv"].map(fileExists));
 
-export const DEVICE_ID_TIMEOUT = 3000;
+    return exists.includes(true);
+}
 
 export class Telemetry {
-    private isBufferingEvents: boolean = true;
-    /** Resolves when the device ID is retrieved or timeout occurs */
-    public deviceIdPromise: Promise<string> | undefined;
+    private deviceIdPromise: Promise<string> | undefined;
+    private containerEnvPromise: Promise<boolean> | undefined;
     private deviceIdAbortController = new AbortController();
     private eventCache: EventCache;
     private getRawMachineId: () => Promise<string>;
+    private getContainerEnv: () => Promise<boolean>;
 
     private constructor(
         private readonly session: Session,
         private readonly userConfig: UserConfig,
-        private readonly commonProperties: CommonProperties,
-        { eventCache, getRawMachineId }: { eventCache: EventCache; getRawMachineId: () => Promise<string> }
+        {
+            eventCache,
+            getRawMachineId,
+            getContainerEnv,
+        }: {
+            eventCache: EventCache;
+            getRawMachineId: () => Promise<string>;
+            getContainerEnv: () => Promise<boolean>;
+        }
     ) {
         this.eventCache = eventCache;
         this.getRawMachineId = getRawMachineId;
+        this.getContainerEnv = getContainerEnv;
     }
 
     static create(
         session: Session,
         userConfig: UserConfig,
         {
-            commonProperties = { ...MACHINE_METADATA },
             eventCache = EventCache.getInstance(),
             getRawMachineId = () => nodeMachineId.machineId(true),
+            getContainerEnv = isContainerized,
         }: {
             eventCache?: EventCache;
             getRawMachineId?: () => Promise<string>;
-            commonProperties?: CommonProperties;
+            getContainerEnv?: () => Promise<boolean>;
         } = {}
     ): Telemetry {
-        const instance = new Telemetry(session, userConfig, commonProperties, { eventCache, getRawMachineId });
+        const instance = new Telemetry(session, userConfig, {
+            eventCache,
+            getRawMachineId,
+            getContainerEnv,
+        });
 
-        void instance.start();
+        instance.start();
         return instance;
     }
 
-    private async start(): Promise<void> {
+    private start(): void {
         if (!this.isTelemetryEnabled()) {
             return;
         }
+
         this.deviceIdPromise = getDeviceId({
             getMachineId: () => this.getRawMachineId(),
             onError: (reason, error) => {
@@ -73,15 +109,11 @@ export class Telemetry {
             },
             abortSignal: this.deviceIdAbortController.signal,
         });
-
-        this.commonProperties.device_id = await this.deviceIdPromise;
-
-        this.isBufferingEvents = false;
+        this.containerEnvPromise = this.getContainerEnv();
     }
 
     public async close(): Promise<void> {
         this.deviceIdAbortController.abort();
-        this.isBufferingEvents = false;
         await this.emitEvents(this.eventCache.getEvents());
     }
 
@@ -106,14 +138,16 @@ export class Telemetry {
      * Gets the common properties for events
      * @returns Object containing common properties for all events
      */
-    public getCommonProperties(): CommonProperties {
+    private async getCommonProperties(): Promise<CommonProperties> {
         return {
-            ...this.commonProperties,
+            ...MACHINE_METADATA,
             mcp_client_version: this.session.agentRunner?.version,
             mcp_client_name: this.session.agentRunner?.name,
             session_id: this.session.sessionId,
             config_atlas_auth: this.session.apiClient.hasCredentials() ? "true" : "false",
             config_connection_string: this.userConfig.connectionString ? "true" : "false",
+            is_container_env: (await this.containerEnvPromise) ? "true" : "false",
+            device_id: await this.deviceIdPromise,
         };
     }
 
@@ -139,11 +173,6 @@ 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];
 
@@ -153,42 +182,34 @@ export class Telemetry {
             `Attempting to send ${allEvents.length} events (${cachedEvents.length} cached)`
         );
 
-        const result = await this.sendEvents(this.session.apiClient, allEvents);
-        if (result.success) {
+        try {
+            await this.sendEvents(this.session.apiClient, allEvents);
             this.eventCache.clearEvents();
             logger.debug(
                 LogId.telemetryEmitSuccess,
                 "telemetry",
                 `Sent ${allEvents.length} events successfully: ${JSON.stringify(allEvents, null, 2)}`
             );
-            return;
+        } catch (error: unknown) {
+            logger.debug(
+                LogId.telemetryEmitFailure,
+                "telemetry",
+                `Error sending event to client: ${error instanceof Error ? error.message : String(error)}`
+            );
+            this.eventCache.appendEvents(events);
         }
-
-        logger.debug(
-            LogId.telemetryEmitFailure,
-            "telemetry",
-            `Error sending event to client: ${result.error instanceof Error ? result.error.message : String(result.error)}`
-        );
-        this.eventCache.appendEvents(events);
     }
 
     /**
      * Attempts to send events through the provided API client
      */
-    private async sendEvents(client: ApiClient, events: BaseEvent[]): Promise<EventResult> {
-        try {
-            await client.sendEvents(
-                events.map((event) => ({
-                    ...event,
-                    properties: { ...this.getCommonProperties(), ...event.properties },
-                }))
-            );
-            return { success: true };
-        } catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error : new Error(String(error)),
-            };
-        }
+    private async sendEvents(client: ApiClient, events: BaseEvent[]): Promise<void> {
+        const commonProperties = await this.getCommonProperties();
+        await client.sendEvents(
+            events.map((event) => ({
+                ...event,
+                properties: { ...commonProperties, ...event.properties },
+            }))
+        );
     }
 }

src/telemetry/types.ts

@@ -71,4 +71,5 @@ export type CommonProperties = {
     config_atlas_auth?: TelemetryBoolSet;
     config_connection_string?: TelemetryBoolSet;
     session_id?: string;
+    is_container_env?: TelemetryBoolSet;
 } & CommonStaticProperties;