@arela/uploader 0.2.12 → 0.3.0

package/src/services/BenchmarkingService.js

@@ -0,0 +1,381 @@
+/**
+ * BenchmarkingService.js
+ * Phase 7 - Task 3: Performance Benchmarking
+ *
+ * Provides comprehensive performance benchmarking including:
+ * - Execution benchmarking
+ * - Memory profiling
+ * - Resource utilization tracking
+ * - Benchmark comparison
+ * - Performance regression detection
+ */
+
+class BenchmarkingService {
+  constructor(logger) {
+    this.logger = logger;
+    this.benchmarks = [];
+    this.profiles = [];
+
+    this.config = {
+      enableMemoryProfiling: true,
+      enableCpuProfiling: true,
+      sampleInterval: 100, // milliseconds
+      retainLimit: 100, // keep last N benchmarks
+    };
+  }
+
+  /**
+   * Start a benchmark session
+   */
+  startBenchmark(name, metadata = {}) {
+    const benchmark = {
+      id: `bench_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      name,
+      startTime: Date.now(),
+      startMemory: process.memoryUsage(),
+      metadata,
+      marks: [],
+      measurements: [],
+      complete: false,
+    };
+
+    return benchmark;
+  }
+
+  /**
+   * Mark a point in benchmark
+   */
+  mark(benchmark, markName) {
+    const mark = {
+      name: markName,
+      timestamp: Date.now(),
+      memory: process.memoryUsage(),
+    };
+
+    benchmark.marks.push(mark);
+    return mark;
+  }
+
+  /**
+   * Complete benchmark and calculate metrics
+   */
+  completeBenchmark(benchmark) {
+    const endTime = Date.now();
+    const endMemory = process.memoryUsage();
+
+    benchmark.endTime = endTime;
+    benchmark.endMemory = endMemory;
+    benchmark.complete = true;
+
+    // Calculate overall duration
+    benchmark.duration = endTime - benchmark.startTime;
+
+    // Calculate memory changes
+    benchmark.memoryDelta = {
+      heapUsed: endMemory.heapUsed - benchmark.startMemory.heapUsed,
+      heapTotal: endMemory.heapTotal - benchmark.startMemory.heapTotal,
+      external: endMemory.external - benchmark.startMemory.external,
+      rss: endMemory.rss - benchmark.startMemory.rss,
+    };
+
+    // Calculate mark durations
+    benchmark.measurements = [];
+    for (let i = 0; i < benchmark.marks.length; i++) {
+      const current = benchmark.marks[i];
+      const previous =
+        i > 0 ? benchmark.marks[i - 1] : { timestamp: benchmark.startTime };
+
+      const measurement = {
+        markName: current.name,
+        duration: current.timestamp - previous.timestamp,
+        memoryUsed: current.memory.heapUsed,
+        memoryDelta: current.memory.heapUsed - previous.memory.heapUsed,
+      };
+
+      benchmark.measurements.push(measurement);
+    }
+
+    // Store benchmark
+    this.benchmarks.push(benchmark);
+
+    // Maintain retention limit
+    if (this.benchmarks.length > this.config.retainLimit) {
+      this.benchmarks = this.benchmarks.slice(-this.config.retainLimit);
+    }
+
+    this.logger.debug(
+      `Benchmark completed: ${benchmark.name} (${benchmark.duration}ms, ` +
+        `Memory: ${(benchmark.memoryDelta.heapUsed / 1024 / 1024).toFixed(2)}MB)`,
+    );
+
+    return benchmark;
+  }
+
+  /**
+   * Profile memory usage over time
+   */
+  async profileMemory(testFunction, duration = 5000) {
+    const profile = {
+      id: `profile_${Date.now()}`,
+      timestamp: new Date().toISOString(),
+      duration,
+      samples: [],
+      summary: {},
+    };
+
+    const startTime = Date.now();
+    const sampleInterval = this.config.sampleInterval;
+
+    // Start test function
+    const testPromise = testFunction();
+
+    // Collect samples
+    const samplingPromise = new Promise((resolve) => {
+      const sampler = setInterval(() => {
+        const memory = process.memoryUsage();
+        profile.samples.push({
+          timestamp: Date.now() - startTime,
+          heapUsed: memory.heapUsed,
+          heapTotal: memory.heapTotal,
+          rss: memory.rss,
+        });
+
+        if (Date.now() - startTime >= duration) {
+          clearInterval(sampler);
+          resolve();
+        }
+      }, sampleInterval);
+    });
+
+    // Wait for both to complete
+    await Promise.all([testPromise, samplingPromise]);
+
+    // Calculate summary statistics
+    if (profile.samples.length > 0) {
+      const heapSamples = profile.samples.map((s) => s.heapUsed);
+      const rssSamples = profile.samples.map((s) => s.rss);
+
+      profile.summary = {
+        peakHeapUsed: Math.max(...heapSamples),
+        minHeapUsed: Math.min(...heapSamples),
+        averageHeapUsed:
+          heapSamples.reduce((a, b) => a + b, 0) / heapSamples.length,
+        heapGrowth: heapSamples[heapSamples.length - 1] - heapSamples[0],
+        peakRss: Math.max(...rssSamples),
+        sampleCount: profile.samples.length,
+      };
+    }
+
+    this.profiles.push(profile);
+    return profile;
+  }
+
+  /**
+   * Compare two benchmarks
+   */
+  compareBenchmarks(benchmark1, benchmark2) {
+    const comparison = {
+      benchmark1: benchmark1.name,
+      benchmark2: benchmark2.name,
+      timestamp: new Date().toISOString(),
+      durationComparison: {
+        benchmark1Duration: benchmark1.duration,
+        benchmark2Duration: benchmark2.duration,
+        difference: benchmark2.duration - benchmark1.duration,
+        percentChange:
+          (
+            ((benchmark2.duration - benchmark1.duration) /
+              benchmark1.duration) *
+            100
+          ).toFixed(2) + '%',
+        faster:
+          benchmark1.duration < benchmark2.duration
+            ? benchmark1.name
+            : benchmark2.name,
+      },
+      memoryComparison: {
+        benchmark1: benchmark1.memoryDelta,
+        benchmark2: benchmark2.memoryDelta,
+        difference: {
+          heapUsed:
+            benchmark2.memoryDelta.heapUsed - benchmark1.memoryDelta.heapUsed,
+          rss: benchmark2.memoryDelta.rss - benchmark1.memoryDelta.rss,
+        },
+      },
+    };
+
+    return comparison;
+  }
+
+  /**
+   * Detect performance regression
+   */
+  detectRegression(baselineIndex, currentIndex, threshold = 0.1) {
+    if (
+      currentIndex >= this.benchmarks.length ||
+      baselineIndex >= this.benchmarks.length
+    ) {
+      return null;
+    }
+
+    const baseline = this.benchmarks[baselineIndex];
+    const current = this.benchmarks[currentIndex];
+
+    const durationIncrease =
+      (current.duration - baseline.duration) / baseline.duration;
+    const memoryIncrease =
+      (current.memoryDelta.heapUsed - baseline.memoryDelta.heapUsed) /
+      Math.abs(baseline.memoryDelta.heapUsed || 1);
+
+    const regression = {
+      detected: false,
+      baseline: baseline.name,
+      current: current.name,
+      metrics: {
+        duration: {
+          baseline: baseline.duration,
+          current: current.duration,
+          increase: durationIncrease,
+          thresholdExceeded: durationIncrease > threshold,
+        },
+        memory: {
+          baseline: baseline.memoryDelta.heapUsed,
+          current: current.memoryDelta.heapUsed,
+          increase: memoryIncrease,
+          thresholdExceeded: Math.abs(memoryIncrease) > threshold,
+        },
+      },
+    };
+
+    regression.detected =
+      regression.metrics.duration.thresholdExceeded ||
+      regression.metrics.memory.thresholdExceeded;
+
+    return regression;
+  }
+
+  /**
+   * Get benchmark statistics
+   */
+  getBenchmarkStatistics() {
+    if (this.benchmarks.length === 0) {
+      return { error: 'No benchmarks available' };
+    }
+
+    const durations = this.benchmarks.map((b) => b.duration);
+    const memoryDeltas = this.benchmarks.map((b) => b.memoryDelta.heapUsed);
+
+    return {
+      totalBenchmarks: this.benchmarks.length,
+      averageDuration:
+        (durations.reduce((a, b) => a + b, 0) / durations.length).toFixed(0) +
+        'ms',
+      minDuration: Math.min(...durations) + 'ms',
+      maxDuration: Math.max(...durations) + 'ms',
+      medianDuration: this._calculateMedian(durations) + 'ms',
+      averageMemoryDelta:
+        (
+          memoryDeltas.reduce((a, b) => a + b, 0) /
+          memoryDeltas.length /
+          1024 /
+          1024
+        ).toFixed(2) + 'MB',
+      standardDeviation:
+        this._calculateStandardDeviation(durations).toFixed(0) + 'ms',
+    };
+  }
+
+  /**
+   * Get memory profile summary
+   */
+  getMemoryProfileSummary() {
+    if (this.profiles.length === 0) {
+      return { error: 'No memory profiles available' };
+    }
+
+    const recentProfiles = this.profiles.slice(-5);
+    const avgPeakHeap =
+      recentProfiles.reduce(
+        (sum, p) => sum + (p.summary.peakHeapUsed || 0),
+        0,
+      ) / recentProfiles.length;
+    const avgHeapGrowth =
+      recentProfiles.reduce((sum, p) => sum + (p.summary.heapGrowth || 0), 0) /
+      recentProfiles.length;
+
+    return {
+      profileCount: this.profiles.length,
+      recentProfiles: recentProfiles.length,
+      averagePeakHeap: (avgPeakHeap / 1024 / 1024).toFixed(2) + 'MB',
+      averageHeapGrowth: (avgHeapGrowth / 1024 / 1024).toFixed(2) + 'MB',
+      lastProfile: recentProfiles[recentProfiles.length - 1].summary,
+    };
+  }
+
+  /**
+   * Generate benchmark report
+   */
+  generateBenchmarkReport() {
+    const report = {
+      timestamp: new Date().toISOString(),
+      benchmarkCount: this.benchmarks.length,
+      profileCount: this.profiles.length,
+      statistics: this.getBenchmarkStatistics(),
+      memoryProfiles: this.getMemoryProfileSummary(),
+      benchmarks: this.benchmarks.map((b) => ({
+        id: b.id,
+        name: b.name,
+        duration: b.duration + 'ms',
+        memoryDelta: {
+          heapUsed: (b.memoryDelta.heapUsed / 1024 / 1024).toFixed(2) + 'MB',
+          rss: (b.memoryDelta.rss / 1024 / 1024).toFixed(2) + 'MB',
+        },
+        markCount: b.marks.length,
+      })),
+    };
+
+    return report;
+  }
+
+  /**
+   * Clear benchmarks
+   */
+  clearBenchmarks() {
+    const count = this.benchmarks.length;
+    this.benchmarks = [];
+    this.logger.info(`Cleared ${count} benchmarks`);
+    return { cleared: count };
+  }
+
+  /**
+   * Clear profiles
+   */
+  clearProfiles() {
+    const count = this.profiles.length;
+    this.profiles = [];
+    this.logger.info(`Cleared ${count} memory profiles`);
+    return { cleared: count };
+  }
+
+  /**
+   * Private helper methods
+   */
+
+  _calculateMedian(values) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2
+      ? sorted[mid]
+      : (sorted[mid - 1] + sorted[mid]) / 2;
+  }
+
+  _calculateStandardDeviation(values) {
+    const mean = values.reduce((a, b) => a + b, 0) / values.length;
+    const variance =
+      values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) /
+      values.length;
+    return Math.sqrt(variance);
+  }
+}
+
+export default BenchmarkingService;