@W-20481777 Setup Generic Telemetry interface

docs/docs/configuration/mcp-config/env-vars.md

@@ -259,6 +259,43 @@ variable.
 
 <hr />
 
+## `TELEMETRY_PROVIDER`
+
+The telemetry provider to use for metrics collection.
+
+- Default: `noop`
+- Possible values:
+  - `noop` - No telemetry (default)
+  - `custom` - Use a custom telemetry provider (requires
+    [`TELEMETRY_PROVIDER_CONFIG`](#telemetry_provider_config))
+
+<hr />
+
+## `TELEMETRY_PROVIDER_CONFIG`
+
+Configuration for the custom telemetry provider. Required when
+[`TELEMETRY_PROVIDER`](#telemetry_provider) is `custom`.
+
+- Format: JSON string with at least a `module` field
+- The `module` field should be a path to a JavaScript file or npm package that exports a class
+  implementing the `TelemetryProvider` interface.
+
+**Example:**
+
+```bash
+TELEMETRY_PROVIDER_CONFIG='{"module": "./my-telemetry-provider.js"}'
+```
+
+The custom provider module should export a default class (or named export `TelemetryProvider`) that
+implements:
+
+```typescript
+interface TelemetryProvider {
+  initialize(): void;
+  recordMetric(name: string, value: number, attributes: Record<string, unknown>): void;
+}
+```
+
 [mcp-transport]: https://modelcontextprotocol.io/docs/concepts/transports
 [tab-ds-connections]:
   https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_data_sources.htm#query_data_source_connections

package.json

@@ -26,6 +26,7 @@
     "build:mcpb": "run-s build:manifest :build:mcpb",
     "build:manifest": "tsx src/scripts/createClaudeMcpBundleManifest.ts",
     "start:http": "node build/index.js",
+    "start:http:apm": "node -r ./build/telemetry/tracing.js build/index.js",
     "start:http:docker": "docker run -p 3927:3927 -i --rm --env-file env.list tableau-mcp",
     "lint": "npm exec eslint",
     "inspect": "npx @modelcontextprotocol/inspector --config config.json --server tableau",

src/config.ts

@@ -2,6 +2,7 @@ import { CorsOptions } from 'cors';
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 
+import { isTelemetryProvider, providerConfigSchema, TelemetryConfig } from './telemetry/types.js';
 import { isToolGroupName, isToolName, toolGroups, ToolName } from './tools/toolName.js';
 import { isTransport, TransportName } from './transports.js';
 import { getDirname } from './utils/getDirname.js';
@@ -78,6 +79,7 @@ export class Config {
     clientIdSecretPairs: Record<string, string> | null;
     dnsServers: string[];
   };
+  telemetry: TelemetryConfig;
 
   constructor() {
     const cleansedVars = removeClaudeMcpBundleUserConfigTemplates(process.env);
@@ -133,6 +135,8 @@ export class Config {
       OAUTH_AUTHORIZATION_CODE_TIMEOUT_MS: authzCodeTimeoutMs,
       OAUTH_ACCESS_TOKEN_TIMEOUT_MS: accessTokenTimeoutMs,
       OAUTH_REFRESH_TOKEN_TIMEOUT_MS: refreshTokenTimeoutMs,
+      TELEMETRY_PROVIDER: telemetryProvider,
+      TELEMETRY_PROVIDER_CONFIG: telemetryProviderConfig,
     } = cleansedVars;
 
     let jwtUsername = '';
@@ -228,6 +232,23 @@ export class Config {
         : null,
     };
 
+    const parsedProvider = isTelemetryProvider(telemetryProvider) ? telemetryProvider : 'noop';
+    if (parsedProvider === 'custom') {
+      if (!telemetryProviderConfig) {
+        throw new Error(
+          'TELEMETRY_PROVIDER_CONFIG is required when TELEMETRY_PROVIDER is "custom"',
+        );
+      }
+      this.telemetry = {
+        provider: 'custom',
+        providerConfig: providerConfigSchema.parse(JSON.parse(telemetryProviderConfig)),
+      };
+    } else {
+      this.telemetry = {
+        provider: parsedProvider,
+      };
+    }
+
     this.auth = isAuthType(auth) ? auth : this.oauth.enabled ? 'oauth' : 'pat';
     this.transport = isTransport(transport) ? transport : this.oauth.enabled ? 'http' : 'stdio';
 

src/scripts/build.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-console */
 
 import { build } from 'esbuild';
-import { chmod, rm } from 'fs/promises';
+import { chmod, mkdir, rm } from 'fs/promises';
 
 const dev = process.argv.includes('--dev');
 
@@ -32,5 +32,26 @@ const dev = process.argv.includes('--dev');
     console.log(`⚠️ ${warning.text}`);
   }
 
+  console.log('🏗️ Building telemetry/tracing.js...');
+  await mkdir('./build/telemetry', { recursive: true });
+  const tracingResult = await build({
+    entryPoints: ['./src/telemetry/tracing.ts'],
+    bundle: true,
+    platform: 'node',
+    format: 'cjs',
+    minify: !dev,
+    packages: 'external',
+    sourcemap: true,
+    outfile: './build/telemetry/tracing.js',
+  });
+
+  for (const error of tracingResult.errors) {
+    console.log(`❌ ${error.text}`);
+  }
+
+  for (const warning of tracingResult.warnings) {
+    console.log(`⚠️ ${warning.text}`);
+  }
+
   await chmod('./build/index.js', '755');
 })();

src/telemetry/init.test.ts

@@ -0,0 +1,68 @@
+import { MockInstance } from 'vitest';
+
+import { initializeTelemetry } from './init.js';
+import { TelemetryConfig } from './types.js';
+
+const mocks = vi.hoisted(() => ({
+  mockGetConfig: vi.fn(),
+  MockNoOpTelemetryProvider: vi.fn(),
+}));
+
+vi.mock('../config.js', () => ({
+  getConfig: mocks.mockGetConfig,
+}));
+
+vi.mock('./noop.js', () => ({
+  NoOpTelemetryProvider: mocks.MockNoOpTelemetryProvider,
+}));
+
+describe('initializeTelemetry', () => {
+  const defaultTelemetryConfig: TelemetryConfig = {
+    provider: 'noop',
+  };
+
+  let consoleErrorSpy: MockInstance;
+  let consoleWarnSpy: MockInstance;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Suppress console output
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    // Default mock implementations
+    mocks.MockNoOpTelemetryProvider.mockImplementation(() => ({
+      initialize: vi.fn(),
+      recordMetric: vi.fn(),
+    }));
+  });
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore();
+    consoleWarnSpy.mockRestore();
+  });
+
+  // NoOp tests
+  it('returns NoOpTelemetryProvider when provider is "noop"', () => {
+    mocks.mockGetConfig.mockReturnValue({
+      telemetry: { ...defaultTelemetryConfig, provider: 'noop' },
+    });
+
+    initializeTelemetry();
+
+    expect(mocks.MockNoOpTelemetryProvider).toHaveBeenCalled();
+  });
+
+  it('returns NoOpTelemetryProvider for unknown provider with warning', () => {
+    mocks.mockGetConfig.mockReturnValue({
+      telemetry: { ...defaultTelemetryConfig, provider: 'unknown-provider' },
+    });
+
+    initializeTelemetry();
+
+    expect(mocks.MockNoOpTelemetryProvider).toHaveBeenCalled();
+    expect(consoleErrorSpy).toHaveBeenCalled();
+    expect(consoleWarnSpy).toHaveBeenCalledWith('Falling back to NoOp telemetry provider');
+  });
+});