Add fallback dev insights string

Author: allison-grady

packages/b2c-dx-mcp/README.md

@@ -525,7 +525,11 @@ When `--config` is not provided, the MCP server searches upward from `~/` for a
 
 ## Telemetry
 
-The MCP server collects anonymous usage telemetry to help improve the developer experience. Telemetry is enabled by default and can be disabled by setting the `SFCC_TELEMETRY` environment variable to `false`.
+The MCP server collects anonymous usage telemetry to help improve the developer experience.
+
+**Development mode**: Telemetry is automatically disabled when `NODE_ENV=development` (set by `bin/dev.js`), so local development and testing won't pollute production data.
+
+**Production**: Telemetry is enabled by default for published releases. To disable, set `SFCC_TELEMETRY=false`.
 
 ### What We Collect
 
@@ -540,22 +544,6 @@ The MCP server collects anonymous usage telemetry to help improve the developer
 - **No tool arguments**: No input parameters or output results from tool calls
 - **No file contents**: No source code, configuration files, or project data
 
-### Disabling Telemetry
-
-Set the `SFCC_TELEMETRY` environment variable to `false`:
-
-```json
-{
-  "mcpServers": {
-    "b2c-dx": {
-      "command": "/path/to/packages/b2c-dx-mcp/bin/dev.js",
-      "args": ["--toolsets", "all"],
-      "env": { "SFCC_TELEMETRY": "false" }
-    }
-  }
-}
-```
-
 ## License
 
 Apache-2.0

packages/b2c-dx-mcp/bin/dev.js

@@ -5,6 +5,9 @@
  * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
  */
 
