strogger/dist/utils/performance.js

📊 A modern structured logging library with functional programming, duck-typing, and comprehensive third-party integrations

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createPerformanceMonitor = void 0;
const createPerformanceMonitor = (initialState) => {
    const state = initialState || { metrics: new Map() };
    const recordMetric = (functionName, metric) => {
        if (!state.metrics.has(functionName)) {
            state.metrics.set(functionName, []);
        }
        const metrics = state.metrics.get(functionName);
        if (metrics) {
            metrics.push(metric);
        }
    };
    const startTimer = (functionName) => {
        const startTime = performance.now();
        return (metadata) => {
            const endTime = performance.now();
            const duration = endTime - startTime;
            const metric = {
                functionName,
                duration,
                startTime,
                endTime,
                ...(metadata && { metadata }),
            };
            recordMetric(functionName, metric);
            return metric;
        };
    };
    const timeAsync = async (functionName, fn, metadata) => {
        const startTime = performance.now();
        try {
            const result = await fn();
            const endTime = performance.now();
            const duration = endTime - startTime;
            const metric = {
                functionName,
                duration,
                startTime,
                endTime,
                ...(metadata && { metadata }),
            };
            recordMetric(functionName, metric);
            return result;
        }
        catch (error) {
            const endTime = performance.now();
            const duration = endTime - startTime;
            const metric = {
                functionName,
                duration,
                startTime,
                endTime,
                ...(metadata && { metadata: { ...metadata, error: true } }),
            };
            recordMetric(functionName, metric);
            throw error;
        }
    };
    const timeSync = (functionName, fn, metadata) => {
        const startTime = performance.now();
        try {
            const result = fn();
            const endTime = performance.now();
            const duration = endTime - startTime;
            const metric = {
                functionName,
                duration,
                startTime,
                endTime,
                ...(metadata && { metadata }),
            };
            recordMetric(functionName, metric);
            return result;
        }
        catch (error) {
            const endTime = performance.now();
            const duration = endTime - startTime;
            const metric = {
                functionName,
                duration,
                startTime,
                endTime,
                ...(metadata && { metadata: { ...metadata, error: true } }),
            };
            recordMetric(functionName, metric);
            throw error;
        }
    };
    const getMetrics = (functionName) => {
        if (functionName) {
            return state.metrics.get(functionName) || [];
        }
        const allMetrics = [];
        for (const metrics of state.metrics.values()) {
            allMetrics.push(...metrics);
        }
        return allMetrics;
    };
    const getAverageDuration = (functionName) => {
        const metrics = getMetrics(functionName);
        if (metrics.length === 0)
            return 0;
        const totalDuration = metrics.reduce((sum, metric) => sum + metric.duration, 0);
        return totalDuration / metrics.length;
    };
    const getSlowestExecution = (functionName) => {
        const metrics = getMetrics(functionName);
        if (metrics.length === 0)
            return null;
        return metrics.reduce((slowest, current) => current.duration > slowest.duration ? current : slowest);
    };
    const clearMetrics = (functionName) => {
        if (functionName) {
            state.metrics.delete(functionName);
        }
        else {
            state.metrics.clear();
        }
    };
    const getMetricsSummary = () => {
        const summary = {};
        for (const [functionName, metrics] of state.metrics.entries()) {
            const count = metrics.length;
            const avgDuration = getAverageDuration(functionName);
            const maxDuration = Math.max(...metrics.map((m) => m.duration));
            summary[functionName] = { count, avgDuration, maxDuration };
        }
        return summary;
    };
    return {
        state,
        startTimer,
        timeAsync,
        timeSync,
        getMetrics,
        getAverageDuration,
        getSlowestExecution,
        clearMetrics,
        getMetricsSummary,
    };
};
exports.createPerformanceMonitor = createPerformanceMonitor;
//# sourceMappingURL=performance.js.map