chrome-cdp-cli 1.5.0 → 1.6.0

package/dist/proxy/server/MessageStore.js

@@ -0,0 +1,360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageStore = void 0;
+const logger_1 = require("../../utils/logger");
+class MessageStore {
+    constructor(maxConsoleMessages = 1000, maxNetworkRequests = 500) {
+        this.consoleMessages = new Map();
+        this.networkRequests = new Map();
+        this.maxConsoleMessages = maxConsoleMessages;
+        this.maxNetworkRequests = maxNetworkRequests;
+        this.logger = (0, logger_1.createLogger)({ component: 'MessageStore' });
+    }
+    addConsoleMessage(connectionId, message) {
+        this.logger.info(`[DEBUG] addConsoleMessage called for connection ${connectionId}, message type: ${message.type}, text: ${message.text.substring(0, 100)}`);
+        if (!this.consoleMessages.has(connectionId)) {
+            this.consoleMessages.set(connectionId, []);
+            this.logger.info(`[DEBUG] Created new message array for connection ${connectionId}`);
+        }
+        const messages = this.consoleMessages.get(connectionId);
+        messages.push(message);
+        this.logger.debug(`Added console message for connection ${connectionId}`, {
+            connectionId,
+            messageType: message.type,
+            messageText: message.text.substring(0, 100),
+            totalMessages: messages.length
+        });
+        if (messages.length > this.maxConsoleMessages) {
+            const removed = messages.splice(0, messages.length - this.maxConsoleMessages);
+            this.logger.logMemoryEvent('limit-reached', `Console message limit reached for connection ${connectionId}`, {
+                connectionCount: 1,
+                messageCount: messages.length,
+                messagesRemoved: removed.length,
+                maxLimit: this.maxConsoleMessages
+            });
+        }
+        this.logger.debug(`Console message stored successfully`, {
+            connectionId,
+            messageType: message.type,
+            source: message.source
+        });
+    }
+    getConsoleMessages(connectionId, filter) {
+        const messages = this.consoleMessages.get(connectionId) || [];
+        if (!filter) {
+            return [...messages];
+        }
+        let filteredMessages = [...messages];
+        if (filter.types && filter.types.length > 0) {
+            filteredMessages = filteredMessages.filter(msg => filter.types.includes(msg.type));
+        }
+        if (filter.textPattern) {
+            const pattern = new RegExp(filter.textPattern, 'i');
+            filteredMessages = filteredMessages.filter(msg => pattern.test(msg.text));
+        }
+        if (filter.source) {
+            filteredMessages = filteredMessages.filter(msg => msg.source === filter.source);
+        }
+        if (filter.startTime) {
+            filteredMessages = filteredMessages.filter(msg => msg.timestamp >= filter.startTime);
+        }
+        if (filter.endTime) {
+            filteredMessages = filteredMessages.filter(msg => msg.timestamp <= filter.endTime);
+        }
+        if (filter.maxMessages && filter.maxMessages > 0) {
+            filteredMessages = filteredMessages.slice(-filter.maxMessages);
+        }
+        return filteredMessages;
+    }
+    getLatestConsoleMessage(connectionId, filter) {
+        const messages = this.getConsoleMessages(connectionId, filter);
+        return messages.length > 0 ? messages[messages.length - 1] : null;
+    }
+    clearConsoleMessages(connectionId) {
+        this.consoleMessages.delete(connectionId);
+        this.logger.debug(`Cleared console messages for connection ${connectionId}`);
+    }
+    getConsoleMessageCount(connectionId, filter) {
+        return this.getConsoleMessages(connectionId, filter).length;
+    }
+    addNetworkRequest(connectionId, request) {
+        this.logger.info(`[DEBUG] addNetworkRequest called for connection ${connectionId}, method: ${request.method}, url: ${request.url.substring(0, 100)}`);
+        if (!this.networkRequests.has(connectionId)) {
+            this.networkRequests.set(connectionId, []);
+            this.logger.info(`[DEBUG] Created new network requests array for connection ${connectionId}`);
+        }
+        const requests = this.networkRequests.get(connectionId);
+        requests.push(request);
+        this.logger.debug(`Added network request for connection ${connectionId}`, {
+            connectionId,
+            method: request.method,
+            url: request.url.substring(0, 100),
+            totalRequests: requests.length
+        });
+        if (requests.length > this.maxNetworkRequests) {
+            const removed = requests.splice(0, requests.length - this.maxNetworkRequests);
+            this.logger.logMemoryEvent('limit-reached', `Network request limit reached for connection ${connectionId}`, {
+                connectionCount: 1,
+                requestCount: requests.length,
+                requestsRemoved: removed.length,
+                maxLimit: this.maxNetworkRequests
+            });
+        }
+        this.logger.debug(`Network request stored successfully`, {
+            connectionId,
+            requestId: request.requestId,
+            method: request.method
+        });
+    }
+    updateNetworkRequest(connectionId, requestId, update) {
+        const requests = this.networkRequests.get(connectionId);
+        if (!requests) {
+            return;
+        }
+        const request = requests.find(r => r.requestId === requestId);
+        if (request) {
+            Object.assign(request, update);
+            this.logger.debug(`Updated network request ${requestId} for connection ${connectionId}`);
+        }
+    }
+    getNetworkRequests(connectionId, filter) {
+        const requests = this.networkRequests.get(connectionId) || [];
+        if (!filter) {
+            return [...requests];
+        }
+        let filteredRequests = [...requests];
+        if (filter.methods && filter.methods.length > 0) {
+            filteredRequests = filteredRequests.filter(req => filter.methods.includes(req.method.toUpperCase()));
+        }
+        if (filter.statusCodes && filter.statusCodes.length > 0) {
+            filteredRequests = filteredRequests.filter(req => req.status && filter.statusCodes.includes(req.status));
+        }
+        if (filter.urlPattern) {
+            const pattern = new RegExp(filter.urlPattern, 'i');
+            filteredRequests = filteredRequests.filter(req => pattern.test(req.url));
+        }
+        if (filter.startTime) {
+            filteredRequests = filteredRequests.filter(req => req.timestamp >= filter.startTime);
+        }
+        if (filter.endTime) {
+            filteredRequests = filteredRequests.filter(req => req.timestamp <= filter.endTime);
+        }
+        if (!filter.includeResponseBody) {
+            filteredRequests = filteredRequests.map(req => ({
+                ...req,
+                responseBody: undefined
+            }));
+        }
+        if (filter.maxRequests && filter.maxRequests > 0) {
+            filteredRequests = filteredRequests.slice(-filter.maxRequests);
+        }
+        return filteredRequests;
+    }
+    getLatestNetworkRequest(connectionId, filter) {
+        const requests = this.getNetworkRequests(connectionId, filter);
+        return requests.length > 0 ? requests[requests.length - 1] : null;
+    }
+    clearNetworkRequests(connectionId) {
+        this.networkRequests.delete(connectionId);
+        this.logger.debug(`Cleared network requests for connection ${connectionId}`);
+    }
+    getNetworkRequestCount(connectionId, filter) {
+        return this.getNetworkRequests(connectionId, filter).length;
+    }
+    cleanupConnection(connectionId) {
+        this.clearConsoleMessages(connectionId);
+        this.clearNetworkRequests(connectionId);
+        this.logger.info(`Cleaned up all data for connection ${connectionId}`);
+    }
+    clearAll() {
+        this.consoleMessages.clear();
+        this.networkRequests.clear();
+        this.logger.info('Cleared all stored messages and requests');
+    }
+    enforceMemoryLimits() {
+        let totalConsoleMessages = 0;
+        let totalNetworkRequests = 0;
+        const connectionCount = Math.max(this.consoleMessages.size, this.networkRequests.size);
+        for (const messages of this.consoleMessages.values()) {
+            totalConsoleMessages += messages.length;
+        }
+        for (const requests of this.networkRequests.values()) {
+            totalNetworkRequests += requests.length;
+        }
+        this.logger.logMemoryEvent('cleanup', 'Memory usage check', {
+            memoryUsage: process.memoryUsage(),
+            connectionCount,
+            messageCount: totalConsoleMessages,
+            requestCount: totalNetworkRequests
+        });
+        if (totalConsoleMessages > this.maxConsoleMessages * 2) {
+            this.logger.logMemoryEvent('limit-reached', 'Global console message limit exceeded, cleaning up oldest messages', {
+                messageCount: totalConsoleMessages,
+                maxLimit: this.maxConsoleMessages * 2,
+                connectionCount
+            });
+            this.cleanupOldestConsoleMessages();
+        }
+        if (totalNetworkRequests > this.maxNetworkRequests * 2) {
+            this.logger.logMemoryEvent('limit-reached', 'Global network request limit exceeded, cleaning up oldest requests', {
+                requestCount: totalNetworkRequests,
+                maxLimit: this.maxNetworkRequests * 2,
+                connectionCount
+            });
+            this.cleanupOldestNetworkRequests();
+        }
+    }
+    getStorageStats() {
+        const stats = {
+            connections: 0,
+            totalConsoleMessages: 0,
+            totalNetworkRequests: 0,
+            consoleMessagesByConnection: {},
+            networkRequestsByConnection: {}
+        };
+        const connectionIds = new Set([
+            ...this.consoleMessages.keys(),
+            ...this.networkRequests.keys()
+        ]);
+        stats.connections = connectionIds.size;
+        for (const connectionId of connectionIds) {
+            const consoleCount = this.consoleMessages.get(connectionId)?.length || 0;
+            const networkCount = this.networkRequests.get(connectionId)?.length || 0;
+            stats.consoleMessagesByConnection[connectionId] = consoleCount;
+            stats.networkRequestsByConnection[connectionId] = networkCount;
+            stats.totalConsoleMessages += consoleCount;
+            stats.totalNetworkRequests += networkCount;
+        }
+        return stats;
+    }
+    processConsoleAPIEvent(connectionId, params) {
+        try {
+            this.logger.info(`[DEBUG] processConsoleAPIEvent called for connection ${connectionId}, type: ${params.type}`);
+            const message = {
+                connectionId,
+                type: this.mapConsoleType(params.type),
+                text: this.formatConsoleArgs(params.args || []),
+                args: (params.args || []).map((arg) => arg.value || arg.description || ''),
+                timestamp: params.timestamp || Date.now(),
+                stackTrace: params.stackTrace ? this.convertStackTrace(params.stackTrace.callFrames) : undefined,
+                source: 'Runtime.consoleAPICalled'
+            };
+            this.logger.info(`[DEBUG] Created console message: ${JSON.stringify(message).substring(0, 200)}`);
+            this.addConsoleMessage(connectionId, message);
+            this.logger.info(`[DEBUG] Console message added to store for connection ${connectionId}`);
+        }
+        catch (error) {
+            this.logger.error('[DEBUG] Error processing console API event:', error);
+        }
+    }
+    processLogEntryEvent(connectionId, params) {
+        try {
+            const entry = params.entry;
+            const message = {
+                connectionId,
+                type: this.mapLogLevel(entry.level),
+                text: entry.text || '',
+                args: [entry.text || ''],
+                timestamp: entry.timestamp || Date.now(),
+                stackTrace: entry.url && entry.lineNumber ? [{
+                        functionName: '<unknown>',
+                        url: entry.url,
+                        lineNumber: entry.lineNumber,
+                        columnNumber: 0
+                    }] : undefined,
+                source: 'Log.entryAdded'
+            };
+            this.addConsoleMessage(connectionId, message);
+        }
+        catch (error) {
+            this.logger.error('Error processing log entry event:', error);
+        }
+    }
+    mapConsoleType(cdpType) {
+        switch (cdpType) {
+            case 'log': return 'log';
+            case 'info': return 'info';
+            case 'warning': return 'warn';
+            case 'error': return 'error';
+            case 'debug': return 'debug';
+            default: return 'log';
+        }
+    }
+    mapLogLevel(logLevel) {
+        switch (logLevel.toLowerCase()) {
+            case 'verbose':
+            case 'info': return 'info';
+            case 'warning': return 'warn';
+            case 'error': return 'error';
+            default: return 'log';
+        }
+    }
+    formatConsoleArgs(args) {
+        return args.map(arg => {
+            if (arg.value !== undefined) {
+                if (typeof arg.value === 'string') {
+                    return arg.value;
+                }
+                return JSON.stringify(arg.value);
+            }
+            return arg.description || '';
+        }).join(' ');
+    }
+    convertStackTrace(callFrames) {
+        return callFrames.map(frame => ({
+            functionName: frame.functionName || '<anonymous>',
+            url: frame.url,
+            lineNumber: frame.lineNumber,
+            columnNumber: frame.columnNumber
+        }));
+    }
+    cleanupOldestConsoleMessages() {
+        let maxMessages = 0;
+        let connectionToCleanup = '';
+        for (const [connectionId, messages] of this.consoleMessages) {
+            if (messages.length > maxMessages) {
+                maxMessages = messages.length;
+                connectionToCleanup = connectionId;
+            }
+        }
+        if (connectionToCleanup) {
+            const messages = this.consoleMessages.get(connectionToCleanup);
+            const toRemove = Math.floor(messages.length * 0.2);
+            const beforeCount = messages.length;
+            messages.splice(0, toRemove);
+            this.logger.logMemoryEvent('cleanup', `Cleaned up old console messages from connection with highest usage`, {
+                connectionCount: 1,
+                messageCount: messages.length,
+                messagesRemoved: toRemove,
+                connectionId: connectionToCleanup,
+                beforeCount,
+                afterCount: messages.length
+            });
+        }
+    }
+    cleanupOldestNetworkRequests() {
+        let maxRequests = 0;
+        let connectionToCleanup = '';
+        for (const [connectionId, requests] of this.networkRequests) {
+            if (requests.length > maxRequests) {
+                maxRequests = requests.length;
+                connectionToCleanup = connectionId;
+            }
+        }
+        if (connectionToCleanup) {
+            const requests = this.networkRequests.get(connectionToCleanup);
+            const toRemove = Math.floor(requests.length * 0.2);
+            const beforeCount = requests.length;
+            requests.splice(0, toRemove);
+            this.logger.logMemoryEvent('cleanup', `Cleaned up old network requests from connection with highest usage`, {
+                connectionCount: 1,
+                requestCount: requests.length,
+                requestsRemoved: toRemove,
+                connectionId: connectionToCleanup,
+                beforeCount,
+                afterCount: requests.length
+            });
+        }
+    }
+}
+exports.MessageStore = MessageStore;