+// Set NODE_ENV to development if not already set (disables production telemetry)
+process.env.NODE_ENV = process.env.NODE_ENV || 'development';
+
 // Load .env file if present (Node.js native support)
 try {
   process.loadEnvFile();

packages/b2c-dx-mcp/src/config.ts

@@ -12,10 +12,28 @@
 const DEFAULT_APPLICATION_INSIGHTS_CONNECTION_STRING =
   'InstrumentationKey=6fcc215f-0b11-4864-ad5c-3945ae19e2f3;IngestionEndpoint=https://eastus-8.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/;ApplicationId=a60f17ec-265a-4dfc-b8df-03a64695697d';
 
+/**
+ * Determines if telemetry should be enabled based on environment.
+ * Telemetry is disabled in development mode to avoid polluting production data.
+ */
+function getConnectionString(): string | undefined {
+  // Allow explicit override via env var
+  if (process.env.B2C_DX_MCP_APP_INSIGHTS_CONNECTION_STRING) {
+    return process.env.B2C_DX_MCP_APP_INSIGHTS_CONNECTION_STRING;
+  }
+
+  // Disable telemetry in development mode
+  if (process.env.NODE_ENV === 'development') {
+    return undefined;
+  }
+
+  return DEFAULT_APPLICATION_INSIGHTS_CONNECTION_STRING;
+}
+
 /**
  * Application Insights connection string for telemetry.
  *
- * Can be overridden via the `B2C_DX_MCP_APP_INSIGHTS_CONNECTION_STRING` environment variable for testing.
+ * Returns undefined in development mode (NODE_ENV=development) to disable telemetry.
+ * Can be overridden via the `B2C_DX_MCP_APP_INSIGHTS_CONNECTION_STRING` environment variable.
  */
-export const APPLICATION_INSIGHTS_CONNECTION_STRING =
-  process.env.B2C_DX_MCP_APP_INSIGHTS_CONNECTION_STRING ?? DEFAULT_APPLICATION_INSIGHTS_CONNECTION_STRING;
+export const APPLICATION_INSIGHTS_CONNECTION_STRING = getConnectionString();

packages/b2c-dx-mcp/test/config.test.ts

@@ -9,17 +9,33 @@ import {APPLICATION_INSIGHTS_CONNECTION_STRING} from '../src/config.js';
 
 describe('config', () => {
   describe('APPLICATION_INSIGHTS_CONNECTION_STRING', () => {
-    it('should export a non-empty connection string', () => {
-      expect(APPLICATION_INSIGHTS_CONNECTION_STRING).to.be.a('string');
-      expect(APPLICATION_INSIGHTS_CONNECTION_STRING.length).to.be.greaterThan(0);
-    });
+    // The connection string behavior depends on NODE_ENV:
+    // - In development mode (NODE_ENV=development): undefined (telemetry disabled)
+    // - In production mode: returns the connection string
 
-    it('should contain InstrumentationKey', () => {
-      expect(APPLICATION_INSIGHTS_CONNECTION_STRING).to.include('InstrumentationKey=');
+    it('should be undefined in development mode or a valid connection string in production', () => {
+      if (process.env.NODE_ENV === 'development') {
+        // In development mode, telemetry is disabled
+        expect(APPLICATION_INSIGHTS_CONNECTION_STRING).to.be.undefined;
+      } else {
+        // In production mode, should have a valid connection string
+        expect(APPLICATION_INSIGHTS_CONNECTION_STRING).to.be.a('string');
+        expect(APPLICATION_INSIGHTS_CONNECTION_STRING!.length).to.be.greaterThan(0);
+        expect(APPLICATION_INSIGHTS_CONNECTION_STRING).to.include('InstrumentationKey=');
+        expect(APPLICATION_INSIGHTS_CONNECTION_STRING).to.include('IngestionEndpoint=');
+      }
     });
 
-    it('should contain IngestionEndpoint', () => {
-      expect(APPLICATION_INSIGHTS_CONNECTION_STRING).to.include('IngestionEndpoint=');
+    it('should respect NODE_ENV for telemetry gating', () => {
+      // This test documents the expected behavior:
+      // Tests run without NODE_ENV=development set, so we get the production string
+      // bin/dev.js sets NODE_ENV=development, so local dev gets undefined
+      const isDevelopment = process.env.NODE_ENV === 'development';
+      if (isDevelopment) {
+        expect(APPLICATION_INSIGHTS_CONNECTION_STRING).to.be.undefined;
+      } else {
+        expect(APPLICATION_INSIGHTS_CONNECTION_STRING).to.not.be.undefined;
+      }
     });
   });
 });

packages/b2c-dx-mcp/test/server.test.ts

@@ -43,6 +43,23 @@ const paramHandler = async (args: Record<string, unknown>) => ({
   content: [{type: 'text' as const, text: `Hello ${args.name}`}],
 });
 
+// Telemetry test handlers
+const successHandler = async () => ({content: [{type: 'text' as const, text: 'success'}]});
+const errorResultHandler = async () => ({
+  content: [{type: 'text' as const, text: 'error occurred'}],
+  isError: true,
+});
+const throwingHandler = async (): Promise<{content: Array<{type: 'text'; text: string}>}> => {
+  throw new Error('Tool execution failed');
+};
+const delayMs = 50;
+const slowHandler = async () => {
+  await new Promise<void>((resolve) => {
+    setTimeout(resolve, delayMs);
+  });
+  return {content: [{type: 'text' as const, text: 'done'}]};
+};
+
 describe('B2CDxMcpServer', () => {
   describe('constructor', () => {
     it('should create server with name and version', () => {
@@ -132,4 +149,121 @@ describe('B2CDxMcpServer', () => {
       expect(server).to.be.instanceOf(B2CDxMcpServer);
     });
   });
+
+  describe('TOOL_CALLED telemetry', () => {
+    let mockTelemetry: MockTelemetry;
+    let capturedHandler: ((args: Record<string, unknown>, extra: unknown) => Promise<unknown>) | null;
+
+    beforeEach(() => {
+      mockTelemetry = new MockTelemetry();
+      capturedHandler = null;
+    });
+
+    /**
+     * Creates a server that captures the wrapped handler for testing.
+     * This allows us to test the telemetry wrapper logic without going through
+     * the full MCP protocol.
+     */
+    function createServerWithHandlerCapture(): B2CDxMcpServer {
+      const server = new B2CDxMcpServer(
+        {name: 'test-server', version: '1.0.0'},
+        {telemetry: mockTelemetry as unknown as Telemetry},
+      );
+
+      // Override registerTool to capture the wrapped handler
+      const originalRegisterTool = server.registerTool.bind(server);
+      server.registerTool = (name, config, handler) => {
+        capturedHandler = handler as (args: Record<string, unknown>, extra: unknown) => Promise<unknown>;
+        return originalRegisterTool(name, config, handler);
+      };
+
+      return server;
+    }
+
+    it('should send TOOL_CALLED event on successful tool execution', async () => {
+      const server = createServerWithHandlerCapture();
+
+      server.addTool('test_tool', 'Test tool', {}, successHandler);
+
+      // Call the captured wrapped handler
+      expect(capturedHandler).to.not.be.null;
+      await capturedHandler!({}, {});
+
+      // Verify telemetry event
+      expect(mockTelemetry.events).to.have.lengthOf(1);
+      expect(mockTelemetry.events[0].name).to.equal('TOOL_CALLED');
+      expect(mockTelemetry.events[0].attributes.toolName).to.equal('test_tool');
+      expect(mockTelemetry.events[0].attributes.isError).to.equal(false);
+      expect(mockTelemetry.events[0].attributes.runTimeMs).to.be.a('number');
+    });
+
+    it('should send TOOL_CALLED event with isError=true when tool returns error', async () => {
+      const server = createServerWithHandlerCapture();
+
+      server.addTool('error_tool', 'Error tool', {}, errorResultHandler);
+
+      await capturedHandler!({}, {});
+
+      expect(mockTelemetry.events).to.have.lengthOf(1);
+      expect(mockTelemetry.events[0].name).to.equal('TOOL_CALLED');
+      expect(mockTelemetry.events[0].attributes.toolName).to.equal('error_tool');
+      expect(mockTelemetry.events[0].attributes.isError).to.equal(true);
+    });
+
+    it('should send TOOL_CALLED event with isError=true when tool throws', async () => {
+      const server = createServerWithHandlerCapture();
+
+      server.addTool('throwing_tool', 'Throwing tool', {}, throwingHandler);
+
+      try {
+        await capturedHandler!({}, {});
+        expect.fail('Should have thrown');
+      } catch {
+        // Expected
+      }
+
+      expect(mockTelemetry.events).to.have.lengthOf(1);
+      expect(mockTelemetry.events[0].name).to.equal('TOOL_CALLED');
+      expect(mockTelemetry.events[0].attributes.toolName).to.equal('throwing_tool');
+      expect(mockTelemetry.events[0].attributes.isError).to.equal(true);
+    });
+
+    it('should measure runTimeMs accurately', async () => {
+      const server = createServerWithHandlerCapture();
+
+      server.addTool('slow_tool', 'Slow tool', {}, slowHandler);
+
+      await capturedHandler!({}, {});
+
+      const runTimeMs = mockTelemetry.events[0].attributes.runTimeMs as number;
+      // Allow some tolerance for timing
+      expect(runTimeMs).to.be.at.least(delayMs - 10);
+      expect(runTimeMs).to.be.at.most(delayMs + 50);
+    });
+
+    it('should not send events when telemetry is disabled', async () => {
+      // Create server without telemetry
+      const server = new B2CDxMcpServer({name: 'test-server', version: '1.0.0'});
+
+      let handlerCalled = false;
+      const handler = async () => {
+        handlerCalled = true;
+        return {content: [{type: 'text' as const, text: 'ok'}]};
+      };
+
+      // Override registerTool to capture handler
+      let noTelemetryHandler: ((args: Record<string, unknown>, extra: unknown) => Promise<unknown>) | null = null;
+      const originalRegisterTool = server.registerTool.bind(server);
+      server.registerTool = (name, config, h) => {
+        noTelemetryHandler = h as (args: Record<string, unknown>, extra: unknown) => Promise<unknown>;
+        return originalRegisterTool(name, config, h);
+      };
+
+      server.addTool('no_telemetry_tool', 'No telemetry', {}, handler);
+
+      // Should not throw even without telemetry
+      await noTelemetryHandler!({}, {});
+      expect(handlerCalled).to.be.true;
+    });
+  });
 });

packages/b2c-dx-mcp/test/utils/index.test.ts

@@ -9,21 +9,32 @@ import {loadAppInsightsKey} from '../../src/utils/index.js';
 
 describe('utils', () => {
   describe('loadAppInsightsKey', () => {
-    it('should return a connection string', () => {
-      const key = loadAppInsightsKey();
-      expect(key).to.be.a('string');
-    });
+    // In development mode (NODE_ENV=development), returns undefined to disable telemetry
+    // In production mode, returns the connection string
 
-    it('should return a string containing InstrumentationKey', () => {
+    it('should return undefined in development mode or a valid connection string in production', () => {
       const key = loadAppInsightsKey();
-      expect(key).to.include('InstrumentationKey=');
+
+      if (process.env.NODE_ENV === 'development') {
+        expect(key).to.be.undefined;
+      } else {
+        expect(key).to.be.a('string');
+        expect(key).to.include('InstrumentationKey=');
+        expect(key).to.include('IngestionEndpoint=');
+      }
     });
 
-    it('should return a valid Application Insights connection string format', () => {
+    it('should gate telemetry based on NODE_ENV', () => {
       const key = loadAppInsightsKey();
-      // Connection string should have key=value pairs separated by semicolons
-      expect(key).to.match(/InstrumentationKey=[^;]+/);
-      expect(key).to.match(/IngestionEndpoint=[^;]+/);
+      const isDevelopment = process.env.NODE_ENV === 'development';
+
+      if (isDevelopment) {
+        // Development mode: telemetry disabled
+        expect(key).to.be.undefined;
+      } else {
+        // Production mode: telemetry enabled
+        expect(key).to.not.be.undefined;
+      }
     });
   });
 });