hook-engine/dist/src/utils/timing.js

Production-grade webhook engine with comprehensive adapter support, security, reliability, structured logging, and CLI tools.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Timer = void 0;
exports.sleep = sleep;
exports.addJitter = addJitter;
exports.calculateBackoffDelay = calculateBackoffDelay;
exports.withTimeout = withTimeout;
exports.measureTime = measureTime;
/**
 * Sleep for a specified number of milliseconds
 */
function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}
/**
 * Add jitter to a delay value to prevent thundering herd
 */
function addJitter(delayMs, jitterFactor = 0.1) {
    const jitter = delayMs * jitterFactor * Math.random();
    return Math.floor(delayMs + jitter);
}
/**
 * Calculate exponential backoff delay
 */
function calculateBackoffDelay(attempt, baseDelayMs, multiplier = 2, maxDelayMs = 30000, jitter = true) {
    const delay = Math.min(baseDelayMs * Math.pow(multiplier, attempt - 1), maxDelayMs);
    return jitter ? addJitter(delay) : delay;
}
/**
 * Performance timer for measuring execution time
 */
class Timer {
    constructor() {
        this.startTime = performance.now();
    }
    /**
     * Stop the timer and return elapsed time in milliseconds
     */
    stop() {
        this.endTime = performance.now();
        return this.elapsed();
    }
    /**
     * Get elapsed time in milliseconds (without stopping the timer)
     */
    elapsed() {
        const end = this.endTime || performance.now();
        return Math.round(end - this.startTime);
    }
    /**
     * Reset the timer
     */
    reset() {
        this.startTime = performance.now();
        this.endTime = undefined;
    }
}
exports.Timer = Timer;
/**
 * Timeout wrapper for promises
 */
function withTimeout(promise, timeoutMs, timeoutMessage = 'Operation timed out') {
    return Promise.race([
        promise,
        new Promise((_, reject) => {
            setTimeout(() => {
                reject(new Error(timeoutMessage));
            }, timeoutMs);
        })
    ]);
}
/**
 * Measure execution time of a function
 */
async function measureTime(fn, label) {
    const timer = new Timer();
    try {
        const result = await fn();
        const duration = timer.stop();
        if (label) {
            console.log(`${label} took ${duration}ms`);
        }
        return { result, duration };
    }
    catch (error) {
        const duration = timer.stop();
        if (label) {
            console.log(`${label} failed after ${duration}ms`);
        }
        throw error;
    }
}