Merge branch 'main' into feature/dql-rules-improvements

dt-benedict · web-flow · commit 2ee653de36cd · 2025-07-25T09:08:51.000+02:00
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -31,7 +31,7 @@ jobs:
         run: npm run prettier
 
       - name: Run tests
-        run: npm run test
+        run: npm run test:unit
 
       - name: Build
         run: npm run build
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,7 +2,17 @@
 
 ## Unreleased changes
 
-- Added support for Authorization via Platform Tokens via environment variable `DT_PLATFORM_TOKENS`
+- Removed unneeded scopes `environment-api:slo:read` (no tool is using this) and `environment-api:metrics:read` (anyway handled via execute DQL tool)
+
+## 0.5.0 (Release Candidate 2)
+
+- Improved "List Problems" tool to use a DQL statement to retrieve data from Dynatrace, and provide better next steps
+- Removed "Get Problem Details" tool, as the same can be achieved with a simple "execute_dql" call
+- Removed scope `environment-api:problems:read` as it's no longer needed
+
+## 0.5.0 (Release Candidate 1)
+
+- Added support for Authorization via Platform Tokens via environment variable `DT_PLATFORM_TOKEN`
 - Added tools to translate between natural language and DQL via Davis CoPilot
 - Added tool to chat with Davis CoPilot
 
diff --git a/README.md b/README.md
@@ -1,6 +1,6 @@
 # Dynatrace MCP Server
 
