bc-code-intelligence-mcp/dist/monitoring/production-monitor.d.ts

BC Code Intelligence MCP Server - Complete Specialist Bundle with AI-driven expert consultation, seamless handoffs, and context-preserving workflows

/**
 * Production Monitoring & Health Management System
 *
 * Comprehensive monitoring, health checks, metrics collection, and alerting
 * for production deployments with Docker, Kubernetes, and cloud integration.
 */
import { EventEmitter } from 'events';
import { PerformanceMonitor } from '../performance/performance-monitor.js';
import { SecurityManager } from '../security/access-control.js';
import { AdvancedCacheManager } from '../cache/cache-manager.js';
export interface HealthCheckResult {
    service: string;
    status: 'healthy' | 'degraded' | 'unhealthy';
    message: string;
    details?: Record<string, any>;
    response_time_ms: number;
    timestamp: number;
}
export interface SystemMetrics {
    timestamp: number;
    system: {
        uptime_seconds: number;
        memory_usage_mb: number;
        memory_usage_percentage: number;
        cpu_usage_percentage: number;
        process_id: number;
        node_version: string;
    };
    application: {
        active_layers: number;
        total_topics: number;
        cache_hit_rate: number;
        average_response_time_ms: number;
        requests_per_minute: number;
        error_rate_percentage: number;
    };
    performance: {
        slowest_operations: Array<{
            operation: string;
            duration_ms: number;
        }>;
        operations_per_second: number;
        p95_response_time_ms: number;
        p99_response_time_ms: number;
    };
    security: {
        active_sessions: number;
        failed_authentications_last_hour: number;
        rate_limited_requests: number;
        suspicious_activities: number;
    };
}
export interface AlertRule {
    id: string;
    name: string;
    condition: string;
    severity: 'info' | 'warning' | 'critical';
    cooldown_minutes: number;
    enabled: boolean;
}
export interface Alert {
    id: string;
    rule_id: string;
    message: string;
    severity: AlertRule['severity'];
    timestamp: number;
    resolved: boolean;
    resolved_at?: number;
    metadata: Record<string, any>;
}
export declare class ProductionMonitor extends EventEmitter {
    private readonly performanceMonitor;
    private readonly securityManager?;
    private readonly cacheManager?;
    private readonly enableFileLogging;
    private readonly metricsRetentionHours;
    private healthChecks;
    private activeAlerts;
    private alertHistory;
    private alertCooldowns;
    private metricsHistory;
    private startTime;
    private healthCheckInterval?;
    private metricsCollectionInterval?;
    private readonly defaultAlertRules;
    private alertRules;
    constructor(performanceMonitor: PerformanceMonitor, securityManager?: SecurityManager, cacheManager?: AdvancedCacheManager, enableFileLogging?: boolean, metricsRetentionHours?: number);
    /**
     * Register a custom health check
     */
    registerHealthCheck(name: string, checkFn: () => Promise<HealthCheckResult>): void;
    /**
     * Run all health checks and return results
     */
    runHealthChecks(): Promise<{
        status: 'healthy' | 'degraded' | 'unhealthy';
        checks: HealthCheckResult[];
    }>;
    /**
     * Collect current system metrics
     */
    collectMetrics(): Promise<SystemMetrics>;
    /**
     * Get metrics history for time range
     */
    getMetricsHistory(hoursBack?: number): SystemMetrics[];
    /**
     * Get active alerts
     */
    getActiveAlerts(): Alert[];
    /**
     * Get alert history
     */
    getAlertHistory(limit?: number): Alert[];
    /**
     * Resolve an active alert
     */
    resolveAlert(alertId: string): boolean;
    /**
     * Export comprehensive system status for monitoring dashboards
     */
    getSystemStatus(): Promise<{
        overall_health: 'healthy' | 'degraded' | 'unhealthy';
        health_checks: HealthCheckResult[];
        current_metrics: SystemMetrics;
        active_alerts: Alert[];
        performance_summary: any;
        uptime_seconds: number;
    }>;
    /**
     * Export monitoring data for external systems (Prometheus, etc.)
     */
    exportMetricsForPrometheus(): string;
    /**
     * Shutdown monitoring and cleanup
     */
    shutdown(): void;
    private setupDefaultHealthChecks;
    private startMonitoring;
    private evaluateAlerts;
    private evaluateCondition;
    private createAlert;
    private logAlertToFile;
    private getRecentFailedAuthentications;
    private getSystemMemory;
    private getCPUUsage;
}
//# sourceMappingURL=production-monitor.d.ts.map