claude-flow-novice 1.0.0

package/dist/src/automation/test-pipeline/PerformanceMonitor.js

@@ -0,0 +1,572 @@
+/**
+ * PerformanceMonitor - Advanced performance monitoring and optimization for test pipelines
+ * Real-time metrics collection, bottleneck detection, and optimization recommendations
+ */ export class PerformanceMonitor {
+    metrics = new Map();
+    thresholds = new Map();
+    realTimeEnabled;
+    alertingEnabled;
+    optimizationEnabled;
+    monitoringInterval = null;
+    constructor(config){
+        this.realTimeEnabled = config.monitoring?.realTime || false;
+        this.alertingEnabled = config.monitoring?.alerting || false;
+        this.optimizationEnabled = config.optimization?.resourceAllocation || false;
+        // Initialize default thresholds
+        this.initializeThresholds(config.monitoring?.thresholds || {});
+    }
+    /**
+   * Initialize performance monitoring system
+   */ async initialize() {
+        console.log('📊 Initializing Performance Monitor');
+        try {
+            // Setup metrics collection
+            await this.setupMetricsCollection();
+            // Initialize real-time monitoring
+            if (this.realTimeEnabled) {
+                await this.startRealTimeMonitoring();
+            }
+            // Configure alerting
+            if (this.alertingEnabled) {
+                await this.configureAlerting();
+            }
+            console.log('✅ Performance Monitor initialized');
+        } catch (error) {
+            console.error('❌ Failed to initialize Performance Monitor:', error);
+            throw error;
+        }
+    }
+    /**
+   * Start monitoring test execution performance
+   */ async startExecutionMonitoring(executionId) {
+        console.log(`📈 Starting performance monitoring for execution: ${executionId}`);
+        // Initialize execution-specific metrics
+        const executionMetrics = [
+            'test_execution_time',
+            'memory_usage',
+            'cpu_utilization',
+            'network_latency',
+            'disk_io',
+            'browser_resource_usage'
+        ];
+        for (const metric of executionMetrics){
+            this.metrics.set(`${executionId}_${metric}`, []);
+        }
+        // Start periodic metric collection
+        if (this.realTimeEnabled) {
+            this.monitoringInterval = setInterval(()=>{
+                this.collectExecutionMetrics(executionId);
+            }, 5000); // Collect every 5 seconds
+        }
+    }
+    /**
+   * Stop monitoring and generate performance report
+   */ async stopExecutionMonitoring(executionId) {
+        console.log(`📉 Stopping performance monitoring for execution: ${executionId}`);
+        // Stop periodic collection
+        if (this.monitoringInterval) {
+            clearInterval(this.monitoringInterval);
+            this.monitoringInterval = null;
+        }
+        // Generate final performance report
+        const report = await this.generatePerformanceReport(executionId);
+        // Analyze bottlenecks
+        const bottlenecks = await this.analyzeBottlenecks(executionId);
+        // Generate optimization recommendations
+        const recommendations = await this.generateOptimizationRecommendations(executionId, bottlenecks);
+        return {
+            executionId,
+            report,
+            bottlenecks,
+            recommendations,
+            summary: this.generatePerformanceSummary(report, bottlenecks)
+        };
+    }
+    /**
+   * Monitor resource utilization across the swarm
+   */ async monitorSwarmResources(swarmId) {
+        console.log(`🤖 Monitoring swarm resource utilization: ${swarmId}`);
+        const swarmMetrics = {
+            agentUtilization: await this.collectAgentUtilization(swarmId),
+            memoryDistribution: await this.collectMemoryDistribution(swarmId),
+            networkLatency: await this.collectNetworkLatency(swarmId),
+            taskThroughput: await this.collectTaskThroughput(swarmId),
+            loadBalancing: await this.analyzeLoadBalancing(swarmId)
+        };
+        // Analyze resource efficiency
+        const efficiency = await this.calculateSwarmEfficiency(swarmMetrics);
+        // Detect resource bottlenecks
+        const resourceBottlenecks = await this.detectResourceBottlenecks(swarmMetrics);
+        return {
+            swarmId,
+            timestamp: new Date(),
+            metrics: swarmMetrics,
+            efficiency,
+            bottlenecks: resourceBottlenecks,
+            recommendations: await this.generateSwarmOptimizationRecommendations(swarmMetrics, efficiency)
+        };
+    }
+    /**
+   * Benchmark test execution performance
+   */ async benchmarkExecution(testSuite, iterations = 10) {
+        console.log(`🏁 Benchmarking test suite: ${testSuite} (${iterations} iterations)`);
+        const benchmarkResults = {
+            testSuite,
+            iterations,
+            startTime: new Date(),
+            endTime: null,
+            results: [],
+            statistics: null,
+            baseline: null,
+            comparison: null
+        };
+        // Load baseline if available
+        const baseline = await this.loadBaseline(testSuite);
+        for(let i = 0; i < iterations; i++){
+            console.log(`  Running iteration ${i + 1}/${iterations}`);
+            const iterationStart = Date.now();
+            // Execute benchmark
+            const iterationMetrics = await this.executeBenchmarkIteration(testSuite, i);
+            const iterationTime = Date.now() - iterationStart;
+            benchmarkResults.results.push({
+                iteration: i + 1,
+                executionTime: iterationTime,
+                metrics: iterationMetrics
+            });
+        }
+        benchmarkResults.endTime = new Date();
+        // Calculate statistics
+        benchmarkResults.statistics = this.calculateBenchmarkStatistics(benchmarkResults.results);
+        // Compare with baseline
+        if (baseline) {
+            benchmarkResults.comparison = this.compareBenchmarkResults(benchmarkResults.statistics, baseline);
+        }
+        // Store as new baseline if significantly better
+        if (!baseline || benchmarkResults.comparison?.improvement > 10) {
+            await this.storeBaseline(testSuite, benchmarkResults.statistics);
+        }
+        console.log(`✅ Benchmark completed: avg ${benchmarkResults.statistics.averageTime}ms`);
+        return benchmarkResults;
+    }
+    /**
+   * Optimize test parallelization based on performance data
+   */ async optimizeParallelization(executionHistory) {
+        console.log('🔧 Optimizing test parallelization strategy');
+        const optimization = {
+            currentStrategy: await this.analyzeCurrentStrategy(executionHistory),
+            recommendations: [],
+            projectedImprovement: 0,
+            optimalConfiguration: null
+        };
+        // Analyze test execution patterns
+        const executionPatterns = await this.analyzeExecutionPatterns(executionHistory);
+        // Calculate optimal agent count
+        const optimalAgentCount = await this.calculateOptimalAgentCount(executionPatterns);
+        // Determine optimal test grouping
+        const optimalGrouping = await this.calculateOptimalTestGrouping(executionPatterns);
+        // Generate optimization recommendations
+        optimization.recommendations = [
+            {
+                type: 'parallelization',
+                priority: 'high',
+                title: 'Optimize Agent Count',
+                description: `Adjust agent count from ${optimization.currentStrategy.agentCount} to ${optimalAgentCount}`,
+                expectedImprovement: `${Math.round((optimalAgentCount / optimization.currentStrategy.agentCount - 1) * 100)}% throughput increase`,
+                implementationComplexity: 'low',
+                estimatedEffort: '1 hour'
+            },
+            {
+                type: 'resource',
+                priority: 'medium',
+                title: 'Optimize Test Grouping',
+                description: 'Reorganize tests into more balanced parallel groups',
+                expectedImprovement: `${optimalGrouping.improvementPercentage}% execution time reduction`,
+                implementationComplexity: 'medium',
+                estimatedEffort: '4 hours'
+            }
+        ];
+        optimization.optimalConfiguration = {
+            agentCount: optimalAgentCount,
+            grouping: optimalGrouping.strategy,
+            loadBalancing: optimalGrouping.loadBalancing
+        };
+        optimization.projectedImprovement = optimization.recommendations.reduce((sum, rec)=>sum + parseFloat(rec.expectedImprovement.match(/(\d+)%/)?.[1] || '0'), 0);
+        return optimization;
+    }
+    /**
+   * Monitor cache performance and efficiency
+   */ async monitorCachePerformance() {
+        console.log('💾 Monitoring cache performance');
+        const cacheMetrics = {
+            hitRate: await this.calculateCacheHitRate(),
+            missRate: await this.calculateCacheMissRate(),
+            size: await this.getCacheSize(),
+            evictionRate: await this.calculateEvictionRate(),
+            accessPatterns: await this.analyzeCacheAccessPatterns()
+        };
+        const cacheAnalysis = {
+            efficiency: this.calculateCacheEfficiency(cacheMetrics),
+            bottlenecks: await this.identifyCacheBottlenecks(cacheMetrics),
+            recommendations: await this.generateCacheOptimizationRecommendations(cacheMetrics)
+        };
+        return {
+            timestamp: new Date(),
+            metrics: cacheMetrics,
+            analysis: cacheAnalysis
+        };
+    }
+    // Private helper methods
+    initializeThresholds(configThresholds) {
+        const defaultThresholds = {
+            response_time: 2000,
+            memory_usage: 85,
+            cpu_utilization: 80,
+            error_rate: 0.05,
+            throughput: 100
+        };
+        for (const [metric, defaultValue] of Object.entries(defaultThresholds)){
+            this.thresholds.set(metric, configThresholds[metric] || defaultValue);
+        }
+    }
+    async setupMetricsCollection() {
+        // Initialize metrics collection infrastructure
+        console.log('📊 Setting up metrics collection');
+    }
+    async startRealTimeMonitoring() {
+        console.log('⚡ Starting real-time performance monitoring');
+    // Setup real-time metrics streaming
+    }
+    async configureAlerting() {
+        console.log('🚨 Configuring performance alerting');
+    // Setup alerting rules and notifications
+    }
+    async collectExecutionMetrics(executionId) {
+        const timestamp = new Date();
+        // Collect various performance metrics
+        const metrics = [
+            {
+                timestamp,
+                metric: 'memory_usage',
+                value: await this.getMemoryUsage(),
+                unit: 'MB',
+                category: 'resource',
+                status: 'normal'
+            },
+            {
+                timestamp,
+                metric: 'cpu_utilization',
+                value: await this.getCpuUtilization(),
+                unit: '%',
+                category: 'resource',
+                status: 'normal'
+            },
+            {
+                timestamp,
+                metric: 'network_latency',
+                value: await this.getNetworkLatency(),
+                unit: 'ms',
+                category: 'network',
+                status: 'normal'
+            }
+        ];
+        // Store metrics with threshold checking
+        for (const metric of metrics){
+            const metricKey = `${executionId}_${metric.metric}`;
+            const metricHistory = this.metrics.get(metricKey) || [];
+            // Check against thresholds
+            const threshold = this.thresholds.get(metric.metric);
+            if (threshold && metric.value > threshold) {
+                metric.status = metric.value > threshold * 1.5 ? 'critical' : 'warning';
+                if (this.alertingEnabled) {
+                    await this.sendPerformanceAlert(metric);
+                }
+            }
+            metricHistory.push(metric);
+            this.metrics.set(metricKey, metricHistory.slice(-100)); // Keep last 100 measurements
+        }
+    }
+    async generatePerformanceReport(executionId) {
+        const report = {
+            executionId,
+            timestamp: new Date(),
+            metrics: {},
+            summary: {},
+            trends: {}
+        };
+        // Aggregate metrics for report
+        for (const [key, metrics] of this.metrics.entries()){
+            if (key.startsWith(executionId)) {
+                const metricName = key.replace(`${executionId}_`, '');
+                const values = metrics.map((m)=>m.value);
+                report.metrics[metricName] = {
+                    count: values.length,
+                    average: values.reduce((sum, val)=>sum + val, 0) / values.length,
+                    min: Math.min(...values),
+                    max: Math.max(...values),
+                    latest: values[values.length - 1] || 0
+                };
+            }
+        }
+        return report;
+    }
+    async analyzeBottlenecks(executionId) {
+        const bottlenecks = [];
+        for (const [key, metrics] of this.metrics.entries()){
+            if (key.startsWith(executionId)) {
+                const metricName = key.replace(`${executionId}_`, '');
+                const recentMetrics = metrics.slice(-10); // Last 10 measurements
+                // Check for performance bottlenecks
+                const threshold = this.thresholds.get(metricName);
+                if (threshold) {
+                    const exceedingThreshold = recentMetrics.filter((m)=>m.value > threshold);
+                    if (exceedingThreshold.length >= recentMetrics.length * 0.6) {
+                        // 60% of recent measurements
+                        const avgValue = exceedingThreshold.reduce((sum, m)=>sum + m.value, 0) / exceedingThreshold.length;
+                        const impact = Math.min((avgValue - threshold) / threshold * 100, 100);
+                        bottlenecks.push({
+                            component: metricName,
+                            severity: impact > 50 ? 'critical' : impact > 25 ? 'high' : 'medium',
+                            impact: Math.round(impact),
+                            description: `${metricName} consistently exceeds threshold (${threshold}${recentMetrics[0]?.unit || ''})`,
+                            recommendations: this.generateBottleneckRecommendations(metricName, avgValue, threshold),
+                            metrics: exceedingThreshold
+                        });
+                    }
+                }
+            }
+        }
+        return bottlenecks.sort((a, b)=>b.impact - a.impact);
+    }
+    async generateOptimizationRecommendations(executionId, bottlenecks) {
+        const recommendations = [];
+        for (const bottleneck of bottlenecks){
+            switch(bottleneck.component){
+                case 'memory_usage':
+                    recommendations.push({
+                        id: `opt_mem_${Date.now()}`,
+                        type: 'resource',
+                        priority: bottleneck.severity === 'critical' ? 'high' : 'medium',
+                        title: 'Optimize Memory Usage',
+                        description: 'Reduce memory consumption by optimizing test data management and browser instances',
+                        expectedImprovement: `${Math.round(bottleneck.impact * 0.7)}% memory reduction`,
+                        implementationComplexity: 'medium',
+                        estimatedEffort: '2-4 hours'
+                    });
+                    break;
+                case 'cpu_utilization':
+                    recommendations.push({
+                        id: `opt_cpu_${Date.now()}`,
+                        type: 'parallelization',
+                        priority: 'high',
+                        title: 'Optimize CPU Utilization',
+                        description: 'Redistribute test load across agents to balance CPU usage',
+                        expectedImprovement: `${Math.round(bottleneck.impact * 0.6)}% CPU efficiency improvement`,
+                        implementationComplexity: 'low',
+                        estimatedEffort: '1-2 hours'
+                    });
+                    break;
+                case 'network_latency':
+                    recommendations.push({
+                        id: `opt_net_${Date.now()}`,
+                        type: 'network',
+                        priority: 'medium',
+                        title: 'Optimize Network Performance',
+                        description: 'Implement request batching and optimize network calls',
+                        expectedImprovement: `${Math.round(bottleneck.impact * 0.5)}% latency reduction`,
+                        implementationComplexity: 'medium',
+                        estimatedEffort: '3-5 hours'
+                    });
+                    break;
+            }
+        }
+        return recommendations;
+    }
+    generatePerformanceSummary(report, bottlenecks) {
+        return {
+            overallHealth: bottlenecks.length === 0 ? 'excellent' : bottlenecks.every((b)=>b.severity !== 'critical') ? 'good' : 'needs-attention',
+            criticalIssues: bottlenecks.filter((b)=>b.severity === 'critical').length,
+            totalBottlenecks: bottlenecks.length,
+            averageImpact: bottlenecks.length > 0 ? Math.round(bottlenecks.reduce((sum, b)=>sum + b.impact, 0) / bottlenecks.length) : 0,
+            topBottleneck: bottlenecks[0] || null
+        };
+    }
+    generateBottleneckRecommendations(metricName, avgValue, threshold) {
+        const recommendations = {
+            memory_usage: [
+                'Optimize test data cleanup',
+                'Reduce concurrent browser instances',
+                'Implement memory pooling'
+            ],
+            cpu_utilization: [
+                'Balance test distribution across agents',
+                'Optimize test execution order',
+                'Reduce parallel test count'
+            ],
+            network_latency: [
+                'Implement request caching',
+                'Optimize API endpoints',
+                'Use local test environment'
+            ]
+        };
+        return recommendations[metricName] || [
+            'Review and optimize component implementation'
+        ];
+    }
+    // Simulation methods for metrics (in production, these would collect real metrics)
+    async getMemoryUsage() {
+        return Math.random() * 1000 + 500; // 500-1500 MB
+    }
+    async getCpuUtilization() {
+        return Math.random() * 100; // 0-100%
+    }
+    async getNetworkLatency() {
+        return Math.random() * 200 + 50; // 50-250ms
+    }
+    async sendPerformanceAlert(metric) {
+        console.log(`🚨 Performance alert: ${metric.metric} = ${metric.value}${metric.unit} (${metric.status})`);
+    }
+    async collectAgentUtilization(swarmId) {
+        // Collect utilization metrics for each agent in the swarm
+        return {
+            average: 75,
+            distribution: [
+                70,
+                80,
+                75,
+                72,
+                78
+            ]
+        };
+    }
+    async collectMemoryDistribution(swarmId) {
+        return {
+            total: 8192,
+            used: 6144,
+            available: 2048,
+            perAgent: 1024
+        };
+    }
+    async collectNetworkLatency(swarmId) {
+        return {
+            average: 45,
+            p95: 120,
+            p99: 200
+        };
+    }
+    async collectTaskThroughput(swarmId) {
+        return {
+            tasksPerSecond: 12,
+            completionRate: 0.95
+        };
+    }
+    async analyzeLoadBalancing(swarmId) {
+        return {
+            efficiency: 0.87,
+            imbalance: 0.13,
+            recommendation: 'rebalance-tasks'
+        };
+    }
+    async calculateSwarmEfficiency(metrics) {
+        return 0.82; // 82% efficiency
+    }
+    async detectResourceBottlenecks(metrics) {
+        return [];
+    }
+    async generateSwarmOptimizationRecommendations(metrics, efficiency) {
+        return [];
+    }
+    async loadBaseline(testSuite) {
+        // Load baseline performance data for comparison
+        return null;
+    }
+    async executeBenchmarkIteration(testSuite, iteration) {
+        // Execute benchmark iteration and collect metrics
+        return {
+            memoryPeak: Math.random() * 500 + 200,
+            cpuPeak: Math.random() * 80 + 20,
+            networkCalls: Math.floor(Math.random() * 50) + 10
+        };
+    }
+    calculateBenchmarkStatistics(results) {
+        const executionTimes = results.map((r)=>r.executionTime);
+        return {
+            averageTime: Math.round(executionTimes.reduce((sum, time)=>sum + time, 0) / executionTimes.length),
+            minTime: Math.min(...executionTimes),
+            maxTime: Math.max(...executionTimes),
+            standardDeviation: this.calculateStandardDeviation(executionTimes)
+        };
+    }
+    compareBenchmarkResults(current, baseline) {
+        const improvement = (baseline.averageTime - current.averageTime) / baseline.averageTime * 100;
+        return {
+            improvement: Math.round(improvement * 100) / 100,
+            status: improvement > 5 ? 'improved' : improvement < -5 ? 'regressed' : 'stable'
+        };
+    }
+    async storeBaseline(testSuite, statistics) {
+        console.log(`💾 Storing new baseline for ${testSuite}: ${statistics.averageTime}ms avg`);
+    }
+    calculateStandardDeviation(values) {
+        const mean = values.reduce((sum, val)=>sum + val, 0) / values.length;
+        const squaredDiffs = values.map((val)=>Math.pow(val - mean, 2));
+        const avgSquaredDiff = squaredDiffs.reduce((sum, val)=>sum + val, 0) / values.length;
+        return Math.sqrt(avgSquaredDiff);
+    }
+    async analyzeCurrentStrategy(history) {
+        return {
+            agentCount: 4,
+            parallelization: 'medium',
+            loadBalancing: 'round-robin'
+        };
+    }
+    async analyzeExecutionPatterns(history) {
+        return {
+            testDistribution: {},
+            executionTimes: {},
+            resourceUsage: {}
+        };
+    }
+    async calculateOptimalAgentCount(patterns) {
+        return 6; // Optimal agent count based on analysis
+    }
+    async calculateOptimalTestGrouping(patterns) {
+        return {
+            strategy: 'balanced',
+            improvementPercentage: 25,
+            loadBalancing: 'dynamic'
+        };
+    }
+    async calculateCacheHitRate() {
+        return 0.78; // 78% hit rate
+    }
+    async calculateCacheMissRate() {
+        return 0.22; // 22% miss rate
+    }
+    async getCacheSize() {
+        return 1024; // 1GB cache size
+    }
+    async calculateEvictionRate() {
+        return 0.05; // 5% eviction rate
+    }
+    async analyzeCacheAccessPatterns() {
+        return {
+            sequential: 0.6,
+            random: 0.4,
+            hotSpots: [
+                'test-data',
+                'fixtures'
+            ]
+        };
+    }
+    calculateCacheEfficiency(metrics) {
+        return metrics.hitRate * 0.8 + (1 - metrics.evictionRate) * 0.2;
+    }
+    async identifyCacheBottlenecks(metrics) {
+        return [];
+    }
+    async generateCacheOptimizationRecommendations(metrics) {
+        return [];
+    }
+}
+
+//# sourceMappingURL=PerformanceMonitor.js.map

