@jagilber-org/index-server 1.19.1

package/dist/dashboard/server/MetricsCollector.js

@@ -0,0 +1,803 @@
+"use strict";
+/**
+ * MetricsCollector — coordinator class (Phase 1–4 Dashboard Foundation).
+ *
+ * Owns all mutable metrics state and delegates:
+ *  - pure math to metricsAggregation.ts
+ *  - output serialisation to metricsSerializer.ts
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsCollector = void 0;
+exports.getMetricsCollector = getMetricsCollector;
+exports.setMetricsCollector = setMetricsCollector;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const v8_1 = __importDefault(require("v8"));
+const FileMetricsStorage_js_1 = require("./FileMetricsStorage.js");
+const BufferRing_js_1 = require("../../utils/BufferRing.js");
+const runtimeConfig_1 = require("../../config/runtimeConfig");
+const metricsAggregation_js_1 = require("./metricsAggregation.js");
+const metricsSerializer_js_1 = require("./metricsSerializer.js");
+class MetricsCollector {
+    tools = new Map();
+    // Resource usage samples (CPU/Memory) for leak/trend analysis
+    resourceSamples;
+    lastCpuUsageSample = null;
+    lastCpuSampleTime = 0;
+    snapshots = []; // Keep small in-memory cache for real-time queries
+    connections = new Set();
+    disconnectedCount = 0;
+    totalSessionTime = 0;
+    sessionStartTimes = new Map();
+    startTime = Date.now();
+    options;
+    collectTimer;
+    lastCpuUsage;
+    // Phase 4: Advanced features
+    recentAlerts = [];
+    activeConnections = 0;
+    // Rolling timestamp buffer for recent tool calls (used for stable RPM calculation)
+    recentCallTimestamps = [];
+    static MAX_RECENT_CALLS = 10000; // cap to avoid unbounded growth
+    static MAX_MEMORY_SNAPSHOTS = 60; // Keep only 1 hour in memory
+    static MAX_TOOL_METRICS = 1000; // cap tool metrics to prevent memory leaks
+    // File storage for historical data (optional)
+    fileStorage = null;
+    useFileStorage;
+    // BufferRing-Enhanced Storage
+    historicalSnapshots;
+    toolCallEvents;
+    // Persistence throttling state for tool call events (defined explicitly to avoid dynamic props)
+    _lastToolPersist = 0;
+    _pendingToolPersist = 0;
+    performanceMetrics;
+    bufferConfig;
+    // Append/segment logging state (optional)
+    appendMode = false;
+    appendLogPath = null;
+    pendingAppendEvents = [];
+    lastAppendFlush = 0;
+    lastAppendCompact = 0;
+    appendChunkSize = 250;
+    appendFlushMs = 5000;
+    appendCompactMs = 5 * 60 * 1000; // 5 min default
+    constructor(options = {}) {
+        this.options = {
+            retentionMinutes: options.retentionMinutes ?? 60,
+            maxSnapshots: options.maxSnapshots ?? 720, // 12 hours at 1-minute intervals
+            collectInterval: options.collectInterval ?? 60000, // 1 minute
+        };
+        const metricsConfig = (0, runtimeConfig_1.getRuntimeConfig)().metrics;
+        // Initialize resource sampling buffer (default capacity ~1h at 5s interval = 720)
+        const resourceCapacity = Math.max(1, metricsConfig.resourceCapacity || 720);
+        this.resourceSamples = new BufferRing_js_1.BufferRing({
+            capacity: resourceCapacity,
+            overflowStrategy: BufferRing_js_1.OverflowStrategy.DROP_OLDEST,
+            autoPersist: false,
+            enableIntegrityCheck: false
+        });
+        try {
+            const intervalMs = Math.max(100, metricsConfig.sampleIntervalMs || 5000);
+            setInterval(() => this.sampleResources(), intervalMs).unref();
+        }
+        catch { /* ignore */ }
+        // Configure BufferRing settings
+        const metricsDir = metricsConfig.dir || path_1.default.join(process.cwd(), 'metrics');
+        this.bufferConfig = {
+            historicalSnapshots: {
+                capacity: this.options.maxSnapshots,
+                retentionMinutes: this.options.retentionMinutes * 12, // Keep 12x longer than original
+                persistenceFile: path_1.default.join(metricsDir, 'historical-snapshots.json')
+            },
+            toolCallEvents: {
+                capacity: 10000, // Store last 10k tool calls
+                retentionMinutes: this.options.retentionMinutes * 2, // 2 hours of tool calls
+                persistenceFile: path_1.default.join(metricsDir, 'tool-call-events.json')
+            },
+            performanceMetrics: {
+                capacity: 1440, // Store 24 hours worth of minute-by-minute metrics
+                persistenceFile: path_1.default.join(metricsDir, 'performance-metrics.json')
+            }
+        };
+        // Check if file storage should be enabled (accept "true", "1", "yes", "on")
+        this.useFileStorage = metricsConfig.fileStorage;
+        // Initialize BufferRing storage
+        this.historicalSnapshots = new BufferRing_js_1.BufferRing({
+            capacity: this.bufferConfig.historicalSnapshots.capacity,
+            overflowStrategy: BufferRing_js_1.OverflowStrategy.DROP_OLDEST,
+            persistPath: this.useFileStorage ? this.bufferConfig.historicalSnapshots.persistenceFile : undefined,
+            autoPersist: this.useFileStorage
+        });
+        this.toolCallEvents = new BufferRing_js_1.BufferRing({
+            capacity: this.bufferConfig.toolCallEvents.capacity,
+            overflowStrategy: BufferRing_js_1.OverflowStrategy.DROP_OLDEST,
+            persistPath: this.useFileStorage ? this.bufferConfig.toolCallEvents.persistenceFile : undefined,
+            autoPersist: false, // we'll manage chunked persistence manually for performance
+            suppressPersistLog: true
+        });
+        this.performanceMetrics = new BufferRing_js_1.BufferRing({
+            capacity: this.bufferConfig.performanceMetrics.capacity,
+            overflowStrategy: BufferRing_js_1.OverflowStrategy.DROP_OLDEST,
+            persistPath: this.useFileStorage ? this.bufferConfig.performanceMetrics.persistenceFile : undefined,
+            autoPersist: this.useFileStorage
+        });
+        // Configure optional append-only logging for tool call events (reduces large snapshot writes)
+        if (this.useFileStorage) {
+            this.appendMode = metricsConfig.toolcall.appendLogEnabled;
+            if (this.appendMode) {
+                this.appendLogPath = path_1.default.join(path_1.default.dirname(this.bufferConfig.toolCallEvents.persistenceFile), 'tool-call-events.ndjson');
+                this.appendChunkSize = Math.max(1, metricsConfig.toolcall.chunkSize || this.appendChunkSize);
+                this.appendFlushMs = Math.max(1, metricsConfig.toolcall.flushMs || this.appendFlushMs);
+                this.appendCompactMs = Math.max(1, metricsConfig.toolcall.compactMs || this.appendCompactMs);
+                try {
+                    // Load any un-compacted append log tail (best-effort)
+                    if (this.appendLogPath && fs_1.default.existsSync(this.appendLogPath)) {
+                        const stat = fs_1.default.statSync(this.appendLogPath);
+                        if (stat.size < 25 * 1024 * 1024) { // safety cap 25MB
+                            const raw = fs_1.default.readFileSync(this.appendLogPath, 'utf8');
+                            const lines = raw.split(/\r?\n/).filter(l => l.trim().length > 0);
+                            for (const line of lines) {
+                                try {
+                                    const evt = JSON.parse(line);
+                                    this.toolCallEvents.add(evt);
+                                }
+                                catch { /* ignore bad line */ }
+                            }
+                        }
+                        else {
+                            console.warn('tool-call-events.ndjson too large to preload (>25MB); will rely on last snapshot');
+                        }
+                    }
+                }
+                catch (err) {
+                    console.warn('Failed to preload append log', err);
+                }
+            }
+        }
+        if (this.useFileStorage) {
+            // Initialize legacy file storage for backward compatibility
+            this.fileStorage = (0, FileMetricsStorage_js_1.getFileMetricsStorage)({
+                storageDir: metricsDir,
+                maxFiles: this.options.maxSnapshots,
+                retentionMinutes: this.options.retentionMinutes,
+            });
+            console.error('📊 MetricsCollector: BufferRing + File storage enabled');
+        }
+        else {
+            console.error('📊 MetricsCollector: BufferRing memory-only mode (set INDEX_SERVER_METRICS_FILE_STORAGE=1|true|yes|on for persistence)');
+        }
+        // Start periodic collection
+        this.startCollection();
+    }
+    /**
+     * Record a tool call event
+     */
+    recordToolCall(toolName, success, responseTimeMs, errorType, clientId) {
+        const now = Date.now();
+        if (!this.tools.has(toolName)) {
+            this.tools.set(toolName, {
+                callCount: 0,
+                successCount: 0,
+                errorCount: 0,
+                totalResponseTime: 0,
+                errorTypes: {},
+            });
+        }
+        const metrics = this.tools.get(toolName);
+        metrics.callCount++;
+        metrics.totalResponseTime += responseTimeMs;
+        metrics.lastCalled = now;
+        if (success) {
+            metrics.successCount++;
+        }
+        else {
+            metrics.errorCount++;
+            if (errorType) {
+                metrics.errorTypes[errorType] = (metrics.errorTypes[errorType] || 0) + 1;
+            }
+        }
+        // Store detailed tool call event in BufferRing
+        this.toolCallEvents.add({
+            timestamp: now,
+            toolName,
+            success,
+            responseTimeMs,
+            errorType,
+            clientId
+        });
+        if (this.useFileStorage) {
+            if (this.appendMode) {
+                this.pendingAppendEvents.push({ timestamp: now, toolName, success, responseTimeMs, errorType, clientId });
+                this.flushToolCallEvents(false); // schedule conditional flush
+            }
+            else {
+                // legacy snapshot batching (retain previous throttling fields)
+                this._pendingToolPersist++;
+                const dueTime = now - this._lastToolPersist > this.appendFlushMs;
+                if (this._pendingToolPersist >= this.appendChunkSize || dueTime) {
+                    setTimeout(() => {
+                        this.toolCallEvents.saveToDisk().catch(() => { });
+                        this._lastToolPersist = Date.now();
+                        this._pendingToolPersist = 0;
+                    }, 0).unref?.();
+                }
+            }
+        }
+        // Track call timestamp for rolling RPM calculation (last 60s window)
+        this.recentCallTimestamps.push(now);
+        // Prune anything older than 5 minutes to constrain memory
+        const cutoff = now - 5 * 60 * 1000;
+        if (this.recentCallTimestamps.length > MetricsCollector.MAX_RECENT_CALLS || (this.recentCallTimestamps.length % 100) === 0) {
+            // Periodically prune (on every 100th push or when over cap)
+            let firstValidIdx = 0;
+            while (firstValidIdx < this.recentCallTimestamps.length && this.recentCallTimestamps[firstValidIdx] < cutoff)
+                firstValidIdx++;
+            if (firstValidIdx > 0)
+                this.recentCallTimestamps.splice(0, firstValidIdx);
+            // Hard cap safeguard
+            if (this.recentCallTimestamps.length > MetricsCollector.MAX_RECENT_CALLS) {
+                this.recentCallTimestamps.splice(0, this.recentCallTimestamps.length - MetricsCollector.MAX_RECENT_CALLS);
+            }
+        }
+        // Prevent unbounded tool metrics growth - cleanup old/unused tools after adding the new tool
+        if (this.tools.size > MetricsCollector.MAX_TOOL_METRICS) {
+            this.cleanupOldToolMetrics();
+        }
+    }
+    /** Flush tool call events (append or snapshot) */
+    flushToolCallEvents(force) {
+        if (!this.useFileStorage)
+            return;
+        const now = Date.now();
+        if (this.appendMode) {
+            const timeDue = (now - this.lastAppendFlush) >= this.appendFlushMs;
+            if (!force && this.pendingAppendEvents.length < this.appendChunkSize && !timeDue)
+                return;
+            if (!this.appendLogPath || this.pendingAppendEvents.length === 0)
+                return;
+            const toWrite = this.pendingAppendEvents.splice(0, this.pendingAppendEvents.length);
+            const lines = toWrite.map(e => JSON.stringify(e)).join('\n') + '\n';
+            fs_1.default.promises.appendFile(this.appendLogPath, lines).catch(() => { });
+            this.lastAppendFlush = now;
+            // Periodic compaction: write full snapshot & truncate log
+            if ((now - this.lastAppendCompact) >= this.appendCompactMs || force) {
+                this.toolCallEvents.saveToDisk().catch(() => { });
+                this.lastAppendCompact = now;
+                if (this.appendLogPath) {
+                    fs_1.default.promises.writeFile(this.appendLogPath, '').catch(() => { }); // truncate
+                }
+            }
+        }
+        else {
+            // snapshot mode manual force
+            if (force) {
+                this.toolCallEvents.saveToDisk().catch(() => { });
+                this._lastToolPersist = now;
+                this._pendingToolPersist = 0;
+            }
+        }
+    }
+    /**
+     * Record client connection
+     */
+    recordConnection(clientId) {
+        this.connections.add(clientId);
+        this.sessionStartTimes.set(clientId, Date.now());
+    }
+    /**
+     * Record client disconnection
+     */
+    recordDisconnection(clientId) {
+        if (this.connections.has(clientId)) {
+            this.connections.delete(clientId);
+            this.disconnectedCount++;
+            const sessionStart = this.sessionStartTimes.get(clientId);
+            if (sessionStart) {
+                this.totalSessionTime += Date.now() - sessionStart;
+                this.sessionStartTimes.delete(clientId);
+            }
+        }
+    }
+    /**
+     * Get current metrics snapshot
+     */
+    getCurrentSnapshot() {
+        const now = Date.now();
+        const uptime = now - this.startTime;
+        // Calculate performance metrics
+        const totalCalls = Array.from(this.tools.values()).reduce((sum, tool) => sum + tool.callCount, 0);
+        const totalSuccesses = Array.from(this.tools.values()).reduce((sum, tool) => sum + tool.successCount, 0);
+        const totalErrors = Array.from(this.tools.values()).reduce((sum, tool) => sum + tool.errorCount, 0);
+        const totalResponseTime = Array.from(this.tools.values()).reduce((sum, tool) => sum + tool.totalResponseTime, 0);
+        // Stable rolling Requests Per Minute based on last 60s calls (not lifetime average)
+        const oneMinuteCutoff = now - 60 * 1000;
+        let recentCount = 0;
+        // Iterate from end backwards until we exit window (timestamps are append-only & ascending)
+        for (let i = this.recentCallTimestamps.length - 1; i >= 0; i--) {
+            const ts = this.recentCallTimestamps[i];
+            if (ts >= oneMinuteCutoff)
+                recentCount++;
+            else
+                break;
+        }
+        const requestsPerMinute = recentCount;
+        const successRate = totalCalls > 0 ? (totalSuccesses / totalCalls) * 100 : 100;
+        const avgResponseTime = totalCalls > 0 ? (totalResponseTime / totalCalls) : 0;
+        const errorRate = totalCalls > 0 ? (totalErrors / totalCalls) * 100 : 0;
+        // Calculate average session duration
+        const activeSessionTime = Array.from(this.sessionStartTimes.values())
+            .reduce((sum, startTime) => sum + (now - startTime), 0);
+        const totalSessions = this.disconnectedCount + this.connections.size;
+        const avgSessionDuration = totalSessions > 0
+            ? (this.totalSessionTime + activeSessionTime) / totalSessions
+            : 0;
+        // Get CPU usage (if available)
+        let cpuUsage;
+        try {
+            cpuUsage = process.cpuUsage(this.lastCpuUsage);
+            this.lastCpuUsage = process.cpuUsage();
+        }
+        catch {
+            // CPU usage not available on all platforms
+        }
+        const memUsage = process.memoryUsage();
+        let heapLimit;
+        try {
+            heapLimit = v8_1.default.getHeapStatistics().heap_size_limit;
+        }
+        catch { /* v8 not available */ }
+        return {
+            timestamp: now,
+            server: {
+                uptime,
+                version: this.getVersion(),
+                memoryUsage: { ...memUsage, ...(heapLimit ? { heapLimit } : {}) },
+                cpuUsage,
+                startTime: this.startTime,
+            },
+            tools: Object.fromEntries(this.tools.entries()),
+            connections: {
+                activeConnections: this.connections.size,
+                totalConnections: this.disconnectedCount + this.connections.size,
+                disconnectedConnections: this.disconnectedCount,
+                avgSessionDuration,
+            },
+            performance: {
+                requestsPerMinute,
+                successRate,
+                avgResponseTime,
+                errorRate,
+            },
+        };
+    }
+    /**
+     * Get historical snapshots (from memory for recent, or from files for historical)
+     */
+    getSnapshots(count) {
+        if (count) {
+            return this.snapshots.slice(-count);
+        }
+        return [...this.snapshots];
+    }
+    /**
+     * Get snapshots from file storage (for historical analysis)
+     */
+    async getHistoricalSnapshots(count = 720) {
+        if (!this.fileStorage) {
+            console.warn('File storage not enabled, returning memory snapshots only');
+            return this.getSnapshots(count);
+        }
+        try {
+            return await this.fileStorage.getRecentSnapshots(count);
+        }
+        catch (error) {
+            console.error('Failed to load historical snapshots:', error);
+            return [];
+        }
+    }
+    /**
+     * Get snapshots within a specific time range from files
+     */
+    async getSnapshotsInRange(startTime, endTime) {
+        if (!this.fileStorage) {
+            console.warn('File storage not enabled, filtering memory snapshots');
+            return this.snapshots.filter(s => s.timestamp >= startTime && s.timestamp <= endTime);
+        }
+        try {
+            return await this.fileStorage.getSnapshotsInRange(startTime, endTime);
+        }
+        catch (error) {
+            console.error('Failed to load snapshots in range:', error);
+            return [];
+        }
+    }
+    /**
+     * Get file storage statistics
+     */
+    async getStorageStats() {
+        if (!this.fileStorage) {
+            return {
+                fileCount: 0,
+                totalSizeKB: 0,
+                memorySnapshots: this.snapshots.length,
+            };
+        }
+        const fileStats = await this.fileStorage.getStorageStats();
+        return {
+            ...fileStats,
+            memorySnapshots: this.snapshots.length,
+        };
+    }
+    /**
+     * Get tool-specific metrics
+     */
+    getToolMetrics(toolName) {
+        if (toolName) {
+            return this.tools.get(toolName) || null;
+        }
+        return Object.fromEntries(this.tools.entries());
+    }
+    /**
+     * Clear all metrics data (memory and files)
+     */
+    async clearMetrics() {
+        // Clear in-memory data
+        this.tools.clear();
+        this.snapshots.length = 0;
+        this.connections.clear();
+        this.disconnectedCount = 0;
+        this.totalSessionTime = 0;
+        this.sessionStartTimes.clear();
+        this.startTime = Date.now();
+        this.recentCallTimestamps.length = 0;
+        // Clear file storage if enabled
+        if (this.fileStorage) {
+            try {
+                await this.fileStorage.clearAll();
+            }
+            catch (error) {
+                console.error('Failed to clear file storage:', error);
+            }
+        }
+    }
+    /**
+     * Clear only memory data (keep files)
+     */
+    clearMemoryMetrics() {
+        this.tools.clear();
+        this.snapshots.length = 0;
+        this.connections.clear();
+        this.disconnectedCount = 0;
+        this.totalSessionTime = 0;
+        this.sessionStartTimes.clear();
+        this.startTime = Date.now();
+        this.recentCallTimestamps.length = 0;
+    }
+    /**
+     * Stop metrics collection
+     */
+    stop() {
+        if (this.collectTimer) {
+            clearInterval(this.collectTimer);
+            this.collectTimer = undefined;
+        }
+    }
+    startCollection() {
+        // Take initial snapshot
+        this.takeSnapshot();
+        // Schedule periodic snapshots
+        this.collectTimer = setInterval(() => {
+            this.takeSnapshot();
+        }, this.options.collectInterval);
+    }
+    takeSnapshot() {
+        const snapshot = this.getCurrentSnapshot();
+        // Store enhanced snapshot in BufferRing with performance data
+        const timeSeriesEntry = {
+            timestamp: snapshot.timestamp,
+            snapshot,
+            performanceData: {
+                responseTimeMs: snapshot.performance.avgResponseTime,
+                requestCount: Array.from(this.tools.values()).reduce((sum, tool) => sum + tool.callCount, 0),
+                errorCount: Array.from(this.tools.values()).reduce((sum, tool) => sum + tool.errorCount, 0),
+                connectionCount: snapshot.connections.activeConnections
+            }
+        };
+        this.historicalSnapshots.add(timeSeriesEntry);
+        // Store performance metrics for charting
+        this.performanceMetrics.add({
+            timestamp: snapshot.timestamp,
+            responseTime: snapshot.performance.avgResponseTime,
+            throughput: snapshot.performance.requestsPerMinute,
+            errorRate: snapshot.performance.errorRate
+        });
+        // Store to file immediately (async, non-blocking) if file storage enabled
+        if (this.fileStorage) {
+            this.fileStorage.storeSnapshot(snapshot).catch(error => {
+                console.error('Failed to store metrics snapshot to file:', error);
+            });
+        }
+        // Keep limited snapshots in memory for real-time queries
+        this.snapshots.push(snapshot);
+        // Trim in-memory snapshots to prevent memory accumulation
+        const maxMemorySnapshots = this.useFileStorage
+            ? MetricsCollector.MAX_MEMORY_SNAPSHOTS
+            : this.options.maxSnapshots;
+        if (this.snapshots.length > maxMemorySnapshots) {
+            this.snapshots.splice(0, this.snapshots.length - maxMemorySnapshots);
+        }
+        // If not using file storage, apply original retention logic
+        if (!this.useFileStorage) {
+            const cutoff = Date.now() - (this.options.retentionMinutes * 60 * 1000);
+            const firstValidIndex = this.snapshots.findIndex(s => s.timestamp >= cutoff);
+            if (firstValidIndex > 0) {
+                this.snapshots.splice(0, firstValidIndex);
+            }
+        }
+        // Periodically cleanup tool metrics (every 10 snapshots, ~10 minutes)
+        if (this.snapshots.length % 10 === 0) {
+            this.cleanupOldToolMetrics();
+        }
+    }
+    getVersion() {
+        try {
+            const candidates = [
+                path_1.default.join(process.cwd(), 'package.json'),
+                path_1.default.join(__dirname, '..', '..', '..', 'package.json')
+            ];
+            for (const candidate of candidates) {
+                if (fs_1.default.existsSync(candidate)) {
+                    const pkg = JSON.parse(fs_1.default.readFileSync(candidate, 'utf8'));
+                    if (pkg?.version)
+                        return pkg.version;
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return '0.0.0';
+    }
+    // ====== Phase 3: Real-time Chart Data Methods ======
+    getRealtimeMetrics() {
+        return (0, metricsSerializer_js_1.buildRealtimeMetrics)(this.getCurrentSnapshot(), this.tools);
+    }
+    getToolUsageChartData(minutes = 60) {
+        return (0, metricsSerializer_js_1.buildToolUsageChartData)(this.snapshots, minutes);
+    }
+    getPerformanceChartData(minutes = 60) {
+        return (0, metricsSerializer_js_1.buildPerformanceChartData)(this.snapshots, minutes);
+    }
+    getTimeRangeMetrics(range) {
+        const rangeMinutes = { '1h': 60, '6h': 360, '24h': 1440, '7d': 10080, '30d': 43200 };
+        const cutoff = Date.now() - rangeMinutes[range] * 60_000;
+        return this.snapshots.filter(s => s.timestamp >= cutoff);
+    }
+    // ====== Phase 4: Advanced Real-time & Analytics Methods ======
+    getRealtimeStreamingData() {
+        const recentSnaps10 = this.snapshots.slice(-10);
+        const latency = recentSnaps10.length > 0
+            ? recentSnaps10.reduce((s, snap) => s + snap.performance.avgResponseTime, 0) / recentSnaps10.length
+            : 0;
+        return {
+            timestamp: Date.now(),
+            systemHealth: this.getSystemHealth(),
+            performanceMetrics: this.getDetailedPerformanceMetrics(),
+            recentActivity: (0, metricsSerializer_js_1.buildRecentActivity)(this.tools),
+            streamingStats: {
+                totalStreamingConnections: this.activeConnections,
+                dataTransferRate: this.connections.size * 0.1 + Math.random() * 0.5,
+                latency,
+                compressionRatio: 0.7,
+            },
+        };
+    }
+    getSystemHealth() {
+        const cpu = (0, metricsAggregation_js_1.estimateCPUUsage)(this.snapshots.slice(-5));
+        const memory = (0, metricsAggregation_js_1.estimateMemoryUsage)(this.connections.size, this.snapshots.length);
+        return {
+            cpuUsage: cpu,
+            memoryUsage: memory,
+            diskUsage: (0, metricsAggregation_js_1.estimateDiskUsage)(this.snapshots.length),
+            networkLatency: (0, metricsAggregation_js_1.getAverageResponseTime)(this.tools),
+            uptime: Date.now() - this.startTime,
+            lastHealthCheck: new Date(),
+            status: (0, metricsAggregation_js_1.getOverallHealthStatus)(cpu, memory, (0, metricsAggregation_js_1.getErrorRate)(this.tools)),
+        };
+    }
+    getDetailedPerformanceMetrics() {
+        const totalRequests = (0, metricsAggregation_js_1.getTotalRequests)(this.tools);
+        const avg = (0, metricsAggregation_js_1.getAverageResponseTime)(this.tools);
+        const rps = (0, metricsAggregation_js_1.calculateRequestsPerSecond)(this.snapshots);
+        return {
+            requestThroughput: rps * 60,
+            averageResponseTime: avg,
+            p95ResponseTime: (0, metricsAggregation_js_1.calculatePercentileFromAvg)(avg, 95),
+            p99ResponseTime: (0, metricsAggregation_js_1.calculatePercentileFromAvg)(avg, 99),
+            errorRate: (0, metricsAggregation_js_1.getErrorRate)(this.tools),
+            concurrentConnections: this.activeConnections,
+            totalRequests,
+            successfulRequests: totalRequests - (0, metricsAggregation_js_1.getTotalErrors)(this.tools),
+            requestsPerSecond: rps,
+            bytesTransferred: totalRequests * 1024 * 2,
+        };
+    }
+    getAdvancedAnalytics(timeRange = '1h') {
+        return (0, metricsSerializer_js_1.buildAdvancedAnalytics)(timeRange, this.snapshots, this.tools, (0, metricsAggregation_js_1.getErrorRate)(this.tools), (0, metricsAggregation_js_1.detectAnomalies)(this.snapshots.slice(-20)));
+    }
+    /**
+     * Generate real-time alert
+     */
+    generateRealTimeAlert(type, severity, message, value, threshold) {
+        const alert = {
+            id: `alert_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            type: type,
+            severity: severity,
+            message,
+            timestamp: new Date(),
+            resolved: false,
+            value,
+            threshold,
+            source: 'MetricsCollector',
+            category: (0, metricsAggregation_js_1.categorizeAlert)(type)
+        };
+        this.recentAlerts.unshift(alert);
+        if (this.recentAlerts.length > 100) {
+            this.recentAlerts = this.recentAlerts.slice(0, 100);
+        }
+        return alert;
+    }
+    /**
+     * Get active alerts
+     */
+    getActiveAlerts() {
+        return this.recentAlerts.filter(alert => !alert.resolved);
+    }
+    /**
+     * Resolve alert by ID
+     */
+    resolveAlert(alertId) {
+        const alert = this.recentAlerts.find(a => a.id === alertId);
+        if (alert) {
+            alert.resolved = true;
+            alert.resolvedAt = new Date();
+            return true;
+        }
+        return false;
+    }
+    // ===== Resource Sampling / Leak Detection =====
+    sampleResources() {
+        try {
+            const now = Date.now();
+            const mem = process.memoryUsage();
+            let cpuPercent = 0;
+            const curr = process.cpuUsage();
+            if (this.lastCpuUsageSample && this.lastCpuSampleTime) {
+                const userDiff = curr.user - this.lastCpuUsageSample.user; // microseconds
+                const systemDiff = curr.system - this.lastCpuUsageSample.system;
+                const elapsedMs = now - this.lastCpuSampleTime;
+                if (elapsedMs > 0) {
+                    // total diff in microseconds / (elapsedMs * 1000) gives fraction of single core; *100 -> percent
+                    cpuPercent = ((userDiff + systemDiff) / 1000) / elapsedMs * 100;
+                    // Clamp 0-100 (single process perspective)
+                    if (cpuPercent < 0)
+                        cpuPercent = 0;
+                    else if (cpuPercent > 100)
+                        cpuPercent = 100;
+                }
+            }
+            this.lastCpuUsageSample = curr;
+            this.lastCpuSampleTime = now;
+            this.resourceSamples.add({ timestamp: now, cpuPercent, heapUsed: mem.heapUsed, rss: mem.rss });
+        }
+        catch { /* ignore sampling errors */ }
+    }
+    getResourceHistory(limit = 200) {
+        const all = this.resourceSamples.getAll();
+        const samples = limit > 0 ? all.slice(-limit) : all;
+        const trend = (0, metricsAggregation_js_1.calculateLinearSlopes)(samples);
+        return { samples, trend };
+    }
+    /** Remove stale / low-activity tool entries to prevent unbounded map growth. */
+    cleanupOldToolMetrics() {
+        const staleThreshold = Date.now() - 3_600_000; // 1 hour
+        const toRemove = (0, metricsAggregation_js_1.computeToolsToCleanup)(this.tools, MetricsCollector.MAX_TOOL_METRICS, staleThreshold);
+        let removedCount = 0;
+        for (const name of toRemove) {
+            if (this.tools.delete(name))
+                removedCount++;
+        }
+        if (removedCount > 0) {
+            console.log(`🧹 MetricsCollector: Cleaned up ${removedCount} stale tool metrics (${this.tools.size} remaining)`);
+        }
+    }
+    // ====== BufferRing-Enhanced Methods ======
+    /**
+     * Get historical metrics data for charting
+     */
+    getHistoricalMetrics(minutes = 60) {
+        const cutoff = Date.now() - (minutes * 60 * 1000);
+        return this.historicalSnapshots.filter(entry => entry.timestamp >= cutoff);
+    }
+    /**
+     * Get recent tool call events for analysis
+     */
+    getRecentToolCallEvents(minutes = 30) {
+        const cutoff = Date.now() - (minutes * 60 * 1000);
+        return this.toolCallEvents.filter(event => event.timestamp >= cutoff);
+    }
+    /**
+     * Get performance metrics time series for dashboard charts (BufferRing-enhanced)
+     */
+    getPerformanceTimeSeriesData(minutes = 60) {
+        return (0, metricsSerializer_js_1.buildPerformanceTimeSeriesData)(this.performanceMetrics.getAll(), minutes);
+    }
+    /**
+     * Get tool usage analytics from historical data
+     */
+    getToolUsageAnalytics(minutes = 60) {
+        return (0, metricsSerializer_js_1.buildToolUsageAnalytics)(this.toolCallEvents.getAll(), minutes);
+    }
+    /**
+     * Get BufferRing statistics for monitoring
+     */
+    getBufferRingStats() {
+        return {
+            historicalSnapshots: this.historicalSnapshots.getStats(),
+            toolCallEvents: this.toolCallEvents.getStats(),
+            performanceMetrics: this.performanceMetrics.getStats()
+        };
+    }
+    /**
+     * Export metrics data for backup/analysis
+     */
+    exportMetricsData(options = {}) {
+        const data = {
+            timestamp: Date.now(),
+            currentSnapshot: this.getCurrentSnapshot(),
+            bufferStats: this.getBufferRingStats()
+        };
+        const result = data;
+        if (options.includeHistorical !== false) {
+            result.historicalSnapshots = this.historicalSnapshots.getAll();
+        }
+        if (options.includeEvents !== false) {
+            result.toolCallEvents = this.toolCallEvents.getAll();
+        }
+        if (options.includePerformance !== false) {
+            result.performanceMetrics = this.performanceMetrics.getAll();
+        }
+        return result;
+    }
+    /**
+     * Clear all BufferRing data (for maintenance)
+     */
+    clearBufferedData() {
+        this.historicalSnapshots.clear();
+        this.toolCallEvents.clear();
+        this.performanceMetrics.clear();
+        console.error('📊 MetricsCollector: Cleared all BufferRing data');
+    }
+}
+exports.MetricsCollector = MetricsCollector;
+// Global singleton instance
+let globalCollector = null;
+/**
+ * Get or create the global metrics collector instance
+ */
+function getMetricsCollector() {
+    if (!globalCollector) {
+        globalCollector = new MetricsCollector();
+    }
+    return globalCollector;
+}
+/**
+ * Set a custom metrics collector instance (useful for testing)
+ */
+function setMetricsCollector(collector) {
+    globalCollector = collector;
+}
+// (No changes needed in this file for the current UI fixes)