@reliverse/dler 2.0.0 → 2.0.1

package/src/cmds/perf/benchmarks/memory.ts

@@ -0,0 +1,249 @@
+// apps/dler/src/cmds/perf/benchmarks/memory.ts
+
+import type { MemoryUsage } from "../types";
+
+export interface MemoryProfile {
+  timestamp: number;
+  memory: MemoryUsage;
+  label?: string;
+}
+
+export interface MemorySnapshot {
+  before: MemoryUsage;
+  after: MemoryUsage;
+  peak: MemoryUsage;
+  growth: number;
+  duration: number;
+}
+
+export class MemoryProfiler {
+  private snapshots: MemoryProfile[] = [];
+  private startMemory: MemoryUsage | null = null;
+  private peakMemory: MemoryUsage | null = null;
+
+  start(label?: string): void {
+    this.startMemory = process.memoryUsage();
+    this.peakMemory = { ...this.startMemory };
+    this.snapshots.push({
+      timestamp: Date.now(),
+      memory: this.startMemory,
+      label: label ?? "start",
+    });
+  }
+
+  snapshot(label?: string): void {
+    const current = process.memoryUsage();
+    this.snapshots.push({
+      timestamp: Date.now(),
+      memory: current,
+      label: label ?? `snapshot-${this.snapshots.length}`,
+    });
+
+    // Update peak memory
+    if (!this.peakMemory) {
+      this.peakMemory = { ...current };
+    } else {
+      this.peakMemory = {
+        rss: Math.max(this.peakMemory.rss, current.rss),
+        heapTotal: Math.max(this.peakMemory.heapTotal, current.heapTotal),
+        heapUsed: Math.max(this.peakMemory.heapUsed, current.heapUsed),
+        external: Math.max(this.peakMemory.external, current.external),
+        arrayBuffers: Math.max(
+          this.peakMemory.arrayBuffers,
+          current.arrayBuffers,
+        ),
+      };
+    }
+  }
+
+  stop(): MemorySnapshot | null {
+    if (!this.startMemory) {
+      return null;
+    }
+
+    const endMemory = process.memoryUsage();
+    const duration =
+      this.snapshots.length > 0
+        ? this.snapshots[this.snapshots.length - 1]!.timestamp -
+          this.snapshots[0]!.timestamp
+        : 0;
+
+    const snapshot: MemorySnapshot = {
+      before: this.startMemory,
+      after: endMemory,
+      peak: this.peakMemory ?? endMemory,
+      growth: endMemory.rss - this.startMemory.rss,
+      duration,
+    };
+
+    // Reset state
+    this.startMemory = null;
+    this.peakMemory = null;
+    this.snapshots = [];
+
+    return snapshot;
+  }
+
+  getSnapshots(): MemoryProfile[] {
+    return [...this.snapshots];
+  }
+
+  getMemoryGrowth(): number {
+    if (this.snapshots.length < 2) return 0;
+
+    const first = this.snapshots[0]!.memory;
+    const last = this.snapshots[this.snapshots.length - 1]!.memory;
+
+    return last.rss - first.rss;
+  }
+
+  getPeakMemory(): MemoryUsage | null {
+    return this.peakMemory;
+  }
+
+  getAverageMemory(): MemoryUsage | null {
+    if (this.snapshots.length === 0) return null;
+
+    const sum = this.snapshots.reduce(
+      (acc, snapshot) => ({
+        rss: acc.rss + snapshot.memory.rss,
+        heapTotal: acc.heapTotal + snapshot.memory.heapTotal,
+        heapUsed: acc.heapUsed + snapshot.memory.heapUsed,
+        external: acc.external + snapshot.memory.external,
+        arrayBuffers: acc.arrayBuffers + snapshot.memory.arrayBuffers,
+      }),
+      { rss: 0, heapTotal: 0, heapUsed: 0, external: 0, arrayBuffers: 0 },
+    );
+
+    const count = this.snapshots.length;
+    return {
+      rss: sum.rss / count,
+      heapTotal: sum.heapTotal / count,
+      heapUsed: sum.heapUsed / count,
+      external: sum.external / count,
+      arrayBuffers: sum.arrayBuffers / count,
+    };
+  }
+}
+
+export const createMemoryProfiler = (): MemoryProfiler => {
+  return new MemoryProfiler();
+};
+
+export const measureMemoryUsage = (
+  fn: () => void | Promise<void>,
+): Promise<MemorySnapshot> => {
+  return new Promise((resolve) => {
+    const profiler = createMemoryProfiler();
+    profiler.start("measurement");
+
+    const executeFn = async () => {
+      try {
+        await fn();
+      } finally {
+        const snapshot = profiler.stop();
+        resolve(snapshot!);
+      }
+    };
+
+    executeFn();
+  });
+};
+
+export const getCurrentMemoryUsage = (): MemoryUsage => {
+  return process.memoryUsage();
+};
+
+export const getMemoryInfo = (): {
+  total: number;
+  free: number;
+  used: number;
+  percentage: number;
+} => {
+  const usage = process.memoryUsage();
+
+  // Note: This is a simplified calculation
+  // In reality, getting accurate system memory info is more complex
+  const total = usage.rss * 4; // Rough estimate
+  const used = usage.rss;
+  const free = total - used;
+  const percentage = (used / total) * 100;
+
+  return {
+    total,
+    free,
+    used,
+    percentage: Math.min(percentage, 100),
+  };
+};
+
+export const formatMemoryUsage = (usage: MemoryUsage): string => {
+  const format = (bytes: number) => {
+    if (bytes === 0) return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+  };
+
+  return `RSS: ${format(usage.rss)}, Heap: ${format(usage.heapUsed)}/${format(usage.heapTotal)}, External: ${format(usage.external)}`;
+};
+
+export const detectMemoryLeaks = (
+  snapshots: MemoryProfile[],
+): {
+  hasLeak: boolean;
+  severity: "low" | "medium" | "high";
+  growthRate: number;
+  suggestion: string;
+} => {
+  if (snapshots.length < 3) {
+    return {
+      hasLeak: false,
+      severity: "low",
+      growthRate: 0,
+      suggestion: "Need more snapshots to detect leaks",
+    };
+  }
+
+  const rssValues = snapshots.map((s) => s.memory.rss);
+  const growthRate =
+    (rssValues[rssValues.length - 1]! - rssValues[0]!) / snapshots.length;
+
+  // Simple heuristic: if memory grows consistently, it might be a leak
+  const isConsistentGrowth = rssValues.every(
+    (val, i) => i === 0 || val >= rssValues[i - 1]! * 0.95,
+  );
+
+  const hasLeak = isConsistentGrowth && growthRate > 1024 * 1024; // 1MB per snapshot
+
+  let severity: "low" | "medium" | "high" = "low";
+  let suggestion = "";
+
+  if (hasLeak) {
+    if (growthRate > 10 * 1024 * 1024) {
+      // 10MB per snapshot
+      severity = "high";
+      suggestion =
+        "Critical memory leak detected. Check for unclosed resources, event listeners, or circular references.";
+    } else if (growthRate > 5 * 1024 * 1024) {
+      // 5MB per snapshot
+      severity = "medium";
+      suggestion =
+        "Moderate memory leak detected. Monitor memory usage and consider garbage collection.";
+    } else {
+      severity = "low";
+      suggestion =
+        "Minor memory growth detected. Monitor for patterns over time.";
+    }
+  } else {
+    suggestion = "No significant memory leaks detected.";
+  }
+
+  return {
+    hasLeak,
+    severity,
+    growthRate,
+    suggestion,
+  };
+};

