xypriss-security/dist/esm/components/fortified-function/core/mods/stats-manager.js

XyPriss Security is an advanced JavaScript security library designed for enterprise applications. It provides military-grade encryption, secure data structures, quantum-resistant cryptography, and comprehensive security utilities for modern web applicatio

import { EventEmitter } from 'events';
import { FortifiedUtils } from '../../utils/utils.js';

/**
 * Statistics Manager for Fortified Function Core
 * Handles performance tracking and audit logging
 */
class StatsManager extends EventEmitter {
    constructor(options) {
        super();
        this.auditLog = [];
        this.options = options;
        this.stats = {
            executionCount: 0,
            totalExecutionTime: 0,
            averageExecutionTime: 0,
            memoryUsage: 0,
            cacheHits: 0,
            cacheMisses: 0,
            errorCount: 0,
            lastExecuted: new Date(),
            securityEvents: 0,
        };
    }
    /**
     * Update execution statistics
     */
    updateStats(context, success) {
        const executionTime = performance.now() - context.startTime;
        this.stats.executionCount++;
        this.stats.totalExecutionTime += executionTime;
        this.stats.averageExecutionTime =
            this.stats.totalExecutionTime / this.stats.executionCount;
        this.stats.lastExecuted = new Date();
        this.stats.memoryUsage = FortifiedUtils.getCurrentMemoryUsage();
        if (!success) {
            this.stats.errorCount++;
        }
        // Update audit entry
        context.auditEntry.executionTime = executionTime;
        context.auditEntry.success = success;
        context.auditEntry.memoryUsage = this.stats.memoryUsage;
        if (this.options.auditLog) {
            this.auditLog.push(context.auditEntry);
            // Limit audit log size
            if (this.auditLog.length > 1000) {
                this.auditLog.splice(0, 100);
            }
        }
        this.emit("stats_updated", {
            executionId: context.executionId,
            success,
            executionTime,
            memoryUsage: this.stats.memoryUsage,
        });
    }
    /**
     * Record cache hit
     */
    recordCacheHit() {
        this.stats.cacheHits++;
        this.emit("cache_hit_recorded");
    }
    /**
     * Record cache miss
     */
    recordCacheMiss() {
        this.stats.cacheMisses++;
        this.emit("cache_miss_recorded");
    }
    /**
     * Record security event
     */
    recordSecurityEvent() {
        this.stats.securityEvents++;
        this.emit("security_event_recorded");
    }
    /**
     * Handle execution error with proper logging
     */
    handleExecutionError(context, error) {
        context.auditEntry.errorMessage = error.message;
        context.auditEntry.securityFlags.push("execution_error");
        this.updateStats(context, false);
        this.emit("execution_failed", {
            executionId: context.executionId,
            error: error.message,
            memoryUsage: context.auditEntry.memoryUsage,
        });
    }
    /**
     * Get current statistics
     */
    getStats() {
        return { ...this.stats };
    }
    /**
     * Get audit log
     */
    getAuditLog() {
        return [...this.auditLog];
    }
    /**
     * Get filtered audit log by criteria
     */
    getFilteredAuditLog(filter) {
        return this.auditLog.filter((entry) => {
            if (filter.success !== undefined &&
                entry.success !== filter.success) {
                return false;
            }
            if (filter.startDate && entry.timestamp < filter.startDate) {
                return false;
            }
            if (filter.endDate && entry.timestamp > filter.endDate) {
                return false;
            }
            if (filter.executionId &&
                entry.executionId !== filter.executionId) {
                return false;
            }
            return true;
        });
    }
    /**
     * Clear audit log
     */
    clearAuditLog() {
        this.auditLog.length = 0;
        this.emit("audit_log_cleared");
    }
    /**
     * Reset statistics
     */
    resetStats() {
        this.stats.executionCount = 0;
        this.stats.totalExecutionTime = 0;
        this.stats.averageExecutionTime = 0;
        this.stats.cacheHits = 0;
        this.stats.cacheMisses = 0;
        this.stats.errorCount = 0;
        this.stats.securityEvents = 0;
        this.stats.lastExecuted = new Date();
        this.stats.memoryUsage = FortifiedUtils.getCurrentMemoryUsage();
        this.emit("stats_reset");
    }
    /**
     * Clean up resources
     */
    destroy() {
        this.clearAuditLog();
        this.removeAllListeners();
    }
}

export { StatsManager };
//# sourceMappingURL=stats-manager.js.map