@push.rocks/smartproxy 19.6.6 → 19.6.8

package/dist_ts/proxies/smart-proxy/metrics-collector.js

@@ -1,211 +1,283 @@
 import * as plugins from '../../plugins.js';
+import { ThroughputTracker } from './throughput-tracker.js';
 import { logger } from '../../core/utils/logger.js';
 /**
- * Collects and computes metrics for SmartProxy on-demand
+ * Collects and provides metrics for SmartProxy with clean API
  */
 export class MetricsCollector {
-    constructor(smartProxy) {
+    constructor(smartProxy, config) {
         this.smartProxy = smartProxy;
-        // RPS tracking (the only state we need to maintain)
+        // Request tracking
         this.requestTimestamps = [];
-        this.RPS_WINDOW_SIZE = 60000; // 1 minute window
-        this.MAX_TIMESTAMPS = 5000; // Maximum timestamps to keep
-        // Optional caching for performance
-        this.cachedMetrics = { timestamp: 0 };
-        this.CACHE_TTL = 1000; // 1 second cache
-        // Subscription will be set up in start() method
-    }
-    /**
-     * Get the current number of active connections
-     */
-    getActiveConnections() {
-        return this.smartProxy.connectionManager.getConnectionCount();
-    }
-    /**
-     * Get connection counts grouped by route name
-     */
-    getConnectionsByRoute() {
-        const now = Date.now();
-        // Return cached value if fresh
-        if (this.cachedMetrics.connectionsByRoute &&
-            now - this.cachedMetrics.timestamp < this.CACHE_TTL) {
-            return new Map(this.cachedMetrics.connectionsByRoute);
-        }
-        // Compute fresh value
-        const routeCounts = new Map();
-        const connections = this.smartProxy.connectionManager.getConnections();
-        if (this.smartProxy.settings?.enableDetailedLogging) {
-            logger.log('debug', `MetricsCollector: Computing route connections`, {
-                totalConnections: connections.size,
-                component: 'metrics'
-            });
-        }
-        for (const [_, record] of connections) {
-            // Try different ways to get the route name
-            const routeName = record.routeName ||
-                record.routeConfig?.name ||
-                record.routeConfig?.routeName ||
-                'unknown';
-            if (this.smartProxy.settings?.enableDetailedLogging) {
-                logger.log('debug', `MetricsCollector: Connection route info`, {
-                    connectionId: record.id,
-                    routeName,
-                    hasRouteConfig: !!record.routeConfig,
-                    routeConfigName: record.routeConfig?.name,
-                    routeConfigKeys: record.routeConfig ? Object.keys(record.routeConfig) : [],
-                    component: 'metrics'
-                });
+        this.totalRequests = 0;
+        // Connection byte tracking for per-route/IP metrics
+        this.connectionByteTrackers = new Map();
+        // Connection metrics implementation
+        this.connections = {
+            active: () => {
+                return this.smartProxy.connectionManager.getConnectionCount();
+            },
+            total: () => {
+                const stats = this.smartProxy.connectionManager.getTerminationStats();
+                let total = this.smartProxy.connectionManager.getConnectionCount();
+                for (const reason in stats.incoming) {
+                    total += stats.incoming[reason];
+                }
+                return total;
+            },
+            byRoute: () => {
+                const routeCounts = new Map();
+                const connections = this.smartProxy.connectionManager.getConnections();
+                for (const [_, record] of connections) {
+                    const routeName = record.routeName ||
+                        record.routeConfig?.name ||
+                        'unknown';
+                    const current = routeCounts.get(routeName) || 0;
+                    routeCounts.set(routeName, current + 1);
+                }
+                return routeCounts;
+            },
+            byIP: () => {
+                const ipCounts = new Map();
+                for (const [_, record] of this.smartProxy.connectionManager.getConnections()) {
+                    const ip = record.remoteIP;
+                    const current = ipCounts.get(ip) || 0;
+                    ipCounts.set(ip, current + 1);
+                }
+                return ipCounts;
+            },
+            topIPs: (limit = 10) => {
+                const ipCounts = this.connections.byIP();
+                return Array.from(ipCounts.entries())
+                    .sort((a, b) => b[1] - a[1])
+                    .slice(0, limit)
+                    .map(([ip, count]) => ({ ip, count }));
             }
-            const current = routeCounts.get(routeName) || 0;
-            routeCounts.set(routeName, current + 1);
-        }
-        // Cache and return
-        this.cachedMetrics.connectionsByRoute = routeCounts;
-        this.cachedMetrics.timestamp = now;
-        return new Map(routeCounts);
-    }
-    /**
-     * Get connection counts grouped by IP address
-     */
-    getConnectionsByIP() {
-        const now = Date.now();
-        // Return cached value if fresh
-        if (this.cachedMetrics.connectionsByIP &&
-            now - this.cachedMetrics.timestamp < this.CACHE_TTL) {
-            return new Map(this.cachedMetrics.connectionsByIP);
-        }
-        // Compute fresh value
-        const ipCounts = new Map();
-        for (const [_, record] of this.smartProxy.connectionManager.getConnections()) {
-            const ip = record.remoteIP;
-            const current = ipCounts.get(ip) || 0;
-            ipCounts.set(ip, current + 1);
-        }
-        // Cache and return
-        this.cachedMetrics.connectionsByIP = ipCounts;
-        this.cachedMetrics.timestamp = now;
-        return new Map(ipCounts);
-    }
-    /**
-     * Get the total number of connections since proxy start
-     */
-    getTotalConnections() {
-        // Get from termination stats
-        const stats = this.smartProxy.connectionManager.getTerminationStats();
-        let total = this.smartProxy.connectionManager.getConnectionCount(); // Add active connections
-        // Add all terminated connections
-        for (const reason in stats.incoming) {
-            total += stats.incoming[reason];
-        }
-        return total;
-    }
-    /**
-     * Get the current requests per second rate
-     */
-    getRequestsPerSecond() {
-        const now = Date.now();
-        const windowStart = now - this.RPS_WINDOW_SIZE;
-        // Clean old timestamps
-        this.requestTimestamps = this.requestTimestamps.filter(ts => ts > windowStart);
-        // Calculate RPS based on window
-        const requestsInWindow = this.requestTimestamps.length;
-        return requestsInWindow / (this.RPS_WINDOW_SIZE / 1000);
+        };
+        // Throughput metrics implementation
+        this.throughput = {
+            instant: () => {
+                return this.throughputTracker.getRate(1);
+            },
+            recent: () => {
+                return this.throughputTracker.getRate(10);
+            },
+            average: () => {
+                return this.throughputTracker.getRate(60);
+            },
+            custom: (seconds) => {
+                return this.throughputTracker.getRate(seconds);
+            },
+            history: (seconds) => {
+                return this.throughputTracker.getHistory(seconds);
+            },
+            byRoute: (windowSeconds = 60) => {
+                const routeThroughput = new Map();
+                const now = Date.now();
+                const windowStart = now - (windowSeconds * 1000);
+                // Aggregate bytes by route with proper time calculation
+                const routeData = new Map();
+                for (const [_, tracker] of this.connectionByteTrackers) {
+                    // Only include connections that were active within the window
+                    if (tracker.lastUpdate > windowStart || tracker.startTime > windowStart) {
+                        // Calculate the actual duration this connection was active within the window
+                        const connectionStart = Math.max(tracker.startTime, windowStart);
+                        const connectionEnd = tracker.lastUpdate;
+                        const durationInWindow = (connectionEnd - connectionStart) / 1000; // Convert to seconds
+                        if (durationInWindow > 0) {
+                            const current = routeData.get(tracker.routeName) || { bytesIn: 0, bytesOut: 0, totalDuration: 0 };
+                            current.bytesIn += tracker.bytesIn;
+                            current.bytesOut += tracker.bytesOut;
+                            current.totalDuration += durationInWindow;
+                            routeData.set(tracker.routeName, current);
+                        }
+                    }
+                }
+                // Convert to rates (bytes per second)
+                for (const [route, data] of routeData) {
+                    if (data.totalDuration > 0) {
+                        routeThroughput.set(route, {
+                            in: Math.round(data.bytesIn / data.totalDuration),
+                            out: Math.round(data.bytesOut / data.totalDuration)
+                        });
+                    }
+                }
+                return routeThroughput;
+            },
+            byIP: (windowSeconds = 60) => {
+                const ipThroughput = new Map();
+                const now = Date.now();
+                const windowStart = now - (windowSeconds * 1000);
+                // Aggregate bytes by IP with proper time calculation
+                const ipData = new Map();
+                for (const [_, tracker] of this.connectionByteTrackers) {
+                    // Only include connections that were active within the window
+                    if (tracker.lastUpdate > windowStart || tracker.startTime > windowStart) {
+                        // Calculate the actual duration this connection was active within the window
+                        const connectionStart = Math.max(tracker.startTime, windowStart);
+                        const connectionEnd = tracker.lastUpdate;
+                        const durationInWindow = (connectionEnd - connectionStart) / 1000; // Convert to seconds
+                        if (durationInWindow > 0) {
+                            const current = ipData.get(tracker.remoteIP) || { bytesIn: 0, bytesOut: 0, totalDuration: 0 };
+                            current.bytesIn += tracker.bytesIn;
+                            current.bytesOut += tracker.bytesOut;
+                            current.totalDuration += durationInWindow;
+                            ipData.set(tracker.remoteIP, current);
+                        }
+                    }
+                }
+                // Convert to rates (bytes per second)
+                for (const [ip, data] of ipData) {
+                    if (data.totalDuration > 0) {
+                        ipThroughput.set(ip, {
+                            in: Math.round(data.bytesIn / data.totalDuration),
+                            out: Math.round(data.bytesOut / data.totalDuration)
+                        });
+                    }
+                }
+                return ipThroughput;
+            }
+        };
+        // Request metrics implementation
+        this.requests = {
+            perSecond: () => {
+                const now = Date.now();
+                const oneSecondAgo = now - 1000;
+                // Clean old timestamps
+                this.requestTimestamps = this.requestTimestamps.filter(ts => ts > now - 60000);
+                // Count requests in last second
+                const recentRequests = this.requestTimestamps.filter(ts => ts > oneSecondAgo);
+                return recentRequests.length;
+            },
+            perMinute: () => {
+                const now = Date.now();
+                const oneMinuteAgo = now - 60000;
+                // Count requests in last minute
+                const recentRequests = this.requestTimestamps.filter(ts => ts > oneMinuteAgo);
+                return recentRequests.length;
+            },
+            total: () => {
+                return this.totalRequests;
+            }
+        };
+        // Totals implementation
+        this.totals = {
+            bytesIn: () => {
+                let total = 0;
+                // Sum from all active connections
+                for (const [_, record] of this.smartProxy.connectionManager.getConnections()) {
+                    total += record.bytesReceived;
+                }
+                // TODO: Add historical data from terminated connections
+                return total;
+            },
+            bytesOut: () => {
+                let total = 0;
+                // Sum from all active connections
+                for (const [_, record] of this.smartProxy.connectionManager.getConnections()) {
+                    total += record.bytesSent;
+                }
+                // TODO: Add historical data from terminated connections
+                return total;
+            },
+            connections: () => {
+                return this.connections.total();
+            }
+        };
+        // Percentiles implementation (placeholder for now)
+        this.percentiles = {
+            connectionDuration: () => {
+                // TODO: Implement percentile calculations
+                return { p50: 0, p95: 0, p99: 0 };
+            },
+            bytesTransferred: () => {
+                // TODO: Implement percentile calculations
+                return {
+                    in: { p50: 0, p95: 0, p99: 0 },
+                    out: { p50: 0, p95: 0, p99: 0 }
+                };
+            }
+        };
+        this.sampleIntervalMs = config?.sampleIntervalMs || 1000;
+        this.retentionSeconds = config?.retentionSeconds || 3600;
+        this.throughputTracker = new ThroughputTracker(this.retentionSeconds);
     }
     /**
-     * Record a new request for RPS tracking
+     * Record a new request
      */
-    recordRequest() {
+    recordRequest(connectionId, routeName, remoteIP) {
         const now = Date.now();
         this.requestTimestamps.push(now);
-        // Prevent unbounded growth - clean up more aggressively
-        if (this.requestTimestamps.length > this.MAX_TIMESTAMPS) {
-            // Keep only timestamps within the window
-            const cutoff = now - this.RPS_WINDOW_SIZE;
+        this.totalRequests++;
+        // Initialize byte tracker for this connection
+        this.connectionByteTrackers.set(connectionId, {
+            connectionId,
+            routeName,
+            remoteIP,
+            bytesIn: 0,
+            bytesOut: 0,
+            startTime: now,
+            lastUpdate: now
+        });
+        // Cleanup old request timestamps
+        if (this.requestTimestamps.length > 5000) {
+            // First try to clean up old timestamps (older than 1 minute)
+            const cutoff = now - 60000;
             this.requestTimestamps = this.requestTimestamps.filter(ts => ts > cutoff);
-        }
-    }
-    /**
-     * Get total throughput (bytes transferred)
-     */
-    getThroughput() {
-        let bytesIn = 0;
-        let bytesOut = 0;
-        // Sum bytes from all active connections
-        for (const [_, record] of this.smartProxy.connectionManager.getConnections()) {
-            bytesIn += record.bytesReceived;
-            bytesOut += record.bytesSent;
-        }
-        return { bytesIn, bytesOut };
-    }
-    /**
-     * Get throughput rate (bytes per second) for last minute
-     */
-    getThroughputRate() {
-        const now = Date.now();
-        let recentBytesIn = 0;
-        let recentBytesOut = 0;
-        // Calculate bytes transferred in last minute from active connections
-        for (const [_, record] of this.smartProxy.connectionManager.getConnections()) {
-            const connectionAge = now - record.incomingStartTime;
-            if (connectionAge < 60000) { // Connection started within last minute
-                recentBytesIn += record.bytesReceived;
-                recentBytesOut += record.bytesSent;
-            }
-            else {
-                // For older connections, estimate rate based on average
-                const rate = connectionAge / 60000;
-                recentBytesIn += record.bytesReceived / rate;
-                recentBytesOut += record.bytesSent / rate;
+            // If still too many, enforce hard cap of 5000 most recent
+            if (this.requestTimestamps.length > 5000) {
+                this.requestTimestamps = this.requestTimestamps.slice(-5000);
             }
         }
-        return {
-            bytesInPerSec: Math.round(recentBytesIn / 60),
-            bytesOutPerSec: Math.round(recentBytesOut / 60)
-        };
-    }
-    /**
-     * Get top IPs by connection count
-     */
-    getTopIPs(limit = 10) {
-        const ipCounts = this.getConnectionsByIP();
-        const sorted = Array.from(ipCounts.entries())
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, limit)
-            .map(([ip, connections]) => ({ ip, connections }));
-        return sorted;
     }
     /**
-     * Check if an IP has reached the connection limit
+     * Record bytes transferred for a connection
      */
-    isIPBlocked(ip, maxConnectionsPerIP) {
-        const ipCounts = this.getConnectionsByIP();
-        const currentConnections = ipCounts.get(ip) || 0;
-        return currentConnections >= maxConnectionsPerIP;
+    recordBytes(connectionId, bytesIn, bytesOut) {
+        // Update global throughput tracker
+        this.throughputTracker.recordBytes(bytesIn, bytesOut);
+        // Update connection-specific tracker
+        const tracker = this.connectionByteTrackers.get(connectionId);
+        if (tracker) {
+            tracker.bytesIn += bytesIn;
+            tracker.bytesOut += bytesOut;
+            tracker.lastUpdate = Date.now();
+        }
     }
     /**
-     * Clean up old request timestamps
+     * Clean up tracking for a closed connection
      */
-    cleanupOldRequests() {
-        const cutoff = Date.now() - this.RPS_WINDOW_SIZE;
-        this.requestTimestamps = this.requestTimestamps.filter(ts => ts > cutoff);
+    removeConnection(connectionId) {
+        this.connectionByteTrackers.delete(connectionId);
     }
     /**
-     * Start the metrics collector and set up subscriptions
+     * Start the metrics collector
      */
     start() {
         if (!this.smartProxy.routeConnectionHandler) {
             throw new Error('MetricsCollector: RouteConnectionHandler not available');
         }
-        // Subscribe to the newConnectionSubject from RouteConnectionHandler
+        // Start periodic sampling
+        this.samplingInterval = setInterval(() => {
+            this.throughputTracker.takeSample();
+            // Clean up old connection trackers (connections closed more than 5 minutes ago)
+            const cutoff = Date.now() - 300000;
+            for (const [id, tracker] of this.connectionByteTrackers) {
+                if (tracker.lastUpdate < cutoff) {
+                    this.connectionByteTrackers.delete(id);
+                }
+            }
+        }, this.sampleIntervalMs);
+        // Subscribe to new connections
         this.connectionSubscription = this.smartProxy.routeConnectionHandler.newConnectionSubject.subscribe({
             next: (record) => {
-                this.recordRequest();
-                // Optional: Log connection details
+                const routeName = record.routeConfig?.name || 'unknown';
+                this.recordRequest(record.id, routeName, record.remoteIP);
                 if (this.smartProxy.settings?.enableDetailedLogging) {
                     logger.log('debug', `MetricsCollector: New connection recorded`, {
                         connectionId: record.id,
                         remoteIP: record.remoteIP,
-                        routeName: record.routeConfig?.name || 'unknown',
+                        routeName,
                         component: 'metrics'
                     });
                 }
@@ -220,9 +292,13 @@ export class MetricsCollector {
         logger.log('debug', 'MetricsCollector started', { component: 'metrics' });
     }
     /**
-     * Stop the metrics collector and clean up resources
+     * Stop the metrics collector
      */
     stop() {
+        if (this.samplingInterval) {
+            clearInterval(this.samplingInterval);
+            this.samplingInterval = undefined;
+        }
         if (this.connectionSubscription) {
             this.connectionSubscription.unsubscribe();
             this.connectionSubscription = undefined;
@@ -230,10 +306,10 @@ export class MetricsCollector {
         logger.log('debug', 'MetricsCollector stopped', { component: 'metrics' });
     }
     /**
-     * Alias for stop() for backward compatibility
+     * Alias for stop() for compatibility
      */
     destroy() {
         this.stop();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metrics-collector.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/metrics-collector.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metrics-collector.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/metrics-collector.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/smart-proxy/models/interfaces.d.ts

@@ -76,6 +76,11 @@ export interface ISmartProxyOptions {
     extendedKeepAliveLifetime?: number;
     useHttpProxy?: number[];
     httpProxyPort?: number;
+    metrics?: {
+        enabled?: boolean;
+        sampleIntervalMs?: number;
+        retentionSeconds?: number;
+    };
     /**
      * Global ACME configuration options for SmartProxy
      *
@@ -111,7 +116,7 @@ export interface IConnectionRecord {
     outgoingClosedTime?: number;
     lockedDomain?: string;
     connectionClosed: boolean;
-    cleanupTimer?: NodeJS.Timeout;
+    cleanupTimer?: NodeJS.Timeout | null;
     alertFallbackTimeout?: NodeJS.Timeout;
     lastActivity: number;
     pendingData: Buffer[];