@push.rocks/smartproxy 22.4.2 → 23.0.0

package/ts/proxies/smart-proxy/http-proxy-bridge.ts

@@ -1,213 +0,0 @@
-import * as plugins from '../../plugins.js';
-import { HttpProxy } from '../http-proxy/index.js';
-import { setupBidirectionalForwarding } from '../../core/utils/socket-utils.js';
-import type { IConnectionRecord } from './models/interfaces.js';
-import type { IRouteConfig } from './models/route-types.js';
-import { WrappedSocket } from '../../core/models/wrapped-socket.js';
-import type { SmartProxy } from './smart-proxy.js';
-
-export class HttpProxyBridge {
-  private httpProxy: HttpProxy | null = null;
-
-  constructor(private smartProxy: SmartProxy) {}
-  
-  /**
-   * Get the HttpProxy instance
-   */
-  public getHttpProxy(): HttpProxy | null {
-    return this.httpProxy;
-  }
-  
-  /**
-   * Initialize HttpProxy instance
-   */
-  public async initialize(): Promise<void> {
-    if (!this.httpProxy && this.smartProxy.settings.useHttpProxy && this.smartProxy.settings.useHttpProxy.length > 0) {
-      const httpProxyOptions: any = {
-        port: this.smartProxy.settings.httpProxyPort!,
-        portProxyIntegration: true,
-        logLevel: this.smartProxy.settings.enableDetailedLogging ? 'debug' : 'info'
-      };
-
-      this.httpProxy = new HttpProxy(httpProxyOptions);
-      console.log(`Initialized HttpProxy on port ${this.smartProxy.settings.httpProxyPort}`);
-
-      // Apply route configurations to HttpProxy
-      await this.syncRoutesToHttpProxy(this.smartProxy.settings.routes || []);
-    }
-  }
-  
-  /**
-   * Sync routes to HttpProxy
-   */
-  public async syncRoutesToHttpProxy(routes: IRouteConfig[]): Promise<void> {
-    if (!this.httpProxy) return;
-    
-    // Convert routes to HttpProxy format
-    const httpProxyConfigs = routes
-      .filter(route => {
-        // Check if this route matches any of the specified network proxy ports
-        const routePorts = Array.isArray(route.match.ports) 
-          ? route.match.ports 
-          : [route.match.ports];
-        
-        return routePorts.some(port => 
-          this.smartProxy.settings.useHttpProxy?.includes(port)
-        );
-      })
-      .map(route => this.routeToHttpProxyConfig(route));
-    
-    // Apply configurations to HttpProxy
-    await this.httpProxy.updateRouteConfigs(httpProxyConfigs);
-  }
-  
-  /**
-   * Convert route to HttpProxy configuration
-   */
-  private routeToHttpProxyConfig(route: IRouteConfig): any {
-    // Convert route to HttpProxy domain config format
-    let domain = '*';
-    if (route.match.domains) {
-      if (Array.isArray(route.match.domains)) {
-        domain = route.match.domains[0] || '*';
-      } else {
-        domain = route.match.domains;
-      }
-    }
-    
-    return {
-      ...route,  // Keep the original route structure
-      match: {
-        ...route.match,
-        domains: domain  // Ensure domains is always set for HttpProxy
-      }
-    };
-  }
-  
-  /**
-   * Check if connection should use HttpProxy
-   */
-  public shouldUseHttpProxy(connection: IConnectionRecord, routeMatch: any): boolean {
-    // Only use HttpProxy for TLS termination
-    return (
-      routeMatch.route.action.tls?.mode === 'terminate' ||
-      routeMatch.route.action.tls?.mode === 'terminate-and-reencrypt'
-    ) && this.httpProxy !== null;
-  }
-  
-  /**
-   * Forward connection to HttpProxy
-   */
-  public async forwardToHttpProxy(
-    connectionId: string,
-    socket: plugins.net.Socket | WrappedSocket,
-    record: IConnectionRecord,
-    initialChunk: Buffer,
-    httpProxyPort: number,
-    cleanupCallback: (reason: string) => void
-  ): Promise<void> {
-    if (!this.httpProxy) {
-      throw new Error('HttpProxy not initialized');
-    }
-
-    // Check if client socket is already destroyed before proceeding
-    const underlyingSocket = socket instanceof WrappedSocket ? socket.socket : socket;
-    if (underlyingSocket.destroyed) {
-      console.log(`[${connectionId}] Client socket already destroyed, skipping HttpProxy forwarding`);
-      cleanupCallback('client_disconnected_before_proxy');
-      return;
-    }
-
-    const proxySocket = new plugins.net.Socket();
-
-    // Handle client disconnect during proxy connection setup
-    const clientDisconnectHandler = () => {
-      console.log(`[${connectionId}] Client disconnected during HttpProxy connection setup`);
-      proxySocket.destroy();
-      cleanupCallback('client_disconnected_during_setup');
-    };
-    underlyingSocket.once('close', clientDisconnectHandler);
-
-    try {
-      await new Promise<void>((resolve, reject) => {
-        proxySocket.connect(httpProxyPort, 'localhost', () => {
-          console.log(`[${connectionId}] Connected to HttpProxy for termination`);
-          resolve();
-        });
-
-        proxySocket.on('error', reject);
-      });
-    } finally {
-      // Remove the disconnect handler after connection attempt
-      underlyingSocket.removeListener('close', clientDisconnectHandler);
-    }
-
-    // Double-check client socket is still connected after async operation
-    if (underlyingSocket.destroyed) {
-      console.log(`[${connectionId}] Client disconnected while connecting to HttpProxy`);
-      proxySocket.destroy();
-      cleanupCallback('client_disconnected_after_proxy_connect');
-      return;
-    }
-    
-    // Send client IP information header first (custom protocol)
-    // Format: "CLIENT_IP:<ip>\r\n"
-    const clientIPHeader = Buffer.from(`CLIENT_IP:${record.remoteIP}\r\n`);
-    proxySocket.write(clientIPHeader);
-    
-    // Send initial chunk if present
-    if (initialChunk) {
-      // Count the initial chunk bytes
-      record.bytesReceived += initialChunk.length;
-      if (this.smartProxy.metricsCollector) {
-        this.smartProxy.metricsCollector.recordBytes(record.id, initialChunk.length, 0);
-      }
-      proxySocket.write(initialChunk);
-    }
-    
-    // Use centralized bidirectional forwarding (underlyingSocket already extracted above)
-    setupBidirectionalForwarding(underlyingSocket, proxySocket, {
-      onClientData: (chunk) => {
-        // Update stats - this is the ONLY place bytes are counted for HttpProxy connections
-        if (record) {
-          record.bytesReceived += chunk.length;
-          if (this.smartProxy.metricsCollector) {
-            this.smartProxy.metricsCollector.recordBytes(record.id, chunk.length, 0);
-          }
-        }
-      },
-      onServerData: (chunk) => {
-        // Update stats - this is the ONLY place bytes are counted for HttpProxy connections
-        if (record) {
-          record.bytesSent += chunk.length;
-          if (this.smartProxy.metricsCollector) {
-            this.smartProxy.metricsCollector.recordBytes(record.id, 0, chunk.length);
-          }
-        }
-      },
-      onCleanup: (reason) => {
-        cleanupCallback(reason);
-      },
-      enableHalfOpen: false // Close both when one closes (required for proxy chains)
-    });
-  }
-  
-  /**
-   * Start HttpProxy
-   */
-  public async start(): Promise<void> {
-    if (this.httpProxy) {
-      await this.httpProxy.start();
-    }
-  }
-  
-  /**
-   * Stop HttpProxy
-   */
-  public async stop(): Promise<void> {
-    if (this.httpProxy) {
-      await this.httpProxy.stop();
-      this.httpProxy = null;
-    }
-  }
-}

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

