@dynatrace-oss/dynatrace-mcp-server 0.9.2 → 0.11.0

package/README.md

@@ -298,6 +298,24 @@ In addition, depending on the features you use, the following variables can be c
 
 - `SLACK_CONNECTION_ID` (string) - connection ID of a [Slack Connection](https://docs.dynatrace.com/docs/analyze-explore-automate/workflows/actions/slack)
 
+### Proxy Configuration
+
+The MCP server honors system proxy settings for corporate environments:
+
+- `https_proxy` or `HTTPS_PROXY` (optional, string, e.g., `http://proxy.example.com:8080`) - Proxy server URL for HTTPS requests
+- `http_proxy` or `HTTP_PROXY` (optional, string, e.g., `http://proxy.example.com:8080`) - Proxy server URL for HTTP requests
+- `no_proxy` or `NO_PROXY` (optional, string, e.g., `localhost,127.0.0.1,.local`) - Comma-separated list of hostnames or domains that should bypass the proxy
+
+**Note:** The `no_proxy` environment variable is currently logged for informational purposes but not fully enforced by the underlying HTTP client. If you need to bypass the proxy for specific hosts, consider configuring your proxy server to handle these exclusions.
+
+Example configuration with proxy:
+
+```bash
+export HTTPS_PROXY=http://proxy.company.com:8080
+export NO_PROXY=localhost,127.0.0.1,.company.local
+export DT_ENVIRONMENT=https://abc12345.apps.dynatrace.com
+```
+
 ### Scopes for Authentication
 
 Depending on the features you are using, the following scopes are needed:
@@ -321,6 +339,7 @@ Depending on the features you are using, the following scopes are needed:
 - `storage:system:read` - needed for `execute_dql` tool to read System Data from Grail
 - `storage:user.events:read` - needed for `execute_dql` tool to read User events from Grail
 - `storage:user.sessions:read` - needed for `execute_dql` tool to read User sessions from Grail
+- `storage:smartscape:read` - needed for `execute_dql` tool to read Smartscape Data
 - `davis-copilot:conversations:execute` - execute conversational skill (chat with Copilot)
 - `davis-copilot:nl2dql:execute` - execute Davis Copilot Natural Language (NL) to DQL skill
 - `davis-copilot:dql2nl:execute` - execute DQL to Natural Language (NL) skill

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findMonitoredEntitiesByName = exports.generateDqlSearchEntityCommand = void 0;
+exports.findMonitoredEntitiesByName = exports.findMonitoredEntityViaSmartscapeByName = exports.generateDqlSearchEntityCommand = void 0;
 const execute_dql_1 = require("./execute-dql");
 const dynatrace_entity_types_1 = require("../utils/dynatrace-entity-types");
 /**
@@ -22,10 +22,35 @@ const generateDqlSearchEntityCommand = (entityNames, extendedSearch) => {
 };
 exports.generateDqlSearchEntityCommand = generateDqlSearchEntityCommand;
 /**
- * Find a monitored entity by name via DQL
+ * Find a monitored entity via "smartscapeNodes" 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
+ * @param entityNames Array of entitiy names to search for
+ * @returns An array with the entity details like id, name and type
+ */
+const findMonitoredEntityViaSmartscapeByName = async (dtClient, entityNames) => {
+    const dql = `smartscapeNodes "*" | search "*${entityNames.join('*" OR "*')}*" | fields id, name, type`;
+    console.error(`Executing DQL: ${dql}`);
+    try {
+        const smartscapeResult = await (0, execute_dql_1.executeDql)(dtClient, { query: dql });
+        if (smartscapeResult && smartscapeResult.records && smartscapeResult.records.length > 0) {
+            // return smartscape results if we found something
+            return smartscapeResult;
+        }
+    }
+    catch (error) {
+        // ignore errors here, as smartscapeNodes may not be ready for all environments/users
+        console.error('Error while querying smartscapeNodes:', error);
+    }
+    console.error('No results from smartscapeNodes');
+    return null;
+};
+exports.findMonitoredEntityViaSmartscapeByName = findMonitoredEntityViaSmartscapeByName;
+/**
+ * Find a monitored entity via "dt.entity.${entityType}" by name via DQL
+ * @param dtClient
+ * @param entityNames Array of entitiy names to search for
+ * @param extendedSearch If true, search over all entity types, otherwise only basic ones
+ * @returns An array with the entity details like id, name and type
  */
 const findMonitoredEntitiesByName = async (dtClient, entityNames, extendedSearch) => {
     // construct a DQL statement for searching the entityName over all entity types

package/dist/index.js

@@ -28,6 +28,7 @@ const telemetry_openkit_1 = require("./utils/telemetry-openkit");
 const dynatrace_entity_types_1 = require("./utils/dynatrace-entity-types");
 const grail_budget_tracker_1 = require("./utils/grail-budget-tracker");
 const dynatrace_connection_utils_1 = require("./utils/dynatrace-connection-utils");
+const proxy_config_1 = require("./utils/proxy-config");
 // Load environment variables from .env file if available, and suppress warnings/logging to stdio
 // as it breaks MCP communication when using stdio transport
 const dotEnvOutput = (0, dotenv_1.config)({ quiet: true });
@@ -79,6 +80,8 @@ const allRequiredScopes = scopesBase.concat([
 ]);
 const main = async () => {
     console.error(`Initializing Dynatrace MCP Server v${(0, version_1.getPackageJsonVersion)()}...`);
+    // Configure proxy from environment variables early in the startup process
+    (0, proxy_config_1.configureProxyFromEnvironment)();
     // read Environment variables
     let dynatraceEnv;
     try {
@@ -91,7 +94,6 @@ const main = async () => {
     // Unpack environment variables
     let { oauthClientId, oauthClientSecret, dtEnvironment, dtPlatformToken, slackConnectionId, grailBudgetGB } = dynatraceEnv;
     // Infer OAuth auth code flow if no OAuth Client credentials are provided
-    // -> configure default OAuth client ID for auth code flow
     if (!oauthClientId && !oauthClientSecret && !dtPlatformToken) {
         console.error('No OAuth credentials or platform token provided - switching to OAuth authorization code flow.');
         oauthClientId = DT_MCP_AUTH_CODE_FLOW_OAUTH_CLIENT_ID; // Default OAuth client ID for auth code flow
@@ -364,22 +366,40 @@ const main = async () => {
     }, {
         readOnlyHint: true,
     }, async ({ entityNames, maxEntitiesToDisplay, extendedSearch }) => {
-        const dtClient = await createAuthenticatedHttpClient(scopesBase.concat('storage:entities:read'));
+        const dtClient = await createAuthenticatedHttpClient(scopesBase.concat('storage:entities:read', 'storage:smartscape:read'));
+        const smartscapeResult = await (0, find_monitored_entity_by_name_1.findMonitoredEntityViaSmartscapeByName)(dtClient, entityNames);
+        if (smartscapeResult && smartscapeResult.records && smartscapeResult.records.length > 0) {
+            // Filter valid entities first, to ensure we display up to maxEntitiesToDisplay entities
+            const validSmartscapeEntities = smartscapeResult.records.filter((entity) => !!(entity && entity.id && entity.type && entity.name));
+            let resp = `Found ${validSmartscapeEntities.length} monitored entities via Smartscape! Displaying the first ${Math.min(maxEntitiesToDisplay, validSmartscapeEntities.length)} valid entities:\n`;
+            validSmartscapeEntities.slice(0, maxEntitiesToDisplay).forEach((entity) => {
+                resp += `- Entity '${entity.name}' of entity-type '${entity.type}' has entity id '${entity.id}' and tags ${entity['tags'] ? JSON.stringify(entity['tags']) : 'none'} - DQL Filter: '| filter dt.smartscape.${String(entity.type).toLowerCase()} == "${entity.id}"'\n`;
+            });
+            resp +=
+                '\n\n**Next Steps:**\n' +
+                    '1. Fetch more details about the entity, using the `execute_dql` tool with the following DQL Statement: "smartscapeNodes \"<entity-type>\" | filter id == <entity-id>"\n' +
+                    '2. Perform a sanity check that found entities are actually the ones you are looking for, by comparing name and by type (hosts vs. containers vs. apps vs. functions) and technology (Java, TypeScript, .NET) with what is available in the local source code repo.\n' +
+                    '3. Find and investigate available metrics for relevant entities, by using the `execute_dql` tool with the following DQL statement: "fetch metric.series | filter dt.smartscape.<entity-type> == <entity-id> | limit 20"\n' +
+                    '4. Find out whether any problems exist for this entity using the `list_problems` or `list_vulnerabilities` tool, and the provided DQL-Filter\n' +
+                    '5. Explore dependency & relationships with: "smartscapeEdges \"*\" | filter source_id == <entity-id> or target_id == <entity-id>" to list inbound/outbound edges (depends_on, dependency_of, owned_by, part_of) for graph context\n';
+            return resp;
+        }
+        // If no result from Smartscape, try the classic entities API
         const result = await (0, find_monitored_entity_by_name_1.findMonitoredEntitiesByName)(dtClient, entityNames, extendedSearch);
         if (result && result.records && result.records.length > 0) {
-            let resp = `Found ${result.records.length} monitored entities! Displaying the first ${maxEntitiesToDisplay} entities:\n`;
+            // Filter valid entities first, to ensure we display up to maxEntitiesToDisplay entities
+            const validClassicEntities = result.records.filter((entity) => !!(entity && entity.id && entity['entity.type'] && entity['entity.name']));
+            let resp = `Found ${validClassicEntities.length} monitored entities! Displaying the first ${Math.min(maxEntitiesToDisplay, validClassicEntities.length)} entities:\n`;
             // iterate over dqlResponse and create a string with the problem details, but only show the top maxEntitiesToDisplay problems
-            result.records.slice(0, maxEntitiesToDisplay).forEach((entity) => {
-                if (entity && entity.id) {
-                    const entityType = (0, dynatrace_entity_types_1.getEntityTypeFromId)(String(entity.id));
-                    resp += `- Entity '${entity['entity.name']}' of type '${entity['entity.type']}' has entity id '${entity.id}' and tags ${entity['tags'] ? entity['tags'] : 'none'} - Use the DQL Filter: '| filter ${entityType} == "${entity.id}"'\n`;
-                }
+            validClassicEntities.slice(0, maxEntitiesToDisplay).forEach((entity) => {
+                const entityType = (0, dynatrace_entity_types_1.getEntityTypeFromId)(String(entity.id));
+                resp += `- Entity '${entity['entity.name']}' of entity-type '${entity['entity.type']}' has entity id '${entity.id}' and tags ${entity['tags'] ? entity['tags'] : 'none'} - DQL Filter: '| filter ${entityType} == "${entity.id}"'\n`;
             });
             resp +=
                 '\n\n**Next Steps:**\n' +
-                    '1. Try to fetch more details about the entity, using the `execute_dql` tool with "describe(dt.entity.<entity-type>)", and "fetch dt.entity.<entity-type> | filter id == <entity-id> | fieldsAdd <field-1>, <field2>, ..."\n' +
+                    '1. Fetch more details about the entity, using the `execute_dql` tool with the following DQL Statements: "describe(dt.entity.<entity-type>)", and "fetch dt.entity.<entity-type> | filter id == <entity-id> | fieldsAdd <field-1>, <field-2>, ..."\n' +
                     '2. Perform a sanity check that found entities are actually the ones you are looking for, by comparing name and by type (hosts vs. containers vs. apps vs. functions) and technology (Java, TypeScript, .NET) with what is available in the local source code repo.\n' +
-                    '3. Find and investigate available metrics for relevant entities, by using the `execute_dql` tool with the following DQL statement: "fetch metric.series | filter dt.entity.<entity-type> == <entity-id>"\n' +
+                    '3. Find and investigate available metrics for relevant entities, by using the `execute_dql` tool with the following DQL statement: "fetch metric.series | filter dt.entity.<entity-type> == <entity-id> | limit 20"\n' +
                     '4. Find out whether any problems exist for this entity using the `list_problems` or `list_vulnerabilities` tool, and the provided DQL-Filter\n';
             return resp;
         }
@@ -428,20 +448,26 @@ 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. ' +
+    tool('execute_dql', 'Get data like Logs, Metrics, Spans, Events, or Entity Data from Dynatrace GRAIL by executing a Dynatrace Query Language (DQL) statement. ' +
         'Use the "generate_dql_from_natural_language" tool upfront to generate or refine a DQL statement based on your request. ' +
         'To learn about possible fields available for filtering, 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], from: now()-4h, to: now() | filter <some-filter> | summarize count(), by:{some-fields}.", or for metrics: "timeseries { avg(<metric-name>), value.A = avg(<metric-name>, scalar: true) }"). ' +
+            .describe('DQL Statement (Ex: "fetch [logs, spans, events, metric.series, ...], from: now()-4h, to: now() [| filter <some-filter>] [| summarize count(), by:{some-fields}]", or for metrics: "timeseries { avg(<metric-name>), value.A = avg(<metric-name>, scalar: true) }", or for entities via smartscape: "smartscapeNodes \"[*, HOST, PROCESS, ...]\" [| filter id == "<ENTITY-ID>"]"). ' +
             'When querying data for a specific entity, call the `find_entity_by_name` tool first to get an appropriate filter like `dt.entity.service == "SERVICE-1234"` or `dt.entity.host == "HOST-1234"` to be used in the DQL statement. '),
+        recordLimit: zod_1.z.number().optional().default(100).describe('Maximum number of records to return (default: 100)'),
+        recordSizeLimitMB: zod_1.z
+            .number()
+            .optional()
+            .default(1)
+            .describe('Maximum size of the returned records in MB (default: 1MB)'),
     }, {
         // not readonly (DQL statements may modify things), not idempotent (may change over time)
         readOnlyHint: false,
         idempotentHint: false,
         // while we are not strictly talking to the open world here, the response from execute DQL could interpreted as a web-search, which often is referred to open-world
         openWorldHint: true,
-    }, async ({ dqlStatement }) => {
+    }, async ({ dqlStatement, recordLimit = 100, recordSizeLimitMB = 1 }) => {
         // Create a HTTP Client that has all storage:*:read scopes
         const dtClient = await createAuthenticatedHttpClient(scopesBase.concat('storage:buckets:read', // Read all system data stored on Grail
         'storage:logs:read', // Read logs for reliability guardian validations
@@ -453,8 +479,9 @@ const main = async () => {
         'storage:system:read', // Read System Data from Grail
         'storage:user.events:read', // Read User events from Grail
         'storage:user.sessions:read', // Read User sessions from Grail
-        'storage:security.events:read'));
-        const response = await (0, execute_dql_1.executeDql)(dtClient, { query: dqlStatement }, grailBudgetGB);
+        'storage:security.events:read', // Read Security events from Grail
+        'storage:smartscape:read'));
+        const response = await (0, execute_dql_1.executeDql)(dtClient, { query: dqlStatement, maxResultRecords: recordLimit, maxResultBytes: recordSizeLimitMB * 1024 * 1024 }, grailBudgetGB);
         if (!response) {
             return 'DQL execution failed or returned no result.';
         }
@@ -472,8 +499,15 @@ const main = async () => {
             result += `- **Scanned Bytes:** ${scannedGB.toFixed(2)} GB`;
             // Show budget status if available
             if (response.budgetState) {
-                const usagePercentage = (response.budgetState.totalBytesScanned / response.budgetState.budgetLimitBytes) * 100;
-                result += ` (Session total: ${(response.budgetState.totalBytesScanned / (1000 * 1000 * 1000)).toFixed(2)} GB / ${response.budgetState.budgetLimitGB} GB budget, ${usagePercentage.toFixed(1)}% used)`;
+                const totalScannedGB = (response.budgetState.totalBytesScanned / (1000 * 1000 * 1000)).toFixed(2);
+                if (response.budgetState.budgetLimitGB > 0) {
+                    const usagePercentage = ((response.budgetState.totalBytesScanned / response.budgetState.budgetLimitBytes) *
+                        100).toFixed(1);
+                    result += ` (Session total: ${totalScannedGB} GB / ${response.budgetState.budgetLimitGB} GB budget, ${usagePercentage}% used)`;
+                }
+                else {
+                    result += ` (Session total: ${totalScannedGB} GB)`;
+                }
             }
             result += '\n';
             if (scannedGB > 500) {
@@ -492,6 +526,9 @@ const main = async () => {
         if (response.sampled !== undefined && response.sampled) {
             result += `- **⚠️ Sampling Used:** Yes (results may be approximate)\n`;
         }
+        if (response.records.length === recordLimit) {
+            result += `- **⚠️ Record Limit Reached:** The result set was limited to ${recordLimit} records. Consider changing your query with a smaller timeframe, an aggregation or a more concise filter. Alternatively, increase the recordLimit if you expect more results.\n`;
+        }
         result += `\n📋 **Query Results**: (${response.records?.length || 0} records):\n\n`;
         result += `\`\`\`json\n${JSON.stringify(response.records, null, 2)}\n\`\`\``;
         return result;

package/dist/utils/proxy-config.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureProxyFromEnvironment = configureProxyFromEnvironment;
+const undici_1 = require("undici");
+/**
+ * Parse and configure system proxy settings from environment variables.
+ * Supports https_proxy, HTTPS_PROXY, http_proxy, HTTP_PROXY, no_proxy, and NO_PROXY.
+ *
+ * This function should be called early in the application lifecycle to ensure
+ * all HTTP requests honor the system proxy settings.
+ */
+function configureProxyFromEnvironment() {
+    // Check for proxy environment variables (case-insensitive)
+    const httpsProxy = process.env.https_proxy || process.env.HTTPS_PROXY;
+    const httpProxy = process.env.http_proxy || process.env.HTTP_PROXY;
+    const noProxy = process.env.no_proxy || process.env.NO_PROXY;
+    // Determine which proxy to use (prefer HTTPS proxy for HTTPS requests)
+    const proxyUrl = httpsProxy || httpProxy;
+    if (!proxyUrl) {
+        // No proxy configured, nothing to do
+        return;
+    }
+    try {
+        console.error(`Configuring proxy from environment: ${proxyUrl}`);
+        // Parse no_proxy list if provided
+        let noProxyHosts = [];
+        if (noProxy) {
+            // Split by comma and trim whitespace
+            noProxyHosts = noProxy
+                .split(',')
+                .map((host) => host.trim())
+                .filter((host) => host.length > 0);
+            console.error(`No proxy hosts configured: ${noProxyHosts.join(', ')}`);
+        }
+        // Create ProxyAgent with the configured proxy URL
+        // Note: undici's ProxyAgent doesn't have built-in no_proxy support.
+        // The no_proxy environment variable is logged for informational purposes,
+        // but the ProxyAgent will route all requests through the proxy.
+        // If no_proxy support is critical for your use case, you may need to
+        // configure your proxy server to handle no_proxy exclusions.
+        const proxyAgent = new undici_1.ProxyAgent({
+            uri: proxyUrl,
+        });
+        // Set the global dispatcher for undici (affects global fetch)
+        (0, undici_1.setGlobalDispatcher)(proxyAgent);
+        console.error(`✅ Proxy configured successfully: ${proxyUrl}`);
+    }
+    catch (error) {
+        console.error(`⚠️ Failed to configure proxy: ${error instanceof Error ? error.message : String(error)}`);
+        console.error('Continuing without proxy configuration.');
+    }
+}

package/dist/utils/proxy-config.test.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const proxy_config_1 = require("./proxy-config");
+// Mock undici
+jest.mock('undici', () => ({
+    ProxyAgent: jest.fn(),
+    setGlobalDispatcher: jest.fn(),
+    getGlobalDispatcher: jest.fn(),
+}));
+const undici_1 = require("undici");
+describe('proxy-config', () => {
+    let originalEnv;
+    beforeEach(() => {
+        // Save original environment
+        originalEnv = { ...process.env };
+        // Clear all proxy-related env vars
+        delete process.env.https_proxy;
+        delete process.env.HTTPS_PROXY;
+        delete process.env.http_proxy;
+        delete process.env.HTTP_PROXY;
+        delete process.env.no_proxy;
+        delete process.env.NO_PROXY;
+        // Clear mocks
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        // Restore original environment
+        process.env = originalEnv;
+    });
+    describe('configureProxyFromEnvironment', () => {
+        it('should configure proxy when HTTPS_PROXY is set', () => {
+            process.env.HTTPS_PROXY = 'http://proxy.example.com:8080';
+            (0, proxy_config_1.configureProxyFromEnvironment)();
+            expect(undici_1.ProxyAgent).toHaveBeenCalledWith({
+                uri: 'http://proxy.example.com:8080',
+            });
+            expect(undici_1.setGlobalDispatcher).toHaveBeenCalled();
+        });
+        it('should configure proxy when https_proxy is set (lowercase)', () => {
+            process.env.https_proxy = 'http://proxy.example.com:8080';
+            (0, proxy_config_1.configureProxyFromEnvironment)();
+            expect(undici_1.ProxyAgent).toHaveBeenCalledWith({
+                uri: 'http://proxy.example.com:8080',
+            });
+            expect(undici_1.setGlobalDispatcher).toHaveBeenCalled();
+        });
+        it('should prefer HTTPS_PROXY over HTTP_PROXY', () => {
+            process.env.HTTPS_PROXY = 'http://https-proxy.example.com:8443';
+            process.env.HTTP_PROXY = 'http://http-proxy.example.com:8080';
+            (0, proxy_config_1.configureProxyFromEnvironment)();
+            expect(undici_1.ProxyAgent).toHaveBeenCalledWith({
+                uri: 'http://https-proxy.example.com:8443',
+            });
+        });
+        it('should fall back to HTTP_PROXY if HTTPS_PROXY is not set', () => {
+            process.env.HTTP_PROXY = 'http://proxy.example.com:8080';
+            (0, proxy_config_1.configureProxyFromEnvironment)();
+            expect(undici_1.ProxyAgent).toHaveBeenCalledWith({
+                uri: 'http://proxy.example.com:8080',
+            });
+        });
+        it('should not configure proxy when no proxy env vars are set', () => {
+            (0, proxy_config_1.configureProxyFromEnvironment)();
+            expect(undici_1.ProxyAgent).not.toHaveBeenCalled();
+            expect(undici_1.setGlobalDispatcher).not.toHaveBeenCalled();
+        });
+        it('should handle errors gracefully', () => {
+            process.env.HTTPS_PROXY = 'http://proxy.example.com:8080';
+            const mockProxyAgent = undici_1.ProxyAgent;
+            mockProxyAgent.mockImplementation(() => {
+                throw new Error('ProxyAgent error');
+            });
+            // Should not throw
+            expect(() => (0, proxy_config_1.configureProxyFromEnvironment)()).not.toThrow();
+            // Should still attempt to create ProxyAgent
+            expect(undici_1.ProxyAgent).toHaveBeenCalled();
+            // Should not set dispatcher if ProxyAgent creation fails
+            expect(undici_1.setGlobalDispatcher).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/utils/telemetry-openkit.js

@@ -215,8 +215,8 @@ function createTelemetry() {
         return new DynatraceMcpTelemetry();
     }
     catch (e) {
-        // Failed to initialize
-        console.error(e);
+        // Failed to initialize (unexpected). Log concise message without stack trace spam.
+        console.error('Dynatrace Telemetry initialization failed:', e.message);
         // fallback to NoOp Telemetry
         return new NoOpTelemetry();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynatrace-oss/dynatrace-mcp-server",
-  "version": "0.9.2",
+  "version": "0.11.0",
   "mcpName": "io.github.dynatrace-oss/Dynatrace-mcp",
   "description": "Model Context Protocol (MCP) server for Dynatrace",
   "keywords": [