wip: simple approach

Author: blva

src/telemetry/telemetry.ts

@@ -6,6 +6,11 @@ import logger from '../logger.js';
 import { mongoLogId } from 'mongodb-log-writer';
 import { ApiClient } from '../common/atlas/apiClient.js';
 import { ApiClientError } from '../common/atlas/apiClientError.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+const isTelemetryEnabled = config.telemetry === 'enabled';
+const CACHE_FILE = path.join(process.cwd(), '.telemetry-cache.json');
 
 export class Telemetry {
     constructor(private readonly session: Session) {}
@@ -23,10 +28,8 @@ export class Telemetry {
             os_version: config.os_version,
         };
 
-    private readonly isTelemetryEnabled = config.telemetry === 'enabled';
-
     async emitToolEvent(command: string, category: string, startTime: number, result: 'success' | 'failure', error?: Error): Promise<void> {
-        if (!this.isTelemetryEnabled) {
+        if (!isTelemetryEnabled) {
             logger.debug(mongoLogId(1_000_000), "telemetry", `Telemetry is disabled, skipping event.`);
             return;
         }
@@ -50,26 +53,72 @@ export class Telemetry {
             event.properties.error_code = error?.message;
         }
 
-        await this.emit(event);
+        await this.emit([event]);
     }
 
-    private async emit(event: BaseEvent): Promise<void> {
+    private async emit(events: BaseEvent[]): Promise<void> {
+        // First try to read any cached events
+        const cachedEvents = await this.readCache();
+        const allEvents = [...cachedEvents, ...events];
+
+        logger.debug(mongoLogId(1_000_000), "telemetry", `Attempting to send ${allEvents.length} events (${cachedEvents.length} cached)`);
+
         try {
             if (this.session.apiClient) {
-                await this.session.apiClient.sendEvents([event]);
+                await this.session.apiClient.sendEvents(allEvents);
+                // If successful, clear the cache
+                await this.clearCache();
+                return;
             }
         } catch (error) {
             logger.warning(mongoLogId(1_000_000), "telemetry", `Error sending event to authenticated client: ${error}`);
+            // Cache the events that failed to send
+            await this.cacheEvents(allEvents);
         }
 
-        // if it is unauthenticated, send to temp client
+        // Try unauthenticated client as fallback
         try {
             const tempApiClient = new ApiClient({
                 baseUrl: config.apiBaseUrl,
             });
-            await tempApiClient.sendEvents([event]);
+            await tempApiClient.sendEvents(allEvents);
+            // If successful, clear the cache
+            await this.clearCache();
         } catch (error) {
             logger.warning(mongoLogId(1_000_000), "telemetry", `Error sending event to unauthenticated client: ${error}`);
+            // Cache the events that failed to send
+            await this.cacheEvents(allEvents);
+        }
+    }
+
+    private async readCache(): Promise<BaseEvent[]> {
+        try {
+            const data = await fs.readFile(CACHE_FILE, 'utf-8');
+            return JSON.parse(data);
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+                logger.warning(mongoLogId(1_000_000), "telemetry", `Error reading telemetry cache: ${error}`);
+            }
+            return [];
+        }
+    }
+
+    private async cacheEvents(events: BaseEvent[]): Promise<void> {
+        try {
+            await fs.writeFile(CACHE_FILE, JSON.stringify(events, null, 2));
+            logger.debug(mongoLogId(1_000_000), "telemetry", `Cached ${events.length} events for later sending`);
+        } catch (error) {
+            logger.warning(mongoLogId(1_000_000), "telemetry", `Failed to cache telemetry events: ${error}`);
+        }
+    }
+
+    private async clearCache(): Promise<void> {
+        try {
+            await fs.unlink(CACHE_FILE);
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+                logger.warning(mongoLogId(1_000_000), "telemetry", `Error clearing telemetry cache: ${error}`);
+            }
         }
     }
 }

src/tools/atlas/atlasTool.ts

@@ -2,7 +2,6 @@ import { ToolBase, ToolCategory } from "../tool.js";
 import { Session } from "../../session.js";
 
 export abstract class AtlasToolBase extends ToolBase {
-    protected category = "atlas";
     constructor(protected readonly session: Session) {
         super(session);
     }

src/tools/tool.ts

@@ -4,19 +4,15 @@ import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { Session } from "../session.js";
 import logger from "../logger.js";
 import { mongoLogId } from "mongodb-log-writer";
-<<<<<<< HEAD
 import config from "../config.js";
-=======
 import { Telemetry } from "../telemetry/telemetry.js";
->>>>>>> 61e295a (wip)
 
 export type ToolArgs<Args extends ZodRawShape> = z.objectOutputType<Args, ZodNever>;
 
 export type OperationType = "metadata" | "read" | "create" | "delete" | "update" | "cluster";
 export type ToolCategory = "mongodb" | "atlas";
 
 export abstract class ToolBase {
-<<<<<<< HEAD
     protected abstract name: string;
 
     protected abstract category: ToolCategory;
@@ -26,13 +22,7 @@ export abstract class ToolBase {
     protected abstract description: string;
 
     protected abstract argsShape: ZodRawShape;
-=======
-    protected abstract readonly name: string;
-    protected abstract readonly description: string;
-    protected abstract readonly argsShape: ZodRawShape;
->>>>>>> 61e295a (wip)
 
-    protected abstract category: string;
     private readonly telemetry: Telemetry;
 
     protected abstract execute(...args: Parameters<ToolCallback<typeof this.argsShape>>): Promise<CallToolResult>;
@@ -76,7 +66,6 @@ export abstract class ToolBase {
         server.tool(this.name, this.description, this.argsShape, callback);
     }
 
-<<<<<<< HEAD
     // Checks if a tool is allowed to run based on the config
     private verifyAllowed(): boolean {
         let errorClarification: string | undefined;
@@ -101,8 +90,6 @@ export abstract class ToolBase {
         return true;
     }
 
-=======
->>>>>>> 61e295a (wip)
     // This method is intended to be overridden by subclasses to handle errors
     protected handleError(error: unknown): Promise<CallToolResult> | CallToolResult {
         return {