mcp-consultant-tools 7.0.0 → 8.0.0

package/README.md

@@ -1,6 +1,6 @@
 # MCP Consultant Tools
 
-A Model Context Protocol (MCP) server providing intelligent access to PowerPlatform/Dataverse, Azure DevOps, Figma, Azure Application Insights, and Azure SQL Database through an AI-friendly interface.
+A Model Context Protocol (MCP) server providing intelligent access to PowerPlatform/Dataverse, Azure DevOps, Figma, Azure Application Insights, Azure Log Analytics, and Azure SQL Database through an AI-friendly interface.
 
 ## Overview
 
@@ -16,11 +16,12 @@ This MCP server enables AI assistants to:
 - **Azure DevOps** (12 tools): Search wikis, manage work items, execute WIQL queries
 - **Figma** (2 tools): Extract design data in simplified, AI-friendly format
 - **Application Insights** (10 tools): Query telemetry, analyze exceptions, monitor performance, troubleshoot issues
+- **Log Analytics** (10 tools): Query Azure Functions logs, analyze errors, monitor function performance, search workspace logs
 - **Azure SQL Database** (9 tools): Explore database schema, query tables safely with read-only access, investigate database structure
 
 All integrations are **optional** - configure only the services you need.
 
-**Total: 105+ MCP tools & 21 prompts** providing comprehensive access to your development and operations lifecycle.
+**Total: 116 MCP tools & 23 prompts** providing comprehensive access to your development and operations lifecycle.
 
 ## Known limitations
 - Cannot create Model-Driven-Apps
@@ -81,6 +82,12 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS)
         "APPINSIGHTS_CLIENT_SECRET": "your-client-secret",
         "APPINSIGHTS_RESOURCES": "[{\"id\":\"prod-api\",\"name\":\"Production API\",\"appId\":\"your-app-id\",\"active\":true}]",
 
+        "LOGANALYTICS_AUTH_METHOD": "entra-id",
+        "LOGANALYTICS_TENANT_ID": "your-tenant-id",
+        "LOGANALYTICS_CLIENT_ID": "your-client-id",
+        "LOGANALYTICS_CLIENT_SECRET": "your-client-secret",
+        "LOGANALYTICS_RESOURCES": "[{\"id\":\"prod-functions\",\"name\":\"Production Functions\",\"workspaceId\":\"your-workspace-id\",\"active\":true}]",
+
         "AZURE_SQL_SERVER": "yourserver.database.windows.net",
         "AZURE_SQL_DATABASE": "yourdatabase",
         "AZURE_SQL_USERNAME": "your-username",
@@ -130,6 +137,12 @@ Create `.vscode/mcp.json` in your project:
         "APPINSIGHTS_CLIENT_SECRET": "your-client-secret",
         "APPINSIGHTS_RESOURCES": "[{\"id\":\"prod-api\",\"name\":\"Production API\",\"appId\":\"your-app-id\",\"active\":true}]",
 
+        "LOGANALYTICS_AUTH_METHOD": "entra-id",
+        "LOGANALYTICS_TENANT_ID": "your-tenant-id",
+        "LOGANALYTICS_CLIENT_ID": "your-client-id",
+        "LOGANALYTICS_CLIENT_SECRET": "your-client-secret",
+        "LOGANALYTICS_RESOURCES": "[{\"id\":\"prod-functions\",\"name\":\"Production Functions\",\"workspaceId\":\"your-workspace-id\",\"active\":true}]",
+
         "AZURE_SQL_SERVER": "yourserver.database.windows.net",
         "AZURE_SQL_DATABASE": "yourdatabase",
         "AZURE_SQL_USERNAME": "your-username",

package/build/LogAnalyticsService.js