package/dist/src/automation/test-pipeline/PerformanceMonitor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/automation/test-pipeline/PerformanceMonitor.ts"],"names":["PerformanceMonitor","metrics","Map","thresholds","realTimeEnabled","alertingEnabled","optimizationEnabled","monitoringInterval","config","monitoring","realTime","alerting","optimization","resourceAllocation","initializeThresholds","initialize","console","log","setupMetricsCollection","startRealTimeMonitoring","configureAlerting","error","startExecutionMonitoring","executionId","executionMetrics","metric","set","setInterval","collectExecutionMetrics","stopExecutionMonitoring","clearInterval","report","generatePerformanceReport","bottlenecks","analyzeBottlenecks","recommendations","generateOptimizationRecommendations","summary","generatePerformanceSummary","monitorSwarmResources","swarmId","swarmMetrics","agentUtilization","collectAgentUtilization","memoryDistribution","collectMemoryDistribution","networkLatency","collectNetworkLatency","taskThroughput","collectTaskThroughput","loadBalancing","analyzeLoadBalancing","efficiency","calculateSwarmEfficiency","resourceBottlenecks","detectResourceBottlenecks","timestamp","Date","generateSwarmOptimizationRecommendations","benchmarkExecution","testSuite","iterations","benchmarkResults","startTime","endTime","results","statistics","baseline","comparison","loadBaseline","i","iterationStart","now","iterationMetrics","executeBenchmarkIteration","iterationTime","push","iteration","executionTime","calculateBenchmarkStatistics","compareBenchmarkResults","improvement","storeBaseline","averageTime","optimizeParallelization","executionHistory","currentStrategy","analyzeCurrentStrategy","projectedImprovement","optimalConfiguration","executionPatterns","analyzeExecutionPatterns","optimalAgentCount","calculateOptimalAgentCount","optimalGrouping","calculateOptimalTestGrouping","type","priority","title","description","agentCount","expectedImprovement","Math","round","implementationComplexity","estimatedEffort","improvementPercentage","grouping","strategy","reduce","sum","rec","parseFloat","match","monitorCachePerformance","cacheMetrics","hitRate","calculateCacheHitRate","missRate","calculateCacheMissRate","size","getCacheSize","evictionRate","calculateEvictionRate","accessPatterns","analyzeCacheAccessPatterns","cacheAnalysis","calculateCacheEfficiency","identifyCacheBottlenecks","generateCacheOptimizationRecommendations","analysis","configThresholds","defaultThresholds","response_time","memory_usage","cpu_utilization","error_rate","throughput","defaultValue","Object","entries","value","getMemoryUsage","unit","category","status","getCpuUtilization","getNetworkLatency","metricKey","metricHistory","get","threshold","sendPerformanceAlert","slice","trends","key","startsWith","metricName","replace","values","map","m","count","length","average","val","min","max","latest","recentMetrics","exceedingThreshold","filter","avgValue","impact","component","severity","generateBottleneckRecommendations","sort","a","b","bottleneck","id","overallHealth","every","criticalIssues","totalBottlenecks","averageImpact","topBottleneck","network_latency","random","distribution","total","used","available","perAgent","p95","p99","tasksPerSecond","completionRate","imbalance","recommendation","memoryPeak","cpuPeak","networkCalls","floor","executionTimes","r","time","minTime","maxTime","standardDeviation","calculateStandardDeviation","current","mean","squaredDiffs","pow","avgSquaredDiff","sqrt","history","parallelization","testDistribution","resourceUsage","patterns","sequential","hotSpots"],"mappings":"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"}