fortify2-js
Version:
MOST POWERFUL JavaScript Security Library! Military-grade cryptography + 19 enhanced object methods + quantum-resistant algorithms + perfect TypeScript support. More powerful than Lodash with built-in security.
187 lines (185 loc) • 6.39 kB
JavaScript
/**
* Performance Timer for FortifiedFunction
* Tracks execution delays and measures performance between specific points
*/
class PerformanceTimer {
constructor(executionId, ultraFastMode = false) {
this.measurements = new Map();
this.completedMeasurements = [];
this.executionId = executionId;
this.ultraFastMode = ultraFastMode;
}
/**
* Start timing a specific operation
*/
startTimer(label, metadata) {
if (this.ultraFastMode) {
// In ultra-fast mode, use minimal overhead timing
this.measurements.set(label, {
label,
startTime: performance.now(),
metadata
});
return;
}
const measurement = {
label,
startTime: performance.now(),
metadata: {
executionId: this.executionId,
timestamp: new Date().toISOString(),
...metadata
}
};
this.measurements.set(label, measurement);
}
/**
* End timing for a specific operation
*/
endTimer(label, additionalMetadata) {
const measurement = this.measurements.get(label);
if (!measurement) {
console.warn(`Timer '${label}' was not started`);
return 0;
}
const endTime = performance.now();
const duration = endTime - measurement.startTime;
// Complete the measurement
measurement.endTime = endTime;
measurement.duration = duration;
if (additionalMetadata && measurement.metadata) {
Object.assign(measurement.metadata, additionalMetadata);
}
// Move to completed measurements
this.completedMeasurements.push(measurement);
this.measurements.delete(label);
if (!this.ultraFastMode) {
console.log(`${label}: ${duration.toFixed(2)}ms`);
}
return duration;
}
/**
* Measure a delay between two points (convenience method)
*/
measureDelay(startPoint, endPoint) {
const startMeasurement = this.completedMeasurements.find(m => m.label === startPoint);
const endMeasurement = this.completedMeasurements.find(m => m.label === endPoint);
if (!startMeasurement || !endMeasurement) {
console.warn(`Cannot measure delay between '${startPoint}' and '${endPoint}' - measurements not found`);
return 0;
}
if (!startMeasurement.endTime || !endMeasurement.startTime) {
console.warn(`Cannot measure delay - incomplete measurements`);
return 0;
}
return endMeasurement.startTime - startMeasurement.endTime;
}
/**
* Time a function execution
*/
async timeFunction(label, fn, metadata) {
this.startTimer(label, metadata);
try {
const result = await fn();
const duration = this.endTimer(label, { success: true });
return { result, duration };
}
catch (error) {
this.endTimer(label, {
success: false,
error: error instanceof Error ? error.message : 'Unknown error'
});
throw error;
}
}
/**
* Get current timing statistics
*/
getStats() {
const allMeasurements = [...this.completedMeasurements];
const completedOnly = this.completedMeasurements.filter(m => m.duration !== undefined);
if (completedOnly.length === 0) {
return {
totalMeasurements: allMeasurements.length,
completedMeasurements: 0,
activeMeasurements: this.measurements.size,
measurements: allMeasurements,
summary: {
totalDuration: 0,
averageDuration: 0,
minDuration: 0,
maxDuration: 0,
slowestOperation: '',
fastestOperation: ''
}
};
}
const durations = completedOnly.map(m => m.duration);
const totalDuration = durations.reduce((sum, d) => sum + d, 0);
const averageDuration = totalDuration / durations.length;
const minDuration = Math.min(...durations);
const maxDuration = Math.max(...durations);
const slowestOp = completedOnly.find(m => m.duration === maxDuration);
const fastestOp = completedOnly.find(m => m.duration === minDuration);
return {
totalMeasurements: allMeasurements.length,
completedMeasurements: completedOnly.length,
activeMeasurements: this.measurements.size,
measurements: allMeasurements,
summary: {
totalDuration,
averageDuration,
minDuration,
maxDuration,
slowestOperation: slowestOp?.label || '',
fastestOperation: fastestOp?.label || ''
}
};
}
/**
* Get measurements by pattern
*/
getMeasurementsByPattern(pattern) {
return this.completedMeasurements.filter(m => pattern.test(m.label));
}
/**
* Clear all measurements
*/
clear() {
this.measurements.clear();
this.completedMeasurements = [];
}
/**
* Get active timers
*/
getActiveTimers() {
return Array.from(this.measurements.keys());
}
/**
* Check if a timer is active
*/
isTimerActive(label) {
return this.measurements.has(label);
}
/**
* Get timing summary for audit logs
*/
getAuditSummary() {
const stats = this.getStats();
return {
executionId: this.executionId,
totalMeasurements: stats.totalMeasurements,
totalDuration: stats.summary.totalDuration,
averageDuration: stats.summary.averageDuration,
slowestOperation: stats.summary.slowestOperation,
fastestOperation: stats.summary.fastestOperation,
measurements: stats.measurements.map(m => ({
label: m.label,
duration: m.duration,
success: m.metadata?.success
}))
};
}
}
export { PerformanceTimer };
//# sourceMappingURL=performance-timer.js.map