@@ -0,0 +1,409 @@
+import { ConfidentialClientApplication } from '@azure/msal-node';
+import axios from 'axios';
+export class LogAnalyticsService {
+    config;
+    msalClient = null;
+    accessToken = null;
+    tokenExpirationTime = 0;
+    baseUrl = 'https://api.loganalytics.io/v1';
+    constructor(config) {
+        this.config = config;
+        // Initialize MSAL client if using Entra ID auth
+        if (this.config.authMethod === 'entra-id') {
+            if (!this.config.tenantId || !this.config.clientId || !this.config.clientSecret) {
+                throw new Error('Entra ID authentication requires tenantId, clientId, and clientSecret');
+            }
+            this.msalClient = new ConfidentialClientApplication({
+                auth: {
+                    clientId: this.config.clientId,
+                    clientSecret: this.config.clientSecret,
+                    authority: `https://login.microsoftonline.com/${this.config.tenantId}`,
+                },
+            });
+        }
+    }
+    /**
+     * Get access token for Log Analytics API using Microsoft Entra ID OAuth
+     * Implements token caching with 5-minute buffer before expiry
+     */
+    async getAccessToken() {
+        if (!this.msalClient) {
+            throw new Error('MSAL client not initialized. Use Entra ID authentication method.');
+        }
+        // Return cached token if still valid (with 5-minute buffer)
+        const currentTime = Date.now();
+        const bufferTime = 5 * 60 * 1000; // 5 minutes in milliseconds
+        if (this.accessToken && this.tokenExpirationTime > currentTime + bufferTime) {
+            return this.accessToken;
+        }
+        // Acquire new token
+        try {
+            const result = await this.msalClient.acquireTokenByClientCredential({
+                scopes: ['https://api.loganalytics.io/.default'],
+            });
+            if (!result || !result.accessToken) {
+                throw new Error('Failed to acquire access token');
+            }
+            this.accessToken = result.accessToken;
+            this.tokenExpirationTime = result.expiresOn ? result.expiresOn.getTime() : 0;
+            return this.accessToken;
+        }
+        catch (error) {
+            throw new Error(`Failed to acquire access token: ${error.message}`);
+        }
+    }
+    /**
+     * Get authorization headers based on authentication method
+     */
+    async getAuthHeaders(resource) {
+        if (this.config.authMethod === 'entra-id') {
+            const token = await this.getAccessToken();
+            return {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            };
+        }
+        else if (this.config.authMethod === 'api-key') {
+            if (!resource.apiKey) {
+                throw new Error(`API key not configured for resource: ${resource.id}`);
+            }
+            return {
+                'X-Api-Key': resource.apiKey,
+                'Content-Type': 'application/json',
+            };
+        }
+        else {
+            throw new Error(`Unsupported authentication method: ${this.config.authMethod}`);
+        }
+    }
+    /**
+     * Execute a KQL query against a Log Analytics workspace
+     */
+    async executeQuery(resourceId, query, timespan) {
+        const resource = this.getResourceById(resourceId);
+        try {
+            const headers = await this.getAuthHeaders(resource);
+            const url = `${this.baseUrl}/workspaces/${resource.workspaceId}/query`;
+            const requestBody = { query };
+            if (timespan) {
+                requestBody.timespan = timespan;
+            }
+            const response = await axios.post(url, requestBody, {
+                headers,
+                timeout: 30000, // 30-second timeout
+            });
+            return response.data;
+        }
+        catch (error) {
+            // Enhanced error handling
+            let errorMessage = 'Unknown error';
+            let errorDetails = {};
+            if (error.response) {
+                const status = error.response.status;
+                const data = error.response.data;
+                switch (status) {
+                    case 401:
+                        errorMessage = 'Authentication failed. Check your credentials and ensure the app registration has proper permissions.';
+                        break;
+                    case 403:
+                        errorMessage = 'Access denied. Ensure the service principal has "Log Analytics Reader" role on the workspace.';
+                        break;
+                    case 429:
+                        errorMessage = 'Rate limit exceeded. Reduce query frequency or upgrade authentication method.';
+                        if (error.response.headers['retry-after']) {
+                            errorMessage += ` Retry after ${error.response.headers['retry-after']} seconds.`;
+                        }
+                        break;
+                    case 400:
+                        if (data && data.error) {
+                            if (data.error.code === 'SyntaxError') {
+                                errorMessage = `KQL syntax error: ${data.error.message}`;
+                            }
+                            else if (data.error.code === 'SemanticError') {
+                                errorMessage = `KQL semantic error: ${data.error.message}. Check table/column names.`;
+                            }
+                            else {
+                                errorMessage = `Bad request: ${data.error.message}`;
+                            }
+                        }
+                        else {
+                            errorMessage = 'Bad request. Check your query syntax.';
+                        }
+                        break;
+                    case 504:
+                        errorMessage = 'Query timeout. Try reducing the time range or simplifying the query.';
+                        break;
+                    default:
+                        errorMessage = `HTTP ${status}: ${data?.error?.message || error.message}`;
+                }
+                errorDetails = {
+                    status,
+                    code: data?.error?.code,
+                    message: data?.error?.message,
+                };
+            }
+            else if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED') {
+                errorMessage = 'Network error: Unable to reach Log Analytics API. Check your internet connection.';
+            }
+            else if (error.code === 'ETIMEDOUT') {
+                errorMessage = 'Request timeout. The query took too long to execute.';
+            }
+            else {
+                errorMessage = error.message;
+            }
+            throw new Error(errorMessage);
+        }
+    }
+    /**
+     * Get workspace metadata (schema)
+     */
+    async getMetadata(resourceId) {
+        const resource = this.getResourceById(resourceId);
+        try {
+            const headers = await this.getAuthHeaders(resource);
+            const url = `${this.baseUrl}/workspaces/${resource.workspaceId}/metadata`;
+            const response = await axios.get(url, {
+                headers,
+                timeout: 15000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`Failed to get metadata: ${error.message}`);
+        }
+    }
+    /**
+     * Test workspace access by executing a simple query
+     */
+    async testWorkspaceAccess(resourceId) {
+        const resource = this.getResourceById(resourceId);
+        try {
+            // Execute a minimal query to test access
+            const result = await this.executeQuery(resourceId, 'print test="success"');
+            return {
+                success: true,
+                message: `Successfully connected to workspace: ${resource.name}`,
+                details: {
+                    workspaceId: resource.workspaceId,
+                    authMethod: this.config.authMethod,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to access workspace: ${error.message}`,
+                details: {
+                    workspaceId: resource.workspaceId,
+                    error: error.message,
+                },
+            };
+        }
+    }
+    /**
+     * Get recent events from any table
+     */
+    async getRecentEvents(resourceId, tableName, timespan = 'PT1H', limit = 100) {
+        const query = `
+      ${tableName}
+      | where TimeGenerated > ago(${this.convertTimespanToKQL(timespan)})
+      | order by TimeGenerated desc
+      | take ${limit}
+    `.trim();
+        return this.executeQuery(resourceId, query, timespan);
+    }
+    /**
+     * Search logs across tables or specific table
+     */
+    async searchLogs(resourceId, searchText, tableName, timespan = 'PT1H', limit = 100) {
+        const tableFilter = tableName || '*';
+        const query = `
+      ${tableFilter}
+      | where TimeGenerated > ago(${this.convertTimespanToKQL(timespan)})
+      | where * contains "${searchText}"
+      | order by TimeGenerated desc
+      | take ${limit}
+    `.trim();
+        return this.executeQuery(resourceId, query, timespan);
+    }
+    /**
+     * Get Azure Function logs from FunctionAppLogs table
+     */
+    async getFunctionLogs(resourceId, functionName, timespan = 'PT1H', severityLevel, limit = 100) {
+        let query = `
+      FunctionAppLogs
+      | where TimeGenerated > ago(${this.convertTimespanToKQL(timespan)})
+    `;
+        if (functionName) {
+            query += `\n      | where FunctionName == "${functionName}"`;
+        }
+        if (severityLevel !== undefined) {
+            query += `\n      | where SeverityLevel >= ${severityLevel}`;
+        }
+        query += `
+      | order by TimeGenerated desc
+      | take ${limit}
+      | project TimeGenerated, FunctionName, Message, SeverityLevel, ExceptionDetails, HostInstanceId
+    `.trim();
+        return this.executeQuery(resourceId, query, timespan);
+    }
+    /**
+     * Get Azure Function errors
+     */
+    async getFunctionErrors(resourceId, functionName, timespan = 'PT1H', limit = 100) {
+        let query = `
+      FunctionAppLogs
+      | where TimeGenerated > ago(${this.convertTimespanToKQL(timespan)})
+      | where ExceptionDetails != ""
+    `;
+        if (functionName) {
+            query += `\n      | where FunctionName == "${functionName}"`;
+        }
+        query += `
+      | order by TimeGenerated desc
+      | take ${limit}
+      | project TimeGenerated, FunctionName, Message, ExceptionDetails, SeverityLevel, HostInstanceId
+    `.trim();
+        return this.executeQuery(resourceId, query, timespan);
+    }
+    /**
+     * Get Azure Function execution statistics
+     */
+    async getFunctionStats(resourceId, functionName, timespan = 'PT1H') {
+        let query = `
+      FunctionAppLogs
+      | where TimeGenerated > ago(${this.convertTimespanToKQL(timespan)})
+    `;
+        if (functionName) {
+            query += `\n      | where FunctionName == "${functionName}"`;
+            query += `
+      | summarize
+          TotalExecutions = count(),
+          ErrorCount = countif(ExceptionDetails != ""),
+          SuccessCount = countif(ExceptionDetails == ""),
+          UniqueHosts = dcount(HostInstanceId)
+      | extend SuccessRate = round(100.0 * SuccessCount / TotalExecutions, 2)
+      `.trim();
+        }
+        else {
+            query += `
+      | summarize
+          TotalExecutions = count(),
+          ErrorCount = countif(ExceptionDetails != ""),
+          SuccessCount = countif(ExceptionDetails == ""),
+          UniqueFunctions = dcount(FunctionName),
+          UniqueHosts = dcount(HostInstanceId)
+        by FunctionName
+      | extend SuccessRate = round(100.0 * SuccessCount / TotalExecutions, 2)
+      | order by TotalExecutions desc
+      `.trim();
+        }
+        return this.executeQuery(resourceId, query, timespan);
+    }
+    /**
+     * Get Azure Function invocations from traces or requests table
+     */
+    async getFunctionInvocations(resourceId, functionName, timespan = 'PT1H', limit = 100) {
+        // Try requests table first (for HTTP-triggered functions)
+        let query = `
+      union isfuzzy=true requests, traces
+      | where TimeGenerated > ago(${this.convertTimespanToKQL(timespan)})
+    `;
+        if (functionName) {
+            query += `\n      | where operation_Name contains "${functionName}" or name contains "${functionName}"`;
+        }
+        query += `
+      | order by TimeGenerated desc
+      | take ${limit}
+      | project TimeGenerated, operation_Name, name, success, resultCode, duration, timestamp
+    `.trim();
+        return this.executeQuery(resourceId, query, timespan);
+    }
+    /**
+     * Get all configured resources
+     */
+    getAllResources() {
+        return this.config.resources;
+    }
+    /**
+     * Get only active resources
+     */
+    getActiveResources() {
+        return this.config.resources.filter((r) => r.active);
+    }
+    /**
+     * Get resource by ID and validate it's active
+     */
+    getResourceById(resourceId) {
+        const resource = this.config.resources.find((r) => r.id === resourceId);
+        if (!resource) {
+            const availableIds = this.config.resources.map((r) => r.id).join(', ');
+            throw new Error(`Resource '${resourceId}' not found. Available resources: ${availableIds || 'none'}`);
+        }
+        if (!resource.active) {
+            throw new Error(`Resource '${resourceId}' is inactive. Set 'active: true' in configuration to enable it.`);
+        }
+        return resource;
+    }
+    /**
+     * Convert ISO 8601 duration to KQL timespan format
+     * PT1H -> 1h, P1D -> 1d, PT30M -> 30m, etc.
+     */
+    convertTimespanToKQL(iso8601Duration) {
+        // Handle common patterns
+        const patterns = {
+            'PT15M': '15m',
+            'PT30M': '30m',
+            'PT1H': '1h',
+            'PT2H': '2h',
+            'PT6H': '6h',
+            'PT12H': '12h',
+            'PT24H': '24h',
+            'P1D': '1d',
+            'P2D': '2d',
+            'P7D': '7d',
+            'P30D': '30d',
+        };
+        if (patterns[iso8601Duration]) {
+            return patterns[iso8601Duration];
+        }
+        // Parse ISO 8601 duration
+        const regex = /P(?:(\d+)D)?T?(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?/;
+        const match = iso8601Duration.match(regex);
+        if (!match) {
+            // If no match, return as-is (might be KQL format already)
+            return iso8601Duration;
+        }
+        const [, days, hours, minutes, seconds] = match;
+        // Convert to KQL format (use largest unit)
+        if (days)
+            return `${days}d`;
+        if (hours)
+            return `${hours}h`;
+        if (minutes)
+            return `${minutes}m`;
+        if (seconds)
+            return `${seconds}s`;
+        return '1h'; // Default fallback
+    }
+    /**
+     * Validate KQL query (basic check)
+     */
+    validateQuery(query) {
+        if (!query || query.trim().length === 0) {
+            return { valid: false, error: 'Query cannot be empty' };
+        }
+        // Check for dangerous operations (optional - KQL is read-only by nature)
+        const dangerousKeywords = ['invoke', 'execute', 'evaluate'];
+        const lowerQuery = query.toLowerCase();
+        for (const keyword of dangerousKeywords) {
+            if (lowerQuery.includes(keyword)) {
+                return {
+                    valid: false,
+                    error: `Query contains potentially dangerous keyword: ${keyword}`
+                };
+            }
+        }
+        return { valid: true };
+    }
+}