MCP Console Automation Server

import { EventEmitter } from 'eventemitter3'; import { Logger } from 'winston'; import { AzureCloudShellSession, AzureBastionSession, AzureArcSession, AzureTokenInfo, AzureResourceInfo, } from '../types/index.js'; export interface AzureMonitoringMetrics { sessionCount: { total: number; byType: Record<string, number>; byRegion: Record<string, number>; byStatus: Record<string, number>; }; authentication: { tokenRefreshCount: number; tokenExpirySoon: number; authFailures: number; lastTokenRefresh: Date | null; }; performance: { averageConnectionTime: number; averageLatency: number; connectionSuccess: number; connectionFailures: number; reconnectAttempts: number; }; resources: { activeSubscriptions: Set<string>; activeResourceGroups: Set<string>; activeRegions: Set<string>; quotaUtilization: Record<string, number>; }; errors: { azureApiErrors: number; networkErrors: number; authenticationErrors: number; configurationErrors: number; }; costs: { estimatedSessionCosts: Record<string, number>; totalEstimatedCost: number; costOptimizationSuggestions: string[]; }; } export interface AzureHealthCheck { timestamp: Date; overall: 'healthy' | 'warning' | 'critical'; checks: { authentication: { status: 'pass' | 'warn' | 'fail'; message: string; tokensExpiringSoon?: number; lastRefresh?: Date; }; connectivity: { status: 'pass' | 'warn' | 'fail'; message: string; activeConnections: number; failureRate: number; }; resources: { status: 'pass' | 'warn' | 'fail'; message: string; quotaUtilization: Record<string, number>; recommendations?: string[]; }; performance: { status: 'pass' | 'warn' | 'fail'; message: string; averageLatency: number; connectionSuccessRate: number; }; }; recommendations: string[]; } export interface AzureAlertConfig { tokenExpiryWarningHours: number; maxConnectionFailureRate: number; maxLatencyMs: number; quotaUtilizationThreshold: number; costThresholdDaily: number; } interface AzureMonitoringEvents { 'token-expiry-warning': (sessionId: string, expiresIn: number) => void; 'connection-failure-threshold': (failureRate: number) => void; 'performance-degradation': (latency: number) => void; 'quota-warning': (resource: string, utilization: number) => void; 'cost-alert': (dailyCost: number) => void; 'health-check-completed': (result: AzureHealthCheck) => void; } export class AzureMonitoring extends EventEmitter<AzureMonitoringEvents> { private metrics: AzureMonitoringMetrics; private alertConfig: AzureAlertConfig; private sessions: Map< string, AzureCloudShellSession | AzureBastionSession | AzureArcSession > = new Map(); private connectionStats: Map< string, { startTime: Date; endTime?: Date; success: boolean; latency?: number } > = new Map(); private monitoringInterval: NodeJS.Timeout | null = null; private logger: Logger; constructor(logger: Logger, config?: Partial<AzureAlertConfig>) { super(); this.logger = logger; this.alertConfig = { tokenExpiryWarningHours: 2, // Warn 2 hours before token expires maxConnectionFailureRate: 0.15, // 15% failure rate maxLatencyMs: 5000, // 5 seconds quotaUtilizationThreshold: 0.8, // 80% quota utilization costThresholdDaily: 100, // $100 per day ...config, }; this.metrics = { sessionCount: { total: 0, byType: {}, byRegion: {}, byStatus: {}, }, authentication: { tokenRefreshCount: 0, tokenExpirySoon: 0, authFailures: 0, lastTokenRefresh: null, }, performance: { averageConnectionTime: 0, averageLatency: 0, connectionSuccess: 0, connectionFailures: 0, reconnectAttempts: 0, }, resources: { activeSubscriptions: new Set(), activeResourceGroups: new Set(), activeRegions: new Set(), quotaUtilization: {}, }, errors: { azureApiErrors: 0, networkErrors: 0, authenticationErrors: 0, configurationErrors: 0, }, costs: { estimatedSessionCosts: {}, totalEstimatedCost: 0, costOptimizationSuggestions: [], }, }; this.startMonitoring(); } /** * Register a new Azure session for monitoring */ registerSession( session: AzureCloudShellSession | AzureBastionSession | AzureArcSession ): void { this.sessions.set(session.sessionId, session); // Update metrics this.metrics.sessionCount.total++; // Determine session type let sessionType: string; if ('webSocketUrl' in session) { sessionType = 'cloud-shell'; } else if ('bastionResourceId' in session) { sessionType = 'bastion'; } else { sessionType = 'arc'; } this.metrics.sessionCount.byType[sessionType] = (this.metrics.sessionCount.byType[sessionType] || 0) + 1; // Track resources if ('subscription' in session) { this.metrics.resources.activeSubscriptions.add(session.subscription); } if ('resourceGroup' in session) { this.metrics.resources.activeResourceGroups.add(session.resourceGroup); } if ('location' in session) { this.metrics.resources.activeRegions.add(session.location); } this.logger.debug( `Registered Azure ${sessionType} session for monitoring: ${session.sessionId}` ); } /** * Unregister an Azure session from monitoring */ unregisterSession(sessionId: string): void { const session = this.sessions.get(sessionId); if (!session) { return; } this.sessions.delete(sessionId); this.connectionStats.delete(sessionId); this.metrics.sessionCount.total--; // Update session type count let sessionType: string; if ('webSocketUrl' in session) { sessionType = 'cloud-shell'; } else if ('bastionResourceId' in session) { sessionType = 'bastion'; } else { sessionType = 'arc'; } if (this.metrics.sessionCount.byType[sessionType] > 0) { this.metrics.sessionCount.byType[sessionType]--; } this.logger.debug( `Unregistered Azure session from monitoring: ${sessionId}` ); } /** * Record authentication event */ recordAuthenticationEvent( eventType: 'token-refresh' | 'auth-failure', tokenInfo?: AzureTokenInfo ): void { switch (eventType) { case 'token-refresh': this.metrics.authentication.tokenRefreshCount++; this.metrics.authentication.lastTokenRefresh = new Date(); if (tokenInfo) { this.checkTokenExpiry(tokenInfo); } break; case 'auth-failure': this.metrics.authentication.authFailures++; this.metrics.errors.authenticationErrors++; break; } } /** * Record connection event */ recordConnectionEvent( sessionId: string, eventType: 'start' | 'success' | 'failure', latency?: number ): void { switch (eventType) { case 'start': this.connectionStats.set(sessionId, { startTime: new Date(), success: false, }); break; case 'success': const successStat = this.connectionStats.get(sessionId); if (successStat) { successStat.success = true; successStat.endTime = new Date(); successStat.latency = latency || successStat.endTime.getTime() - successStat.startTime.getTime(); this.metrics.performance.connectionSuccess++; this.updatePerformanceMetrics(); } break; case 'failure': const failureStat = this.connectionStats.get(sessionId); if (failureStat) { failureStat.success = false; failureStat.endTime = new Date(); this.metrics.performance.connectionFailures++; this.checkConnectionFailureRate(); } break; } } /** * Record error event */ recordErrorEvent( errorType: 'api' | 'network' | 'authentication' | 'configuration', error: Error ): void { switch (errorType) { case 'api': this.metrics.errors.azureApiErrors++; break; case 'network': this.metrics.errors.networkErrors++; break; case 'authentication': this.metrics.errors.authenticationErrors++; break; case 'configuration': this.metrics.errors.configurationErrors++; break; } this.logger.warn(`Azure ${errorType} error recorded:`, error.message); } /** * Update estimated costs */ updateCostEstimates(sessionId: string, costEstimate: number): void { this.metrics.costs.estimatedSessionCosts[sessionId] = costEstimate; this.metrics.costs.totalEstimatedCost = Object.values( this.metrics.costs.estimatedSessionCosts ).reduce((sum, cost) => sum + cost, 0); if ( this.metrics.costs.totalEstimatedCost > this.alertConfig.costThresholdDaily ) { this.emit('cost-alert', this.metrics.costs.totalEstimatedCost); } } /** * Get current metrics */ getMetrics(): AzureMonitoringMetrics { return { ...this.metrics, // Convert Sets to arrays for serialization resources: { ...this.metrics.resources, activeSubscriptions: new Set( Array.from(this.metrics.resources.activeSubscriptions) ), activeResourceGroups: new Set( Array.from(this.metrics.resources.activeResourceGroups) ), activeRegions: new Set( Array.from(this.metrics.resources.activeRegions) ), }, }; } /** * Perform comprehensive health check */ async performHealthCheck(): Promise<AzureHealthCheck> { const result: AzureHealthCheck = { timestamp: new Date(), overall: 'healthy', checks: { authentication: this.checkAuthentication(), connectivity: this.checkConnectivity(), resources: this.checkResources(), performance: this.checkPerformance(), }, recommendations: [], }; // Determine overall health const checks = Object.values(result.checks); const failCount = checks.filter((check) => check.status === 'fail').length; const warnCount = checks.filter((check) => check.status === 'warn').length; if (failCount > 0) { result.overall = 'critical'; } else if (warnCount > 0) { result.overall = 'warning'; } // Generate recommendations result.recommendations = this.generateRecommendations(result.checks); this.emit('health-check-completed', result); return result; } /** * Start monitoring */ private startMonitoring(): void { if (this.monitoringInterval) { return; } this.monitoringInterval = setInterval(() => { this.performRoutineChecks(); }, 60000); // Check every minute this.logger.info('Azure monitoring started'); } /** * Stop monitoring */ stop(): void { if (this.monitoringInterval) { clearInterval(this.monitoringInterval); this.monitoringInterval = null; } this.logger.info('Azure monitoring stopped'); } /** * Perform routine monitoring checks */ private performRoutineChecks(): void { // Check token expiry for all sessions this.sessions.forEach((session) => { const hoursUntilExpiry = (session.tokenExpiry.getTime() - Date.now()) / (1000 * 60 * 60); if (hoursUntilExpiry <= this.alertConfig.tokenExpiryWarningHours) { this.emit('token-expiry-warning', session.sessionId, hoursUntilExpiry); } }); // Update cost optimization suggestions this.updateCostOptimizationSuggestions(); } /** * Check token expiry */ private checkTokenExpiry(tokenInfo: AzureTokenInfo): void { const hoursUntilExpiry = (tokenInfo.expiresOn.getTime() - Date.now()) / (1000 * 60 * 60); if (hoursUntilExpiry <= this.alertConfig.tokenExpiryWarningHours) { this.metrics.authentication.tokenExpirySoon++; } } /** * Check connection failure rate */ private checkConnectionFailureRate(): void { const totalConnections = this.metrics.performance.connectionSuccess + this.metrics.performance.connectionFailures; if (totalConnections > 0) { const failureRate = this.metrics.performance.connectionFailures / totalConnections; if (failureRate > this.alertConfig.maxConnectionFailureRate) { this.emit('connection-failure-threshold', failureRate); } } } /** * Update performance metrics */ private updatePerformanceMetrics(): void { const latencies = Array.from(this.connectionStats.values()) .filter((stat) => stat.success && stat.latency) .map((stat) => stat.latency!); if (latencies.length > 0) { this.metrics.performance.averageLatency = latencies.reduce((sum, lat) => sum + lat, 0) / latencies.length; if ( this.metrics.performance.averageLatency > this.alertConfig.maxLatencyMs ) { this.emit( 'performance-degradation', this.metrics.performance.averageLatency ); } } } /** * Check authentication health */ private checkAuthentication(): AzureHealthCheck['checks']['authentication'] { const tokensExpiring = Array.from(this.sessions.values()).filter( (session) => (session.tokenExpiry.getTime() - Date.now()) / (1000 * 60 * 60) <= this.alertConfig.tokenExpiryWarningHours ).length; if (tokensExpiring > 0) { return { status: 'warn', message: `${tokensExpiring} token(s) expiring soon`, tokensExpiringSoon: tokensExpiring, lastRefresh: this.metrics.authentication.lastTokenRefresh || undefined, }; } if (this.metrics.authentication.authFailures > 5) { return { status: 'fail', message: `High number of authentication failures: ${this.metrics.authentication.authFailures}`, lastRefresh: this.metrics.authentication.lastTokenRefresh || undefined, }; } return { status: 'pass', message: 'Authentication is healthy', tokensExpiringSoon: 0, lastRefresh: this.metrics.authentication.lastTokenRefresh || undefined, }; } /** * Check connectivity health */ private checkConnectivity(): AzureHealthCheck['checks']['connectivity'] { const totalConnections = this.metrics.performance.connectionSuccess + this.metrics.performance.connectionFailures; const failureRate = totalConnections > 0 ? this.metrics.performance.connectionFailures / totalConnections : 0; if (failureRate > this.alertConfig.maxConnectionFailureRate) { return { status: 'fail', message: `High connection failure rate: ${(failureRate * 100).toFixed(1)}%`, activeConnections: this.sessions.size, failureRate, }; } if (failureRate > this.alertConfig.maxConnectionFailureRate * 0.5) { return { status: 'warn', message: `Elevated connection failure rate: ${(failureRate * 100).toFixed(1)}%`, activeConnections: this.sessions.size, failureRate, }; } return { status: 'pass', message: 'Connectivity is healthy', activeConnections: this.sessions.size, failureRate, }; } /** * Check resources health */ private checkResources(): AzureHealthCheck['checks']['resources'] { const highUtilization = Object.entries( this.metrics.resources.quotaUtilization ).filter( ([_, utilization]) => utilization > this.alertConfig.quotaUtilizationThreshold ); if (highUtilization.length > 0) { return { status: 'warn', message: `High quota utilization in ${highUtilization.length} resource(s)`, quotaUtilization: this.metrics.resources.quotaUtilization, recommendations: highUtilization.map( ([resource, util]) => `Consider increasing quota or reducing usage for ${resource} (${(util * 100).toFixed(1)}% utilized)` ), }; } return { status: 'pass', message: 'Resource utilization is healthy', quotaUtilization: this.metrics.resources.quotaUtilization, }; } /** * Check performance health */ private checkPerformance(): AzureHealthCheck['checks']['performance'] { const totalConnections = this.metrics.performance.connectionSuccess + this.metrics.performance.connectionFailures; const successRate = totalConnections > 0 ? this.metrics.performance.connectionSuccess / totalConnections : 1; if ( this.metrics.performance.averageLatency > this.alertConfig.maxLatencyMs ) { return { status: 'fail', message: `High average latency: ${this.metrics.performance.averageLatency}ms`, averageLatency: this.metrics.performance.averageLatency, connectionSuccessRate: successRate, }; } if ( this.metrics.performance.averageLatency > this.alertConfig.maxLatencyMs * 0.7 ) { return { status: 'warn', message: `Elevated average latency: ${this.metrics.performance.averageLatency}ms`, averageLatency: this.metrics.performance.averageLatency, connectionSuccessRate: successRate, }; } return { status: 'pass', message: 'Performance is healthy', averageLatency: this.metrics.performance.averageLatency, connectionSuccessRate: successRate, }; } /** * Generate recommendations based on health check results */ private generateRecommendations( checks: AzureHealthCheck['checks'] ): string[] { const recommendations: string[] = []; if (checks.authentication.status !== 'pass') { recommendations.push( 'Consider implementing proactive token refresh before expiry' ); } if (checks.connectivity.status !== 'pass') { recommendations.push( 'Review network configuration and Azure service health' ); } if (checks.performance.status !== 'pass') { recommendations.push( 'Consider optimizing connection strategies or using regional endpoints' ); } if ( this.metrics.costs.totalEstimatedCost > this.alertConfig.costThresholdDaily * 0.8 ) { recommendations.push('Review session usage patterns to optimize costs'); } return recommendations; } /** * Update cost optimization suggestions */ private updateCostOptimizationSuggestions(): void { const suggestions: string[] = []; // Suggest session consolidation if many small sessions const activeSessionCount = this.sessions.size; if (activeSessionCount > 10) { suggestions.push( 'Consider consolidating multiple short sessions into fewer long-running sessions' ); } // Suggest region optimization const regions = Array.from(this.metrics.resources.activeRegions); if (regions.length > 3) { suggestions.push( 'Consider consolidating resources to fewer regions to reduce data transfer costs' ); } // Suggest resource cleanup const idleSessions = Array.from(this.sessions.entries()).filter( ([_, session]) => { const lastActivity = session.metadata?.lastActivity as Date; return ( lastActivity && Date.now() - lastActivity.getTime() > 30 * 60 * 1000 ); // 30 minutes idle } ); if (idleSessions.length > 0) { suggestions.push( `Consider closing ${idleSessions.length} idle session(s) to reduce costs` ); } this.metrics.costs.costOptimizationSuggestions = suggestions; } }