fix: tests

Author: fmenezes

src/index.ts

@@ -20,7 +20,7 @@ try {
         version: packageInfo.version,
     });
 
-    const telemetry = Telemetry.create({ session, userConfig: config });
+    const telemetry = Telemetry.create(session, config);
 
     const server = new Server({
         mcpServer,

src/logger.ts

@@ -25,6 +25,7 @@ export const LogId = {
     telemetryMetadataError: mongoLogId(1_002_005),
     telemetryDeviceIdFailure: mongoLogId(1_002_006),
     telemetryDeviceIdTimeout: mongoLogId(1_002_007),
+    telemetryContainerEnvFailure: mongoLogId(1_002_008),
 
     toolExecute: mongoLogId(1_003_001),
     toolExecuteFailure: mongoLogId(1_003_002),

src/telemetry/telemetry.ts

@@ -8,6 +8,7 @@ import { EventCache } from "./eventCache.js";
 import nodeMachineId from "node-machine-id";
 import { getDeviceId } from "@mongodb-js/device-id";
 import fs from "fs/promises";
+import { get } from "http";
 
 type EventResult = {
     success: boolean;
@@ -22,30 +23,74 @@ export type TelemetryOptions = {
     commonProperties?: CommonProperties;
     eventCache?: EventCache;
     getRawMachineId?: () => Promise<string>;
+    getContainerEnv?: () => Promise<boolean>;
 };
 
+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
+    }
+}
+
+async function isContainerized(): Promise<boolean> {
+    for (const file of ["/.dockerenv", "/run/.containerenv", "/var/run/.containerenv"]) {
+        const exists = await fileExists(file);
+        if (exists) {
+            return true;
+        }
+    }
+    return !!process.env.container;
+}
+
 export class Telemetry {
     private isBufferingEvents: boolean = true;
     /** Resolves when the device ID is retrieved or timeout occurs */
     public deviceIdPromise: Promise<string> | 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,
-        private readonly eventCache: EventCache,
-        private readonly getRawMachineId: () => Promise<string>
-    ) {}
-
-    static create({ session, userConfig, commonProperties, eventCache, getRawMachineId }: TelemetryOptions): Telemetry {
-        const instance = new Telemetry(
-            session,
-            userConfig,
-            commonProperties || { ...MACHINE_METADATA },
-            eventCache || EventCache.getInstance(),
-            getRawMachineId || (() => nodeMachineId.machineId(true))
-        );
+        { 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,
+        }: {
+            commonProperties?: CommonProperties;
+            eventCache?: EventCache;
+            getRawMachineId?: () => Promise<string>;
+            getContainerEnv?: () => Promise<boolean>;
+        } = {}
+    ): Telemetry {
+        const instance = new Telemetry(session, userConfig, commonProperties, { eventCache, getRawMachineId, getContainerEnv });
 
         void instance.start();
         return instance;
@@ -73,9 +118,17 @@ export class Telemetry {
             abortSignal: this.deviceIdAbortController.signal,
         });
 
+        // try {
+        //     this.commonProperties.is_container_env = (await this.getContainerEnv()) ? "true" : "false";
+        // } catch (error: unknown) {
+        //     logger.info(
+        //         LogId.telemetryContainerEnvFailure,
+        //         "telemetry",
+        //         `Failed trying to check if is in container environment ${error as string}`
+        //     );
+        // }
         this.commonProperties.device_id = await this.deviceIdPromise;
-        this.commonProperties.is_container_env = (await this.isContainerized()) ? "true" : "false";
-
+        
         this.isBufferingEvents = false;
     }
 
@@ -117,35 +170,6 @@ export class Telemetry {
         };
     }
 
-    private async 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
-        }
-    }
-
-    private async isContainerized(): Promise<boolean> {
-        for (const file of ["/.dockerenv", "/run/.containerenv", "/var/run/.containerenv"]) {
-            const fileExists = await this.fileExists(file);
-            if (fileExists) {
-                return true;
-            }
-        }
-        return !!process.env.container;
-    }
-
     /**
      * Checks if telemetry is currently enabled
      * This is a method rather than a constant to capture runtime config changes

tests/integration/helpers.ts

@@ -67,7 +67,7 @@ export function setupIntegrationTest(getUserConfig: () => UserConfig): Integrati
 
         userConfig.telemetry = "disabled";
 
-        const telemetry = Telemetry.create({ session, userConfig });
+        const telemetry = Telemetry.create(session, userConfig);
 
         mcpServer = new Server({
             session,

tests/integration/telemetry.test.ts

@@ -10,11 +10,8 @@ describe("Telemetry", () => {
 
         const actualHashedId = createHmac("sha256", actualId.toUpperCase()).update("atlascli").digest("hex");
 
-        const telemetry = Telemetry.create({
-            session: new Session({
-                apiBaseUrl: "",
-            }),
-            userConfig: config,
+        const telemetry = Telemetry.create(new Session({ apiBaseUrl: "" }), config, {
+            getContainerEnv: () => Promise.resolve(false),
         });
 
         expect(telemetry.getCommonProperties().device_id).toBe(undefined);

tests/unit/telemetry.test.ts

@@ -130,6 +130,7 @@ describe("Telemetry", () => {
             userConfig: config,
             eventCache: mockEventCache,
             getRawMachineId: () => Promise.resolve(machineId),
+            getContainerEnv: () => Promise.resolve(false),
         });
 
         config.telemetry = "enabled";
@@ -216,6 +217,7 @@ describe("Telemetry", () => {
                         session,
                         userConfig: config,
                         getRawMachineId: () => Promise.resolve(machineId),
+                        getContainerEnv: () => Promise.resolve(false),
                     });
 
                     expect(telemetry["isBufferingEvents"]).toBe(true);
@@ -234,6 +236,7 @@ describe("Telemetry", () => {
                         session,
                         userConfig: config,
                         getRawMachineId: () => Promise.reject(new Error("Failed to get device ID")),
+                        getContainerEnv: () => Promise.resolve(false),
                     });
 
                     expect(telemetry["isBufferingEvents"]).toBe(true);
@@ -258,6 +261,7 @@ describe("Telemetry", () => {
                         session,
                         userConfig: config,
                         getRawMachineId: () => new Promise(() => {}),
+                        getContainerEnv: () => Promise.resolve(false),
                     });
 
                     expect(telemetry["isBufferingEvents"]).toBe(true);