xypriss 1.0.0 → 1.1.0

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

@@ -0,0 +1,894 @@
+'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