@dynatrace-oss/dynatrace-mcp-server 0.5.0-rc.3 → 0.5.0

package/README.md

@@ -11,6 +11,11 @@ Bring real-time observability data directly into your development workflow.
 - **Contextual debugging** - Fix issues with full context from monitored exceptions, logs, and anomalies
 - **Security insights** - Get detailed vulnerability analysis and security problem tracking
 - **Natural language queries** - Use AI-powered DQL generation and explanation
+- **Multi-phase incident investigation** - Systematic 4-phase approach with automated impact assessment
+- **Advanced transaction analysis** - Precise root cause identification with file/line-level accuracy
+- **Cross-data source correlation** - Connect problems → spans → logs with trace ID correlation
+- **DevOps automation** - Deployment health gates with automated promotion/rollback logic
+- **Security compliance monitoring** - Multi-cloud compliance assessment with evidence-based investigation
 
 ## Capabilities
 
@@ -22,6 +27,20 @@ Bring real-time observability data directly into your development workflow.
 - Get more information about a monitored entity
 - Get Ownership of an entity
 
+## Costs
+
+**Important:** While this local MCP server is provided for free, using it to access data in Dynatrace Grail may incur additional costs based
+on your Dynatrace consumption model. This affects `execute_dql` tool and other capabilities that **query** Dynatrace Grail storage, and costs
+depend on the volume (GB scanned/billed).
+
+**Before using this MCP server extensively, please:**
+
+1. Review your current Dynatrace consumption model and pricing
+2. Understand the cost implications of the specific data you plan to query (logs, events, metrics) - see [Dynatrace Pricing and Rate Card](https://www.dynatrace.com/pricing/)
+3. Start with smaller timeframes (e.g., 12h-24h) and make use of [buckets](https://docs.dynatrace.com/docs/discover-dynatrace/platform/grail/data-model#built-in-grail-buckets) to reduce the cost impact
+
+**Note**: We will be providing a way to monitor Query Usage of the dynatrace-mcp-server in the future.
+
 ### AI-Powered Assistance (Preview)
 
 - **Natural Language to DQL** - Convert plain English queries to Dynatrace Query Language
@@ -31,6 +50,97 @@ Bring real-time observability data directly into your development workflow.
 
 > **Note:** While Davis CoPilot AI is generally available (GA), the Davis CoPilot APIs are currently in preview. For more information, visit the [Davis CoPilot Preview Community](https://dt-url.net/copilot-community).
 
+## 🎯 AI-Powered Observability Workshop Rules
+
+Enhance your AI assistant with comprehensive Dynatrace observability analysis capabilities through our streamlined workshop rules. These rules provide hierarchical workflows for security, compliance, incident response, and distributed systems investigation.
+
+### **🚀 Quick Setup for AI Assistants**
+
+Copy the comprehensive rule files from the [`rules/`](./rules/) directory to your AI assistant's rules directory:
+
+**IDE-Specific Locations:**
+
+- **Amazon Q**: `.amazonq/rules/` (project) or `~/.aws/amazonq/rules/` (global)
+- **Cursor**: `.cursor/rules/` (project) or via Settings → Rules (global)
+- **Windsurf**: `.windsurfrules/` (project) or via Customizations → Rules (global)
+- **Cline**: `.clinerules/` (project) or `~/Documents/Cline/Rules/` (global)
+- **GitHub Copilot**: `.github/copilot-instructions.md` (project only)
+
+Then initialize the agent in your AI chat:
+
+```
+load dynatrace mcp
+```
+
+### **🏗️ Enhanced Analysis Capabilities**
+
+The workshop rules unlock advanced observability analysis modes:
+
+#### **🚨 Incident Response & Problem Investigation**
+
+- **4-phase structured investigation** workflow (Detection → Impact → Root Cause → Resolution)
+- **Cross-data source correlation** (problems → logs → spans → metrics)
+- **Kubernetes-aware incident analysis** with namespace and pod context
+- **User impact assessment** with Davis AI integration
+
+#### **📊 Comprehensive Data Investigation**
+
+- **Unified log-service-process analysis** in single workflow
+- **Business logic error detection** patterns
+- **Deployment correlation analysis** with ArgoCD/GitOps integration
+- **Golden signals monitoring** (Rate, Errors, Duration, Saturation)
+
+#### **🔗 Advanced Transaction Analysis**
+
+- **Precise root cause identification** with file/line numbers
+- **Exception stack trace analysis** with business context
+- **Multi-service cascade failure analysis**
+- **Performance impact correlation** across distributed systems
+
+#### **🛡️ Enhanced Security & Compliance**
+
+- **Latest-scan analysis** prevents outdated data aggregation
+- **Multi-cloud compliance** (AWS, Azure, GCP, Kubernetes)
+- **Evidence-based investigation** with detailed remediation paths
+- **Risk-based scoring** with team-specific guidance
+
+#### **⚡ DevOps Automation & SRE**
+
+- **Deployment health gates** with automated promotion/rollback
+- **SLO/SLI automation** with error budget calculations
+- **Infrastructure as Code remediation** with auto-generated templates
+- **Alert optimization workflows** with pattern recognition
+
+### **📁 Hierarchical Rule Architecture**
+
+The rules are organized in a context-window optimized structure:
+
+```
+rules/
+├── DynatraceMcpIntegration.md                    # 🎯 MAIN ORCHESTRATOR
+├── workflows/                                    # 🔧 ANALYSIS WORKFLOWS
+│   ├── incidentResponse.md                       # Core incident investigation
+│   ├── DynatraceSecurityCompliance.md           # Security & compliance analysis
+│   ├── DynatraceDevOpsIntegration.md            # CI/CD automation
+│   └── dataSourceGuides/                        # 📊 DATA ANALYSIS GUIDES
+│       ├── dataInvestigation.md                 # Logs, services, processes
+│       └── DynatraceSpanAnalysis.md             # Transaction tracing
+└── reference/                                   # 📚 TECHNICAL DOCUMENTATION
+    ├── DynatraceQueryLanguage.md                # DQL syntax foundation
+    ├── DynatraceExplore.md                      # Field discovery patterns
+    ├── DynatraceSecurityEvents.md               # Security events schema
+    └── DynatraceProblemsSpec.md                 # Problems schema reference
+```
+
+**Key Architectural Benefits:**
+
+- **All files under 6,500 tokens** - Compatible with most LLM context limits
+- **Hierarchical organization** - Clear entry points and specialized guides
+- **Eliminated circular references** - No more confusing cross-referencing webs
+- **DQL-first approach** - Prefer flexible queries over rigid MCP calls
+
+For detailed information about the workshop rules, see the [Rules README](./rules/README.md).
+
 ## Quickstart
 
 You can add this MCP server (using STDIO) to your MCP Client like VS Code, Claude, Cursor, Amazon Q Developer CLI, Windsurf Github Copilot via the package `@dynatrace-oss/dynatrace-mcp-server`.
@@ -111,6 +221,82 @@ The [Amazon Q Developer CLI](https://docs.aws.amazon.com/amazonq/latest/qdevelop
 
 This configuration should be stored in `<your-repo>/.amazonq/mcp.json`.
 
+### HTTP Server Mode (Alternative)
+
+For scenarios where you need to run the MCP server as an HTTP service instead of using stdio (e.g., for stateful sessions, load balancing, or integration with web clients), you can use the HTTP server mode:
+
+**Running as HTTP server:**
+
+```bash
+# Get help and see all available options
+npx -y @dynatrace-oss/dynatrace-mcp-server --help
+
+# Run with HTTP server on default port 3000
+npx -y @dynatrace-oss/dynatrace-mcp-server --http
+
+# Run with custom port (using short or long flag)
+npx -y @dynatrace-oss/dynatrace-mcp-server --server -p 8080
+npx -y @dynatrace-oss/dynatrace-mcp-server --http --port 3001
+
+# Run with custom host/IP (using short or long flag)
+npx -y @dynatrace-oss/dynatrace-mcp-server --http --host 127.0.0.1
+npx -y @dynatrace-oss/dynatrace-mcp-server --http -H 192.168.0.1
+
+# Check version
+npx -y @dynatrace-oss/dynatrace-mcp-server --version
+```
+
+**Configuration for MCP clients that support HTTP transport:**
+
+```json
+{
+  "mcpServers": {
+    "dynatrace-http": {
+      "url": "http://localhost:3000",
+      "transport": "http"
+    }
+  }
+}
+```
+
+**Configuration for MCP clients that support HTTP transport:**
+
+```json
+{
+  "mcpServers": {
+    "dynatrace-http": {
+      "url": "http://localhost:3000",
+      "transport": "http"
+    }
+  }
+}
+```
+
+### Rule File
+
+For efficient result retrieval from Dynatrace, please consider creating a rule file (e.g., [.github/copilot-instructions.md](https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions), [.amazonq/rules/](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/context-project-rules.html)), instructing coding agents on how to get more details for your component/app/service. Here is an example for [easytrade](https://github.com/Dynatrace/easytrade), please adapt the names and filters to fit your use-cases and components:
+
+```
+# Observability
+
+We use Dynatrace as an Observability solution. This document provides instructions on how to get data for easytrade from Dynatrace using DQL.
+
+## How to get any data for my App
+
+Depending on the query and tool used, the following filters can be applied to narrow down results:
+
+* `contains(entity.name, "easytrade")`
+* `contains(affected_entity.name, "easytrade")`
+* `contains(container.name, "easytrade")`
+
+For best results, you can combine these filters with an `OR` operator.
+
+## Logs
+
+To fetch logs for easytrade, execute `fetch logs | filter contains(container.name, "easyatrade")`.
+For fetching just error-logs, add `| filter loglevel == "ERROR"`.
+```
+
 ## Environment Variables
 
 You can set up authentication via **OAuth Client** or **Platform Tokens** (v0.5.0 and newer) via the following environment variables:
@@ -134,7 +320,7 @@ 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:entities:read` - read monitored entities (_currently not available for Platform Tokens_)
+- `environment-api:entities:read` - for retrieving ownership details from 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
@@ -159,7 +345,9 @@ Depending on the features you are using, the following scopes are needed:
 ## ✨ Example prompts ✨
 
 Use these example prompts as a starting point. Just copy them into your IDE or agent setup, adapt them to your services/stack/architecture,
-and extend them as needed. They’re here to help you imagine how real-time observability and automation work together in the MCP context in your IDE.
+and extend them as needed. They're here to help you imagine how real-time observability and automation work together in the MCP context in your IDE.
+
+### **Basic Queries & AI Assistance**
 
 **Write a DQL query from natural language:**
 
@@ -180,6 +368,85 @@ fetch logs | filter dt.source_entity == 'SERVICE-123' | summarize count(), by:{s
 How can I investigate slow database queries in Dynatrace?
 ```
 
+### **Advanced Incident Investigation**
+
+**Multi-phase incident response:**
+
+```
+Our checkout service is experiencing high error rates. Start a systematic 4-phase incident investigation:
+1. Detect and triage the active problems
+2. Assess user impact and affected services
+3. Perform cross-data source analysis (problems → spans → logs)
+4. Identify root cause with file/line-level precision
+```
+
+**Cross-service failure analysis:**
+
+```
+We have cascading failures across our microservices architecture.
+Analyze the entity relationships and trace the failure propagation from the initial problem
+through all downstream services. Show me the correlation timeline.
+```
+
+### **Security & Compliance Analysis**
+
+**Latest-scan vulnerability assessment:**
+
+```
+Perform a comprehensive security analysis using the latest scan data:
+- Check for new vulnerabilities in our production environment
+- Focus on critical and high-severity findings
+- Provide evidence-based remediation paths
+- Generate risk scores with team-specific guidance
+```
+
+**Multi-cloud compliance monitoring:**
+
+```
+Run a compliance assessment across our AWS, Azure, and Kubernetes environments.
+Check for configuration drift and security posture changes in the last 24 hours.
+```
+
+### **DevOps & SRE Automation**
+
+**Deployment health gate analysis:**
+
+```
+Our latest deployment is showing performance degradation.
+Run deployment health gate analysis with:
+- Golden signals monitoring (Rate, Errors, Duration, Saturation)
+- SLO/SLI validation with error budget calculations
+- Generate automated rollback recommendation if needed
+```
+
+**Infrastructure as Code remediation:**
+
+```
+Generate Infrastructure as Code templates to remediate the current alert patterns.
+Include automated scaling policies and resource optimization recommendations.
+```
+
+### **Deep Transaction Analysis**
+
+**Business logic error investigation:**
+
+```
+Our payment processing is showing intermittent failures.
+Perform advanced transaction analysis:
+- Extract exception details with full stack traces
+- Correlate with deployment events and ArgoCD changes
+- Identify the exact code location causing the issue
+```
+
+**Performance correlation analysis:**
+
+```
+Analyze the performance impact across our distributed system for the slow checkout flow.
+Show me the complete trace analysis with business context and identify bottlenecks.
+```
+
+### **Traditional Use Cases (Enhanced)**
+
 **Find open vulnerabilities on production, setup alert:**
 
 ```
@@ -301,6 +568,20 @@ Third, create a `.env` file in this repository (you can copy from `.env.template
 
 Finally, make changes to your code and compile it with `npm run build` or just run `npm run watch` and it auto-compiles.
 
+## Releasing
+
+When you are preparing for a release, you can use GitHub Copilot to guide you through the preparations.
+
+In Visual Studio Code, you can use `/release` in the chat with Copilot in Agent Mode, which will execute [release.prompt.md](.github/prompts/release.prompt.md).
+
+You may include additional information such as the version number. If not specified, you will be asked.
+
+This will
+
+- prepare the [changelog](CHANGELOG.md),
+- update the version number in [package.json](package.json),
+- commit the changes.
+
 ## Notes
 
 This product is not officially supported by Dynatrace.

package/dist/authentication/dynatrace-clients.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDtHttpClient = void 0;
 const http_client_1 = require("@dynatrace-sdk/http-client");
 const dt_app_1 = require("dt-app");
-const package_json_1 = require("../../package.json");
+const user_agent_1 = require("../utils/user-agent");
 /**
  * Uses the provided oauth Client ID and Secret and requests a token via client-credentials flow
  * @param clientId - OAuth Client ID for Dynatrace
@@ -60,7 +60,7 @@ const createBearerTokenHttpClient = async (environmentUrl, dtPlatformToken) => {
         baseUrl: environmentUrl,
         defaultHeaders: {
             'Authorization': `Bearer ${dtPlatformToken}`,
-            'User-Agent': `dynatrace-mcp-server/v${package_json_1.version} (${process.platform}-${process.arch})`,
+            'User-Agent': (0, user_agent_1.getUserAgent)(),
         },
     });
 };

package/dist/authentication/dynatrace-clients.test.js

@@ -62,7 +62,7 @@ describe('dynatrace-clients', () => {
                     baseUrl: environmentUrl,
                     defaultHeaders: {
                         'Authorization': 'Bearer test-access-token',
-                        'User-Agent': 'dynatrace-mcp-server/v1.0.0-test (linux-x64)',
+                        'User-Agent': expect.stringMatching(/^dynatrace-mcp-server\/v1\.0\.0-test \(\w+-\w+\)$/),
                     },
                 });
                 expect(result).toBeInstanceOf(http_client_1.PlatformHttpClient);
@@ -131,7 +131,7 @@ describe('dynatrace-clients', () => {
                     baseUrl: environmentUrl,
                     defaultHeaders: {
                         'Authorization': `Bearer ${dtPlatformToken}`,
-                        'User-Agent': 'dynatrace-mcp-server/v1.0.0-test (linux-x64)',
+                        'User-Agent': expect.stringMatching(/^dynatrace-mcp-server\/v1\.0\.0-test \(\w+-\w+\)$/),
                     },
                 });
                 expect(result).toBeInstanceOf(http_client_1.PlatformHttpClient);

package/dist/capabilities/execute-dql.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeDql = exports.verifyDqlStatement = void 0;
 const client_query_1 = require("@dynatrace-sdk/client-query");
+const user_agent_1 = require("../utils/user-agent");
 const verifyDqlStatement = async (dtClient, dqlStatement) => {
     const queryAssistanceClient = new client_query_1.QueryAssistanceClient(dtClient);
     const response = await queryAssistanceClient.queryVerify({
@@ -22,7 +23,10 @@ exports.verifyDqlStatement = verifyDqlStatement;
  */
 const executeDql = async (dtClient, body) => {
     const queryExecutionClient = new client_query_1.QueryExecutionClient(dtClient);
-    const response = await queryExecutionClient.queryExecute({ body });
+    const response = await queryExecutionClient.queryExecute({
+        body,
+        dtClientContext: (0, user_agent_1.getUserAgent)(),
+    });
     if (response.result) {
         // return response result immediately
         return response.result.records;
@@ -36,6 +40,7 @@ const executeDql = async (dtClient, body) => {
             await new Promise((resolve) => setTimeout(resolve, 2000));
             pollResponse = await queryExecutionClient.queryPoll({
                 requestToken: response.requestToken,
+                dtClientContext: (0, user_agent_1.getUserAgent)(),
             });
             // done - let's return it
             if (pollResponse.result) {

package/dist/capabilities/find-monitored-entity-by-name.js

@@ -1,13 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findMonitoredEntityByName = void 0;
+exports.findMonitoredEntityByName = exports.generateDqlSearchEntityCommand = void 0;
 const execute_dql_1 = require("./execute-dql");
+const dynatrace_entity_types_1 = require("../utils/dynatrace-entity-types");
+/**
+ * Construct a DQL statement like "fetch <entityType> | search "*<entityName>*" | fieldsAdd entity.type" for each entity type,
+ * and join them with " | append [ ... ]"
+ * @param entityName
+ * @returns DQL Statement for searching all entity types
+ */
+const generateDqlSearchEntityCommand = (entityName) => {
+    const fetchDqlCommands = dynatrace_entity_types_1.DYNATRACE_ENTITY_TYPES.map((entityType, index) => {
+        const dql = `fetch ${entityType} | search "*${entityName}*" | fieldsAdd entity.type`;
+        if (index === 0) {
+            return dql;
+        }
+        return `  | append [ ${dql} ]\n`;
+    });
+    return fetchDqlCommands.join('');
+};
+exports.generateDqlSearchEntityCommand = generateDqlSearchEntityCommand;
+/**
+ * Find a monitored entity by name via DQL
+ * @param dtClient
+ * @param entityName
+ * @returns A string with the entity details like id, name and type, or an error message if no entity was found
+ */
 const findMonitoredEntityByName = async (dtClient, entityName) => {
-    const dql = `fetch dt.entity.application | search "*${entityName}*" | fieldsAdd entity.type
-                | append [fetch dt.entity.service | search "*${entityName}*" | fieldsAdd entity.type]
-                | append [fetch dt.entity.host | search "*${entityName}*" | fieldsAdd entity.type]
-                | append [fetch dt.entity.process_group | search "*${entityName}*" | fieldsAdd entity.type]
-                | append [fetch dt.entity.cloud_application | search "*${entityName}*" | fieldsAdd entity.type]`;
+    if (!entityName) {
+        return 'You need to provide an entity name to search for.';
+    }
+    // construct a DQL statement for searching the entityName over all entity types
+    const dql = (0, exports.generateDqlSearchEntityCommand)(entityName);
+    // Get response from API
+    // Note: This may be slow, as we are appending multiple entity types above
     const dqlResponse = await (0, execute_dql_1.executeDql)(dtClient, { query: dql });
     if (dqlResponse && dqlResponse.length > 0) {
         let resp = 'The following monitored entities were found:\n';

package/dist/capabilities/find-monitored-entity-by-name.test.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dynatrace_entity_types_1 = require("../utils/dynatrace-entity-types");
+const find_monitored_entity_by_name_1 = require("./find-monitored-entity-by-name");
+describe('generateDqlSearchCommand', () => {
+    beforeEach(() => {
+        // Ensure we have at least some entity types for testing
+        expect(dynatrace_entity_types_1.DYNATRACE_ENTITY_TYPES.length).toBeGreaterThan(0);
+    });
+    it('should include all entity types from DYNATRACE_ENTITY_TYPES', () => {
+        const entityName = 'test';
+        const result = (0, find_monitored_entity_by_name_1.generateDqlSearchEntityCommand)(entityName);
+        console.log(result);
+        // Check that all entity types are included in the DQL
+        dynatrace_entity_types_1.DYNATRACE_ENTITY_TYPES.forEach((entityType) => {
+            expect(result).toContain(`fetch ${entityType}`);
+        });
+    });
+    it('should structure the DQL correctly with first fetch and subsequent appends', () => {
+        const entityName = 'test';
+        const result = (0, find_monitored_entity_by_name_1.generateDqlSearchEntityCommand)(entityName);
+        // First entity type should not have append prefix
+        const firstEntityType = dynatrace_entity_types_1.DYNATRACE_ENTITY_TYPES[0];
+        expect(result).toContain(`fetch ${firstEntityType} | search "*${entityName}*" | fieldsAdd entity.type`);
+        // Subsequent entity types should have append prefix (if there are more than 1)
+        if (dynatrace_entity_types_1.DYNATRACE_ENTITY_TYPES.length > 1) {
+            const secondEntityType = dynatrace_entity_types_1.DYNATRACE_ENTITY_TYPES[1];
+            expect(result).toContain(`  | append [ fetch ${secondEntityType} | search "*${entityName}*" | fieldsAdd entity.type ]`);
+        }
+    });
+});

package/dist/capabilities/get-monitored-entity-details.js

@@ -1,12 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMonitoredEntityDetails = void 0;
-const client_classic_environment_v2_1 = require("@dynatrace-sdk/client-classic-environment-v2");
+const execute_dql_1 = require("./execute-dql");
+const dynatrace_entity_types_1 = require("../utils/dynatrace-entity-types");
+/**
+ * Get monitored entity details by entity ID via DQL
+ * @param dtClient
+ * @param entityId
+ * @returns Details about the monitored entity, or undefined in case we couldn't find it
+ */
 const getMonitoredEntityDetails = async (dtClient, entityId) => {
-    const monitoredEntitiesClient = new client_classic_environment_v2_1.MonitoredEntitiesClient(dtClient);
-    const entityDetails = await monitoredEntitiesClient.getEntity({
-        entityId: entityId,
-    });
-    return entityDetails;
+    // Try to determine the entity type directly from the entity ID (e.g., PROCESS_GROUP-F84E4759809ADA84 -> dt.entity.process_group)
+    const entityType = (0, dynatrace_entity_types_1.getEntityTypeFromId)(entityId);
+    if (!entityType) {
+        console.error(`Couldn't determine entity type for ID: ${entityId}. Please raise an issue at https://github.com/dynatrace-oss/dynatrace-mcp/issues if you believe this is a bug.`);
+        return;
+    }
+    // construct DQL statement like `fetch dt.entity.hosts | filter id == "HOST-1234"`
+    const dql = `fetch ${entityType} | filter id == "${entityId}" | expand tags | fieldsAdd entity.type`;
+    // Get response from API
+    const dqlResponse = await (0, execute_dql_1.executeDql)(dtClient, { query: dql });
+    // verify response and length
+    if (!dqlResponse || dqlResponse.length === 0) {
+        console.error(`No entity found for ID: ${entityId}`);
+        return;
+    }
+    // in case we have more than one entity -> log it
+    if (dqlResponse.length > 1) {
+        console.error(`Multiple entities (${dqlResponse.length}) found for entity ID: ${entityId}. Returning the first one.`);
+    }
+    const entity = dqlResponse[0];
+    // make typescript happy; entity should never be null though
+    if (!entity) {
+        console.error(`No entity found for ID: ${entityId}`);
+        return;
+    }
+    // return entity details
+    return {
+        entityId: String(entity.id),
+        displayName: String(entity['entity.name']),
+        type: String(entity['entity.type']),
+        allProperties: entity || undefined,
+    };
 };
 exports.getMonitoredEntityDetails = getMonitoredEntityDetails;

package/dist/index.js

@@ -4,8 +4,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const client_platform_management_service_1 = require("@dynatrace-sdk/client-platform-management-service");
 const shared_errors_1 = require("@dynatrace-sdk/shared-errors");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const dotenv_1 = require("dotenv");
+const node_http_1 = require("node:http");
+const node_crypto_1 = require("node:crypto");
+const commander_1 = require("commander");
 const zod_1 = require("zod");
 const package_json_1 = require("../package.json");
 const dynatrace_clients_1 = require("./authentication/dynatrace-clients");
@@ -13,7 +17,6 @@ const list_vulnerabilities_1 = require("./capabilities/list-vulnerabilities");
 const list_problems_1 = require("./capabilities/list-problems");
 const get_monitored_entity_details_1 = require("./capabilities/get-monitored-entity-details");
 const get_ownership_information_1 = require("./capabilities/get-ownership-information");
-const get_logs_for_entity_1 = require("./capabilities/get-logs-for-entity");
 const get_events_for_cluster_1 = require("./capabilities/get-events-for-cluster");
 const create_workflow_for_problem_notification_1 = require("./capabilities/create-workflow-for-problem-notification");
 const update_workflow_1 = require("./capabilities/update-workflow");
@@ -27,6 +30,24 @@ let scopesBase = [
     'app-engine:apps:run', // needed for environmentInformationClient
     'app-engine:functions:run', // needed for environmentInformationClient
 ];
+/**
+ * Performs a connection test to the Dynatrace environment.
+ * Throws an error if the connection or authentication fails.
+ */
+async function testDynatraceConnection(dtEnvironment, oauthClientId, oauthClientSecret, dtPlatformToken) {
+    const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase, oauthClientId, oauthClientSecret, dtPlatformToken);
+    const environmentInformationClient = new client_platform_management_service_1.EnvironmentInformationClient(dtClient);
+    // This call will fail if authentication is incorrect.
+    await environmentInformationClient.getEnvironmentInformation();
+}
+function handleClientRequestError(error) {
+    let additionalErrorInformation = '';
+    if (error.response.status === 403) {
+        additionalErrorInformation =
+            'Note: Your user or service-user is most likely lacking the necessary permissions/scopes for this API Call.';
+    }
+    return `Client Request Error: ${error.message} with HTTP status: ${error.response.status}. ${additionalErrorInformation} (body: ${JSON.stringify(error.body)})`;
+}
 const main = async () => {
     // read Environment variables
     let dynatraceEnv;
@@ -39,6 +60,34 @@ const main = async () => {
     }
     console.error(`Initializing Dynatrace MCP Server v${package_json_1.version}...`);
     const { oauthClientId, oauthClientSecret, dtEnvironment, dtPlatformToken, slackConnectionId } = dynatraceEnv;
+    // Test connection on startup
+    let retryCount = 0;
+    const maxRetries = 5;
+    while (true) {
+        try {
+            console.error(`Testing connection to Dynatrace environment: ${dtEnvironment}... (Attempt ${retryCount + 1} of ${maxRetries})`);
+            await testDynatraceConnection(dtEnvironment, oauthClientId, oauthClientSecret, dtPlatformToken);
+            console.error(`Successfully connected to the Dynatrace environment at ${dtEnvironment}.`);
+            break;
+        }
+        catch (error) {
+            console.error(`Error: Could not connect to the Dynatrace environment.`);
+            if ((0, shared_errors_1.isClientRequestError)(error)) {
+                console.error(handleClientRequestError(error));
+            }
+            else {
+                console.error(`Error: ${error.message}`);
+            }
+            retryCount++;
+            if (retryCount >= maxRetries) {
+                console.error(`Fatal: Maximum number of connection retries (${maxRetries}) exceeded. Exiting.`);
+                process.exit(1);
+            }
+            const delay = Math.pow(2, retryCount) * 1000; // Exponential backoff
+            console.error(`Retrying in ${delay / 1000} seconds...`);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
     console.error(`Starting Dynatrace MCP Server v${package_json_1.version}...`);
     const server = new mcp_js_1.McpServer({
         name: 'Dynatrace MCP Server',
@@ -60,19 +109,8 @@ const main = async () => {
             catch (error) {
                 // check if it's an error originating from the Dynatrace SDK / API Gateway and provide an appropriate message to the user
                 if ((0, shared_errors_1.isClientRequestError)(error)) {
-                    const e = error;
-                    let additionalErrorInformation = '';
-                    if (e.response.status == 403) {
-                        additionalErrorInformation =
-                            'Note: Your user or service-user is most likely lacking the necessary permissions/scopes for this API Call.';
-                    }
                     return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Client Request Error: ${e.message} with HTTP status: ${e.response.status}. ${additionalErrorInformation} (body: ${JSON.stringify(e.body)})`,
-                            },
-                        ],
+                        content: [{ type: 'text', text: handleClientRequestError(error) }],
                         isError: true,
                     };
                 }
@@ -86,7 +124,7 @@ const main = async () => {
         };
         server.tool(name, description, paramsSchema, (args) => wrappedCb(args));
     };
-    tool('get_environment_info', 'Get information about the connected Dynatrace Environment (Tenant)', {}, async ({}) => {
+    tool('get_environment_info', 'Get information about the connected Dynatrace Environment (Tenant) and verify the connection and authentication.', {}, async ({}) => {
         // create an oauth-client
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase, oauthClientId, oauthClientSecret, dtPlatformToken);
         const environmentInformationClient = new client_platform_management_service_1.EnvironmentInformationClient(dtClient);
@@ -183,20 +221,23 @@ const main = async () => {
             return 'No problems found';
         }
     });
-    tool('find_entity_by_name', 'Get the entityId of a monitored entity based on the name of the entity on Dynatrace', {
-        entityName: zod_1.z.string(),
+    tool('find_entity_by_name', 'Get the entityId of a monitored entity (service, host, process-group, application, kubernetes-node, ...) within the topology based on the name of the entity on Dynatrace', {
+        entityName: zod_1.z.string().describe('Name of the entity to search for, e.g., "my-service" or "my-host"'),
     }, async ({ entityName }) => {
-        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('environment-api:entities:read', 'storage:entities:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
+        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('storage:entities:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const entityResponse = await (0, find_monitored_entity_by_name_1.findMonitoredEntityByName)(dtClient, entityName);
         return entityResponse;
     });
     tool('get_entity_details', 'Get details of a monitored entity based on the entityId on Dynatrace', {
         entityId: zod_1.z.string().optional(),
     }, async ({ entityId }) => {
-        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('environment-api:entities:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
+        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('storage:entities:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const entityDetails = await (0, get_monitored_entity_details_1.getMonitoredEntityDetails)(dtClient, entityId);
+        if (!entityDetails) {
+            return `No entity found with entityId: ${entityId}`;
+        }
         let resp = `Entity ${entityDetails.displayName} of type ${entityDetails.type} with \`entityId\` ${entityDetails.entityId}\n` +
-            `Properties: ${JSON.stringify(entityDetails.properties)}\n`;
+            `Properties: ${JSON.stringify(entityDetails.allProperties)}\n`;
         if (entityDetails.type == 'SERVICE') {
             resp += `You can find more information about the service at ${dtEnvironment}/ui/apps/dynatrace.services/explorer?detailsId=${entityDetails.entityId}&sidebarOpen=false`;
         }
@@ -219,13 +260,6 @@ const main = async () => {
         const response = await (0, send_slack_message_1.sendSlackMessage)(dtClient, slackConnectionId, channel, message);
         return `Message sent to Slack channel: ${JSON.stringify(response)}`;
     });
-    tool('get_logs_for_entity', 'Get Logs for a monitored entity based on name of the entity on Dynatrace', {
-        entityName: zod_1.z.string().optional(),
-    }, async ({ entityName }) => {
-        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('storage:logs:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
-        const logs = await (0, get_logs_for_entity_1.getLogsForEntity)(dtClient, entityName);
-        return `Logs:\n${JSON.stringify(logs?.map((logLine) => (logLine ? logLine.content : 'Empty log')))}`;
-    });
     tool('verify_dql', 'Verify a Dynatrace Query Language (DQL) statement on Dynatrace GRAIL before executing it. This step is recommended for DQL statements that have been dynamically created by non-expert tools. For statements coming from the `generate_dql_from_natural_language` tool as well as from documentation, this step can be omitted.', {
         dqlStatement: zod_1.z.string(),
     }, async ({ dqlStatement }) => {
@@ -246,9 +280,14 @@ const main = async () => {
         }
         return resp;
     });
-    tool('execute_dql', 'Get Logs, Metrics, Spans or Events from Dynatrace GRAIL by executing a Dynatrace Query Language (DQL) statement. It\'s recommended to use "verify_dql" tool before you execute a DQL statement. A valid statement looks like this: "fetch [logs, spans, events] | filter <some-filter> | summarize count(), by:{some-fields}. Adapt filters for certain attributes: `traceId` could be `trace_id` or `trace.id`.', {
-        dqlStatement: zod_1.z.string(),
+    tool('execute_dql', 'Get Logs, Metrics, Spans or Events from Dynatrace GRAIL by executing a Dynatrace Query Language (DQL) statement. ' +
+        'You can also use "generate_dql_from_natural_language" to generate a DQL statement based on your request. ' +
+        'Note: For more information about available fields for filters and aggregation, use the query "fetch dt.semantic_dictionary.models | filter data_object == \"logs\""', {
+        dqlStatement: zod_1.z
+            .string()
+            .describe('DQL Statement (Ex: "fetch [logs, spans, events] | filter <some-filter> | summarize count(), by:{some-fields}.", "timeseries { avg(<metric-name>), value.A = avg(<metric-name>, scalar: true) }")'),
     }, async ({ dqlStatement }) => {
+        // Create a HTTP Client that has all storage:*:read scopes
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('storage:buckets:read', // Read all system data stored on Grail
         'storage:logs:read', // Read logs for reliability guardian validations
         'storage:metrics:read', // Read metrics for reliability guardian validations
@@ -397,10 +436,67 @@ const main = async () => {
         resp += JSON.stringify(ownershipInformation);
         return resp;
     });
-    const transport = new stdio_js_1.StdioServerTransport();
-    console.error('Connecting server to transport...');
-    await server.connect(transport);
-    console.error('Dynatrace MCP Server running on stdio');
+    // Parse command line arguments using commander
+    const program = new commander_1.Command();
+    program
+        .name('dynatrace-mcp-server')
+        .description('Dynatrace Model Context Protocol (MCP) Server')
+        .version(package_json_1.version)
+        .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')
+        .option('-H, --host <host>', 'host for HTTP server', '0.0.0.0')
+        .parse();
+    const options = program.opts();
+    const httpMode = options.http || options.server;
+    const httpPort = parseInt(options.port, 10);
+    const host = options.host || '0.0.0.0';
+    if (httpMode) {
+        // HTTP server mode
+        const httpTransport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+            sessionIdGenerator: () => (0, node_crypto_1.randomUUID)(),
+        });
+        const httpServer = (0, node_http_1.createServer)(async (req, res) => {
+            // Parse request body for POST requests
+            let body;
+            if (req.method === 'POST') {
+                const chunks = [];
+                for await (const chunk of req) {
+                    chunks.push(chunk);
+                }
+                const rawBody = Buffer.concat(chunks).toString();
+                try {
+                    body = JSON.parse(rawBody);
+                }
+                catch (error) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                    return;
+                }
+            }
+            await httpTransport.handleRequest(req, res, body);
+        });
+        console.error('Connecting server to HTTP transport...');
+        await server.connect(httpTransport);
+        // Start HTTP Server on the specified host and port
+        httpServer.listen(httpPort, host, () => {
+            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);
+            });
+        });
+    }
+    else {
+        // Default stdio mode
+        const transport = new stdio_js_1.StdioServerTransport();
+        console.error('Connecting server to transport...');
+        await server.connect(transport);
+        console.error('Dynatrace MCP Server running on stdio');
+    }
 };
 main().catch((error) => {
     console.error('Fatal error in main():', error);

package/dist/utils/dynatrace-entity-types.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Dynatrace Entity Types
+ *
+ * Complete list of Dynatrace entity types for querying monitored entities.
+ * Generated from ENTITY_ID_PREFIX_TO_TYPE_MAP values to ensure consistency.
+ * Last Updated: 2025-08-14
+ * @see https://docs.dynatrace.com/docs/discover-dynatrace/references/semantic-dictionary/model/dt-entities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DYNATRACE_ENTITY_TYPES = void 0;
+exports.getEntityTypeFromId = getEntityTypeFromId;
+/**
+ * Entity ID prefixes mapped to their corresponding Dynatrace entity types
+ * When adding a new Entity, there should also be a corresponding test in dynatrace-entity-types.test.ts
+ * to ensure that the entity type can be correctly derived from the entity ID.
+ *
+ * Disclaimer: This mapping is based on the current Dynatrace API and may change in future versions. Use at your own risk!
+ *
+ * Recommendation: Use `verify_dql` and/or `execute_dql` to ensure that the entity type can be queried correctly.
+ */
+const ENTITY_ID_PREFIX_TO_TYPE_MAP = {
+    // Core Applications and Services
+    APPLICATION: 'dt.entity.application', // Verified!
+    SERVICE: 'dt.entity.service', // Verified!
+    SERVICE_INSTANCE: 'dt.entity.service_instance', // Verified!
+    MOBILE_APPLICATION: 'dt.entity.mobile_application', // Verified! (0 rows found, manually verified that entity exists)
+    CUSTOM_APPLICATION: 'dt.entity.custom_application', // Verified!
+    // Infrastructure
+    HOST: 'dt.entity.host', // Verified!
+    HOST_GROUP: 'dt.entity.host_group', // Verified!
+    PROCESS_GROUP: 'dt.entity.process_group', // Verified!
+    PROCESS_GROUP_INSTANCE: 'dt.entity.process_group_instance', // Verified!
+    DISK: 'dt.entity.disk', // Verified!
+    NETWORK_INTERFACE: 'dt.entity.network_interface', // Verified!
+    // Cloud Services
+    CLOUD_APPLICATION: 'dt.entity.cloud_application', // Verified!
+    CLOUD_APPLICATION_INSTANCE: 'dt.entity.cloud_application_instance', // Verified!
+    CLOUD_APPLICATION_NAMESPACE: 'dt.entity.cloud_application_namespace', // Verified!
+    // Containers and Container Groups
+    CONTAINER_GROUP: 'dt.entity.container_group', // Verified!
+    CONTAINER_GROUP_INSTANCE: 'dt.entity.container_group_instance', // Verified!
+    DCG_INSTANCE: 'dt.entity.docker_container_group_instance', // Verified! (0 rows found, manually verified that entity exists, but this might be deprecated / old)
+    // Environment
+    ENVIRONMENT: 'dt.entity.environment', // Verified!
+    // Operating System
+    OS: 'dt.entity.os', // Verified!
+    // Synthetic Monitoring
+    SYNTHETIC_TEST: 'dt.entity.synthetic_test', // Verified!
+    SYNTHETIC_LOCATION: 'dt.entity.synthetic_location', // Verified!
+    // Custom Devices and Entities
+    CUSTOM_DEVICE: 'dt.entity.custom_device', // Verified!
+    CUSTOM_DEVICE_GROUP: 'dt.entity.custom_device_group', // Verified!
+    // Geolocation
+    GEOLOCATION: 'dt.entity.geolocation', // Verified!
+    // Database Services
+    RELATIONAL_DATABASE_SERVICE: 'dt.entity.relational_database_service', // Verified - might need an additional integration/config to work properly though
+    // AWS Services
+    EC2_INSTANCE: 'dt.entity.ec2_instance', // Verified!
+    AWS_LAMBDA_FUNCTION: 'dt.entity.aws_lambda_function', // Verified!
+    AWS_AVAILABILITY_ZONE: 'dt.entity.aws_availability_zone', // Verified!
+    AWS_APPLICATION_LOAD_BALANCER: 'dt.entity.aws_application_load_balancer', // Verified!
+    AWS_NETWORK_LOAD_BALANCER: 'dt.entity.aws_network_load_balancer', // Verified!
+    // GCP Services
+    GCP_ZONE: 'dt.entity.gcp_zone', // Verified!
+    // Virtual Machines
+    AZURE_VM: 'dt.entity.azure_vm', // Verified
+    OPENSTACK_VM: 'dt.entity.openstack_vm', // Needs manual verification - available only if OpenStack integration is configured
+    // Kubernetes Entities
+    KUBERNETES_NODE: 'dt.entity.kubernetes_node', // Verified!
+    KUBERNETES_CLUSTER: 'dt.entity.kubernetes_cluster', // Verified!
+    KUBERNETES_SERVICE: 'dt.entity.kubernetes_service', // Verified!
+};
+exports.DYNATRACE_ENTITY_TYPES = Object.values(ENTITY_ID_PREFIX_TO_TYPE_MAP).sort();
+/**
+ * Maps a Dynatrace entity ID to its corresponding entity type.
+ *
+ * @param entityId - The Dynatrace entity ID (e.g., "PROCESS_GROUP-F84E4759809ADA84")
+ * @returns The corresponding entity type (e.g., "dt.entity.process_group") or null if no mapping exists
+ *
+ * @example
+ * ```typescript
+ * getEntityTypeFromId("PROCESS_GROUP-F84E4759809ADA84"); // Returns "dt.entity.process_group"
+ * getEntityTypeFromId("APPLICATION-1234567890ABCDEF"); // Returns "dt.entity.application"
+ * getEntityTypeFromId("KUBERNETES_SERVICE-ABCDEF1234567890"); // Returns "dt.entity.kubernetes_service"
+ * getEntityTypeFromId("INVALID_ID"); // Returns null
+ * ```
+ */
+function getEntityTypeFromId(entityId) {
+    if (!entityId || typeof entityId !== 'string') {
+        return null;
+    }
+    // Extract the prefix (everything before the first hyphen)
+    const hyphenIndex = entityId.indexOf('-');
+    if (hyphenIndex === -1) {
+        return null;
+    }
+    const prefix = entityId.substring(0, hyphenIndex);
+    // Look up the entity type in our mapping
+    return ENTITY_ID_PREFIX_TO_TYPE_MAP[prefix] || null;
+}

package/dist/utils/dynatrace-entity-types.test.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dynatrace_entity_types_1 = require("./dynatrace-entity-types");
+describe('DYNATRACE_ENTITY_TYPES', () => {
+    it('should be sorted alphabetically', () => {
+        const sortedTypes = [...dynatrace_entity_types_1.DYNATRACE_ENTITY_TYPES].sort();
+        expect(dynatrace_entity_types_1.DYNATRACE_ENTITY_TYPES).toEqual(sortedTypes);
+    });
+    it('should have unique values', () => {
+        const uniqueTypes = [...new Set(dynatrace_entity_types_1.DYNATRACE_ENTITY_TYPES)];
+        expect(dynatrace_entity_types_1.DYNATRACE_ENTITY_TYPES.length).toBe(uniqueTypes.length);
+    });
+});
+describe('getEntityTypeFromId', () => {
+    it('should map PROCESS_GROUP entity ID to dt.entity.process_group', () => {
+        const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)('PROCESS_GROUP-F84E4759809ADA84');
+        expect(result).toBe('dt.entity.process_group');
+    });
+    it('should map APPLICATION entity ID to dt.entity.application', () => {
+        const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)('APPLICATION-1234567890ABCDEF');
+        expect(result).toBe('dt.entity.application');
+    });
+    it('should map SERVICE entity ID to dt.entity.service', () => {
+        const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)('SERVICE-ABCDEF1234567890');
+        expect(result).toBe('dt.entity.service');
+    });
+    it('should map HOST entity ID to dt.entity.host', () => {
+        const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)('HOST-1234567890ABCDEF');
+        expect(result).toBe('dt.entity.host');
+    });
+    it('should map KUBERNETES_CLUSTER entity ID to dt.entity.kubernetes_cluster', () => {
+        const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)('KUBERNETES_CLUSTER-1234567890ABCDEF');
+        expect(result).toBe('dt.entity.kubernetes_cluster');
+    });
+    it('should map CLOUD_APPLICATION entity ID to dt.entity.cloud_application', () => {
+        const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)('CLOUD_APPLICATION-FEDCBA0987654321');
+        expect(result).toBe('dt.entity.cloud_application');
+    });
+    it('should return null for entity ID without hyphen', () => {
+        const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)('INVALID_ENTITY_ID');
+        expect(result).toBeNull();
+    });
+    it('should return null for unknown entity prefix', () => {
+        const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)('UNKNOWN_PREFIX-1234567890ABCDEF');
+        expect(result).toBeNull();
+    });
+    it('should return null for empty string', () => {
+        const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)('');
+        expect(result).toBeNull();
+    });
+    it('should return null for null input', () => {
+        const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)(null);
+        expect(result).toBeNull();
+    });
+    it('should return null for undefined input', () => {
+        const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)(undefined);
+        expect(result).toBeNull();
+    });
+    it('should return null for non-string input', () => {
+        const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)(123);
+        expect(result).toBeNull();
+    });
+    it('should handle entity ID with multiple hyphens correctly', () => {
+        const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)('PROCESS_GROUP-F84E-4759-809A-DA84');
+        expect(result).toBe('dt.entity.process_group');
+    });
+    // Tests for verified entity types found in the environment
+    describe('Verified Entity Types', () => {
+        const verifiedEntityTypesTestCases = [
+            {
+                entityId: 'ENVIRONMENT-2D0F07E264ABBB14',
+                expectedType: 'dt.entity.environment',
+                description: 'ENVIRONMENT entity ID',
+            },
+            {
+                entityId: 'KUBERNETES_NODE-03169E17F0A60BE7',
+                expectedType: 'dt.entity.kubernetes_node',
+                description: 'KUBERNETES_NODE entity ID',
+            },
+            {
+                entityId: 'SERVICE_INSTANCE-02072B90BE476A9D',
+                expectedType: 'dt.entity.service_instance',
+                description: 'SERVICE_INSTANCE entity ID',
+            },
+            {
+                entityId: 'PROCESS_GROUP_INSTANCE-02072B90BE476A9D',
+                expectedType: 'dt.entity.process_group_instance',
+                description: 'PROCESS_GROUP_INSTANCE entity ID',
+            },
+            {
+                entityId: 'EC2_INSTANCE-4F09B64F7C5EC72D',
+                expectedType: 'dt.entity.ec2_instance',
+                description: 'EC2_INSTANCE entity ID',
+            },
+            {
+                entityId: 'AWS_LAMBDA_FUNCTION-65CB1C926C7A1C03',
+                expectedType: 'dt.entity.aws_lambda_function',
+                description: 'AWS_LAMBDA_FUNCTION entity ID',
+            },
+            {
+                entityId: 'CLOUD_APPLICATION_INSTANCE-00BAA09E6EC91E39',
+                expectedType: 'dt.entity.cloud_application_instance',
+                description: 'CLOUD_APPLICATION_INSTANCE entity ID',
+            },
+            {
+                entityId: 'DCG_INSTANCE-02072B90BE476A9D',
+                expectedType: 'dt.entity.docker_container_group_instance',
+                description: 'DCG_INSTANCE entity ID',
+            },
+            {
+                entityId: 'OS-006B30874F10C837',
+                expectedType: 'dt.entity.os',
+                description: 'OS entity ID',
+            },
+            {
+                entityId: 'AWS_AVAILABILITY_ZONE-0BAF92AC03BF3E25',
+                expectedType: 'dt.entity.aws_availability_zone',
+                description: 'AWS_AVAILABILITY_ZONE entity ID',
+            },
+            {
+                entityId: 'AWS_APPLICATION_LOAD_BALANCER-52D56F3FD851FF0C',
+                expectedType: 'dt.entity.aws_application_load_balancer',
+                description: 'AWS_APPLICATION_LOAD_BALANCER entity ID',
+            },
+            {
+                entityId: 'AWS_NETWORK_LOAD_BALANCER-617A06EFED8F4AB4',
+                expectedType: 'dt.entity.aws_network_load_balancer',
+                description: 'AWS_NETWORK_LOAD_BALANCER entity ID',
+            },
+            {
+                entityId: 'SYNTHETIC_LOCATION-0000000000000010',
+                expectedType: 'dt.entity.synthetic_location',
+                description: 'SYNTHETIC_LOCATION entity ID',
+            },
+            {
+                entityId: 'GEOLOCATION-0000000000000000',
+                expectedType: 'dt.entity.geolocation',
+                description: 'GEOLOCATION entity ID',
+            },
+            {
+                entityId: 'GCP_ZONE-0C3C7E567EAAB95B',
+                expectedType: 'dt.entity.gcp_zone',
+                description: 'GCP_ZONE entity ID',
+            },
+            {
+                entityId: 'AZURE_VM-42EA5AB8F028E280',
+                expectedType: 'dt.entity.azure_vm',
+                description: 'AZURE_VM entity ID',
+            },
+            {
+                entityId: 'RELATIONAL_DATABASE_SERVICE-B4EDC0E1E1279494',
+                expectedType: 'dt.entity.relational_database_service',
+                description: 'RELATIONAL_DATABASE_SERVICE entity ID',
+            },
+        ];
+        it.each(verifiedEntityTypesTestCases)('should map $description to $expectedType', ({ entityId, expectedType }) => {
+            const result = (0, dynatrace_entity_types_1.getEntityTypeFromId)(entityId);
+            expect(result).toBe(expectedType);
+        });
+    });
+});

package/dist/utils/user-agent.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserAgent = void 0;
+const package_json_1 = require("../../package.json");
+/**
+ * Generate a user agent string for Dynatrace MCP Server
+ * @returns User agent string in format: dynatrace-mcp-server/vX.X.X (platform-arch)
+ */
+const getUserAgent = () => {
+    return `dynatrace-mcp-server/v${package_json_1.version} (${process.platform}-${process.arch})`;
+};
+exports.getUserAgent = getUserAgent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynatrace-oss/dynatrace-mcp-server",
-  "version": "0.5.0-rc.3",
+  "version": "0.5.0",
   "description": "Model Context Protocol (MCP) server for Dynatrace",
   "keywords": [
     "Dynatrace",
@@ -47,13 +47,13 @@
   "license": "MIT",
   "dependencies": {
     "@dynatrace-sdk/client-automation": "^5.3.0",
-    "@dynatrace-sdk/client-classic-environment-v2": "^3.6.8",
     "@dynatrace-sdk/client-platform-management-service": "^1.6.3",
     "@dynatrace-sdk/client-query": "^1.18.1",
     "@dynatrace-sdk/shared-errors": "^1.0.0",
     "@modelcontextprotocol/sdk": "^1.8.0",
-    "dotenv": "^16.4.7",
-    "dt-app": "^0.140.1",
+    "commander": "^14.0.0",
+    "dotenv": "^17.2.1",
+    "dt-app": "^0.148.1",
     "zod-to-json-schema": "^3.24.5"
   },
   "devDependencies": {

package/dist/capabilities/get-logs-for-entity.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLogsForEntity = void 0;
-const execute_dql_1 = require("./execute-dql");
-const getLogsForEntity = async (dtClient, entityId) => {
-    const dql = `fetch logs | filter dt.source_entity == "${entityId}"`;
-    return (0, execute_dql_1.executeDql)(dtClient, { query: dql });
-};
-exports.getLogsForEntity = getLogsForEntity;