codecrucible-synth/dist/core/performance/enterprise-performance-system.d.ts

Production-Ready AI Development Platform with Multi-Voice Synthesis, Smithery MCP Integration, Enterprise Security, and Zero-Timeout Reliability

/**
 * Enterprise Performance Monitoring and Optimization System
 * Integrates with existing PerformanceMonitor to provide enterprise-grade capabilities
 */
import { EventEmitter } from 'events';
import { PerformanceMonitor } from './performance-monitor.js';
import { SecurityAuditLogger } from '../security/security-audit-logger.js';
export interface EnterprisePerformanceConfig {
    enableSLOMonitoring: boolean;
    enableCapacityPlanning: boolean;
    enableAnomalyDetection: boolean;
    enablePredictiveScaling: boolean;
    enableCostOptimization: boolean;
    enableBusinessMetrics: boolean;
    alerting: {
        enabled: boolean;
        channels: string[];
        escalationRules: EscalationRule[];
    };
    slo: {
        availability: number;
        latencyP99: number;
        errorRate: number;
        throughput: number;
    };
}
export interface EscalationRule {
    condition: string;
    delay: number;
    channels: string[];
    severity: 'warning' | 'critical';
}
export interface SLOViolation {
    metric: string;
    target: number;
    actual: number;
    duration: number;
    impact: 'low' | 'medium' | 'high' | 'critical';
    timestamp: number;
}
export interface CapacityPrediction {
    resource: string;
    currentUsage: number;
    predictedUsage: number;
    timeToCapacity: number;
    confidence: number;
    recommendations: string[];
}
export interface BusinessMetric {
    name: string;
    value: number;
    unit: string;
    timestamp: number;
    correlations: Record<string, number>;
}
export interface PerformanceOptimization {
    area: string;
    currentValue: number;
    optimizedValue: number;
    improvement: number;
    confidence: number;
    effort: 'low' | 'medium' | 'high';
    risk: 'low' | 'medium' | 'high';
    recommendations: string[];
}
export interface AnomalyAlert {
    metric: string;
    anomalyType: 'spike' | 'drop' | 'trend' | 'outlier';
    severity: number;
    confidence: number;
    description: string;
    timestamp: number;
    context: Record<string, any>;
}
export declare class EnterprisePerformanceSystem extends EventEmitter {
    private config;
    private performanceMonitor;
    private auditLogger?;
    private sloViolations;
    private capacityPredictions;
    private businessMetrics;
    private anomalies;
    private optimizations;
    private baselineData;
    private monitoringInterval?;
    private predictionInterval?;
    constructor(performanceMonitor: PerformanceMonitor, auditLogger?: SecurityAuditLogger, config?: Partial<EnterprisePerformanceConfig>);
    /**
     * Initialize enterprise performance monitoring
     */
    private initialize;
    /**
     * Process individual metrics for enterprise analysis
     */
    private processMetric;
    /**
     * Process performance snapshots for trend analysis
     */
    private processSnapshot;
    /**
     * Start SLO monitoring
     */
    private startSLOMonitoring;
    /**
     * Start capacity planning
     */
    private startCapacityPlanning;
    /**
     * Start anomaly detection
     */
    private startAnomalyDetection;
    /**
     * Check SLO compliance for a metric
     */
    private checkSLOCompliance;
    /**
     * Calculate current error rate
     */
    private calculateErrorRate;
    /**
     * Determine SLO impact level
     */
    private determineSLOImpact;
    /**
     * Handle SLO violation
     */
    private handleSLOViolation;
    /**
     * Update baseline data for anomaly detection
     */
    private updateBaseline;
    /**
     * Detect anomalies in metrics
     */
    private detectAnomaly;
    /**
     * Calculate anomaly score using statistical methods
     */
    private calculateAnomalyScore;
    /**
     * Analyze capacity trends and predictions
     */
    private analyzeCapacity;
    /**
     * Predict capacity requirements
     */
    private predictCapacity;
    /**
     * Calculate linear trend
     */
    private calculateTrend;
    /**
     * Generate capacity recommendations
     */
    private generateCapacityRecommendations;
    /**
     * Identify performance optimization opportunities
     */
    private identifyOptimizations;
    /**
     * Update business metric correlations
     */
    private updateBusinessMetricCorrelations;
    /**
     * Record business metric
     */
    recordBusinessMetric(name: string, value: number, unit: string): void;
    /**
     * Check all SLOs
     */
    private checkAllSLOs;
    /**
     * Calculate SLO compliance
     */
    private calculateSLOCompliance;
    /**
     * Get capacity status
     */
    private getCapacityStatus;
    /**
     * Update capacity predictions
     */
    private updateCapacityPredictions;
    /**
     * Perform comprehensive anomaly analysis
     */
    private performAnomalyAnalysis;
    /**
     * Analyze anomaly trends
     */
    private analyzeAnomalyTrends;
    /**
     * Trigger alert
     */
    private triggerAlert;
    /**
     * Handle critical threshold events from base monitor
     */
    private handleCriticalThreshold;
    /**
     * Get enterprise performance dashboard data
     */
    getEnterpriseMetrics(): {
        slo: {
            overall: number;
            availability: number;
            latency: number;
            errorRate: number;
            throughput: number;
        };
        capacity: Record<string, CapacityPrediction>;
        anomalies: AnomalyAlert[];
        optimizations: PerformanceOptimization[];
        businessMetrics: Record<string, BusinessMetric[]>;
        alerts: {
            violations: number;
            anomalies: number;
            capacity: number;
        };
    };
    /**
     * Stop enterprise monitoring
     */
    stop(): void;
}
export declare const enterprisePerformanceSystem: EnterprisePerformanceSystem;
//# sourceMappingURL=enterprise-performance-system.d.ts.map