@rudderstack/integrations-lib/build/utils/benchmark.js

A comprehensive TypeScript library providing shared utilities, SDKs, and tools for RudderStack integrations and destinations.

"use strict";
/**
 * Benchmark utilities for performance testing
 *
 * Provides easy-to-use tools for measuring function performance,
 * memory usage, and creating performance comparisons.
 *
 * @example
 * ```typescript
 * import { benchmark, createBenchmarkSuite } from './benchmark';
 *
 * // Simple benchmark
 * const result = await benchmark('myFunction', () => myFunction(data));
 * console.log(`Duration: ${result.duration}ms`);
 *
 * // Benchmark suite
 * const suite = createBenchmarkSuite('Array Operations');
 * suite.add('native map', () => data.map(x => x * 2));
 * suite.add('custom map', () => customMap(data, x => x * 2));
 * await suite.run();
 * ```
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.BenchmarkSuite = void 0;
exports.benchmark = benchmark;
exports.compareBenchmarks = compareBenchmarks;
exports.createBenchmarkSuite = createBenchmarkSuite;
exports.measureMemory = measureMemory;
/**
 * Force garbage collection if available
 */
function forceGarbageCollection() {
    if (typeof global !== 'undefined' && global.gc) {
        global.gc();
    }
}
/**
 * Calculate standard deviation of an array of numbers
 */
function calculateStdDev(values) {
    const mean = values.reduce((sum, val) => sum + val, 0) / values.length;
    const squaredDiffs = values.map((val) => (val - mean) ** 2);
    const avgSquaredDiff = squaredDiffs.reduce((sum, val) => sum + val, 0) / values.length;
    return Math.sqrt(avgSquaredDiff);
}
/**
 * Run a benchmark for a single function
 *
 * @param name - Name of the benchmark
 * @param fn - Function to benchmark
 * @param options - Benchmark configuration options
 * @returns Promise resolving to benchmark results
 *
 * @example
 * ```typescript
 * const result = await benchmark('Array.map', () => {
 *   return largeArray.map(x => x * 2);
 * }, { iterations: 10, warmupRuns: 3 });
 *
 * console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms avg`);
 * ```
 */
// eslint-disable-next-line require-await
async function benchmark(name, fn, options = {}) {
    const { iterations = 1, warmupRuns = 1, forceGC = false, measureMemory: shouldMeasureMemory = true, timeout = 30000, } = options;
    // Timeout protection
    let timeoutId;
    const timeoutPromise = new Promise((_, reject) => {
        timeoutId = setTimeout(() => reject(new Error(`Benchmark "${name}" timed out after ${timeout}ms`)), timeout);
    });
    const benchmarkPromise = async () => {
        // Warmup runs
        await Promise.all(Array.from({ length: warmupRuns }, async () => {
            await fn();
        }));
        if (forceGC) {
            forceGarbageCollection();
        }
        const durations = [];
        const startMemory = shouldMeasureMemory ? process.memoryUsage().heapUsed : 0;
        const overallStart = performance.now();
        // Actual benchmark runs
        for (let i = 0; i < iterations; i += 1) {
            if (forceGC && i > 0) {
                forceGarbageCollection();
            }
            const iterationStart = performance.now();
            // eslint-disable-next-line no-await-in-loop
            await fn();
            const iterationEnd = performance.now();
            durations.push(iterationEnd - iterationStart);
        }
        const overallEnd = performance.now();
        const endMemory = shouldMeasureMemory ? process.memoryUsage().heapUsed : 0;
        const totalDuration = overallEnd - overallStart;
        const avgDuration = durations.length > 0 ? durations.reduce((sum, d) => sum + d, 0) / durations.length : 0;
        const minDuration = durations.length > 0 ? Math.min(...durations) : 0;
        const maxDuration = durations.length > 0 ? Math.max(...durations) : 0;
        const stdDev = durations.length > 0 ? calculateStdDev(durations) : 0;
        const opsPerSecond = totalDuration > 0 ? iterations / (totalDuration / 1000) : 0;
        const memoryUsed = endMemory - startMemory;
        return {
            name,
            duration: totalDuration,
            opsPerSecond,
            memoryUsed,
            iterations,
            avgDuration,
            stdDev,
            minDuration,
            maxDuration,
        };
    };
    return Promise.race([benchmarkPromise(), timeoutPromise]).finally(() => {
        clearTimeout(timeoutId);
    });
}
/**
 * Compare multiple functions with the same benchmark configuration
 *
 * @param benchmarks - Object with benchmark names and functions
 * @param options - Benchmark configuration options
 * @returns Promise resolving to array of benchmark results
 *
 * @example
 * ```typescript
 * const results = await compareBenchmarks({
 *   'native map': () => data.map(x => x * 2),
 *   'for loop': () => {
 *     const result = [];
 *     for (let i = 0; i < data.length; i++) {
 *       result.push(data[i] * 2);
 *     }
 *     return result;
 *   }
 * }, { iterations: 5 });
 *
 * results.forEach(result => {
 *   console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms`);
 * });
 * ```
 */
