feat: Replace list-problems with a DQL based tool (#73)

christian-kreuzberger-dtx · MrManny · web-flow · commit 9fe20bf90b5a · 2025-07-24T11:55:13.000+02:00
* feat: Replace list-problems with a DQL based tool, remove get-problem-details tool.

* Fixed additional space

Co-authored-by: Manuel Warum &lt;manuel.warum@dynatrace.com&gt;

* Fix timeframe for list_problems and docs

* chore: Refactor executeDql to take an object for config

---------

Co-authored-by: Manuel Warum &lt;manuel.warum@dynatrace.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @dynatrace-oss/dynatrace-mcp-server
 
+## 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`
diff --git a/README.md b/README.md
@@ -136,7 +136,6 @@ Depending on the features you are using, the following scopes are needed:
 - `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_)
 - `automation:workflows:read` - read Workflows
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.5.0-rc.1",
+  "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.5.0-rc.1",`
	`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`	`};`