@arela/uploader 0.2.13 → 1.0.0

package/src/services/PerformanceOptimizer.js

@@ -0,0 +1,511 @@
+/**
+ * PerformanceOptimizer.js
+ * Phase 6 - Task 5: Performance Optimization
+ *
+ * Optimizes signal handling, cleanup operations, and resource management.
+ * Implements monitoring, profiling, and optimization strategies.
+ */
+
+class PerformanceOptimizer {
+  constructor(logger, cleanupManager, errorMonitor) {
+    this.logger = logger;
+    this.cleanupManager = cleanupManager;
+    this.errorMonitor = errorMonitor;
+
+    // Performance metrics
+    this.metrics = {
+      signalResponseTimes: [],
+      cleanupTimes: [],
+      resourceCleanupTimes: {},
+      memoryUsage: [],
+      errorRate: 0,
+    };
+
+    // Performance thresholds (milliseconds)
+    this.thresholds = {
+      signalResponse: 100, // Signal should be handled within 100ms
+      totalCleanup: 5000, // Total cleanup should complete within 5 seconds
+      resourceCleanup: 2000, // Individual resource cleanup < 2 seconds
+      memoryIncrease: 50 * 1024 * 1024, // Max 50MB increase during cleanup
+    };
+
+    // Optimization settings
+    this.optimizations = {
+      parallelizeCleanup: false, // Can we run some cleanups in parallel?
+      cacheDependencies: true,
+      compressSessions: true,
+      pruneOldLogs: true,
+    };
+  }
+
+  /**
+   * Monitor signal response time
+   */
+  startSignalMonitoring() {
+    const signalStart = Date.now();
+
+    return () => {
+      const responseTime = Date.now() - signalStart;
+      this.metrics.signalResponseTimes.push(responseTime);
+
+      if (responseTime > this.thresholds.signalResponse) {
+        this.logger.warn(
+          `Slow signal response: ${responseTime}ms (threshold: ${this.thresholds.signalResponse}ms)`,
+        );
+      }
+
+      return responseTime;
+    };
+  }
+
+  /**
+   * Analyze cleanup performance
+   */
+  async analyzeCleanupPerformance(cleanupResult) {
+    const analysis = {
+      timestamp: new Date().toISOString(),
+      totalDuration: cleanupResult.totalDuration,
+      resourceCount: cleanupResult.results.length,
+      successCount: cleanupResult.successCount,
+      failureCount: cleanupResult.failureCount,
+      slowResources: [],
+      recommendations: [],
+    };
+
+    // Identify slow resources
+    for (const res of cleanupResult.results) {
+      if (res.duration > this.thresholds.resourceCleanup) {
+        analysis.slowResources.push({
+          name: res.name,
+          duration: res.duration,
+          threshold: this.thresholds.resourceCleanup,
+          overage: res.duration - this.thresholds.resourceCleanup,
+        });
+      }
+    }
+
+    // Check total cleanup time
+    if (cleanupResult.totalDuration > this.thresholds.totalCleanup) {
+      analysis.recommendations.push(
+        `Total cleanup took ${cleanupResult.totalDuration}ms (threshold: ${this.thresholds.totalCleanup}ms). ` +
+          `Consider optimizing resource cleanup functions.`,
+      );
+    }
+
+    // Analyze error correlation with performance
+    const stats = this.errorMonitor.getStatistics();
+    if (stats.totalErrors > 0) {
+      const errorRate =
+        (stats.totalErrors / (stats.totalErrors + stats.recoveredErrors)) * 100;
+      analysis.errorRate = errorRate.toFixed(2) + '%';
+
+      if (errorRate > 5) {
+        analysis.recommendations.push(
+          `High error rate (${errorRate.toFixed(2)}%). ` +
+            `Improve error handling in cleanup functions.`,
+        );
+      }
+    }
+
+    // Memory analysis
+    const memUsage = process.memoryUsage();
+    if (memUsage.heapUsed > this.thresholds.memoryIncrease) {
+      analysis.recommendations.push(
+        `High memory usage (${(memUsage.heapUsed / 1024 / 1024).toFixed(2)}MB). ` +
+          `Consider clearing error records or session data periodically.`,
+      );
+    }
+
+    this.metrics.cleanupTimes.push(cleanupResult.totalDuration);
+    return analysis;
+  }
+
+  /**
+   * Get performance report
+   */
+  getPerformanceReport() {
+    const report = {
+      timestamp: new Date().toISOString(),
+      summary: this._generateSummary(),
+      signalMetrics: this._analyzeSignalMetrics(),
+      cleanupMetrics: this._analyzeCleanupMetrics(),
+      memoryMetrics: this._analyzeMemoryMetrics(),
+      recommendations: this._getRecommendations(),
+    };
+
+    return report;
+  }
+
+  /**
+   * Optimize cleanup timeout based on historical data
+   */
+  optimizeCleanupTimeout() {
+    if (this.metrics.cleanupTimes.length === 0) {
+      return this.cleanupManager.cleanupTimeout;
+    }
+
+    // Calculate 95th percentile of cleanup times
+    const sorted = [...this.metrics.cleanupTimes].sort((a, b) => a - b);
+    const p95Index = Math.ceil(sorted.length * 0.95) - 1;
+    const p95Time = sorted[Math.max(0, p95Index)];
+
+    // Add 20% buffer for safety
+    const optimizedTimeout = Math.ceil(p95Time * 1.2);
+
+    // Don't increase timeout beyond maximum of 60 seconds
+    const finalTimeout = Math.min(optimizedTimeout, 60000);
+
+    if (finalTimeout !== this.cleanupManager.cleanupTimeout) {
+      this.logger.info(
+        `Optimizing cleanup timeout: ${this.cleanupManager.cleanupTimeout}ms → ${finalTimeout}ms ` +
+          `(based on 95th percentile: ${p95Time}ms)`,
+      );
+      this.cleanupManager.cleanupTimeout = finalTimeout;
+    }
+
+    return finalTimeout;
+  }
+
+  /**
+   * Monitor and detect resource leaks
+   */
+  detectResourceLeaks() {
+    const report = {
+      timestamp: new Date().toISOString(),
+      registeredResources: this.cleanupManager.getResourceCount(),
+      resourceNames: this.cleanupManager.getResourceNames(),
+      possibleLeaks: [],
+      memoryTrend: this._analyzeMemoryTrend(),
+    };
+
+    // Track memory growth
+    const currentMemory = process.memoryUsage().heapUsed;
+    this.metrics.memoryUsage.push(currentMemory);
+
+    // Detect memory leaks (increasing trend over time)
+    if (this.metrics.memoryUsage.length >= 5) {
+      const recentValues = this.metrics.memoryUsage.slice(-5);
+      const isIncreasing = recentValues.every(
+        (val, i) => i === 0 || val >= recentValues[i - 1],
+      );
+
+      if (isIncreasing) {
+        report.possibleLeaks.push({
+          type: 'memory_leak',
+          severity: 'warning',
+          message: 'Memory usage is continuously increasing',
+          recentValues: recentValues.map(
+            (v) => (v / 1024 / 1024).toFixed(2) + 'MB',
+          ),
+          recommendation: 'Check for resource leaks in cleanup functions',
+        });
+      }
+    }
+
+    // Check for unreleased resources
+    if (this.cleanupManager.getResourceCount() > 10) {
+      report.possibleLeaks.push({
+        type: 'resource_accumulation',
+        severity: 'info',
+        message: `${this.cleanupManager.getResourceCount()} resources are registered`,
+        recommendation:
+          'Consider limiting resource registrations or clearing old resources',
+      });
+    }
+
+    return report;
+  }
+
+  /**
+   * Generate optimization plan
+   */
+  generateOptimizationPlan() {
+    const currentState = {
+      avgSignalResponseTime: this._calculateAverage(
+        this.metrics.signalResponseTimes,
+      ),
+      avgCleanupTime: this._calculateAverage(this.metrics.cleanupTimes),
+      totalErrors: this.errorMonitor.getStatistics().totalErrors,
+      resourceCount: this.cleanupManager.getResourceCount(),
+    };
+
+    const plan = {
+      timestamp: new Date().toISOString(),
+      currentState,
+      optimizationSteps: [],
+    };
+
+    // Recommend signal optimization if response is slow
+    if (currentState.avgSignalResponseTime > this.thresholds.signalResponse) {
+      plan.optimizationSteps.push({
+        priority: 'high',
+        area: 'signal_handling',
+        issue: `Average signal response time: ${currentState.avgSignalResponseTime.toFixed(0)}ms`,
+        recommendations: [
+          'Reduce number of operations in signal handlers',
+          'Defer non-critical cleanup to after signal handling',
+          'Use async operations more efficiently',
+        ],
+      });
+    }
+
+    // Recommend cleanup optimization if too slow
+    if (currentState.avgCleanupTime > this.thresholds.totalCleanup) {
+      plan.optimizationSteps.push({
+        priority: 'high',
+        area: 'cleanup_performance',
+        issue: `Average cleanup time: ${currentState.avgCleanupTime.toFixed(0)}ms`,
+        recommendations: [
+          'Profile individual resource cleanup times',
+          'Consider parallel cleanup for independent resources',
+          'Optimize database disconnect procedures',
+        ],
+      });
+    }
+
+    // Recommend error handling optimization if rate is high
+    const stats = this.errorMonitor.getStatistics();
+    if (currentState.totalErrors > 5) {
+      plan.optimizationSteps.push({
+        priority: 'medium',
+        area: 'error_handling',
+        issue: `Total errors recorded: ${currentState.totalErrors}`,
+        recommendations: [
+          'Implement retry logic for transient errors',
+          'Improve error context tracking',
+          'Create error-specific recovery procedures',
+        ],
+      });
+    }
+
+    // Recommend memory optimization
+    const memUsage = process.memoryUsage();
+    if (memUsage.heapUsed > 100 * 1024 * 1024) {
+      plan.optimizationSteps.push({
+        priority: 'medium',
+        area: 'memory_management',
+        issue: `Heap memory: ${(memUsage.heapUsed / 1024 / 1024).toFixed(2)}MB`,
+        recommendations: [
+          'Clear error records periodically',
+          'Implement session data pruning',
+          'Monitor error array growth',
+        ],
+      });
+    }
+
+    return plan;
+  }
+
+  /**
+   * Benchmark cleanup operations
+   */
+  async benchmarkCleanup(iterations = 3) {
+    const results = [];
+
+    for (let i = 0; i < iterations; i++) {
+      // Reset for clean benchmark
+      this.cleanupManager.reset();
+      this.errorMonitor.reset();
+
+      // Register test resources
+      this.cleanupManager.registerResource('TestResource1', {}, async () => {
+        return new Promise((resolve) => setTimeout(resolve, 100));
+      });
+
+      this.cleanupManager.registerResource('TestResource2', {}, async () => {
+        return new Promise((resolve) => setTimeout(resolve, 100));
+      });
+
+      // Measure cleanup
+      const start = Date.now();
+      const result = await this.cleanupManager.performCleanup('benchmark');
+      const duration = Date.now() - start;
+
+      results.push({
+        iteration: i + 1,
+        duration,
+        success: result.success,
+        resourceCount: result.results.length,
+      });
+    }
+
+    return {
+      timestamp: new Date().toISOString(),
+      iterations,
+      results,
+      avgDuration:
+        results.reduce((sum, r) => sum + r.duration, 0) / results.length,
+      minDuration: Math.min(...results.map((r) => r.duration)),
+      maxDuration: Math.max(...results.map((r) => r.duration)),
+    };
+  }
+
+  /**
+   * Health check
+   */
+  getHealthStatus() {
+    const stats = this.errorMonitor.getStatistics();
+    const memUsage = process.memoryUsage();
+    const avgCleanup = this._calculateAverage(this.metrics.cleanupTimes);
+
+    const health = {
+      timestamp: new Date().toISOString(),
+      overall: 'healthy',
+      components: {
+        signalHandling: {
+          status: 'healthy',
+          avgResponseTime:
+            this._calculateAverage(this.metrics.signalResponseTimes).toFixed(
+              2,
+            ) + 'ms',
+          threshold: this.thresholds.signalResponse + 'ms',
+        },
+        cleanup: {
+          status:
+            avgCleanup > this.thresholds.totalCleanup ? 'degraded' : 'healthy',
+          avgDuration: avgCleanup.toFixed(0) + 'ms',
+          threshold: this.thresholds.totalCleanup + 'ms',
+        },
+        errorHandling: {
+          status: stats.totalErrors > 10 ? 'degraded' : 'healthy',
+          totalErrors: stats.totalErrors,
+          recoveryRate: stats.successRate + '%',
+        },
+        memory: {
+          status: memUsage.heapUsed > 100 * 1024 * 1024 ? 'warning' : 'healthy',
+          heapUsed: (memUsage.heapUsed / 1024 / 1024).toFixed(2) + 'MB',
+          heapTotal: (memUsage.heapTotal / 1024 / 1024).toFixed(2) + 'MB',
+        },
+      },
+    };
+
+    // Determine overall health
+    const degradedCount = Object.values(health.components).filter(
+      (c) => c.status === 'degraded' || c.status === 'warning',
+    ).length;
+
+    if (degradedCount > 1) {
+      health.overall = 'warning';
+    } else if (degradedCount > 2) {
+      health.overall = 'critical';
+    }
+
+    return health;
+  }
+
+  /**
+   * Private helper methods
+   */
+
+  _generateSummary() {
+    return {
+      signalCount: this.metrics.signalResponseTimes.length,
+      cleanupCount: this.metrics.cleanupTimes.length,
+      totalErrors: this.errorMonitor.getStatistics().totalErrors,
+      avgMemoryUsage:
+        (
+          this._calculateAverage(this.metrics.memoryUsage) /
+          1024 /
+          1024
+        ).toFixed(2) + 'MB',
+    };
+  }
+
+  _analyzeSignalMetrics() {
+    const times = this.metrics.signalResponseTimes;
+    return {
+      sampleCount: times.length,
+      avgTime: this._calculateAverage(times).toFixed(2) + 'ms',
+      minTime: Math.min(...times, Infinity).toFixed(2) + 'ms',
+      maxTime: Math.max(...times, -Infinity).toFixed(2) + 'ms',
+      p95Time: this._calculatePercentile(times, 0.95).toFixed(2) + 'ms',
+    };
+  }
+
+  _analyzeCleanupMetrics() {
+    const times = this.metrics.cleanupTimes;
+    return {
+      sampleCount: times.length,
+      avgTime: this._calculateAverage(times).toFixed(0) + 'ms',
+      minTime: Math.min(...times, Infinity).toFixed(0) + 'ms',
+      maxTime: Math.max(...times, -Infinity).toFixed(0) + 'ms',
+      p95Time: this._calculatePercentile(times, 0.95).toFixed(0) + 'ms',
+      threshold: this.thresholds.totalCleanup + 'ms',
+    };
+  }
+
+  _analyzeMemoryMetrics() {
+    const usage = this.metrics.memoryUsage;
+    const current = process.memoryUsage();
+
+    return {
+      currentHeapUsed: (current.heapUsed / 1024 / 1024).toFixed(2) + 'MB',
+      currentHeapTotal: (current.heapTotal / 1024 / 1024).toFixed(2) + 'MB',
+      avgMemoryUsage: this._calculateAverage(usage).toFixed(0) + ' bytes',
+      trend: this._analyzeMemoryTrend(),
+    };
+  }
+
+  _analyzeMemoryTrend() {
+    if (this.metrics.memoryUsage.length < 2) {
+      return 'insufficient_data';
+    }
+
+    const recent = this.metrics.memoryUsage.slice(-5);
+    const avg = recent.reduce((a, b) => a + b, 0) / recent.length;
+    const older = this.metrics.memoryUsage.slice(-10, -5);
+    const avgOlder =
+      older.length > 0 ? older.reduce((a, b) => a + b, 0) / older.length : avg;
+
+    if (avg > avgOlder * 1.1) {
+      return 'increasing';
+    } else if (avg < avgOlder * 0.9) {
+      return 'decreasing';
+    }
+    return 'stable';
+  }
+
+  _getRecommendations() {
+    const recommendations = [];
+    const stats = this.errorMonitor.getStatistics();
+    const avgCleanup = this._calculateAverage(this.metrics.cleanupTimes);
+
+    if (avgCleanup > this.thresholds.totalCleanup) {
+      recommendations.push(
+        `Cleanup performance needs improvement. ` +
+          `Average: ${avgCleanup.toFixed(0)}ms, ` +
+          `Target: ${this.thresholds.totalCleanup}ms`,
+      );
+    }
+
+    if (stats.totalErrors > 0) {
+      recommendations.push(
+        `Review ${stats.totalErrors} recorded errors. ` +
+          `Recovery rate: ${stats.successRate}%`,
+      );
+    }
+
+    if (this.metrics.memoryUsage.length > 3) {
+      const trend = this._analyzeMemoryTrend();
+      if (trend === 'increasing') {
+        recommendations.push('Memory usage is increasing. Check for leaks.');
+      }
+    }
+
+    return recommendations;
+  }
+
+  _calculateAverage(values) {
+    if (values.length === 0) return 0;
+    return values.reduce((a, b) => a + b, 0) / values.length;
+  }
+
+  _calculatePercentile(values, percentile) {
+    if (values.length === 0) return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.ceil(sorted.length * percentile) - 1;
+    return sorted[Math.max(0, index)];
+  }
+}
+
+export default PerformanceOptimizer;