@push.rocks/smartproxy 19.5.26 → 19.6.1

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

@@ -0,0 +1,239 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../core/utils/logger.js';
+/**
+ * Collects and computes metrics for SmartProxy on-demand
+ */
+export class MetricsCollector {
+    constructor(smartProxy) {
+        this.smartProxy = smartProxy;
+        // RPS tracking (the only state we need to maintain)
+        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'
+                });
+            }
+            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);
+    }
+    /**
+     * Record a new request for RPS tracking
+     */
+    recordRequest() {
+        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.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;
+            }
+        }
+        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
+     */
+    isIPBlocked(ip, maxConnectionsPerIP) {
+        const ipCounts = this.getConnectionsByIP();
+        const currentConnections = ipCounts.get(ip) || 0;
+        return currentConnections >= maxConnectionsPerIP;
+    }
+    /**
+     * Clean up old request timestamps
+     */
+    cleanupOldRequests() {
+        const cutoff = Date.now() - this.RPS_WINDOW_SIZE;
+        this.requestTimestamps = this.requestTimestamps.filter(ts => ts > cutoff);
+    }
+    /**
+     * Start the metrics collector and set up subscriptions
+     */
+    start() {
+        if (!this.smartProxy.routeConnectionHandler) {
+            throw new Error('MetricsCollector: RouteConnectionHandler not available');
+        }
+        // Subscribe to the newConnectionSubject from RouteConnectionHandler
+        this.connectionSubscription = this.smartProxy.routeConnectionHandler.newConnectionSubject.subscribe({
+            next: (record) => {
+                this.recordRequest();
+                // Optional: Log connection details
+                if (this.smartProxy.settings?.enableDetailedLogging) {
+                    logger.log('debug', `MetricsCollector: New connection recorded`, {
+                        connectionId: record.id,
+                        remoteIP: record.remoteIP,
+                        routeName: record.routeConfig?.name || 'unknown',
+                        component: 'metrics'
+                    });
+                }
+            },
+            error: (err) => {
+                logger.log('error', `MetricsCollector: Error in connection subscription`, {
+                    error: err.message,
+                    component: 'metrics'
+                });
+            }
+        });
+        logger.log('debug', 'MetricsCollector started', { component: 'metrics' });
+    }
+    /**
+     * Stop the metrics collector and clean up resources
+     */
+    stop() {
+        if (this.connectionSubscription) {
+            this.connectionSubscription.unsubscribe();
+            this.connectionSubscription = undefined;
+        }
+        logger.log('debug', 'MetricsCollector stopped', { component: 'metrics' });
+    }
+    /**
+     * Alias for stop() for backward 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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"}

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

@@ -3,3 +3,4 @@
  */
 export type { ISmartProxyOptions, IConnectionRecord, TSmartProxyCertProvisionObject } from './interfaces.js';
 export * from './route-types.js';
+export * from './metrics-types.js';

package/dist_ts/proxies/smart-proxy/models/index.js

@@ -1,2 +1,3 @@
 export * from './route-types.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxjQUFjLGtCQUFrQixDQUFDIn0=
+export * from './metrics-types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsb0JBQW9CLENBQUMifQ==

package/dist_ts/proxies/smart-proxy/models/metrics-types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Interface for proxy statistics and metrics
+ */
+export interface IProxyStats {
+    /**
+     * Get the current number of active connections
+     */
+    getActiveConnections(): number;
+    /**
+     * Get connection counts grouped by route name
+     */
+    getConnectionsByRoute(): Map<string, number>;
+    /**
+     * Get connection counts grouped by IP address
+     */
+    getConnectionsByIP(): Map<string, number>;
+    /**
+     * Get the total number of connections since proxy start
+     */
+    getTotalConnections(): number;
+    /**
+     * Get the current requests per second rate
+     */
+    getRequestsPerSecond(): number;
+    /**
+     * Get total throughput (bytes transferred)
+     */
+    getThroughput(): {
+        bytesIn: number;
+        bytesOut: number;
+    };
+}
+/**
+ * Extended interface for additional metrics helpers
+ */
+export interface IProxyStatsExtended extends IProxyStats {
+    /**
+     * Get throughput rate (bytes per second) for last minute
+     */
+    getThroughputRate(): {
+        bytesInPerSec: number;
+        bytesOutPerSec: number;
+    };
+    /**
+     * Get top IPs by connection count
+     */
+    getTopIPs(limit?: number): Array<{
+        ip: string;
+        connections: number;
+    }>;
+    /**
+     * Check if an IP has reached the connection limit
+     */
+    isIPBlocked(ip: string, maxConnectionsPerIP: number): boolean;
+}

package/dist_ts/proxies/smart-proxy/models/metrics-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0cmljcy10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL3Byb3hpZXMvc21hcnQtcHJveHkvbW9kZWxzL21ldHJpY3MtdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts/proxies/smart-proxy/route-connection-handler.d.ts

@@ -1,5 +1,5 @@
 import * as plugins from '../../plugins.js';
-import type { ISmartProxyOptions } from './models/interfaces.js';
+import type { IConnectionRecord, ISmartProxyOptions } from './models/interfaces.js';
 import { ConnectionManager } from './connection-manager.js';
 import { SecurityManager } from './security-manager.js';
 import { TlsManager } from './tls-manager.js';
@@ -17,7 +17,7 @@ export declare class RouteConnectionHandler {
     private timeoutManager;
     private routeManager;
     private settings;
-    private routeContextCache;
+    newConnectionSubject: plugins.smartrx.rxjs.Subject<IConnectionRecord>;
     constructor(settings: ISmartProxyOptions, connectionManager: ConnectionManager, securityManager: SecurityManager, tlsManager: TlsManager, httpProxyBridge: HttpProxyBridge, timeoutManager: TimeoutManager, routeManager: RouteManager);
     /**
      * Create a route context object for port and host mapping functions