Merge branch 'main' into fmenezes/refactor_test

Author: fmenezes

.github/workflows/code_health.yaml

@@ -31,8 +31,7 @@ jobs:
           cache: "npm"
       - name: Install dependencies
         run: npm ci
-      - name: Run style check
-        run: npm run generate
+      - run: npm run generate
 
   run-tests:
     strategy:
@@ -44,6 +43,26 @@ jobs:
       - uses: GitHubSecurityLab/actions-permissions/monitor@v1
         if: matrix.os != 'windows-latest'
       - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: package.json
+          cache: "npm"
+      - name: Install dependencies
+        run: npm ci
+      - name: Run tests
+        run: npm test
+      - name: Upload test results
+        if: always() && matrix.os == 'ubuntu-latest'
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-results
+          path: coverage/lcov.info
+
+  run-atlas-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: GitHubSecurityLab/actions-permissions/monitor@v1
+      - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with:
           node-version-file: package.json
@@ -55,10 +74,40 @@ jobs:
           MDB_MCP_API_CLIENT_ID: ${{ secrets.TEST_ATLAS_CLIENT_ID }}
           MDB_MCP_API_CLIENT_SECRET: ${{ secrets.TEST_ATLAS_CLIENT_SECRET }}
           MDB_MCP_API_BASE_URL: ${{ vars.TEST_ATLAS_BASE_URL }}
-        run: npm test
+        run: npm test -- --testPathIgnorePatterns "tests/integration/tools/mongodb" --testPathIgnorePatterns "tests/integration/[^/]+\.ts"
+      - name: Upload test results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: atlas-test-results
+          path: coverage/lcov.info
+  coverage:
+    runs-on: ubuntu-latest
+    needs: [run-tests, run-atlas-tests]
+    if: always()
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: package.json
+          cache: "npm"
+      - name: Install dependencies
+        run: npm ci
+      - name: Download test results
+        uses: actions/download-artifact@v4
+        with:
+          name: test-results
+          path: coverage/mongodb
+      - name: Download atlas test results
+        uses: actions/download-artifact@v4
+        with:
+          name: atlas-test-results
+          path: coverage/atlas
+      - name: Merge coverage reports
+        run: |
+          npx -y lcov-result-merger "coverage/*/lcov.info" "coverage/lcov.info"
       - name: Coveralls GitHub Action
         uses: coverallsapp/github-action@v2.3.6
-        if: matrix.os == 'ubuntu-latest'
         with:
           file: coverage/lcov.info
           git-branch: ${{ github.head_ref || github.ref_name }}

package-lock.json

@@ -47,6 +47,7 @@
     "jest-environment-node": "^29.7.0",
     "jest-extended": "^4.0.2",
     "mongodb-runner": "^5.8.2",
+    "native-machine-id": "^0.0.8",
     "openapi-types": "^12.1.3",
     "openapi-typescript": "^7.6.1",
     "prettier": "^3.5.3",
@@ -61,6 +62,7 @@
     "@mongodb-js/devtools-connect": "^3.7.2",
     "@mongosh/service-provider-node-driver": "^3.6.0",
     "bson": "^6.10.3",
+    "lru-cache": "^11.1.0",
     "mongodb": "^6.15.0",
     "mongodb-log-writer": "^2.4.1",
     "mongodb-redact": "^1.1.6",

package.json

@@ -1,7 +1,11 @@
-import createClient, { Client, FetchOptions, Middleware } from "openapi-fetch";
+import createClient, { Client, Middleware } from "openapi-fetch";
+import type { FetchOptions } from "openapi-fetch";
 import { AccessToken, ClientCredentials } from "simple-oauth2";
 import { ApiClientError } from "./apiClientError.js";
 import { paths, operations } from "./openapi.js";
+import { BaseEvent } from "../../telemetry/types.js";
+import { mongoLogId } from "mongodb-log-writer";
+import logger from "../../logger.js";
 import { packageInfo } from "../../packageInfo.js";
 
 const ATLAS_API_VERSION = "2025-03-12";
@@ -93,6 +97,15 @@ export class ApiClient {
         this.client.use(this.errorMiddleware);
     }
 
+    public hasCredentials(): boolean {
+        logger.info(
+            mongoLogId(1_000_000),
+            "api-client",
+            `Checking if API client has credentials: ${!!(this.oauth2Client && this.accessToken)}`
+        );
+        return !!(this.oauth2Client && this.accessToken);
+    }
+
     public async getIpInfo(): Promise<{
         currentIpv4Address: string;
     }> {
@@ -118,6 +131,32 @@ export class ApiClient {
         }>;
     }
 
