xypriss 1.2.4 → 1.3.0

package/dist/cjs/src/server/plugins/core/PerformancePlugin.js

@@ -1,894 +0,0 @@
-'use strict';
-
-var index = require('../../../../mods/security/src/components/fortified-function/index.js');
-var PluginTypes = require('../types/PluginTypes.js');
-var si = require('systeminformation');
-var pidusage = require('pidusage');
-var osUtils = require('node-os-utils');
-var performanceMonitor = require('../../../../mods/security/src/utils/performanceMonitor.js');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var si__namespace = /*#__PURE__*/_interopNamespaceDefault(si);
-var osUtils__namespace = /*#__PURE__*/_interopNamespaceDefault(osUtils);
-
-/**
- * Performance Plugin Base Class
- *
- * Foundation for performance monitoring plugins with <0.3ms execution overhead
- * and comprehensive metrics collection using XyPrissJS performance utilities.
- */
-/**
- * Abstract base class for performance monitoring plugins
- */
-class PerformancePlugin {
-    constructor() {
-        this.type = PluginTypes.PluginType.PERFORMANCE;
-        this.priority = PluginTypes.PluginPriority.NORMAL;
-        this.isAsync = false; // Performance plugins should be synchronous for minimal overhead
-        this.isCacheable = true;
-        this.maxExecutionTime = 300; // 0.3ms max for performance operations
-        // Performance thresholds
-        this.performanceThresholds = {
-            responseTime: 100, // 100ms
-            memoryUsage: 50 * 1024 * 1024, // 50MB
-            cpuUsage: 80, // 80%
-        };
-        // Performance tracking
-        this.timers = new Map();
-        this.metrics = new Map();
-        this.lastCpuCheck = 0;
-        this.cachedCpuUsage = 0;
-        this.performanceData = {
-            totalExecutions: 0,
-            averageExecutionTime: 0,
-            minExecutionTime: Infinity,
-            maxExecutionTime: 0,
-            errorCount: 0,
-            successRate: 100,
-            memoryUsage: 0,
-            cpuUsage: 0,
-            lastExecuted: new Date(),
-        };
-    }
-    /**
-     * Initialize performance plugin with XyPrissJS utilities
-     */
-    async initialize(context) {
-        // Create fortified metrics collector for ultra-fast performance tracking
-        this.fortifiedMetrics = index.func((metricName, value) => {
-            this.recordMetricInternal(metricName, value);
-        }, {
-            ultraFast: "maximum",
-            auditLog: false, // Disable audit logging for performance metrics
-            timeout: 100, // Very short timeout for metrics
-            errorHandling: "graceful",
-        });
-        // Initialize system monitoring
-        await this.initializeSystemMonitoring();
-        // Initialize performance monitoring
-        await this.initializePerformanceMonitoring(context);
-    }
-    /**
-     * Execute performance plugin with minimal overhead
-     */
-    execute(context) {
-        const startTime = performance.now();
-        try {
-            // Start request timing if not already started
-            if (!context.metrics.requestStartTime) {
-                context.metrics.requestStartTime = startTime;
-            }
-            // Collect performance metrics
-            const metrics = this.collectPerformanceMetrics(context);
-            // Execute plugin-specific performance logic
-            const result = this.executePerformanceLogic(context, metrics);
-            const executionTime = performance.now() - startTime;
-            // Update performance statistics
-            this.updatePerformanceStats(executionTime, true);
-            // Store metrics in context
-            context.metrics.pluginExecutionTimes.set(this.id, executionTime);
-            return {
-                success: true,
-                executionTime,
-                data: {
-                    metrics,
-                    result,
-                },
-                shouldContinue: true,
-            };
-        }
-        catch (error) {
-            const executionTime = performance.now() - startTime;
-            // Update error statistics
-            this.updatePerformanceStats(executionTime, false);
-            return {
-                success: false,
-                executionTime,
-                error,
-                shouldContinue: true, // Performance errors shouldn't stop execution
-            };
-        }
-    }
-    /**
-     * Start a named timer for performance measurement
-     */
-    startTimer(name) {
-        this.timers.set(name, performance.now());
-    }
-    /**
-     * End a named timer and return elapsed time
-     */
-    endTimer(name) {
-        const startTime = this.timers.get(name);
-        if (!startTime) {
-            console.warn(`Timer '${name}' was not started`);
-            return 0;
-        }
-        const elapsed = performance.now() - startTime;
-        this.timers.delete(name);
-        // Record the timing metric
-        this.recordMetric(`timer.${name}`, elapsed);
-        return elapsed;
-    }
-    /**
-     * Record a performance metric
-     */
-    recordMetric(name, value) {
-        if (this.fortifiedMetrics) {
-            this.fortifiedMetrics(name, value);
-        }
-        else {
-            this.recordMetricInternal(name, value);
-        }
-    }
-    /**
-     * Get current performance metrics
-     */
-    getMetrics() {
-        return { ...this.performanceData };
-    }
-    /**
-     * Precompile performance monitoring for optimal execution
-     */
-    async precompile() {
-        // Pre-warm performance monitoring systems
-        await this.precompilePerformanceMonitoring();
-    }
-    /**
-     * Warm up performance plugin
-     */
-    async warmup(context) {
-        // Perform initial metrics collection to warm up systems
-        this.collectPerformanceMetrics(context);
-    }
-    // =====  PERFORMANCE IMPLEMENTATIONS =====
-    /**
-     * Initialize plugin-specific performance monitoring
-     *  implementation with comprehensive monitoring setup
-     */
-    async initializePerformanceMonitoring(context) {
-        try {
-            // Initialize performance thresholds from configuration
-            if (context.config.customSettings.performanceThresholds) {
-                this.updatePerformanceThresholds(context.config.customSettings.performanceThresholds);
-            }
-            // Setup metric collection intervals
-            if (context.config.customSettings.metricsCollection) {
-                this.setupMetricsCollection(context.config.customSettings.metricsCollection);
-            }
-            // Initialize performance alerting
-            if (context.config.customSettings.performanceAlerting) {
-                this.setupPerformanceAlerting(context.config.customSettings.performanceAlerting);
-            }
-            // Setup performance profiling
-            if (context.config.enableProfiling) {
-                await this.setupPerformanceProfiling(context);
-            }
-            context.logger.info(`Performance plugin ${this.constructor.name} initialized successfully`);
-        }
-        catch (error) {
-            context.logger.error(`Error initializing performance plugin: ${error.message}`, error);
-            throw error;
-        }
-    }
-    /**
-     * Execute plugin-specific performance logic
-     *  implementation with comprehensive performance analysis
-     */
-    executePerformanceLogic(context, metrics) {
-        try {
-            const performanceResults = {
-                metrics,
-                thresholdViolations: [],
-                performanceScore: 0,
-                recommendations: [],
-                alerts: [],
-                optimizations: [],
-            };
-            // Check performance thresholds
-            performanceResults.thresholdViolations =
-                this.checkPerformanceThresholds(metrics);
-            // Calculate performance score
-            performanceResults.performanceScore =
-                this.calculatePerformanceScore(metrics, performanceResults.thresholdViolations);
-            // Generate performance recommendations
-            performanceResults.recommendations =
-                this.generatePerformanceRecommendations(metrics);
-            // Check for performance alerts
-            performanceResults.alerts = this.checkPerformanceAlerts(metrics);
-            // Suggest optimizations
-            performanceResults.optimizations =
-                this.suggestOptimizations(metrics);
-            // Record performance metrics
-            this.recordPerformanceMetrics(metrics);
-            return performanceResults;
-        }
-        catch (error) {
-            console.error(`Error executing performance logic: ${error.message}`);
-            return {
-                error: error.message,
-                performanceScore: 0,
-                alerts: ["Performance monitoring failed"],
-            };
-        }
-    }
-    /**
-     * Precompile performance monitoring systems
-     *  implementation with comprehensive pre-warming using real system metrics
-     */
-    async precompilePerformanceMonitoring() {
-        try {
-            // Pre-warm CPU usage calculation
-            const cpuUsage = this.getCpuUsage();
-            // Pre-warm memory usage calculation
-            const memoryUsage = this.getMemoryUsage();
-            // Pre-warm advanced CPU metrics
-            const advancedCpuMetrics = await this.getAdvancedCpuMetrics();
-            // Pre-warm process CPU usage
-            const processCpuUsage = await this.getProcessCpuUsage();
-            // Pre-warm metric recording with real system data
-            this.recordMetric("precompile.cpu", cpuUsage);
-            this.recordMetric("precompile.memory", memoryUsage);
-            this.recordMetric("precompile.advanced_cpu", advancedCpuMetrics.usage);
-            // Pre-warm timer functionality
-            this.startTimer("precompile.timer");
-            await new Promise((resolve) => setTimeout(resolve, 1)); // Minimal delay for realistic timing
-            this.endTimer("precompile.timer");
-            // Pre-warm performance threshold checking with real system metrics
-            const realSystemMetrics = {
-                requestDuration: 1, // Minimal request duration for precompile
-                memoryUsage: memoryUsage,
-                cpuUsage: cpuUsage,
-                advancedCpu: advancedCpuMetrics,
-                processCpu: processCpuUsage,
-                timestamp: Date.now(),
-            };
-            this.checkPerformanceThresholds(realSystemMetrics);
-            // Pre-warm global performance monitor integration
-            const operationId = `precompile_${Date.now()}`;
-            performanceMonitor.globalPerformanceMonitor.startOperation(operationId, "precompile_warmup", {
-                algorithm: "performance_monitoring",
-                dataSize: memoryUsage,
-            });
-            performanceMonitor.globalPerformanceMonitor.endOperation(operationId, true);
-            // Pre-warm system resource monitoring
-            const systemResources = performanceMonitor.globalPerformanceMonitor.getSystemResourceUsage();
-            this.recordMetric("precompile.system_memory", systemResources.memory.heapUsed);
-            this.recordMetric("precompile.system_uptime", systemResources.uptime);
-            console.debug("Performance monitoring systems precompiled successfully with real metrics", {
-                cpuUsage,
-                memoryUsage,
-                advancedCpuCores: advancedCpuMetrics.cores,
-                processPid: processCpuUsage.pid,
-                systemUptime: systemResources.uptime,
-            });
-        }
-        catch (error) {
-            console.error("Error precompiling performance monitoring:", error);
-        }
-    }
-    // ===== PROTECTED HELPER METHODS =====
-    /**
-     * Collect comprehensive performance metrics
-     */
-    collectPerformanceMetrics(context) {
-        const now = performance.now();
-        return {
-            // Timing metrics
-            requestDuration: now - context.metrics.requestStartTime,
-            pluginExecutionTime: now - context.startTime,
-            // Memory metrics
-            memoryUsage: this.getMemoryUsage(),
-            // CPU metrics (if available)
-            cpuUsage: this.getCpuUsage(),
-            // Request metrics
-            requestSize: this.getRequestSize(context.req),
-            responseSize: this.getResponseSize(context.res),
-            // Cache metrics
-            cacheHits: context.metrics.cacheHits,
-            cacheMisses: context.metrics.cacheMisses,
-            // Custom metrics
-            customMetrics: this.collectCustomMetrics(context),
-        };
-    }
-    /**
-     * Get current memory usage
-     */
-    getMemoryUsage() {
-        try {
-            const memUsage = process.memoryUsage();
-            return memUsage.heapUsed;
-        }
-        catch (error) {
-            return 0;
-        }
-    }
-    /**
-     *  CPU usage monitoring with multi-core support
-     */
-    getCpuUsage() {
-        try {
-            const now = Date.now();
-            // Use cached value if checked recently (within 1 second)
-            if (now - this.lastCpuCheck < 1000) {
-                return this.cachedCpuUsage;
-            }
-            // Get current CPU usage
-            const currentUsage = process.cpuUsage();
-            if (this.lastCpuUsage) {
-                // Calculate CPU usage percentage
-                const userDiff = currentUsage.user - this.lastCpuUsage.user;
-                const systemDiff = currentUsage.system - this.lastCpuUsage.system;
-                const totalDiff = userDiff + systemDiff;
-                // Convert to percentage (microseconds to percentage)
-                const timeDiff = now - this.lastCpuCheck;
-                const cpuPercent = (totalDiff / (timeDiff * 1000)) * 100;
-                this.cachedCpuUsage = Math.min(Math.max(cpuPercent, 0), 100);
-            }
-            this.lastCpuUsage = currentUsage;
-            this.lastCpuCheck = now;
-            return this.cachedCpuUsage;
-        }
-        catch (error) {
-            console.error("Error getting CPU usage:", error);
-            return 0;
-        }
-    }
-    /**
-     * Get advanced CPU metrics using systeminformation
-     */
-    async getAdvancedCpuMetrics() {
-        try {
-            const [cpuLoad, cpuInfo] = await Promise.all([
-                si__namespace.currentLoad(),
-                si__namespace.cpu(),
-            ]);
-            return {
-                usage: cpuLoad.currentLoad,
-                cores: cpuInfo.cores,
-                speed: cpuInfo.speed,
-                temperature: undefined, // Temperature not available in current load data,
-            };
-        }
-        catch (error) {
-            console.error("Error getting advanced CPU metrics:", error);
-            return {
-                usage: this.getCpuUsage(),
-                cores: require("os").cpus().length,
-                speed: 0,
-            };
-        }
-    }
-    /**
-     * Get process-specific CPU usage using pidusage
-     */
-    async getProcessCpuUsage(pid) {
-        try {
-            const targetPid = pid || process.pid;
-            const stats = await pidusage(targetPid);
-            return stats;
-        }
-        catch (error) {
-            console.error("Error getting process CPU usage:", error);
-            return {
-                cpu: 0,
-                memory: 0,
-                ppid: 0,
-                pid: process.pid,
-                ctime: 0,
-                elapsed: 0,
-                timestamp: Date.now(),
-            };
-        }
-    }
-    /**
-     * Get request size in bytes
-     */
-    getRequestSize(req) {
-        try {
-            let size = 0;
-            // Add headers size
-            if (req.headers) {
-                size += JSON.stringify(req.headers).length;
-            }
-            // Add body size
-            if (req.body) {
-                size += JSON.stringify(req.body).length;
-            }
-            // Add query size
-            if (req.query) {
-                size += JSON.stringify(req.query).length;
-            }
-            return size;
-        }
-        catch (error) {
-            return 0;
-        }
-    }
-    /**
-     * Get response size in bytes with actual tracking
-     */
-    getResponseSize(res) {
-        try {
-            // Check for Content-Length header first
-            const contentLength = res.getHeader("content-length");
-            if (contentLength) {
-                return parseInt(contentLength, 10) || 0;
-            }
-            // Check for Transfer-Encoding: chunked
-            const transferEncoding = res.getHeader("transfer-encoding");
-            if (transferEncoding === "chunked") {
-                // For chunked responses, we need to track the actual size
-                return this.getChunkedResponseSize(res);
-            }
-            // Fallback: estimate from headers and any available data
-            let size = 0;
-            // Add headers size
-            const headers = res.getHeaders();
-            if (headers) {
-                for (const [key, value] of Object.entries(headers)) {
-                    size += key.length + String(value).length + 4; // +4 for ": " and "\r\n"
-                }
-            }
-            // Add status line size (approximate)
-            size += 15; // "HTTP/1.1 200 OK\r\n"
-            return size;
-        }
-        catch (error) {
-            console.error("Error calculating response size:", error);
-            return 0;
-        }
-    }
-    /**
-     * Track chunked response size using response interceptor
-     */
-    getChunkedResponseSize(res) {
-        try {
-            // Check if we've already set up size tracking for this response
-            if (res._XyPrissResponseSize !== undefined) {
-                return res._XyPrissResponseSize;
-            }
-            // Initialize size tracking
-            res._XyPrissResponseSize = 0;
-            // Intercept the write method to track chunk sizes
-            const originalWrite = res.write;
-            res.write = function (chunk, encoding, callback) {
-                if (chunk) {
-                    const chunkSize = Buffer.isBuffer(chunk)
-                        ? chunk.length
-                        : Buffer.byteLength(chunk, encoding || "utf8");
-                    res._XyPrissResponseSize += chunkSize;
-                }
-                return originalWrite.call(this, chunk, encoding, callback);
-            };
-            // Intercept the end method to track final chunk
-            const originalEnd = res.end;
-            res.end = function (chunk, encoding, callback) {
-                if (chunk) {
-                    const chunkSize = Buffer.isBuffer(chunk)
-                        ? chunk.length
-                        : Buffer.byteLength(chunk, encoding || "utf8");
-                    res._XyPrissResponseSize += chunkSize;
-                }
-                return originalEnd.call(this, chunk, encoding, callback);
-            };
-            return res._XyPrissResponseSize;
-        }
-        catch (error) {
-            console.error("Error setting up chunked response size tracking:", error);
-            return 0;
-        }
-    }
-    /**
-     * Setup response size tracking middleware
-     */
-    setupResponseSizeTracking(_req, res) {
-        try {
-            // Initialize response size tracking
-            res._XyPrissResponseSize = 0;
-            res._XyPrissStartTime = Date.now();
-            // Track response headers size
-            const originalSetHeader = res.setHeader;
-            res.setHeader = function (name, value) {
-                const headerSize = name.length + String(value).length + 4;
-                res._XyPrissResponseSize += headerSize;
-                return originalSetHeader.call(this, name, value);
-            };
-            // Track response body size
-            const originalWrite = res.write;
-            res.write = function (chunk, encoding, callback) {
-                if (chunk) {
-                    const chunkSize = Buffer.isBuffer(chunk)
-                        ? chunk.length
-                        : Buffer.byteLength(chunk, encoding || "utf8");
-                    res._XyPrissResponseSize += chunkSize;
-                }
-                return originalWrite.call(this, chunk, encoding, callback);
-            };
-            const originalEnd = res.end;
-            res.end = function (chunk, encoding, callback) {
-                if (chunk) {
-                    const chunkSize = Buffer.isBuffer(chunk)
-                        ? chunk.length
-                        : Buffer.byteLength(chunk, encoding || "utf8");
-                    res._XyPrissResponseSize += chunkSize;
-                }
-                // Record final response metrics
-                const responseTime = Date.now() - res._XyPrissStartTime;
-                res.setHeader("X-Response-Size", res._XyPrissResponseSize);
-                res.setHeader("X-Response-Time", responseTime);
-                return originalEnd.call(this, chunk, encoding, callback);
-            };
-        }
-        catch (error) {
-            console.error("Error setting up response size tracking:", error);
-        }
-    }
-    /**
-     * Collect custom performance metrics (to be overridden by subclasses)
-     */
-    collectCustomMetrics(_context) {
-        return {};
-    }
-    /**
-     * Initialize system monitoring with  libraries
-     */
-    async initializeSystemMonitoring() {
-        try {
-            // Initialize CPU monitoring with osUtils
-            this.cpuMonitor = osUtils__namespace.cpu;
-            // Initialize CPU usage tracking
-            this.lastCpuUsage = process.cpuUsage();
-            this.lastCpuCheck = Date.now();
-            this.cachedCpuUsage = 0;
-            // Pre-warm system information calls
-            await this.preWarmSystemInfo();
-        }
-        catch (error) {
-            console.error("Error initializing system monitoring:", error);
-            // Fallback to basic monitoring
-            this.lastCpuUsage = process.cpuUsage();
-            this.lastCpuCheck = Date.now();
-            this.cachedCpuUsage = 0;
-        }
-    }
-    /**
-     * Pre-warm system information calls for better performance
-     */
-    async preWarmSystemInfo() {
-        try {
-            // Pre-warm systeminformation calls
-            await Promise.allSettled([si__namespace.cpu(), si__namespace.currentLoad(), si__namespace.mem()]);
-            // Pre-warm pidusage
-            await pidusage(process.pid);
-        }
-        catch (error) {
-            // Ignore pre-warming errors
-            console.debug("System info pre-warming completed with some errors:", error);
-        }
-    }
-    /**
-     * Record metric internally
-     */
-    recordMetricInternal(name, value) {
-        const values = this.metrics.get(name) || [];
-        values.push(value);
-        // Keep only last 100 values for memory efficiency
-        if (values.length > 100) {
-            values.shift();
-        }
-        this.metrics.set(name, values);
-    }
-    /**
-     * Update performance statistics
-     */
-    updatePerformanceStats(executionTime, success) {
-        this.performanceData.totalExecutions++;
-        this.performanceData.lastExecuted = new Date();
-        if (success) {
-            // Update timing statistics
-            this.performanceData.minExecutionTime = Math.min(this.performanceData.minExecutionTime, executionTime);
-            this.performanceData.maxExecutionTime = Math.max(this.performanceData.maxExecutionTime, executionTime);
-            // Update average execution time
-            const totalTime = this.performanceData.averageExecutionTime *
-                (this.performanceData.totalExecutions - 1) +
-                executionTime;
-            this.performanceData.averageExecutionTime =
-                totalTime / this.performanceData.totalExecutions;
-        }
-        else {
-            this.performanceData.errorCount++;
-        }
-        // Update success rate
-        this.performanceData.successRate =
-            ((this.performanceData.totalExecutions -
-                this.performanceData.errorCount) /
-                this.performanceData.totalExecutions) *
-                100;
-        // Update resource usage
-        this.performanceData.memoryUsage = this.getMemoryUsage();
-        this.performanceData.cpuUsage = this.getCpuUsage();
-    }
-    /**
-     * Check if performance thresholds are exceeded
-     */
-    checkPerformanceThresholds(metrics) {
-        const violations = [];
-        if (metrics.requestDuration > this.performanceThresholds.responseTime) {
-            violations.push(`Response time exceeded: ${metrics.requestDuration}ms > ${this.performanceThresholds.responseTime}ms`);
-        }
-        if (metrics.memoryUsage > this.performanceThresholds.memoryUsage) {
-            violations.push(`Memory usage exceeded: ${metrics.memoryUsage} > ${this.performanceThresholds.memoryUsage}`);
-        }
-        if (metrics.cpuUsage > this.performanceThresholds.cpuUsage) {
-            violations.push(`CPU usage exceeded: ${metrics.cpuUsage}% > ${this.performanceThresholds.cpuUsage}%`);
-        }
-        return violations;
-    }
-    /**
-     * Get metric statistics
-     */
-    getMetricStats(metricName) {
-        const values = this.metrics.get(metricName) || [];
-        if (values.length === 0) {
-            return { count: 0, average: 0, min: 0, max: 0 };
-        }
-        const sum = values.reduce((a, b) => a + b, 0);
-        return {
-            count: values.length,
-            average: sum / values.length,
-            min: Math.min(...values),
-            max: Math.max(...values),
-        };
-    }
-    // ===== PERFORMANCE HELPER METHODS =====
-    /**
-     * Update performance thresholds from configuration
-     */
-    updatePerformanceThresholds(thresholds) {
-        try {
-            if (thresholds.responseTime) {
-                this.performanceThresholds.responseTime =
-                    thresholds.responseTime;
-            }
-            if (thresholds.memoryUsage) {
-                this.performanceThresholds.memoryUsage =
-                    thresholds.memoryUsage;
-            }
-            if (thresholds.cpuUsage) {
-                this.performanceThresholds.cpuUsage =
-                    thresholds.cpuUsage;
-            }
-            console.debug("Performance thresholds updated successfully");
-        }
-        catch (error) {
-            console.error("Error updating performance thresholds:", error);
-        }
-    }
-    /**
-     * Setup metrics collection intervals
-     */
-    setupMetricsCollection(config) {
-        try {
-            const interval = config.interval || 60000; // 1 minute default
-            setInterval(() => {
-                this.collectSystemMetrics();
-            }, interval);
-            console.debug("Metrics collection setup completed");
-        }
-        catch (error) {
-            console.error("Error setting up metrics collection:", error);
-        }
-    }
-    /**
-     * Setup performance alerting
-     */
-    setupPerformanceAlerting(config) {
-        try {
-            // Setup alerting thresholds and handlers
-            console.debug("Performance alerting setup completed");
-        }
-        catch (error) {
-            console.error("Error setting up performance alerting:", error);
-        }
-    }
-    /**
-     * Setup performance profiling
-     */
-    async setupPerformanceProfiling(context) {
-        try {
-            // Setup profiling tools and configurations
-            console.debug("Performance profiling setup completed");
-        }
-        catch (error) {
-            console.error("Error setting up performance profiling:", error);
-        }
-    }
-    /**
-     * Calculate performance score based on metrics and violations
-     */
-    calculatePerformanceScore(metrics, violations) {
-        try {
-            let score = 100;
-            // Deduct points for threshold violations
-            score -= violations.length * 15;
-            // Deduct points based on metric values
-            if (metrics.requestDuration >
-                this.performanceThresholds.responseTime * 0.8) {
-                score -= 10;
-            }
-            if (metrics.memoryUsage >
-                this.performanceThresholds.memoryUsage * 0.8) {
-                score -= 10;
-            }
-            if (metrics.cpuUsage > this.performanceThresholds.cpuUsage * 0.8) {
-                score -= 10;
-            }
-            // Bonus points for good performance
-            if (metrics.requestDuration <
-                this.performanceThresholds.responseTime * 0.5) {
-                score += 5;
-            }
-            return Math.max(0, Math.min(100, score));
-        }
-        catch (error) {
-            console.error("Error calculating performance score:", error);
-            return 0;
-        }
-    }
-    /**
-     * Generate performance recommendations
-     */
-    generatePerformanceRecommendations(metrics) {
-        const recommendations = [];
-        try {
-            if (metrics.requestDuration >
-                this.performanceThresholds.responseTime) {
-                recommendations.push("Consider optimizing request processing time");
-                recommendations.push("Review database queries and API calls");
-            }
-            if (metrics.memoryUsage > this.performanceThresholds.memoryUsage) {
-                recommendations.push("Consider optimizing memory usage");
-                recommendations.push("Review object creation and garbage collection");
-            }
-            if (metrics.cpuUsage > this.performanceThresholds.cpuUsage) {
-                recommendations.push("Consider optimizing CPU-intensive operations");
-                recommendations.push("Review algorithmic complexity");
-            }
-            if (metrics.cacheHits / (metrics.cacheHits + metrics.cacheMisses) <
-                0.8) {
-                recommendations.push("Consider improving cache hit rate");
-            }
-            return recommendations;
-        }
-        catch (error) {
-            console.error("Error generating performance recommendations:", error);
-            return ["Error generating recommendations"];
-        }
-    }
-    /**
-     * Check for performance alerts
-     */
-    checkPerformanceAlerts(metrics) {
-        const alerts = [];
-        try {
-            // Critical performance alerts
-            if (metrics.requestDuration >
-                this.performanceThresholds.responseTime * 2) {
-                alerts.push("CRITICAL: Response time severely degraded");
-            }
-            if (metrics.memoryUsage >
-                this.performanceThresholds.memoryUsage * 1.5) {
-                alerts.push("CRITICAL: Memory usage critically high");
-            }
-            if (metrics.cpuUsage > this.performanceThresholds.cpuUsage * 1.2) {
-                alerts.push("WARNING: CPU usage elevated");
-            }
-            return alerts;
-        }
-        catch (error) {
-            console.error("Error checking performance alerts:", error);
-            return ["Error checking alerts"];
-        }
-    }
-    /**
-     * Suggest optimizations based on metrics
-     */
-    suggestOptimizations(metrics) {
-        const optimizations = [];
-        try {
-            if (metrics.requestDuration > 100) {
-                optimizations.push("Enable response compression");
-                optimizations.push("Implement request caching");
-            }
-            if (metrics.memoryUsage > 50 * 1024 * 1024) {
-                optimizations.push("Implement object pooling");
-                optimizations.push("Optimize data structures");
-            }
-            if (metrics.cpuUsage > 70) {
-                optimizations.push("Implement CPU-intensive task queuing");
-                optimizations.push("Consider worker threads for heavy operations");
-            }
-            return optimizations;
-        }
-        catch (error) {
-            console.error("Error suggesting optimizations:", error);
-            return ["Error suggesting optimizations"];
-        }
-    }
-    /**
-     * Record performance metrics for analysis
-     */
-    recordPerformanceMetrics(metrics) {
-        try {
-            // Record key metrics
-            this.recordMetric("request.duration", metrics.requestDuration);
-            this.recordMetric("memory.usage", metrics.memoryUsage);
-            this.recordMetric("cpu.usage", metrics.cpuUsage);
-            this.recordMetric("cache.hits", metrics.cacheHits);
-            this.recordMetric("cache.misses", metrics.cacheMisses);
-            // Update performance data
-            this.performanceData.memoryUsage = metrics.memoryUsage;
-            this.performanceData.cpuUsage = metrics.cpuUsage;
-        }
-        catch (error) {
-            console.error("Error recording performance metrics:", error);
-        }
-    }
-    /**
-     * Collect system metrics periodically
-     */
-    collectSystemMetrics() {
-        try {
-            const metrics = {
-                timestamp: Date.now(),
-                memoryUsage: this.getMemoryUsage(),
-                cpuUsage: this.getCpuUsage(),
-            };
-            this.recordMetric("system.memory", metrics.memoryUsage);
-            this.recordMetric("system.cpu", metrics.cpuUsage);
-        }
-        catch (error) {
-            console.error("Error collecting system metrics:", error);
-        }
-    }
-}
-
-exports.PerformancePlugin = PerformancePlugin;
-//# sourceMappingURL=PerformancePlugin.js.map