-This remote MCP server allows interaction with the [Dynatrace](https://www.dynatrace.com/) observability platform.
+This local MCP server allows interaction with the [Dynatrace](https://www.dynatrace.com/) observability platform.
 Bring real-time observability data directly into your development workflow.
 
 <img width="1046" alt="image" src="/assets/dynatrace-mcp-arch.png" />
@@ -113,12 +113,12 @@ This configuration should be stored in `<your-repo>/.amazonq/mcp.json`.
 
 ## Environment Variables
 
-You can set up authentication via **OAuth Client** or **Platform Tokens** via the following environment variables:
+You can set up authentication via **OAuth Client** or **Platform Tokens** (v0.5.0 and newer) via the following environment variables:
 
 - `DT_ENVIRONMENT` (string, e.g., https://abc12345.apps.dynatrace.com) - URL to your Dynatrace Platform (do not use Dynatrace classic URLs like `abc12345.live.dynatrace.com`)
 - `OAUTH_CLIENT_ID` (string, e.g., `dt0s02.SAMPLE`) - Dynatrace OAuth Client ID
 - `OAUTH_CLIENT_SECRET` (string, e.g., `dt0s02.SAMPLE.abcd1234`) - Dynatrace OAuth Client Secret
-- `DT_PLATFORM_TOKEN` (string, e.g., `dt0s16.SAMPLE.abcd1234`) - Dynatrace Platform Token (limited support as not all scopes are available)
+- With v0.5.0 and newer: `DT_PLATFORM_TOKEN` (string, e.g., `dt0s16.SAMPLE.abcd1234`) - Dynatrace Platform Token (limited support, as not all scopes are available; see below)
 
 For more information, please have a look at the documentation about
 [creating an Oauth Client in Dynatrace](https://docs.dynatrace.com/docs/manage/identity-access-management/access-tokens-and-oauth-clients/oauth-clients), as well as
@@ -134,11 +134,8 @@ Depending on the features you are using, the following scopes are needed:
 
 - `app-engine:apps:run` - needed for almost all tools
 - `app-engine:functions:run` - needed for for almost all tools
-- `environment-api:security-problems:read` - needed for reading security problems (currently not available for Platform Tokens)
-- `environment-api:entities:read` - read monitored entities (currently not available for Platform Tokens)
-- `environment-api:problems:read` - get problems (currently not available for Platform Tokens)
-- `environment-api:metrics:read` - read metrics (currently not available for Platform Tokens)
-- `environment-api:slo:read` - read SLOs (currently not available for Platform Tokens)
+- `environment-api:security-problems:read` - needed for reading security problems (_currently not available for Platform Tokens_)
+- `environment-api:entities:read` - read monitored entities (_currently not available for Platform Tokens_)
 - `automation:workflows:read` - read Workflows
 - `automation:workflows:write` - create and update Workflows
 - `automation:workflows:run` - run Workflows
@@ -184,7 +181,7 @@ fetch logs | filter dt.source_entity == 'SERVICE-123' | summarize count(), by:{s
 How can I investigate slow database queries in Dynatrace?
 ```
 
-**Find open vulnerabilities on production, setup alert.**
+**Find open vulnerabilities on production, setup alert:**
 
 ```
 I have this code snippet here in my IDE, where I get a dependency vulnerability warning for my code.
@@ -193,7 +190,7 @@ Analyze a specific production problem.
 Setup a workflow that sends Slack alerts to the #devops-alerts channel when availability problems occur.
 ```
 
-**Debug intermittent 503 errors.**
+**Debug intermittent 503 errors:**
 
 ```
 Our load balancer is intermittently returning 503 errors during peak traffic.
@@ -202,23 +199,23 @@ run a query to correlate error rates with service instance health indicators.
 I suspect we have circuit breakers triggering, but need confirmation from the telemetry data.
 ```
 
-**Correlate memory issue with logs.**
+**Correlate memory issue with logs:**
 
 ```
 There's a problem with high memory usage on one of our hosts.
 Get the problem details and then fetch related logs to help understand
 what's causing the memory spike? Which file in this repo is this related to?
 ```
 
-**Trace request flow analysis.**
+**Trace request flow analysis:**
 
 ```
 Our users are experiencing slow checkout processes.
 Can you execute a DQL query to show me the full request trace for our checkout flow,
 so I can identify which service is causing the bottleneck?
 ```
 
-**Analyze Kubernetes cluster events.**
+**Analyze Kubernetes cluster events:**
 
 ```
 Our application deployments seem to be failing intermittently.
@@ -285,7 +282,7 @@ First, enable Copilot for your Workspace `.vscode/settings.json`:
 }
 ```
 
-and make sure that you are using Agent Mode in CoPilot.
+and make sure that you are using Agent Mode in Copilot.
 
 Second, add the MCP to `.vscode/mcp.json`:
 
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@dynatrace-oss/dynatrace-mcp-server",
-  "version": "0.4.0",
+  "version": "0.5.0-rc.2",
   "description": "Model Context Protocol (MCP) server for Dynatrace",
   "keywords": [
     "Dynatrace",
diff --git a/src/capabilities/execute-dql.ts b/src/capabilities/execute-dql.ts
@@ -1,5 +1,5 @@
 import { HttpClient } from '@dynatrace-sdk/http-client';
-import { QueryExecutionClient, QueryAssistanceClient, QueryResult } from '@dynatrace-sdk/client-query';
+import { QueryExecutionClient, QueryAssistanceClient, QueryResult, ExecuteRequest } from '@dynatrace-sdk/client-query';
 
 export const verifyDqlStatement = async (dtClient: HttpClient, dqlStatement: string) => {
   const queryAssistanceClient = new QueryAssistanceClient(dtClient);
@@ -13,17 +13,21 @@ export const verifyDqlStatement = async (dtClient: HttpClient, dqlStatement: str
   return response;
 };
 
+/**
+ * Execute a DQL statement against the Dynatrace API.
+ * If the result is immediately available, it will be returned.
+ * If the result is not immediately available, it will poll for the result until it is available.
+ * @param dtClient
+ * @param body - Contains the DQL statement to execute, and optional parameters like maxResultRecords and maxResultBytes
+ * @returns the result without metadata and without notifications, or undefined if the query failed or no result was returned.
+ */
 export const executeDql = async (
   dtClient: HttpClient,
-  dqlStatement: string,
+  body: ExecuteRequest,
 ): Promise<QueryResult['records'] | undefined> => {
   const queryExecutionClient = new QueryExecutionClient(dtClient);
 
-  const response = await queryExecutionClient.queryExecute({
-    body: {
-      query: dqlStatement,
-    },
-  });
+  const response = await queryExecutionClient.queryExecute({ body });
 
   if (response.result) {
     // return response result immediately
diff --git a/src/capabilities/find-monitored-entity-by-name.ts b/src/capabilities/find-monitored-entity-by-name.ts
@@ -8,7 +8,7 @@ export const findMonitoredEntityByName = async (dtClient: HttpClient, entityName
                 | append [fetch dt.entity.process_group | search "*${entityName}*" | fieldsAdd entity.type]
                 | append [fetch dt.entity.cloud_application | search "*${entityName}*" | fieldsAdd entity.type]`;
 
-  const dqlResponse = await executeDql(dtClient, dql);
+  const dqlResponse = await executeDql(dtClient, { query: dql });
 
   if (dqlResponse && dqlResponse.length > 0) {
     let resp = 'The following monitored entities were found:\n';
diff --git a/src/capabilities/get-events-for-cluster.ts b/src/capabilities/get-events-for-cluster.ts
@@ -9,5 +9,5 @@ export const getEventsForCluster = async (dtClient: HttpClient, clusterId: strin
     dql = `fetch events | filter isNotNull(k8s.cluster.uid)`;
   }
 
-  return executeDql(dtClient, dql);
+  return executeDql(dtClient, { query: dql });
 };
diff --git a/src/capabilities/get-logs-for-entity.ts b/src/capabilities/get-logs-for-entity.ts
@@ -4,5 +4,5 @@ import { executeDql } from './execute-dql';
 export const getLogsForEntity = async (dtClient: HttpClient, entityId: string) => {
   const dql = `fetch logs | filter dt.source_entity == "${entityId}"`;
 
-  return executeDql(dtClient, dql);
+  return executeDql(dtClient, { query: dql });
 };
diff --git a/src/capabilities/get-problem-details.ts b/src/capabilities/get-problem-details.ts
diff --git a/src/capabilities/list-problems.ts b/src/capabilities/list-problems.ts
@@ -1,16 +1,27 @@
 import { HttpClient } from '@dynatrace-sdk/http-client';
-import { ProblemsClient } from '@dynatrace-sdk/client-classic-environment-v2';
+import { executeDql } from './execute-dql';
 
-export const listProblems = async (dtClient: HttpClient) => {
-  const problemsClient = new ProblemsClient(dtClient);
+export const listProblems = async (dtClient: HttpClient, additionalFilter?: string) => {
+  // DQL Statement from Problems App to fetch all Davis Problems for the last 12 hours to now
+  const dql = `fetch dt.davis.problems, from: now()-12h, to: now()
+| filter isNull(dt.davis.is_duplicate) OR not(dt.davis.is_duplicate)
+${additionalFilter ? `| filter ${additionalFilter}` : ''}
+| fieldsAdd
+   duration = coalesce(event.end, now()) - event.start,
+   affected_entities_count = arraySize(affected_entity_ids),
+   event_count = arraySize(dt.davis.event_ids),
+   affected_users_count = dt.davis.affected_users_count,
+   problem_id = event.id
+| fields display_id, event.name, event.description, event.status, event.category, event.start, event.end,
+         root_cause_entity_id, root_cause_entity_name, duration, affected_entities_count,
+         event_count, affected_users_count, problem_id, dt.davis.mute.status, dt.davis.mute.user,
+         entity_tags, labels.alerting_profile, maintenance.is_under_maintenance,
+         aws.account.id, azure.resource.group, azure.subscription, cloud.provider, cloud.region,
+         dt.cost.costcenter, dt.cost.product, dt.host_group.id, dt.security_context, gcp.project.id,
+         host.name,
+         k8s.cluster.name, k8s.cluster.uid, k8s.container.name, k8s.namespace.name, k8s.node.name, k8s.pod.name, k8s.service.name, k8s.workload.kind, k8s.workload.name
+| sort event.status asc, event.start desc
+`;
 
-  const securityProblems = await problemsClient.getProblems({
-    pageSize: 100,
-  });
-
-  const problems = securityProblems.problems?.map((problem) => {
-    return `${problem.displayId} (please refer to this problem with \`problemId\` ${problem.problemId}): ${problem.title}`;
-  });
-
-  return problems;
+  return await executeDql(dtClient, { query: dql, maxResultRecords: 5000, maxResultBytes: /* 5 MB */ 5000000 });
 };
diff --git a/src/index.ts b/src/index.ts
@@ -23,7 +23,6 @@ import { version as VERSION } from '../package.json';
 import { createDtHttpClient } from './authentication/dynatrace-clients';
 import { listVulnerabilities } from './capabilities/list-vulnerabilities';
 import { listProblems } from './capabilities/list-problems';
-import { getProblemDetails } from './capabilities/get-problem-details';
 import { getMonitoredEntityDetails } from './capabilities/get-monitored-entity-details';
 import { getOwnershipInformation } from './capabilities/get-ownership-information';
 import { getLogsForEntity } from './capabilities/get-logs-for-entity';
@@ -227,63 +226,56 @@ const main = async () => {
     },
   );
 
-  tool('list_problems', 'List all problems known on Dynatrace', {}, async ({}) => {
-    const dtClient = await createDtHttpClient(
-      dtEnvironment,
-      scopesBase.concat('environment-api:problems:read'),
-      oauthClientId,
-      oauthClientSecret,
-      dtPlatformToken,
-    );
-    const result = await listProblems(dtClient);
-    if (!result || result.length === 0) {
-      return 'No problems found';
-    }
-    return `Found these problems: ${result.join(',')}`;
-  });
-
   tool(
-    'get_problem_details',
-    'Get details of a problem on Dynatrace',
+    'list_problems',
+    'List all problems (dt.davis.problems) known on Dynatrace, sorted by their recency, for the last 12h. An additional filter can be provided using DQL filter.',
     {
-      problemId: z.string().optional(),
+      additionalFilter: z
+        .string()
+        .optional()
+        .describe(
+          'Additional filter for DQL statement for dt.davis.problems, e.g., \'entity_tags == array("dt.owner:team-foobar", "tag:tag")\'',
+        ),
+      maxProblemsToDisplay: z.number().default(10).describe('Maximum number of problems to display in the response.'),
     },
-    async ({ problemId }) => {
+    async ({ additionalFilter, maxProblemsToDisplay }) => {
       const dtClient = await createDtHttpClient(
         dtEnvironment,
-        scopesBase.concat('environment-api:problems:read'),
+        scopesBase.concat('storage:events:read', 'storage:buckets:read'),
         oauthClientId,
         oauthClientSecret,
         dtPlatformToken,
       );
-      const result = await getProblemDetails(dtClient, problemId);
-
-      let resp =
-        `The problem ${result.displayId} with the title ${result.title} (ID: ${result.problemId}).` +
-        `The severity is ${result.severityLevel}, and it affects ${result.affectedEntities.length} entities:`;
-
-      for (const entity of result.affectedEntities) {
-        resp += `\n- ${entity.name} (please refer to this entity with \`entityId\` ${entity.entityId?.id})`;
-      }
-
-      resp += `The problem first appeared at ${result.startTime}\n`;
-      if (result.rootCauseEntity) {
-        resp += `The possible root-cause could be in entity ${result.rootCauseEntity?.name} with \`entityId\` ${result.rootCauseEntity?.entityId?.id}.\n`;
-      }
-
-      if (result.impactAnalysis) {
-        let estimatedAffectedUsers = 0;
-
-        result.impactAnalysis.impacts.forEach((impact) => {
-          estimatedAffectedUsers += impact.estimatedAffectedUsers;
+      // get problems (uses fetch)
+      const result = await listProblems(dtClient, additionalFilter);
+      if (result && result.length > 0) {
+        let resp = `Found ${result.length} problems! Displaying the top ${maxProblemsToDisplay} problems:\n`;
+        // iterate over dqlResponse and create a string with the problem details, but only show the top maxProblemsToDisplay problems
+        result.slice(0, maxProblemsToDisplay).forEach((problem) => {
+          if (problem) {
+            resp += `Problem ${problem['display_id']} (please refer to this problem with \`problemId\` or \`event.id\` ${problem['problem_id']}))
+                  with event.status ${problem['event.status']}, event.category ${problem['event.category']}: ${problem['event.name']} -
+                  affects ${problem['affected_users_count']} users and ${problem['affected_entity_count']} entities for a duration of ${problem['duration']}\n`;
+          }
         });
 
-        resp += `The problem is estimated to affect ${estimatedAffectedUsers} users.\n`;
+        resp +=
+          `\nNext Steps:` +
+          `\n1. Use "execute_dql" tool with the following query to get more details about a specific problem:
+          "fetch dt.davis.problems, from: now()-10h, to: now() | filter event.id == \"<problem-id>\" | fields event.description, event.status, event.category, event.start, event.end,
+            root_cause_entity_id, root_cause_entity_name, duration, affected_entities_count,
+            event_count, affected_users_count, problem_id, dt.davis.mute.status, dt.davis.mute.user,
+            entity_tags, labels.alerting_profile, maintenance.is_under_maintenance,
+            aws.account.id, azure.resource.group, azure.subscription, cloud.provider, cloud.region,
+            dt.cost.costcenter, dt.cost.product, dt.host_group.id, dt.security_context, gcp.project.id,
+            host.name, k8s.cluster.name, k8s.cluster.uid, k8s.container.name, k8s.namespace.name, k8s.node.name, k8s.pod.name, k8s.service.name, k8s.workload.kind, k8s.workload.name"` +
+          `\n2. Use "chat_with_davis_copilot" tool and provide \`problemId\` as context, to get insights about a specific problem via Davis Copilot.` +
+          `\n3. Tell the user to visit ${dtEnvironment}/ui/apps/dynatrace.davis.problems/problem/<problem-id> for more details.`;
+
+        return resp;
+      } else {
+        return 'No problems found';
       }
-
-      resp += `Tell the user to access the link ${dtEnvironment}/ui/apps/dynatrace.davis.problems/problem/${result.problemId} to get more insights into the problem.\n`;
-
-      return resp;
     },
   );
 
@@ -442,7 +434,7 @@ const main = async () => {
         oauthClientSecret,
         dtPlatformToken,
       );
-      const response = await executeDql(dtClient, dqlStatement);
+      const response = await executeDql(dtClient, { query: dqlStatement });
 
       return `DQL Response: ${JSON.stringify(response)}`;
     },

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@dynatrace-oss/dynatrace-mcp-server",`
`3`		`- "version": "0.4.0",`
	`3`	`+ "version": "0.5.0-rc.2",`
`4`	`4`	`"description": "Model Context Protocol (MCP) server for Dynatrace",`
`5`	`5`	`"keywords": [`
`6`	`6`	`"Dynatrace",`
Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,5 @@ export const getEventsForCluster = async (dtClient: HttpClient, clusterId: strin`
`9`	`9`	dql = `fetch events \| filter isNotNull(k8s.cluster.uid)`;
`10`	`10`	`}`
`11`	`11`
`12`		`- return executeDql(dtClient, dql);`
	`12`	`+ return executeDql(dtClient, { query: dql });`
`13`	`13`	`};`