patch: Added Telemetry via Dynatrace OpenKit (#129)

* patch: Added Telemetry via Dynatrace OpenKit

* Apply suggestions from code review

Co-authored-by: Manuel Warum <[email protected]>

* patch: Switch to the proper Dt telemetry endpoint

Signed-off-by: Christian Kreuzberger <[email protected]>

* chore: Refactor package.json version retrieval function into a dedicated file

* chore: Refactor sigterm/sigint handler

* chore: Rename telemetry track functions

* chore: Added code docs for return statements

---------

Signed-off-by: Christian Kreuzberger <[email protected]>
Co-authored-by: Manuel Warum <[email protected]>

Author: christian-kreuzberger-dtx

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 - Added metadata output which includes scanned bytes (for cost tracking) to `execute_dql`
 - Added next-steps for `get_entity_details` to find out about metrics, problems and logs
+- Added Telemetry via Dynatrace OpenKit to improve the product with anonymous usage statistics and error information (can be disabled via `DT_MCP_DISABLE_TELEMETRY` environment variable)
 
 ## 0.5.0
 

README.md

@@ -553,6 +553,34 @@ curl -X GET https://abc12345.apps.dynatrace.com/platform/management/v1/environme
 
 Grail has a dedicated section about permissions in the Dynatrace Docs. Please refer to https://docs.dynatrace.com/docs/discover-dynatrace/platform/grail/data-model/assign-permissions-in-grail for more details.
 
+## Telemetry
+
+The Dynatrace MCP Server includes sending Telemetry Data via Dynatrace OpenKit to help improve the product. This includes:
+
+- Server start events
+- Tool usage (which tools are called, success/failure, execution duration)
+- Error tracking for debugging and improvement
+
+**Privacy and Opt-out:**
+
+- Telemetry is **enabled by default** but can be disabled by setting `DT_MCP_DISABLE_TELEMETRY=true`
+- No sensitive data from your Dynatrace environment is tracked
+- Only anonymous usage statistics and error information are collected
+- Usage statistics and error data are transmitted to Dynatrace’s analytics endpoint
+
+**Configuration options:**
+
+- `DT_MCP_DISABLE_TELEMETRY` (boolean, default: `false`) - Disable Telemetry
+- `DT_MCP_TELEMETRY_APPLICATION_ID` (string, default: `dynatrace-mcp-server`) - Application ID for tracking
+- `DT_MCP_TELEMETRY_ENDPOINT_URL` (string, default: Dynatrace endpoint) - OpenKit endpoint URL
+- `DT_MCP_TELEMETRY_DEVICE_ID` (string, default: auto-generated) - Device identifier for tracking
+
+To disable usage tracking, add this to your environment:
+
+```bash
+DT_MCP_DISABLE_TELEMETRY=true
+```
+
 ## Development
 
 For local development purposes, you can use VSCode and GitHub Copilot.

package-lock.json

@@ -50,6 +50,7 @@
     "@dynatrace-sdk/client-platform-management-service": "^1.6.3",
     "@dynatrace-sdk/client-query": "^1.18.1",
     "@dynatrace-sdk/shared-errors": "^1.0.0",
+    "@dynatrace/openkit-js": "^4.1.0",
     "@modelcontextprotocol/sdk": "^1.8.0",
     "commander": "^14.0.0",
     "dotenv": "^17.2.1",

package.json

@@ -9,7 +9,7 @@ import { OAuthTokenResponse } from './types';
  * @param clientSecret - Oauth Client Secret for Dynatrace
  * @param ssoAuthUrl - SSO Authentication URL
  * @param scopes - List of requested scopes
- * @returns
+ * @returns Response of the OAuth Endpoint (which, in the best case includes a token)
  */
 const requestToken = async (
   clientId: string,
@@ -45,7 +45,7 @@ const requestToken = async (
  * @param clientId
  * @param clientSecret
  * @param dtPlatformToken
- * @returns
+ * @returns an authenticated HttpClient
  */
 export const createDtHttpClient = async (
   environmentUrl: string,

src/authentication/dynatrace-clients.ts

@@ -23,7 +23,7 @@ import { randomUUID } from 'node:crypto';
 import { Command } from 'commander';
 import { z, ZodRawShape, ZodTypeAny } from 'zod';
 
-import { version as VERSION } from '../package.json';
+import { getPackageJsonVersion } from './utils/version';
 import { createDtHttpClient } from './authentication/dynatrace-clients';
 import { listVulnerabilities } from './capabilities/list-vulnerabilities';
 import { listProblems } from './capabilities/list-problems';
@@ -41,7 +41,9 @@ import {
   generateDqlFromNaturalLanguage,
 } from './capabilities/davis-copilot';
 import { DynatraceEnv, getDynatraceEnv } from './getDynatraceEnv';
+import { createTelemetry, Telemetry } from './utils/telemetry-openkit';
 import { getEntityTypeFromId } from './utils/dynatrace-entity-types';
+import { Http2ServerRequest } from 'node:http2';
 
 config();
 
@@ -90,7 +92,7 @@ const main = async () => {
     console.error((err as Error).message);
     process.exit(1);
   }
-  console.error(`Initializing Dynatrace MCP Server v${VERSION}...`);
+  console.error(`Initializing Dynatrace MCP Server v${getPackageJsonVersion()}...`);
   const { oauthClientId, oauthClientSecret, dtEnvironment, dtPlatformToken, slackConnectionId } = dynatraceEnv;
 
   // Test connection on startup
@@ -122,11 +124,28 @@ const main = async () => {
     }
   }
 
-  console.error(`Starting Dynatrace MCP Server v${VERSION}...`);
+  console.error(`Starting Dynatrace MCP Server v${getPackageJsonVersion()}...`);
+
+  // Initialize usage tracking
+  const telemetry = createTelemetry();
+  await telemetry.trackMcpServerStart();
+
+  // Create a shutdown handler that takes shutdown operations as parameters
+  const shutdownHandler = (...shutdownOps: Array<() => void | Promise<void>>) => {
+    return async () => {
+      console.error('Shutting down MCP server...');
+      for (const op of shutdownOps) {
+        await op();
+      }
+      process.exit(0);
+    };
+  };
+
+  // Initialize Metadata for MCP Server
   const server = new McpServer(
     {
       name: 'Dynatrace MCP Server',
-      version: VERSION,
+      version: getPackageJsonVersion(),
     },
     {
       capabilities: {
@@ -143,12 +162,22 @@ const main = async () => {
     cb: (args: z.objectOutputType<ZodRawShape, ZodTypeAny>) => Promise<string>,
   ) => {
     const wrappedCb = async (args: ZodRawShape): Promise<CallToolResult> => {
+      // track starttime for telemetry
+      const startTime = Date.now();
+      // track toolcall for telemetry
+      let toolCallSuccessful = false;
+
       try {
+        // call the tool
         const response = await cb(args);
+        toolCallSuccessful = true;
         return {
           content: [{ type: 'text', text: response }],
         };
       } catch (error: any) {
+        // Track error
+        telemetry.trackError(error, `tool_${name}`).catch((e) => console.warn('Failed to track error:', e));
+
         // check if it's an error originating from the Dynatrace SDK / API Gateway and provide an appropriate message to the user
         if (isClientRequestError(error)) {
           return {
@@ -162,12 +191,20 @@ const main = async () => {
           content: [{ type: 'text', text: `Error: ${error.message}` }],
           isError: true,
         };
+      } finally {
+        // Track tool usage
+        const duration = Date.now() - startTime;
+        telemetry
+          .trackMcpToolUsage(name, toolCallSuccessful, duration)
+          .catch((e) => console.warn('Failed to track tool usage:', e));
       }
     };
 
     server.tool(name, description, paramsSchema, (args) => wrappedCb(args));
   };
 
+  /** Tool Definitions below */
+
   tool(
     'get_environment_info',
     'Get information about the connected Dynatrace Environment (Tenant) and verify the connection and authentication.',
@@ -778,7 +815,7 @@ const main = async () => {
   program
     .name('dynatrace-mcp-server')
     .description('Dynatrace Model Context Protocol (MCP) Server')
-    .version(VERSION)
+    .version(getPackageJsonVersion())
     .option('--http', 'enable HTTP server mode instead of stdio')
     .option('--server', 'enable HTTP server mode (alias for --http)')
     .option('-p, --port <number>', 'port for HTTP server', '3000')
@@ -825,13 +862,14 @@ const main = async () => {
       console.error(`Dynatrace MCP Server running on HTTP at http://${host}:${httpPort}`);
     });
 
-    // Handle graceful shutdown
-    process.on('SIGINT', () => {
-      console.error('Shutting down HTTP server...');
-      httpServer.close(() => {
-        process.exit(0);
-      });
-    });
+    // Handle graceful shutdown for http server mode
+    process.on(
+      'SIGINT',
+      shutdownHandler(
+        async () => await telemetry.shutdown(),
+        () => new Promise<void>((resolve) => httpServer.close(() => resolve())),
+      ),
+    );
   } else {
     // Default stdio mode
     const transport = new StdioServerTransport();
@@ -840,10 +878,28 @@ const main = async () => {
     await server.connect(transport);
 
     console.error('Dynatrace MCP Server running on stdio');
+
+    // Handle graceful shutdown for stdio mode
+    process.on(
+      'SIGINT',
+      shutdownHandler(async () => await telemetry.shutdown()),
+    );
+    process.on(
+      'SIGTERM',
+      shutdownHandler(async () => await telemetry.shutdown()),
+    );
   }
 };
 
-main().catch((error) => {
+main().catch(async (error) => {
   console.error('Fatal error in main():', error);
+  try {
+    // report error in main
+    const telemetry = createTelemetry();
+    await telemetry.trackError(error, 'main_error');
+    await telemetry.shutdown();
+  } catch (e) {
+    console.warn('Failed to track fatal error:', e);
+  }
   process.exit(1);
 });