chore: use redact by default

src/server.ts

@@ -190,7 +190,7 @@ export class Server {
 
         if (command === "start") {
             event.properties.startup_time_ms = commandDuration;
-            event.properties.read_only_mode = this.userConfig.readOnly || false;
+            event.properties.read_only_mode = this.userConfig.readOnly ? "true" : "false";
             event.properties.disabled_tools = this.userConfig.disabledTools || [];
             event.properties.confirmation_required_tools = this.userConfig.confirmationRequiredTools || [];
         }

src/telemetry/telemetry.ts

@@ -8,6 +8,7 @@
 import { detectContainerEnv } from "../helpers/container.js";
 import type { DeviceId } from "../helpers/deviceId.js";
 import { EventEmitter } from "events";
+import { redact } from "mongodb-redact";
 
 type EventResult = {
     success: boolean;
@@ -52,8 +53,8 @@
         } = {}
     ): Telemetry {
         const mergedProperties = {
-            ...MACHINE_METADATA,
-            ...commonProperties,
+            ...redact(MACHINE_METADATA, session.keychain.allSecrets),
+            ...redact(commonProperties, session.keychain.allSecrets),
         };
         const instance = new Telemetry(session, userConfig, mergedProperties, {
             eventCache,
@@ -79,7 +80,7 @@
         const [deviceIdValue, containerEnv] = await this.setupPromise;
 
         this.commonProperties.device_id = deviceIdValue;
-        this.commonProperties.is_container_env = containerEnv;
+        this.commonProperties.is_container_env = containerEnv ? "true" : "false";
 
         this.isBufferingEvents = false;
     }
@@ -123,7 +124,6 @@
             this.events.emit("events-skipped");
             return;
         }
-
         // Don't wait for events to be sent - we should not block regular server
         // operations on telemetry
         void this.emit(events);
@@ -135,11 +135,11 @@
      */
     public getCommonProperties(): CommonProperties {
         return {
-            ...this.commonProperties,
+            ...redact(this.commonProperties, this.session.keychain.allSecrets),
             transport: this.userConfig.transport,
-            mcp_client_version: this.session.mcpClient?.version,
-            mcp_client_name: this.session.mcpClient?.name,
-            session_id: this.session.sessionId,
+            mcp_client_version: redact(this.session.mcpClient?.version, this.session.keychain.allSecrets),
+            mcp_client_name: redact(this.session.mcpClient?.name, this.session.keychain.allSecrets),
+            session_id: redact(this.session.sessionId, this.session.keychain.allSecrets),
             config_atlas_auth: this.session.apiClient.hasCredentials() ? "true" : "false",
             config_connection_string: this.userConfig.connectionString ? "true" : "false",
         };
@@ -214,13 +214,17 @@
 
     /**
      * Attempts to send events through the provided API client
+     * Events are redacted before being sent to ensure no sensitive data is transmitted
      */
     private async sendEvents(client: ApiClient, events: BaseEvent[]): Promise<EventResult> {
         try {
             await client.sendEvents(
                 events.map((event) => ({
                     ...event,
-                    properties: { ...this.getCommonProperties(), ...event.properties },
+                    properties: {
+                        ...this.getCommonProperties(),
+                        ...redact(event.properties, this.session.keychain.allSecrets),
+                    },
                 }))
             );
             return { success: true };

src/telemetry/types.ts

@@ -43,7 +43,7 @@ export type ServerEventProperties = {
     reason?: string;
     startup_time_ms?: number;
     runtime_duration_ms?: number;
-    read_only_mode?: boolean;
+    read_only_mode?: TelemetryBoolSet;
     disabled_tools?: string[];
     confirmation_required_tools?: string[];
 };
@@ -97,7 +97,7 @@ export type CommonProperties = {
     /**
      * A boolean indicating whether the server is running in a container environment.
      */
-    is_container_env?: boolean;
+    is_container_env?: TelemetryBoolSet;
 
     /**
      * The version of the MCP client as reported by the client on session establishment.

tests/integration/telemetry.test.ts

@@ -36,4 +36,32 @@ describe("Telemetry", () => {
         expect(telemetry.getCommonProperties().device_id).toBe(actualDeviceId);
         expect(telemetry["isBufferingEvents"]).toBe(false);
     });
+
+    it("should redact sensitive data", async () => {
+        const logger = new CompositeLogger();
+        const deviceId = DeviceId.create(logger);
+
+        // configure keychain with a secret that would show up in random properties
+        const keychain = new Keychain();
+        keychain.register(process.platform, "url");
+
+        const telemetry = Telemetry.create(
+            new Session({
+                apiBaseUrl: "",
+                logger,
+                exportsManager: ExportsManager.init(config, logger),
+                connectionManager: new MCPConnectionManager(config, driverOptions, logger, deviceId),
+                keychain: keychain,
+            }),
+            config,
+            deviceId
+        );
+
+        await telemetry.setupPromise;
+
+        // expect the platform to be redacted
+        const commonProperties = telemetry.getCommonProperties();
+        expect(commonProperties.platform).toBe("<url>");
+        expect(telemetry["isBufferingEvents"]).toBe(false);
+    });
 });