package/dist/proxy/server/PerformanceMonitor.js

@@ -0,0 +1,277 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceMonitor = void 0;
+const logger_1 = require("../../utils/logger");
+const os = __importStar(require("os"));
+class PerformanceMonitor {
+    constructor(connectionPool, messageStore, thresholds) {
+        this.metricsHistory = [];
+        this.maxHistorySize = 100;
+        this.lastAlertTimes = new Map();
+        this.alertCooldownMs = 300000;
+        this.logger = (0, logger_1.createLogger)({ component: 'PerformanceMonitor' });
+        this.connectionPool = connectionPool;
+        this.messageStore = messageStore;
+        this.startTime = Date.now();
+        this.thresholds = {
+            memoryUtilizationWarning: 80,
+            memoryUtilizationCritical: 95,
+            heapUtilizationWarning: 80,
+            heapUtilizationCritical: 95,
+            connectionCountWarning: 50,
+            connectionCountCritical: 100,
+            messageCountWarning: 10000,
+            messageCountCritical: 50000,
+            ...thresholds
+        };
+    }
+    start(intervalMs = 60000) {
+        if (this.monitoringInterval) {
+            this.logger.warn('Performance monitoring is already running');
+            return;
+        }
+        this.logger.info('Starting performance monitoring', {
+            intervalMs,
+            thresholds: this.thresholds
+        });
+        this.collectMetrics();
+        this.monitoringInterval = setInterval(() => {
+            this.collectMetrics();
+        }, intervalMs);
+    }
+    stop() {
+        if (this.monitoringInterval) {
+            clearInterval(this.monitoringInterval);
+            this.monitoringInterval = undefined;
+            this.logger.info('Performance monitoring stopped');
+        }
+    }
+    collectMetrics() {
+        const now = Date.now();
+        const memoryUsage = process.memoryUsage();
+        const connections = this.connectionPool.getAllConnections();
+        const storageStats = this.messageStore.getStorageStats();
+        const loadAvg = os.loadavg();
+        const freeMemory = os.freemem();
+        const totalMemory = os.totalmem();
+        const memoryUtilization = ((totalMemory - freeMemory) / totalMemory) * 100;
+        const heapUtilization = (memoryUsage.heapUsed / memoryUsage.heapTotal) * 100;
+        const healthyConnections = connections.filter(c => c.isHealthy).length;
+        const totalClientConnections = connections.reduce((sum, c) => sum + c.clientCount, 0);
+        const averageClientCount = connections.length > 0 ? totalClientConnections / connections.length : 0;
+        const averageMessagesPerConnection = connections.length > 0
+            ? storageStats.totalConsoleMessages / connections.length
+            : 0;
+        const averageRequestsPerConnection = connections.length > 0
+            ? storageStats.totalNetworkRequests / connections.length
+            : 0;
+        const metrics = {
+            timestamp: now,
+            uptime: now - this.startTime,
+            memory: {
+                heapUsed: memoryUsage.heapUsed,
+                heapTotal: memoryUsage.heapTotal,
+                external: memoryUsage.external,
+                rss: memoryUsage.rss,
+                heapUtilization
+            },
+            system: {
+                loadAverage: loadAvg,
+                freeMemory,
+                totalMemory,
+                memoryUtilization,
+                cpuCount: os.cpus().length
+            },
+            connections: {
+                total: connections.length,
+                healthy: healthyConnections,
+                unhealthy: connections.length - healthyConnections,
+                averageClientCount,
+                totalClientConnections
+            },
+            messages: {
+                totalConsoleMessages: storageStats.totalConsoleMessages,
+                totalNetworkRequests: storageStats.totalNetworkRequests,
+                averageMessagesPerConnection,
+                averageRequestsPerConnection
+            },
+            performance: {}
+        };
+        this.metricsHistory.push(metrics);
+        if (this.metricsHistory.length > this.maxHistorySize) {
+            this.metricsHistory.shift();
+        }
+        this.logger.logPerformanceMetrics('PerformanceMonitor', {
+            uptime: metrics.uptime,
+            memoryUtilization: metrics.system.memoryUtilization,
+            heapUtilization: metrics.memory.heapUtilization,
+            connectionCount: metrics.connections.total,
+            messageCount: metrics.messages.totalConsoleMessages,
+            requestCount: metrics.messages.totalNetworkRequests,
+            loadAverage: metrics.system.loadAverage[0]
+        });
+        this.checkThresholds(metrics);
+        return metrics;
+    }
+    checkThresholds(metrics) {
+        if (metrics.system.memoryUtilization >= this.thresholds.memoryUtilizationCritical) {
+            this.sendAlert('memory-critical', 'Critical system memory utilization', {
+                utilization: metrics.system.memoryUtilization,
+                threshold: this.thresholds.memoryUtilizationCritical,
+                freeMemory: metrics.system.freeMemory,
+                totalMemory: metrics.system.totalMemory
+            });
+        }
+        else if (metrics.system.memoryUtilization >= this.thresholds.memoryUtilizationWarning) {
+            this.sendAlert('memory-warning', 'High system memory utilization', {
+                utilization: metrics.system.memoryUtilization,
+                threshold: this.thresholds.memoryUtilizationWarning,
+                freeMemory: metrics.system.freeMemory,
+                totalMemory: metrics.system.totalMemory
+            });
+        }
+        if (metrics.memory.heapUtilization >= this.thresholds.heapUtilizationCritical) {
+            this.sendAlert('heap-critical', 'Critical heap memory utilization', {
+                utilization: metrics.memory.heapUtilization,
+                threshold: this.thresholds.heapUtilizationCritical,
+                heapUsed: metrics.memory.heapUsed,
+                heapTotal: metrics.memory.heapTotal
+            });
+        }
+        else if (metrics.memory.heapUtilization >= this.thresholds.heapUtilizationWarning) {
+            this.sendAlert('heap-warning', 'High heap memory utilization', {
+                utilization: metrics.memory.heapUtilization,
+                threshold: this.thresholds.heapUtilizationWarning,
+                heapUsed: metrics.memory.heapUsed,
+                heapTotal: metrics.memory.heapTotal
+            });
+        }
+        if (metrics.connections.total >= this.thresholds.connectionCountCritical) {
+            this.sendAlert('connections-critical', 'Critical number of connections', {
+                connectionCount: metrics.connections.total,
+                threshold: this.thresholds.connectionCountCritical,
+                healthyConnections: metrics.connections.healthy,
+                totalClientConnections: metrics.connections.totalClientConnections
+            });
+        }
+        else if (metrics.connections.total >= this.thresholds.connectionCountWarning) {
+            this.sendAlert('connections-warning', 'High number of connections', {
+                connectionCount: metrics.connections.total,
+                threshold: this.thresholds.connectionCountWarning,
+                healthyConnections: metrics.connections.healthy,
+                totalClientConnections: metrics.connections.totalClientConnections
+            });
+        }
+        const totalMessages = metrics.messages.totalConsoleMessages + metrics.messages.totalNetworkRequests;
+        if (totalMessages >= this.thresholds.messageCountCritical) {
+            this.sendAlert('messages-critical', 'Critical number of stored messages', {
+                totalMessages,
+                threshold: this.thresholds.messageCountCritical,
+                consoleMessages: metrics.messages.totalConsoleMessages,
+                networkRequests: metrics.messages.totalNetworkRequests
+            });
+        }
+        else if (totalMessages >= this.thresholds.messageCountWarning) {
+            this.sendAlert('messages-warning', 'High number of stored messages', {
+                totalMessages,
+                threshold: this.thresholds.messageCountWarning,
+                consoleMessages: metrics.messages.totalConsoleMessages,
+                networkRequests: metrics.messages.totalNetworkRequests
+            });
+        }
+    }
+    sendAlert(alertType, message, data) {
+        const now = Date.now();
+        const lastAlert = this.lastAlertTimes.get(alertType);
+        if (!lastAlert || (now - lastAlert) >= this.alertCooldownMs) {
+            this.logger.warn(`[PERFORMANCE ALERT] ${message}`, data);
+            this.lastAlertTimes.set(alertType, now);
+        }
+    }
+    getCurrentMetrics() {
+        return this.metricsHistory.length > 0
+            ? this.metricsHistory[this.metricsHistory.length - 1]
+            : null;
+    }
+    getMetricsHistory(count) {
+        if (count && count < this.metricsHistory.length) {
+            return this.metricsHistory.slice(-count);
+        }
+        return [...this.metricsHistory];
+    }
+    getPerformanceSummary(periodMs = 3600000) {
+        const now = Date.now();
+        const cutoff = now - periodMs;
+        const recentMetrics = this.metricsHistory.filter(m => m.timestamp >= cutoff);
+        if (recentMetrics.length === 0) {
+            return {
+                averageMemoryUtilization: 0,
+                averageHeapUtilization: 0,
+                averageConnectionCount: 0,
+                averageMessageCount: 0,
+                peakMemoryUtilization: 0,
+                peakConnectionCount: 0,
+                alertCount: 0
+            };
+        }
+        const avgMemoryUtilization = recentMetrics.reduce((sum, m) => sum + m.system.memoryUtilization, 0) / recentMetrics.length;
+        const avgHeapUtilization = recentMetrics.reduce((sum, m) => sum + m.memory.heapUtilization, 0) / recentMetrics.length;
+        const avgConnectionCount = recentMetrics.reduce((sum, m) => sum + m.connections.total, 0) / recentMetrics.length;
+        const avgMessageCount = recentMetrics.reduce((sum, m) => sum + m.messages.totalConsoleMessages + m.messages.totalNetworkRequests, 0) / recentMetrics.length;
+        const peakMemoryUtilization = Math.max(...recentMetrics.map(m => m.system.memoryUtilization));
+        const peakConnectionCount = Math.max(...recentMetrics.map(m => m.connections.total));
+        const alertCount = Math.floor(periodMs / this.alertCooldownMs) * this.lastAlertTimes.size;
+        return {
+            averageMemoryUtilization: avgMemoryUtilization,
+            averageHeapUtilization: avgHeapUtilization,
+            averageConnectionCount: avgConnectionCount,
+            averageMessageCount: avgMessageCount,
+            peakMemoryUtilization,
+            peakConnectionCount,
+            alertCount
+        };
+    }
+    updateThresholds(newThresholds) {
+        this.thresholds = { ...this.thresholds, ...newThresholds };
+        this.logger.info('Performance thresholds updated', { thresholds: this.thresholds });
+    }
+    clearHistory() {
+        this.metricsHistory = [];
+        this.lastAlertTimes.clear();
+        this.logger.info('Performance metrics history cleared');
+    }
+}
+exports.PerformanceMonitor = PerformanceMonitor;