+    async sendEvents(events: BaseEvent[]): Promise<void> {
+        let endpoint = "api/private/unauth/telemetry/events";
+        const headers: Record<string, string> = {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": this.options.userAgent,
+        };
+
+        const accessToken = await this.getAccessToken();
+        if (accessToken) {
+            endpoint = "api/private/v1.0/telemetry/events";
+            headers["Authorization"] = `Bearer ${accessToken}`;
+        }
+
+        const url = new URL(endpoint, this.options.baseUrl);
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(events),
+        });
+
+        if (!response.ok) {
+            throw await ApiClientError.fromResponse(response);
+        }
+    }
+
     // DO NOT EDIT. This is auto-generated code.
     async listClustersForAllProjects(options?: FetchOptions<operations["listClustersForAllProjects"]>) {
         const { data } = await this.client.GET("/api/atlas/v2/clusters", options);

src/common/atlas/apiClient.ts

@@ -10,6 +10,7 @@ export interface UserConfig {
     apiBaseUrl?: string;
     apiClientId?: string;
     apiClientSecret?: string;
+    telemetry?: "enabled" | "disabled";
     logPath: string;
     connectionString?: string;
     connectOptions: {

src/config.ts

@@ -30,6 +30,5 @@ try {
     await server.connect(transport);
 } catch (error: unknown) {
     logger.emergency(mongoLogId(1_000_004), "server", `Fatal error running server: ${error as string}`);
-
     process.exit(1);
 }

src/index.ts

@@ -5,6 +5,8 @@ import { AtlasTools } from "./tools/atlas/tools.js";
 import { MongoDbTools } from "./tools/mongodb/tools.js";
 import logger, { initializeLogger } from "./logger.js";
 import { mongoLogId } from "mongodb-log-writer";
+import { ObjectId } from "mongodb";
+import { Telemetry } from "./telemetry/telemetry.js";
 import { UserConfig } from "./config.js";
 
 export interface ServerOptions {
@@ -16,25 +18,35 @@ export interface ServerOptions {
 export class Server {
     public readonly session: Session;
     private readonly mcpServer: McpServer;
+    private readonly telemetry: Telemetry;
     private readonly userConfig: UserConfig;
 
     constructor({ session, mcpServer, userConfig }: ServerOptions) {
         this.session = session;
+        this.telemetry = new Telemetry(session);
         this.mcpServer = mcpServer;
         this.userConfig = userConfig;
     }
 
     async connect(transport: Transport) {
         this.mcpServer.server.registerCapabilities({ logging: {} });
-
         this.registerTools();
         this.registerResources();
 
         await initializeLogger(this.mcpServer, this.userConfig.logPath);
 
         await this.mcpServer.connect(transport);
 
-        logger.info(mongoLogId(1_000_004), "server", `Server started with transport ${transport.constructor.name}`);
+        this.mcpServer.server.oninitialized = () => {
+            this.session.setAgentRunner(this.mcpServer.server.getClientVersion());
+            this.session.sessionId = new ObjectId().toString();
+
+            logger.info(
+                mongoLogId(1_000_004),
+                "server",
+                `Server started with transport ${transport.constructor.name} and agent runner ${this.session.agentRunner?.name}`
+            );
+        };
     }
 
     async close(): Promise<void> {
@@ -44,7 +56,7 @@ export class Server {
 
     private registerTools() {
         for (const tool of [...AtlasTools, ...MongoDbTools]) {
-            new tool(this.session, this.userConfig).register(this.mcpServer);
+            new tool(this.session, this.userConfig, this.telemetry).register(this.mcpServer);
         }
     }
 

src/server.ts

@@ -1,5 +1,6 @@
 import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
 import { ApiClient, ApiClientCredentials } from "./common/atlas/apiClient.js";
+import { Implementation } from "@modelcontextprotocol/sdk/types.js";
 
 export interface SessionOptions {
     apiBaseUrl?: string;
@@ -8,8 +9,13 @@ export interface SessionOptions {
 }
 
 export class Session {
+    sessionId?: string;
     serviceProvider?: NodeDriverServiceProvider;
     apiClient: ApiClient;
+    agentRunner?: {
+        name: string;
+        version: string;
+    };
 
     constructor({ apiBaseUrl, apiClientId, apiClientSecret }: SessionOptions = {}) {
         const credentials: ApiClientCredentials | undefined =
@@ -26,6 +32,15 @@ export class Session {
         });
     }
 
+    setAgentRunner(agentRunner: Implementation | undefined) {
+        if (agentRunner?.name && agentRunner?.version) {
+            this.agentRunner = {
+                name: agentRunner.name,
+                version: agentRunner.version,
+            };
+        }
+    }
+
     async close(): Promise<void> {
         if (this.serviceProvider) {
             try {

src/session.ts

@@ -0,0 +1,15 @@
+import { getMachineIdSync } from "native-machine-id";
+import { packageInfo } from "../packageInfo.js";
+
+/**
+ * Machine-specific metadata formatted for telemetry
+ */
+export const MACHINE_METADATA = {
+    device_id: getMachineIdSync(),
+    mcp_server_version: packageInfo.version,
+    mcp_server_name: packageInfo.mcpServerName,
+    platform: process.platform,
+    arch: process.arch,
+    os_type: process.platform,
+    os_version: process.version,
+} as const;