@push.rocks/smartproxy 19.5.26 → 19.6.0

package/dist_ts/plugins.d.ts

@@ -23,7 +23,8 @@ import * as smartacmeHandlers from '@push.rocks/smartacme/dist_ts/handlers/index
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartlogDestinationLocal from '@push.rocks/smartlog/destination-local';
 import * as taskbuffer from '@push.rocks/taskbuffer';
-export { lik, smartdelay, smartrequest, smartpromise, smartstring, smartfile, smartcrypto, smartacme, smartacmePlugins, smartacmeHandlers, smartlog, smartlogDestinationLocal, taskbuffer, };
+import * as smartrx from '@push.rocks/smartrx';
+export { lik, smartdelay, smartrequest, smartpromise, smartstring, smartfile, smartcrypto, smartacme, smartacmePlugins, smartacmeHandlers, smartlog, smartlogDestinationLocal, taskbuffer, smartrx, };
 import prettyMs from 'pretty-ms';
 import * as ws from 'ws';
 import wsDefault from 'ws';

package/dist_ts/plugins.js

@@ -26,11 +26,12 @@ import * as smartacmeHandlers from '@push.rocks/smartacme/dist_ts/handlers/index
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartlogDestinationLocal from '@push.rocks/smartlog/destination-local';
 import * as taskbuffer from '@push.rocks/taskbuffer';
-export { lik, smartdelay, smartrequest, smartpromise, smartstring, smartfile, smartcrypto, smartacme, smartacmePlugins, smartacmeHandlers, smartlog, smartlogDestinationLocal, taskbuffer, };
+import * as smartrx from '@push.rocks/smartrx';
+export { lik, smartdelay, smartrequest, smartpromise, smartstring, smartfile, smartcrypto, smartacme, smartacmePlugins, smartacmeHandlers, smartlog, smartlogDestinationLocal, taskbuffer, smartrx, };
 // third party scope
 import prettyMs from 'pretty-ms';
 import * as ws from 'ws';
 import wsDefault from 'ws';
 import { minimatch } from 'minimatch';
 export { prettyMs, ws, wsDefault, minimatch };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/smart-proxy/metrics-collector.d.ts

@@ -0,0 +1,79 @@
+import type { SmartProxy } from './smart-proxy.js';
+import type { IProxyStatsExtended } from './models/metrics-types.js';
+/**
+ * Collects and computes metrics for SmartProxy on-demand
+ */
+export declare class MetricsCollector implements IProxyStatsExtended {
+    private smartProxy;
+    private requestTimestamps;
+    private readonly RPS_WINDOW_SIZE;
+    private cachedMetrics;
+    private readonly CACHE_TTL;
+    private connectionSubscription?;
+    constructor(smartProxy: SmartProxy);
+    /**
+     * 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;
+    /**
+     * Record a new request for RPS tracking
+     */
+    recordRequest(): void;
+    /**
+     * Get total throughput (bytes transferred)
+     */
+    getThroughput(): {
+        bytesIn: number;
+        bytesOut: number;
+    };
+    /**
+     * 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;
+    /**
+     * Clean up old request timestamps
+     */
+    private cleanupOldRequests;
+    /**
+     * Start the metrics collector and set up subscriptions
+     */
+    start(): void;
+    /**
+     * Stop the metrics collector and clean up resources
+     */
+    stop(): void;
+    /**
+     * Alias for stop() for backward compatibility
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,235 @@
+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
+        // 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() {
+        this.requestTimestamps.push(Date.now());
+        // Prevent unbounded growth
+        if (this.requestTimestamps.length > 10000) {
+            this.cleanupOldRequests();
+        }
+    }
+    /**
+     * 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';
@@ -18,6 +18,7 @@ export declare class RouteConnectionHandler {
     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