package/src/cmds/perf/benchmarks/runner.ts

@@ -0,0 +1,220 @@
+// apps/dler/src/cmds/perf/benchmarks/runner.ts
+
+import { logger } from "@reliverse/dler-logger";
+import pMap from "@reliverse/dler-mapper";
+import type { BenchmarkResult, Measurement, MemoryStats } from "../types";
+import { formatProgress } from "../utils/formatter";
+
+import {
+  calculateMemoryAverage,
+  calculateStatistics,
+  findPeakMemory,
+} from "../utils/stats";
+import { executeCommandWithMemoryTracking } from "./command";
+
+export interface BenchmarkRunnerOptions {
+  command: string;
+  runs: number;
+  warmup: number;
+  concurrency: number;
+  cwd?: string;
+  timeout?: number;
+  env?: Record<string, string>;
+  verbose?: boolean;
+}
+
+export class BenchmarkRunner {
+  private options: BenchmarkRunnerOptions;
+
+  constructor(options: BenchmarkRunnerOptions) {
+    this.options = options;
+  }
+
+  async run(): Promise<BenchmarkResult> {
+    const { command, runs, warmup, concurrency, verbose } = this.options;
+    const startTime = Date.now();
+
+    if (verbose) {
+      logger.info(`🚀 Starting benchmark for: ${command}`);
+      logger.info(
+        `   Runs: ${runs}, Warmup: ${warmup}, Concurrency: ${concurrency}`,
+      );
+    }
+
+    // Run warmup iterations
+    if (warmup > 0) {
+      if (verbose) {
+        logger.info(`🔥 Running ${warmup} warmup iterations...`);
+      }
+
+      await this.runWarmup();
+    }
+
+    // Run actual benchmark iterations
+    if (verbose) {
+      logger.info(`📊 Running ${runs} benchmark iterations...`);
+    }
+
+    const measurements = await this.runBenchmark();
+    const statistics = this.calculateStatistics(measurements);
+    const memory = this.calculateMemoryStats(measurements);
+    const executionTime = Date.now() - startTime;
+
+    // Check for failures
+    const failures = measurements.filter((m) => !m.success);
+    const success = failures.length === 0;
+
+    if (verbose && failures.length > 0) {
+      logger.warn(`⚠️  ${failures.length} out of ${runs} runs failed`);
+    }
+
+    return {
+      command,
+      runs,
+      warmup,
+      concurrency,
+      measurements,
+      statistics,
+      memory,
+      executionTime,
+      success,
+      error: failures.length > 0 ? `${failures.length} runs failed` : undefined,
+    };
+  }
+
+  private async runWarmup(): Promise<void> {
+    const { command, warmup, cwd, timeout, env } = this.options;
+
+    // Run warmup iterations sequentially to avoid interference
+    for (let i = 0; i < warmup; i++) {
+      try {
+        await executeCommandWithMemoryTracking(command, {
+          cwd,
+          timeout,
+          env,
+        });
+      } catch {
+        // Ignore warmup failures
+      }
+    }
+  }
+
+  private async runBenchmark(): Promise<Measurement[]> {
+    const { command, runs, concurrency, cwd, timeout, env, verbose } =
+      this.options;
+
+    const runIndices = Array.from({ length: runs }, (_, i) => i);
+
+    const measurements = await pMap(
+      runIndices,
+      async (runIndex) => {
+        if (verbose) {
+          logger.info(formatProgress(runIndex + 1, runs));
+        }
+
+        const measurement = await executeCommandWithMemoryTracking(command, {
+          cwd,
+          timeout,
+          env,
+        });
+
+        measurement.run = runIndex + 1;
+        return measurement;
+      },
+      {
+        concurrency,
+        stopOnError: false,
+      },
+    );
+
+    return measurements;
+  }
+
+  private calculateStatistics(
+    measurements: Measurement[],
+  ): ReturnType<typeof calculateStatistics> {
+    const durations = measurements
+      .filter((m) => m.success)
+      .map((m) => m.duration);
+
+    if (durations.length === 0) {
+      return calculateStatistics([]);
+    }
+
+    return calculateStatistics(durations);
+  }
+
+  private calculateMemoryStats(measurements: Measurement[]): MemoryStats {
+    const successfulMeasurements = measurements.filter((m) => m.success);
+
+    if (successfulMeasurements.length === 0) {
+      return {
+        peak: {
+          rss: 0,
+          heapTotal: 0,
+          heapUsed: 0,
+          external: 0,
+          arrayBuffers: 0,
+        },
+        average: {
+          rss: 0,
+          heapTotal: 0,
+          heapUsed: 0,
+          external: 0,
+          arrayBuffers: 0,
+        },
+        growth: 0,
+      };
+    }
+
+    const rssValues = successfulMeasurements.map((m) => m.memory.rss);
+    const heapTotalValues = successfulMeasurements.map(
+      (m) => m.memory.heapTotal,
+    );
+    const heapUsedValues = successfulMeasurements.map((m) => m.memory.heapUsed);
+    const externalValues = successfulMeasurements.map((m) => m.memory.external);
+    const arrayBuffersValues = successfulMeasurements.map(
+      (m) => m.memory.arrayBuffers,
+    );
+
+    const peak: MemoryStats["peak"] = {
+      rss: findPeakMemory(rssValues),
+      heapTotal: findPeakMemory(heapTotalValues),
+      heapUsed: findPeakMemory(heapUsedValues),
+      external: findPeakMemory(externalValues),
+      arrayBuffers: findPeakMemory(arrayBuffersValues),
+    };
+
+    const average: MemoryStats["average"] = {
+      rss: calculateMemoryAverage(rssValues),
+      heapTotal: calculateMemoryAverage(heapTotalValues),
+      heapUsed: calculateMemoryAverage(heapUsedValues),
+      external: calculateMemoryAverage(externalValues),
+      arrayBuffers: calculateMemoryAverage(arrayBuffersValues),
+    };
+
+    const growth =
+      rssValues.length > 1
+        ? rssValues[rssValues.length - 1]! - rssValues[0]!
+        : 0;
+
+    return {
+      peak,
+      average,
+      growth,
+    };
+  }
+}
+
+export const runBenchmark = async (
+  options: BenchmarkRunnerOptions,
+): Promise<BenchmarkResult> => {
+  const runner = new BenchmarkRunner(options);
+  return runner.run();
+};
+
+export const createBenchmarkRunner = (
+  options: BenchmarkRunnerOptions,
+): BenchmarkRunner => {
+  return new BenchmarkRunner(options);
+};