async function compareBenchmarks(benchmarks, options = {}) {
    const results = await Promise.all(Object.entries(benchmarks).map(([name, fn]) => benchmark(name, fn, options)));
    return results.sort((a, b) => a.avgDuration - b.avgDuration);
}
/**
 * Benchmark suite for organizing and running multiple related benchmarks
 */
class BenchmarkSuite {
    constructor(suiteName, options = {}) {
        this.suiteName = suiteName;
        this.benchmarks = [];
        this.options = options;
    }
    /**
     * Add a benchmark to the suite
     *
     * @param name - Name of the benchmark
     * @param fn - Function to benchmark
     * @returns This suite instance for chaining
     */
    add(name, fn) {
        this.benchmarks.push({ name, fn });
        return this;
    }
    /**
     * Run all benchmarks in the suite
     *
     * @param customOptions - Override suite options for this run
     * @returns Promise resolving to array of benchmark results
     */
    async run(customOptions) {
        const options = { ...this.options, ...customOptions };
        const results = [];
        // eslint-disable-next-line no-console
        console.log(`\n🚀 Running benchmark suite: ${this.suiteName}`);
        // eslint-disable-next-line no-console
        console.log('='.repeat(60));
        // eslint-disable-next-line no-restricted-syntax
        for (const { name, fn } of this.benchmarks) {
            // eslint-disable-next-line no-console
            console.log(`\n⏱️  Running: ${name}...`);
            try {
                // eslint-disable-next-line no-await-in-loop
                const result = await benchmark(name, fn, options);
                results.push(result);
                // eslint-disable-next-line no-console
                console.log(`   ✅ ${result.avgDuration.toFixed(2)}ms avg (${result.opsPerSecond.toFixed(0)} ops/sec)`);
                if (options.measureMemory) {
                    // eslint-disable-next-line no-console
                    console.log(`   💾 Memory: ${(result.memoryUsed / 1024 / 1024).toFixed(2)}MB`);
                }
            }
            catch (error) {
                // eslint-disable-next-line no-console
                console.log(`   ❌ Failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
            }
        }
        // Summary
        if (results.length > 1) {
            // eslint-disable-next-line no-console
            console.log(`\n📊 Summary (sorted by performance):`);
            const sortedResults = [...results].sort((a, b) => a.avgDuration - b.avgDuration);
            const fastest = sortedResults[0];
            sortedResults.forEach((result, index) => {
                const relative = result.avgDuration / fastest.avgDuration;
                let icon = '  ';
                if (index === 0)
                    icon = '🥇';
                else if (index === 1)
                    icon = '🥈';
                else if (index === 2)
                    icon = '🥉';
                // eslint-disable-next-line no-console
                console.log(`   ${icon} ${result.name.padEnd(25)} | ${result.avgDuration.toFixed(2)}ms | ${relative.toFixed(2)}x`);
            });
        }
        // eslint-disable-next-line no-console
        console.log(`\n✅ Suite completed: ${results.length}/${this.benchmarks.length} benchmarks successful\n`);
        return results;
    }
    /**
     * Get the number of benchmarks in the suite
     */
    get size() {
        return this.benchmarks.length;
    }
    /**
     * Clear all benchmarks from the suite
     */
    clear() {
        this.benchmarks = [];
        return this;
    }
}
exports.BenchmarkSuite = BenchmarkSuite;
/**
 * Create a new benchmark suite
 *
 * @param suiteName - Name of the benchmark suite
 * @param options - Default options for all benchmarks in the suite
 * @returns New BenchmarkSuite instance
 *
 * @example
 * ```typescript
 * const suite = createBenchmarkSuite('String Operations', {
 *   iterations: 10,
 *   warmupRuns: 2
 * });
 *
 * suite
 *   .add('concat', () => str1 + str2)
 *   .add('template', () => `${str1}${str2}`)
 *   .add('join', () => [str1, str2].join(''));
 *
 * await suite.run();
 * ```
 */
function createBenchmarkSuite(suiteName, options) {
    return new BenchmarkSuite(suiteName, options);
}
/**
 * Utility to measure memory usage of a function
 *
 * @param fn - Function to measure
 * @param forceGC - Whether to force garbage collection before measuring
 * @returns Memory usage in bytes
 *
 * @example
 * ```typescript
 * const memoryUsed = await measureMemory(() => {
 *   return new Array(100000).fill(0).map(x => ({ value: x }));
 * });
 *
 * console.log(`Memory used: ${(memoryUsed / 1024 / 1024).toFixed(2)}MB`);
 * ```
 */
async function measureMemory(fn, forceGC = true) {
    if (forceGC) {
        forceGarbageCollection();
    }
    const startMemory = process.memoryUsage().heapUsed;
    await fn();
    const endMemory = process.memoryUsage().heapUsed;
    return endMemory - startMemory;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"benchmark.js","sourceRoot":"","sources":["../../src/utils/benchmark.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Benchmark utilities for performance testing\n *\n * Provides easy-to-use tools for measuring function performance,\n * memory usage, and creating performance comparisons.\n *\n * @example\n * ```typescript\n * import { benchmark, createBenchmarkSuite } from './benchmark';\n *\n * // Simple benchmark\n * const result = await benchmark('myFunction', () => myFunction(data));\n * console.log(`Duration: ${result.duration}ms`);\n *\n * // Benchmark suite\n * const suite = createBenchmarkSuite('Array Operations');\n * suite.add('native map', () => data.map(x => x * 2));\n * suite.add('custom map', () => customMap(data, x => x * 2));\n * await suite.run();\n * ```\n */\n\n/**\n * Result of a benchmark measurement\n */\nexport type BenchmarkResult = {\n  /** Name of the benchmark */\n  name: string;\n  /** Total duration in milliseconds */\n  duration: number;\n  /** Operations per second */\n  opsPerSecond: number;\n  /** Memory used in bytes (heap difference) */\n  memoryUsed: number;\n  /** Number of iterations run */\n  iterations: number;\n  /** Average duration per iteration in milliseconds */\n  avgDuration: number;\n  /** Standard deviation of durations */\n  stdDev: number;\n  /** Minimum duration observed */\n  minDuration: number;\n  /** Maximum duration observed */\n  maxDuration: number;\n};\n\n/**\n * Configuration options for benchmarks\n */\nexport type BenchmarkOptions = {\n  /** Number of iterations to run (default: 1) */\n  iterations?: number;\n  /** Number of warmup runs before measuring (default: 1) */\n  warmupRuns?: number;\n  /** Whether to force garbage collection between runs (default: false) */\n  forceGC?: boolean;\n  /** Whether to measure memory usage (default: true) */\n  measureMemory?: boolean;\n  /** Timeout in milliseconds for the entire benchmark (default: 30000) */\n  timeout?: number;\n};\n\n/**\n * Benchmark function type\n */\nexport type BenchmarkFunction<T = unknown> = () => T | Promise<T>;\n\n/**\n * Force garbage collection if available\n */\nfunction forceGarbageCollection(): void {\n  if (typeof global !== 'undefined' && global.gc) {\n    global.gc();\n  }\n}\n\n/**\n * Calculate standard deviation of an array of numbers\n */\nfunction calculateStdDev(values: number[]): number {\n  const mean = values.reduce((sum, val) => sum + val, 0) / values.length;\n  const squaredDiffs = values.map((val) => (val - mean) ** 2);\n  const avgSquaredDiff = squaredDiffs.reduce((sum, val) => sum + val, 0) / values.length;\n  return Math.sqrt(avgSquaredDiff);\n}\n\n/**\n * Run a benchmark for a single function\n *\n * @param name - Name of the benchmark\n * @param fn - Function to benchmark\n * @param options - Benchmark configuration options\n * @returns Promise resolving to benchmark results\n *\n * @example\n * ```typescript\n * const result = await benchmark('Array.map', () => {\n *   return largeArray.map(x => x * 2);\n * }, { iterations: 10, warmupRuns: 3 });\n *\n * console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms avg`);\n * ```\n */\n// eslint-disable-next-line require-await\nexport async function benchmark(\n  name: string,\n  fn: BenchmarkFunction,\n  options: BenchmarkOptions = {},\n): Promise<BenchmarkResult> {\n  const {\n    iterations = 1,\n    warmupRuns = 1,\n    forceGC = false,\n    measureMemory: shouldMeasureMemory = true,\n    timeout = 30000,\n  } = options;\n\n  // Timeout protection\n  let timeoutId: NodeJS.Timeout;\n  const timeoutPromise = new Promise<never>((_, reject) => {\n    timeoutId = setTimeout(\n      () => reject(new Error(`Benchmark \"${name}\" timed out after ${timeout}ms`)),\n      timeout,\n    );\n  });\n\n  const benchmarkPromise = async (): Promise<BenchmarkResult> => {\n    // Warmup runs\n    await Promise.all(\n      Array.from({ length: warmupRuns }, async () => {\n        await fn();\n      }),\n    );\n\n    if (forceGC) {\n      forceGarbageCollection();\n    }\n\n    const durations: number[] = [];\n    const startMemory = shouldMeasureMemory ? process.memoryUsage().heapUsed : 0;\n    const overallStart = performance.now();\n\n    // Actual benchmark runs\n    for (let i = 0; i < iterations; i += 1) {\n      if (forceGC && i > 0) {\n        forceGarbageCollection();\n      }\n\n      const iterationStart = performance.now();\n      // eslint-disable-next-line no-await-in-loop\n      await fn();\n      const iterationEnd = performance.now();\n\n      durations.push(iterationEnd - iterationStart);\n    }\n\n    const overallEnd = performance.now();\n    const endMemory = shouldMeasureMemory ? process.memoryUsage().heapUsed : 0;\n\n    const totalDuration = overallEnd - overallStart;\n    const avgDuration =\n      durations.length > 0 ? durations.reduce((sum, d) => sum + d, 0) / durations.length : 0;\n    const minDuration = durations.length > 0 ? Math.min(...durations) : 0;\n    const maxDuration = durations.length > 0 ? Math.max(...durations) : 0;\n    const stdDev = durations.length > 0 ? calculateStdDev(durations) : 0;\n    const opsPerSecond = totalDuration > 0 ? iterations / (totalDuration / 1000) : 0;\n    const memoryUsed = endMemory - startMemory;\n\n    return {\n      name,\n      duration: totalDuration,\n      opsPerSecond,\n      memoryUsed,\n      iterations,\n      avgDuration,\n      stdDev,\n      minDuration,\n      maxDuration,\n    };\n  };\n\n  return Promise.race([benchmarkPromise(), timeoutPromise]).finally(() => {\n    clearTimeout(timeoutId);\n  });\n}\n\n/**\n * Compare multiple functions with the same benchmark configuration\n *\n * @param benchmarks - Object with benchmark names and functions\n * @param options - Benchmark configuration options\n * @returns Promise resolving to array of benchmark results\n *\n * @example\n * ```typescript\n * const results = await compareBenchmarks({\n *   'native map': () => data.map(x => x * 2),\n *   'for loop': () => {\n *     const result = [];\n *     for (let i = 0; i < data.length; i++) {\n *       result.push(data[i] * 2);\n *     }\n *     return result;\n *   }\n * }, { iterations: 5 });\n *\n * results.forEach(result => {\n *   console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms`);\n * });\n * ```\n */\nexport async function compareBenchmarks(\n  benchmarks: Record<string, BenchmarkFunction>,\n  options: BenchmarkOptions = {},\n): Promise<BenchmarkResult[]> {\n  const results = await Promise.all(\n    Object.entries(benchmarks).map(([name, fn]) => benchmark(name, fn, options)),\n  );\n\n  return results.sort((a, b) => a.avgDuration - b.avgDuration);\n}\n\n/**\n * Benchmark suite for organizing and running multiple related benchmarks\n */\nexport class BenchmarkSuite {\n  private benchmarks: Array<{ name: string; fn: BenchmarkFunction }> = [];\n\n  private options: BenchmarkOptions;\n\n  constructor(public readonly suiteName: string, options: BenchmarkOptions = {}) {\n    this.options = options;\n  }\n\n  /**\n   * Add a benchmark to the suite\n   *\n   * @param name - Name of the benchmark\n   * @param fn - Function to benchmark\n   * @returns This suite instance for chaining\n   */\n  add(name: string, fn: BenchmarkFunction): this {\n    this.benchmarks.push({ name, fn });\n    return this;\n  }\n\n  /**\n   * Run all benchmarks in the suite\n   *\n   * @param customOptions - Override suite options for this run\n   * @returns Promise resolving to array of benchmark results\n   */\n  async run(customOptions?: BenchmarkOptions): Promise<BenchmarkResult[]> {\n    const options = { ...this.options, ...customOptions };\n    const results: BenchmarkResult[] = [];\n\n    // eslint-disable-next-line no-console\n    console.log(`\\n🚀 Running benchmark suite: ${this.suiteName}`);\n    // eslint-disable-next-line no-console\n    console.log('='.repeat(60));\n\n    // eslint-disable-next-line no-restricted-syntax\n    for (const { name, fn } of this.benchmarks) {\n      // eslint-disable-next-line no-console\n      console.log(`\\n⏱️  Running: ${name}...`);\n\n      try {\n        // eslint-disable-next-line no-await-in-loop\n        const result = await benchmark(name, fn, options);\n        results.push(result);\n\n        // eslint-disable-next-line no-console\n        console.log(\n          `   ✅ ${result.avgDuration.toFixed(2)}ms avg (${result.opsPerSecond.toFixed(\n            0,\n          )} ops/sec)`,\n        );\n        if (options.measureMemory) {\n          // eslint-disable-next-line no-console\n          console.log(`   💾 Memory: ${(result.memoryUsed / 1024 / 1024).toFixed(2)}MB`);\n        }\n      } catch (error) {\n        // eslint-disable-next-line no-console\n        console.log(`   ❌ Failed: ${error instanceof Error ? error.message : 'Unknown error'}`);\n      }\n    }\n\n    // Summary\n    if (results.length > 1) {\n      // eslint-disable-next-line no-console\n      console.log(`\\n📊 Summary (sorted by performance):`);\n      const sortedResults = [...results].sort((a, b) => a.avgDuration - b.avgDuration);\n      const fastest = sortedResults[0];\n\n      sortedResults.forEach((result, index) => {\n        const relative = result.avgDuration / fastest.avgDuration;\n        let icon = '  ';\n        if (index === 0) icon = '🥇';\n        else if (index === 1) icon = '🥈';\n        else if (index === 2) icon = '🥉';\n\n        // eslint-disable-next-line no-console\n        console.log(\n          `   ${icon} ${result.name.padEnd(25)} | ${result.avgDuration.toFixed(\n            2,\n          )}ms | ${relative.toFixed(2)}x`,\n        );\n      });\n    }\n\n    // eslint-disable-next-line no-console\n    console.log(\n      `\\n✅ Suite completed: ${results.length}/${this.benchmarks.length} benchmarks successful\\n`,\n    );\n\n    return results;\n  }\n\n  /**\n   * Get the number of benchmarks in the suite\n   */\n  get size(): number {\n    return this.benchmarks.length;\n  }\n\n  /**\n   * Clear all benchmarks from the suite\n   */\n  clear(): this {\n    this.benchmarks = [];\n    return this;\n  }\n}\n\n/**\n * Create a new benchmark suite\n *\n * @param suiteName - Name of the benchmark suite\n * @param options - Default options for all benchmarks in the suite\n * @returns New BenchmarkSuite instance\n *\n * @example\n * ```typescript\n * const suite = createBenchmarkSuite('String Operations', {\n *   iterations: 10,\n *   warmupRuns: 2\n * });\n *\n * suite\n *   .add('concat', () => str1 + str2)\n *   .add('template', () => `${str1}${str2}`)\n *   .add('join', () => [str1, str2].join(''));\n *\n * await suite.run();\n * ```\n */\nexport function createBenchmarkSuite(\n  suiteName: string,\n  options?: BenchmarkOptions,\n): BenchmarkSuite {\n  return new BenchmarkSuite(suiteName, options);\n}\n\n/**\n * Utility to measure memory usage of a function\n *\n * @param fn - Function to measure\n * @param forceGC - Whether to force garbage collection before measuring\n * @returns Memory usage in bytes\n *\n * @example\n * ```typescript\n * const memoryUsed = await measureMemory(() => {\n *   return new Array(100000).fill(0).map(x => ({ value: x }));\n * });\n *\n * console.log(`Memory used: ${(memoryUsed / 1024 / 1024).toFixed(2)}MB`);\n * ```\n */\nexport async function measureMemory(fn: BenchmarkFunction, forceGC = true): Promise<number> {\n  if (forceGC) {\n    forceGarbageCollection();\n  }\n\n  const startMemory = process.memoryUsage().heapUsed;\n  await fn();\n  const endMemory = process.memoryUsage().heapUsed;\n\n  return endMemory - startMemory;\n}\n"]}