@@ -1,453 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { SmartProxy } from './smart-proxy.js';
-import type { 
-  IMetrics, 
-  IThroughputData, 
-  IThroughputHistoryPoint,
-  IByteTracker 
-} from './models/metrics-types.js';
-import { ThroughputTracker } from './throughput-tracker.js';
-import { logger } from '../../core/utils/logger.js';
-
-/**
- * Collects and provides metrics for SmartProxy with clean API
- */
-export class MetricsCollector implements IMetrics {
-  // Throughput tracking
-  private throughputTracker: ThroughputTracker;
-  private routeThroughputTrackers = new Map<string, ThroughputTracker>();
-  private ipThroughputTrackers = new Map<string, ThroughputTracker>();
-  
-  // Request tracking
-  private requestTimestamps: number[] = [];
-  private totalRequests: number = 0;
-  
-  // Connection byte tracking for per-route/IP metrics
-  private connectionByteTrackers = new Map<string, IByteTracker>();
-  
-  // Subscriptions
-  private samplingInterval?: NodeJS.Timeout;
-  private connectionSubscription?: plugins.smartrx.rxjs.Subscription;
-  
-  // Configuration
-  private readonly sampleIntervalMs: number;
-  private readonly retentionSeconds: number;
-  
-  // Track connection durations for percentile calculations
-  private connectionDurations: number[] = [];
-  private bytesInArray: number[] = [];
-  private bytesOutArray: number[] = [];
-  
-  constructor(
-    private smartProxy: SmartProxy,
-    config?: {
-      sampleIntervalMs?: number;
-      retentionSeconds?: number;
-    }
-  ) {
-    this.sampleIntervalMs = config?.sampleIntervalMs || 1000;
-    this.retentionSeconds = config?.retentionSeconds || 3600;
-    this.throughputTracker = new ThroughputTracker(this.retentionSeconds);
-  }
-  
-  // Connection metrics implementation
-  public connections = {
-    active: (): number => {
-      return this.smartProxy.connectionManager.getConnectionCount();
-    },
-    
-    total: (): number => {
-      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: (): Map<string, number> => {
-      const routeCounts = new Map<string, number>();
-      const connections = this.smartProxy.connectionManager.getConnections();
-      
-      for (const [_, record] of connections) {
-        const routeName = (record as any).routeName || 
-                         record.routeConfig?.name || 
-                         'unknown';
-        
-        const current = routeCounts.get(routeName) || 0;
-        routeCounts.set(routeName, current + 1);
-      }
-      
-      return routeCounts;
-    },
-    
-    byIP: (): Map<string, number> => {
-      const ipCounts = new Map<string, number>();
-      
-      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: number = 10): Array<{ ip: string; count: number }> => {
-      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 }));
-    }
-  };
-  
-  // Throughput metrics implementation
-  public throughput = {
-    instant: (): IThroughputData => {
-      return this.throughputTracker.getRate(1);
-    },
-    
-    recent: (): IThroughputData => {
-      return this.throughputTracker.getRate(10);
-    },
-    
-    average: (): IThroughputData => {
-      return this.throughputTracker.getRate(60);
-    },
-    
-    custom: (seconds: number): IThroughputData => {
-      return this.throughputTracker.getRate(seconds);
-    },
-    
-    history: (seconds: number): Array<IThroughputHistoryPoint> => {
-      return this.throughputTracker.getHistory(seconds);
-    },
-    
-    byRoute: (windowSeconds: number = 1): Map<string, IThroughputData> => {
-      const routeThroughput = new Map<string, IThroughputData>();
-      
-      // Get throughput from each route's dedicated tracker
-      for (const [route, tracker] of this.routeThroughputTrackers) {
-        const rate = tracker.getRate(windowSeconds);
-        if (rate.in > 0 || rate.out > 0) {
-          routeThroughput.set(route, rate);
-        }
-      }
-      
-      return routeThroughput;
-    },
-    
-    byIP: (windowSeconds: number = 1): Map<string, IThroughputData> => {
-      const ipThroughput = new Map<string, IThroughputData>();
-      
-      // Get throughput from each IP's dedicated tracker
-      for (const [ip, tracker] of this.ipThroughputTrackers) {
-        const rate = tracker.getRate(windowSeconds);
-        if (rate.in > 0 || rate.out > 0) {
-          ipThroughput.set(ip, rate);
-        }
-      }
-      
-      return ipThroughput;
-    }
-  };
-  
-  // Request metrics implementation
-  public requests = {
-    perSecond: (): number => {
-      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: (): number => {
-      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: (): number => {
-      return this.totalRequests;
-    }
-  };
-  
-  // Totals implementation
-  public totals = {
-    bytesIn: (): number => {
-      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: (): number => {
-      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: (): number => {
-      return this.connections.total();
-    }
-  };
-  
-  // Helper to calculate percentiles from an array
-  private calculatePercentile(arr: number[], percentile: number): number {
-    if (arr.length === 0) return 0;
-    const sorted = [...arr].sort((a, b) => a - b);
-    const index = Math.floor((sorted.length - 1) * percentile);
-    return sorted[index];
-  }
-  
-  // Percentiles implementation
-  public percentiles = {
-    connectionDuration: (): { p50: number; p95: number; p99: number } => {
-      return {
-        p50: this.calculatePercentile(this.connectionDurations, 0.5),
-        p95: this.calculatePercentile(this.connectionDurations, 0.95),
-        p99: this.calculatePercentile(this.connectionDurations, 0.99)
-      };
-    },
-    
-    bytesTransferred: (): { 
-      in: { p50: number; p95: number; p99: number };
-      out: { p50: number; p95: number; p99: number };
-    } => {
-      return {
-        in: {
-          p50: this.calculatePercentile(this.bytesInArray, 0.5),
-          p95: this.calculatePercentile(this.bytesInArray, 0.95),
-          p99: this.calculatePercentile(this.bytesInArray, 0.99)
-        },
-        out: {
-          p50: this.calculatePercentile(this.bytesOutArray, 0.5),
-          p95: this.calculatePercentile(this.bytesOutArray, 0.95),
-          p99: this.calculatePercentile(this.bytesOutArray, 0.99)
-        }
-      };
-    }
-  };
-  
-  /**
-   * Record a new request
-   */
-  public recordRequest(connectionId: string, routeName: string, remoteIP: string): void {
-    const now = Date.now();
-    this.requestTimestamps.push(now);
-    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);
-      
-      // If still too many, enforce hard cap of 5000 most recent
-      if (this.requestTimestamps.length > 5000) {
-        this.requestTimestamps = this.requestTimestamps.slice(-5000);
-      }
-    }
-  }
-  
-  /**
-   * Record bytes transferred for a connection
-   */
-  public recordBytes(connectionId: string, bytesIn: number, bytesOut: number): void {
-    // 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();
-      
-      // Update per-route throughput tracker
-      let routeTracker = this.routeThroughputTrackers.get(tracker.routeName);
-      if (!routeTracker) {
-        routeTracker = new ThroughputTracker(this.retentionSeconds);
-        this.routeThroughputTrackers.set(tracker.routeName, routeTracker);
-      }
-      routeTracker.recordBytes(bytesIn, bytesOut);
-      
-      // Update per-IP throughput tracker
-      let ipTracker = this.ipThroughputTrackers.get(tracker.remoteIP);
-      if (!ipTracker) {
-        ipTracker = new ThroughputTracker(this.retentionSeconds);
-        this.ipThroughputTrackers.set(tracker.remoteIP, ipTracker);
-      }
-      ipTracker.recordBytes(bytesIn, bytesOut);
-    }
-  }
-  
-  /**
-   * Clean up tracking for a closed connection
-   */
-  public removeConnection(connectionId: string): void {
-    const tracker = this.connectionByteTrackers.get(connectionId);
-    if (tracker) {
-      // Calculate connection duration
-      const duration = Date.now() - tracker.startTime;
-      
-      // Add to arrays for percentile calculations (bounded to prevent memory growth)
-      const MAX_SAMPLES = 5000;
-      
-      this.connectionDurations.push(duration);
-      if (this.connectionDurations.length > MAX_SAMPLES) {
-        this.connectionDurations.shift();
-      }
-      
-      this.bytesInArray.push(tracker.bytesIn);
-      if (this.bytesInArray.length > MAX_SAMPLES) {
-        this.bytesInArray.shift();
-      }
-      
-      this.bytesOutArray.push(tracker.bytesOut);
-      if (this.bytesOutArray.length > MAX_SAMPLES) {
-        this.bytesOutArray.shift();
-      }
-    }
-    
-    this.connectionByteTrackers.delete(connectionId);
-  }
-  
-  /**
-   * Start the metrics collector
-   */
-  public start(): void {
-    if (!this.smartProxy.routeConnectionHandler) {
-      throw new Error('MetricsCollector: RouteConnectionHandler not available');
-    }
-    
-    // Start periodic sampling
-    this.samplingInterval = setInterval(() => {
-      // Sample global throughput
-      this.throughputTracker.takeSample();
-      
-      // Sample per-route throughput
-      for (const [_, tracker] of this.routeThroughputTrackers) {
-        tracker.takeSample();
-      }
-      
-      // Sample per-IP throughput
-      for (const [_, tracker] of this.ipThroughputTrackers) {
-        tracker.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);
-        }
-      }
-      
-      // Clean up unused route trackers
-      const activeRoutes = new Set(Array.from(this.connectionByteTrackers.values()).map(t => t.routeName));
-      for (const [route, _] of this.routeThroughputTrackers) {
-        if (!activeRoutes.has(route)) {
-          this.routeThroughputTrackers.delete(route);
-        }
-      }
-      
-      // Clean up unused IP trackers
-      const activeIPs = new Set(Array.from(this.connectionByteTrackers.values()).map(t => t.remoteIP));
-      for (const [ip, _] of this.ipThroughputTrackers) {
-        if (!activeIPs.has(ip)) {
-          this.ipThroughputTrackers.delete(ip);
-        }
-      }
-    }, this.sampleIntervalMs);
-    
-    // Unref the interval so it doesn't keep the process alive
-    if (this.samplingInterval.unref) {
-      this.samplingInterval.unref();
-    }
-    
-    // Subscribe to new connections
-    this.connectionSubscription = this.smartProxy.routeConnectionHandler.newConnectionSubject.subscribe({
-      next: (record) => {
-        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,
-            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
-   */
-  public stop(): void {
-    if (this.samplingInterval) {
-      clearInterval(this.samplingInterval);
-      this.samplingInterval = undefined;
-    }
-    
-    if (this.connectionSubscription) {
-      this.connectionSubscription.unsubscribe();
-      this.connectionSubscription = undefined;
-    }
-    
-    logger.log('debug', 'MetricsCollector stopped', { component: 'metrics' });
-  }
-  
-  /**
-   * Alias for stop() for compatibility
-   */
-  public destroy(): void {
-    this.stop();
-  }
-}