update

Author: blva

src/common/session.ts

@@ -11,6 +11,7 @@ import type {
     ConnectionSettings,
     ConnectionStateConnected,
     ConnectionStateErrored,
+    ConnectionStringAuthType,
 } from "./connectionManager.js";
 import type { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
 import { ErrorCodes, MongoDBError } from "./errors.js";
@@ -182,4 +183,8 @@ export class Session extends EventEmitter<SessionEvents> {
     get connectedAtlasCluster(): AtlasClusterConnectionInfo | undefined {
         return this.connectionManager.currentConnectionState.connectedAtlasCluster;
     }
+
+    get connectionStringAuthType(): ConnectionStringAuthType | undefined {
+        return this.connectionManager.currentConnectionState.connectionStringAuthType;
+    }
 }

src/tools/atlas/connect/connectCluster.ts

@@ -8,7 +8,7 @@ import { ensureCurrentIpInAccessList } from "../../../common/atlas/accessListUti
 import type { AtlasClusterConnectionInfo } from "../../../common/connectionManager.js";
 import { getDefaultRoleFromConfig } from "../../../common/atlas/roles.js";
 import { AtlasArgs } from "../../args.js";
-import { AtlasLocalToolMetadata } from "../../../telemetry/types.js";
+import { ConnectionMetadata } from "../../../telemetry/types.js";
 
 const addedIpAccessListMessage =
     "Note: Your current IP address has been added to the Atlas project's IP access list to enable secure connection.";
@@ -306,8 +306,8 @@ export class ConnectClusterTool extends AtlasToolBase {
     }
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    protected override resolveTelemetryMetadata(_args: ToolArgs<typeof this.argsShape>): AtlasLocalToolMetadata {
-        const metadata: AtlasLocalToolMetadata = {};
+    protected override resolveTelemetryMetadata(_args: ToolArgs<typeof this.argsShape>): ConnectionMetadata {
+        const metadata: ConnectionMetadata = {};
         const connectionStringAuthType = this.session.connectionManager.currentConnectionState.connectionStringAuthType;
         if (connectionStringAuthType) {
             metadata.connection_auth_type = connectionStringAuthType;

src/tools/mongodb/connect/connect.ts

@@ -5,7 +5,7 @@ import type { ToolArgs, OperationType, ToolConstructorParams } from "../../tool.
 import assert from "assert";
 import type { Server } from "../../../server.js";
 import { LogId } from "../../../common/logger.js";
-import { AtlasLocalToolMetadata } from "../../../telemetry/types.js";
+import { ConnectionMetadata } from "../../../telemetry/types.js";
 
 const disconnectedSchema = z
     .object({

src/tools/tool.ts

@@ -306,15 +306,15 @@ export abstract class ToolBase {
 
     protected getConnectionInfoMetadata(): ConnectionMetadata {
         const metadata: ConnectionMetadata = {};
-        const connectionStringAuthType = this.session.connectionManager.currentConnectionState.connectionStringAuthType;
-        if (connectionStringAuthType) {
-            metadata.connection_auth_type = connectionStringAuthType;
-        }
-
         if (this.session.connectedAtlasCluster?.projectId) {
             metadata.project_id = this.session.connectedAtlasCluster.projectId;
         }
 
+        const connectionStringAuthType = this.session.connectionStringAuthType;
+        if (connectionStringAuthType !== undefined) {
+            metadata.connection_auth_type = connectionStringAuthType;
+        }
+
         return metadata;
     }
 }

tests/unit/toolBase.test.ts

@@ -175,6 +175,90 @@ describe("ToolBase", () => {
             expect(event.properties).toHaveProperty("test_param2", "three");
         });
     });
+
+    describe("getConnectionInfoMetadata", () => {
+        it("should return empty metadata when neither connectedAtlasCluster nor connectionStringAuthType are set", () => {
+            (mockSession as { connectedAtlasCluster?: unknown }).connectedAtlasCluster = undefined;
+            (mockSession as { connectionStringAuthType?: unknown }).connectionStringAuthType = undefined;
+
+            const metadata = testTool["getConnectionInfoMetadata"]();
+
+            expect(metadata).toEqual({});
+            expect(metadata).not.toHaveProperty("project_id");
+            expect(metadata).not.toHaveProperty("connection_auth_type");
+        });
+
+        it("should return metadata with project_id when connectedAtlasCluster.projectId is set", () => {
+            (mockSession as { connectedAtlasCluster?: unknown }).connectedAtlasCluster = {
+                projectId: "test-project-id",
+                username: "test-user",
+                clusterName: "test-cluster",
+                expiryDate: new Date(),
+            };
+            (mockSession as { connectionStringAuthType?: unknown }).connectionStringAuthType = undefined;
+
+            const metadata = testTool["getConnectionInfoMetadata"]();
+
+            expect(metadata).toEqual({
+                project_id: "test-project-id",
+            });
+            expect(metadata).not.toHaveProperty("connection_auth_type");
+        });
+
+        it("should return empty metadata when connectedAtlasCluster exists but projectId is falsy", () => {
+            (mockSession as { connectedAtlasCluster?: unknown }).connectedAtlasCluster = {
+                projectId: "",
+                username: "test-user",
+                clusterName: "test-cluster",
+                expiryDate: new Date(),
+            };
+            (mockSession as { connectionStringAuthType?: unknown }).connectionStringAuthType = undefined;
+
+            const metadata = testTool["getConnectionInfoMetadata"]();
+
+            expect(metadata).toEqual({});
+            expect(metadata).not.toHaveProperty("project_id");
+        });
+
+        it("should return metadata with connection_auth_type when connectionStringAuthType is set", () => {
+            (mockSession as { connectedAtlasCluster?: unknown }).connectedAtlasCluster = undefined;
+            (mockSession as { connectionStringAuthType?: unknown }).connectionStringAuthType = "scram";
+
+            const metadata = testTool["getConnectionInfoMetadata"]();
+
+            expect(metadata).toEqual({
+                connection_auth_type: "scram",
+            });
+            expect(metadata).not.toHaveProperty("project_id");
+        });
+
+        it("should return metadata with both project_id and connection_auth_type when both are set", () => {
+            (mockSession as { connectedAtlasCluster?: unknown }).connectedAtlasCluster = {
+                projectId: "test-project-id",
+                username: "test-user",
+                clusterName: "test-cluster",
+                expiryDate: new Date(),
+            };
+            (mockSession as { connectionStringAuthType?: unknown }).connectionStringAuthType = "oidc-auth-flow";
+
+            const metadata = testTool["getConnectionInfoMetadata"]();
+
+            expect(metadata).toEqual({
+                project_id: "test-project-id",
+                connection_auth_type: "oidc-auth-flow",
+            });
+        });
+
+        it("should handle different connectionStringAuthType values", () => {
+            const authTypes = ["scram", "ldap", "kerberos", "oidc-auth-flow", "oidc-device-flow", "x.509"] as const;
+
+            for (const authType of authTypes) {
+                (mockSession as { connectionStringAuthType?: unknown }).connectionStringAuthType = authType;
+                const metadata = testTool["getConnectionInfoMetadata"]();
+                expect(metadata.connection_auth_type).toBe(authType);
+            }
+        });
+    });
 });
 
 class TestTool extends ToolBase {