@push.rocks/smartproxy 3.24.0 → 3.25.1

package/ts/classes.portproxy.ts

@@ -7,8 +7,14 @@ export interface IDomainConfig {
   blockedIPs?: string[];     // Glob patterns for blocked IPs
   targetIPs?: string[];      // If multiple targetIPs are given, use round robin.
   portRanges?: Array<{ from: number; to: number }>; // Optional port ranges
+  // Protocol-specific timeout overrides
+  httpTimeout?: number;      // HTTP connection timeout override (ms)
+  wsTimeout?: number;        // WebSocket connection timeout override (ms)
 }
 
+/** Connection protocol types for timeout management */
+export type ProtocolType = 'http' | 'websocket' | 'https' | 'tls' | 'unknown';
+
 /** Port proxy settings including global allowed port ranges */
 export interface IPortProxySettings extends plugins.tls.TlsOptions {
   fromPort: number;
@@ -19,17 +25,66 @@ export interface IPortProxySettings extends plugins.tls.TlsOptions {
   defaultAllowedIPs?: string[];
   defaultBlockedIPs?: string[];
   preserveSourceIP?: boolean;
-  maxConnectionLifetime?: number; // (ms) force cleanup of long-lived connections
+  
+  // Updated timeout settings with better defaults
+  initialDataTimeout?: number;        // Timeout for initial data/SNI (ms), default: 15000 (15s)
+  socketTimeout?: number;             // Socket inactivity timeout (ms), default: 300000 (5m)
+  inactivityCheckInterval?: number;   // How often to check for inactive connections (ms), default: 30000 (30s)
+  
+  // Protocol-specific timeouts
+  maxConnectionLifetime?: number;      // Default max connection lifetime (ms), default: 3600000 (1h)
+  httpConnectionTimeout?: number;      // HTTP specific timeout (ms), default: 1800000 (30m)
+  wsConnectionTimeout?: number;        // WebSocket specific timeout (ms), default: 14400000 (4h)
+  httpKeepAliveTimeout?: number;       // HTTP keep-alive header timeout (ms), default: 1200000 (20m)
+  
+  gracefulShutdownTimeout?: number;    // (ms) maximum time to wait for connections to close during shutdown
   globalPortRanges: Array<{ from: number; to: number }>; // Global allowed port ranges
-  forwardAllGlobalRanges?: boolean; // When true, forwards all connections on global port ranges to the global targetIP
-  gracefulShutdownTimeout?: number; // (ms) maximum time to wait for connections to close during shutdown
+  forwardAllGlobalRanges?: boolean;    // When true, forwards all connections on global port ranges to the global targetIP
   
   // Socket optimization settings
-  noDelay?: boolean;                  // Disable Nagle's algorithm (default: true)
-  keepAlive?: boolean;                // Enable TCP keepalive (default: true)
-  keepAliveInitialDelay?: number;     // Initial delay before sending keepalive probes (ms)
-  maxPendingDataSize?: number;        // Maximum bytes to buffer during connection setup
-  initialDataTimeout?: number;        // Timeout for initial data/SNI (ms)
+  noDelay?: boolean;                   // Disable Nagle's algorithm (default: true)
+  keepAlive?: boolean;                 // Enable TCP keepalive (default: true)
+  keepAliveInitialDelay?: number;      // Initial delay before sending keepalive probes (ms)
+  maxPendingDataSize?: number;         // Maximum bytes to buffer during connection setup
+  
+  // Enable enhanced features
+  disableInactivityCheck?: boolean;    // Disable inactivity checking entirely
+  enableKeepAliveProbes?: boolean;     // Enable TCP keep-alive probes
+  enableProtocolDetection?: boolean;   // Enable HTTP/WebSocket protocol detection
+  enableDetailedLogging?: boolean;     // Enable detailed connection logging
+  
+  // Rate limiting and security
+  maxConnectionsPerIP?: number;        // Maximum simultaneous connections from a single IP
+  connectionRateLimitPerMinute?: number; // Max new connections per minute from a single IP
+}
+
+/**
+ * Enhanced connection record with protocol-specific handling
+ */
+interface IConnectionRecord {
+  id: string;                         // Unique connection identifier
+  incoming: plugins.net.Socket;
+  outgoing: plugins.net.Socket | null;
+  incomingStartTime: number;
+  outgoingStartTime?: number;
+  outgoingClosedTime?: number;
+  lockedDomain?: string;              // Used to lock this connection to the initial SNI
+  connectionClosed: boolean;          // Flag to prevent multiple cleanup attempts
+  cleanupTimer?: NodeJS.Timeout;      // Timer for max lifetime/inactivity
+  lastActivity: number;               // Last activity timestamp for inactivity detection
+  pendingData: Buffer[];              // Buffer to hold data during connection setup
+  pendingDataSize: number;            // Track total size of pending data
+  
+  // Enhanced tracking fields
+  protocolType: ProtocolType;         // Connection protocol type
+  isPooledConnection: boolean;        // Whether this is likely a browser pooled connection
+  lastHttpRequest?: number;           // Timestamp of last HTTP request (for keep-alive tracking)
+  httpKeepAliveTimeout?: number;      // HTTP keep-alive timeout from headers
+  bytesReceived: number;              // Total bytes received
+  bytesSent: number;                  // Total bytes sent
+  remoteIP: string;                   // Remote IP (cached for logging after socket close)
+  localPort: number;                  // Local port (cached for logging)
+  httpRequests: number;               // Count of HTTP requests on this connection
 }
 
 /**
@@ -95,21 +150,6 @@ function extractSNI(buffer: Buffer): string | undefined {
   return undefined;
 }
 
-interface IConnectionRecord {
-  id: string;                       // Unique connection identifier
-  incoming: plugins.net.Socket;
-  outgoing: plugins.net.Socket | null;
-  incomingStartTime: number;
-  outgoingStartTime?: number;
-  outgoingClosedTime?: number;
-  lockedDomain?: string;            // Used to lock this connection to the initial SNI
-  connectionClosed: boolean;        // Flag to prevent multiple cleanup attempts
-  cleanupTimer?: NodeJS.Timeout;    // Timer for max lifetime/inactivity
-  lastActivity: number;             // Last activity timestamp for inactivity detection
-  pendingData: Buffer[];            // Buffer to hold data during connection setup
-  pendingDataSize: number;          // Track total size of pending data
-}
-
 // Helper: Check if a port falls within any of the given port ranges
 const isPortInRanges = (port: number, ranges: Array<{ from: number; to: number }>): boolean => {
   return ranges.some(range => port >= range.from && port <= range.to);
@@ -145,6 +185,34 @@ const generateConnectionId = (): string => {
   return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
 };
 
+// Protocol detection helpers
+const isHttpRequest = (buffer: Buffer): boolean => {
+  if (buffer.length < 4) return false;
+  const start = buffer.toString('ascii', 0, 4).toUpperCase();
+  return (
+    start.startsWith('GET ') ||
+    start.startsWith('POST') ||
+    start.startsWith('PUT ') ||
+    start.startsWith('HEAD') ||
+    start.startsWith('DELE') ||
+    start.startsWith('PATC') ||
+    start.startsWith('OPTI')
+  );
+};
+
+const isWebSocketUpgrade = (buffer: Buffer): boolean => {
+  if (buffer.length < 20) return false;
+  const data = buffer.toString('ascii', 0, Math.min(buffer.length, 200));
+  return (
+    data.includes('Upgrade: websocket') ||
+    data.includes('Upgrade: WebSocket')
+  );
+};
+
+const isTlsHandshake = (buffer: Buffer): boolean => {
+  return buffer.length > 0 && buffer[0] === 22; // ContentType.handshake
+};
+
 export class PortProxy {
   private netServers: plugins.net.Server[] = [];
   settings: IPortProxySettings;
@@ -155,6 +223,7 @@ export class PortProxy {
   // Map to track round robin indices for each domain config
   private domainTargetIndices: Map<IDomainConfig, number> = new Map();
 
+  // Enhanced stats tracking
   private terminationStats: {
     incoming: Record<string, number>;
     outgoing: Record<string, number>;
@@ -162,25 +231,218 @@ export class PortProxy {
     incoming: {},
     outgoing: {},
   };
+  
+  // Connection tracking by IP for rate limiting
+  private connectionsByIP: Map<string, Set<string>> = new Map();
+  private connectionRateByIP: Map<string, number[]> = new Map();
 
   constructor(settingsArg: IPortProxySettings) {
+    // Set reasonable defaults for all settings
     this.settings = {
       ...settingsArg,
       targetIP: settingsArg.targetIP || 'localhost',
-      maxConnectionLifetime: settingsArg.maxConnectionLifetime || 600000,
-      gracefulShutdownTimeout: settingsArg.gracefulShutdownTimeout || 30000,
+      
+      // Timeout settings with browser-friendly defaults
+      initialDataTimeout: settingsArg.initialDataTimeout || 15000, // 15 seconds
+      socketTimeout: settingsArg.socketTimeout || 300000, // 5 minutes
+      inactivityCheckInterval: settingsArg.inactivityCheckInterval || 30000, // 30 seconds
+      
+      // Protocol-specific timeouts
+      maxConnectionLifetime: settingsArg.maxConnectionLifetime || 3600000, // 1 hour default
+      httpConnectionTimeout: settingsArg.httpConnectionTimeout || 1800000, // 30 minutes
+      wsConnectionTimeout: settingsArg.wsConnectionTimeout || 14400000, // 4 hours
+      httpKeepAliveTimeout: settingsArg.httpKeepAliveTimeout || 1200000, // 20 minutes
+      
+      gracefulShutdownTimeout: settingsArg.gracefulShutdownTimeout || 30000, // 30 seconds
+      
+      // Socket optimization settings
       noDelay: settingsArg.noDelay !== undefined ? settingsArg.noDelay : true,
       keepAlive: settingsArg.keepAlive !== undefined ? settingsArg.keepAlive : true,
       keepAliveInitialDelay: settingsArg.keepAliveInitialDelay || 60000, // 1 minute
       maxPendingDataSize: settingsArg.maxPendingDataSize || 1024 * 1024, // 1MB
-      initialDataTimeout: settingsArg.initialDataTimeout || 5000 // 5 seconds
+      
+      // Feature flags
+      disableInactivityCheck: settingsArg.disableInactivityCheck || false,
+      enableKeepAliveProbes: settingsArg.enableKeepAliveProbes || false,
+      enableProtocolDetection: settingsArg.enableProtocolDetection !== undefined ? settingsArg.enableProtocolDetection : true,
+      enableDetailedLogging: settingsArg.enableDetailedLogging || false,
+      
+      // Rate limiting defaults
+      maxConnectionsPerIP: settingsArg.maxConnectionsPerIP || 100, // 100 connections per IP
+      connectionRateLimitPerMinute: settingsArg.connectionRateLimitPerMinute || 300, // 300 per minute
     };
   }
 
+  /**
+   * Get connections count by IP
+   */
+  private getConnectionCountByIP(ip: string): number {
+    return this.connectionsByIP.get(ip)?.size || 0;
+  }
+
+  /**
+   * Check and update connection rate for an IP
+   */
+  private checkConnectionRate(ip: string): boolean {
+    const now = Date.now();
+    const minute = 60 * 1000;
+    
+    if (!this.connectionRateByIP.has(ip)) {
+      this.connectionRateByIP.set(ip, [now]);
+      return true;
+    }
+    
+    // Get timestamps and filter out entries older than 1 minute
+    const timestamps = this.connectionRateByIP.get(ip)!.filter(time => now - time < minute);
+    timestamps.push(now);
+    this.connectionRateByIP.set(ip, timestamps);
+    
+    // Check if rate exceeds limit
+    return timestamps.length <= this.settings.connectionRateLimitPerMinute!;
+  }
+
+  /**
+   * Track connection by IP
+   */
+  private trackConnectionByIP(ip: string, connectionId: string): void {
+    if (!this.connectionsByIP.has(ip)) {
+      this.connectionsByIP.set(ip, new Set());
+    }
+    this.connectionsByIP.get(ip)!.add(connectionId);
+  }
+
+  /**
+   * Remove connection tracking for an IP
+   */
+  private removeConnectionByIP(ip: string, connectionId: string): void {
+    if (this.connectionsByIP.has(ip)) {
+      const connections = this.connectionsByIP.get(ip)!;
+      connections.delete(connectionId);
+      if (connections.size === 0) {
+        this.connectionsByIP.delete(ip);
+      }
+    }
+  }
+
+  /**
+   * Track connection termination statistic
+   */
   private incrementTerminationStat(side: 'incoming' | 'outgoing', reason: string): void {
     this.terminationStats[side][reason] = (this.terminationStats[side][reason] || 0) + 1;
   }
 
+  /**
+   * Get protocol-specific timeout based on connection type
+   */
+  private getProtocolTimeout(record: IConnectionRecord, domainConfig?: IDomainConfig): number {
+    // If the protocol has a domain-specific timeout, use that
+    if (domainConfig) {
+      if (record.protocolType === 'http' && domainConfig.httpTimeout) {
+        return domainConfig.httpTimeout;
+      }
+      if (record.protocolType === 'websocket' && domainConfig.wsTimeout) {
+        return domainConfig.wsTimeout;
+      }
+    }
+
+    // Use HTTP keep-alive timeout from headers if available
+    if (record.httpKeepAliveTimeout) {
+      return record.httpKeepAliveTimeout;
+    }
+    
+    // Otherwise use default protocol-specific timeout
+    switch (record.protocolType) {
+      case 'http':
+        return this.settings.httpConnectionTimeout!;
+      case 'websocket':
+        return this.settings.wsConnectionTimeout!;
+      case 'https':
+      case 'tls':
+        return this.settings.httpConnectionTimeout!; // Use HTTP timeout for HTTPS by default
+      default:
+        return this.settings.maxConnectionLifetime!;
+    }
+  }
+
+  /**
+   * Detect protocol and update connection record
+   */
+  private detectProtocol(data: Buffer, record: IConnectionRecord): void {
+    if (!this.settings.enableProtocolDetection || record.protocolType !== 'unknown') {
+      return;
+    }
+
+    try {
+      // Detect TLS/HTTPS
+      if (isTlsHandshake(data)) {
+        record.protocolType = 'tls';
+        if (this.settings.enableDetailedLogging) {
+          console.log(`[${record.id}] Protocol detected: TLS`);
+        }
+        return;
+      }
+
+      // Detect HTTP including WebSocket upgrades
+      if (isHttpRequest(data)) {
+        record.httpRequests++;
+        record.lastHttpRequest = Date.now();
+
+        // Check for WebSocket upgrade
+        if (isWebSocketUpgrade(data)) {
+          record.protocolType = 'websocket';
+          if (this.settings.enableDetailedLogging) {
+            console.log(`[${record.id}] Protocol detected: WebSocket Upgrade`);
+          }
+        } else {
+          record.protocolType = 'http';
+          
+          // Parse HTTP keep-alive headers
+          this.parseHttpHeaders(data, record);
+          
+          if (this.settings.enableDetailedLogging) {
+            console.log(`[${record.id}] Protocol detected: HTTP${record.isPooledConnection ? ' (KeepAlive)' : ''}`);
+          }
+        }
+      }
+    } catch (err) {
+      console.log(`[${record.id}] Error detecting protocol: ${err}`);
+    }
+  }
+
+  /**
+   * Parse HTTP headers for keep-alive and other connection info
+   */
+  private parseHttpHeaders(data: Buffer, record: IConnectionRecord): void {
+    try {
+      const headerStr = data.toString('utf8', 0, Math.min(data.length, 1024));
+      
+      // Check for HTTP keep-alive
+      const connectionHeader = headerStr.match(/\r\nConnection:\s*([^\r\n]+)/i);
+      if (connectionHeader && connectionHeader[1].toLowerCase().includes('keep-alive')) {
+        record.isPooledConnection = true;
+        
+        // Check for Keep-Alive timeout value
+        const keepAliveHeader = headerStr.match(/\r\nKeep-Alive:\s*([^\r\n]+)/i);
+        if (keepAliveHeader) {
+          const timeoutMatch = keepAliveHeader[1].match(/timeout=(\d+)/i);
+          if (timeoutMatch && timeoutMatch[1]) {
+            const timeoutSec = parseInt(timeoutMatch[1], 10);
+            if (!isNaN(timeoutSec) && timeoutSec > 0) {
+              // Convert seconds to milliseconds and add some buffer
+              record.httpKeepAliveTimeout = (timeoutSec * 1000) + 5000;
+              
+              if (this.settings.enableDetailedLogging) {
+                console.log(`[${record.id}] HTTP Keep-Alive timeout set to ${timeoutSec} seconds`);
+              }
+            }
+          }
+        }
+      }
+    } catch (err) {
+      console.log(`[${record.id}] Error parsing HTTP headers: ${err}`);
+    }
+  }
+
   /**
    * Cleans up a connection record.
    * Destroys both incoming and outgoing sockets, clears timers, and removes the record.
@@ -191,11 +453,20 @@ export class PortProxy {
     if (!record.connectionClosed) {
       record.connectionClosed = true;
       
+      // Track connection termination
+      this.removeConnectionByIP(record.remoteIP, record.id);
+      
       if (record.cleanupTimer) {
         clearTimeout(record.cleanupTimer);
         record.cleanupTimer = undefined;
       }
       
+      // Detailed logging data
+      const duration = Date.now() - record.incomingStartTime;
+      const bytesReceived = record.bytesReceived;
+      const bytesSent = record.bytesSent;
+      const httpRequests = record.httpRequests;
+      
       try {
         if (!record.incoming.destroyed) {
           // Try graceful shutdown first, then force destroy after a short timeout
@@ -206,7 +477,7 @@ export class PortProxy {
                 record.incoming.destroy();
               }
             } catch (err) {
-              console.log(`Error destroying incoming socket: ${err}`);
+              console.log(`[${record.id}] Error destroying incoming socket: ${err}`);
             }
           }, 1000);
           
@@ -216,13 +487,13 @@ export class PortProxy {
           }
         }
       } catch (err) {
-        console.log(`Error closing incoming socket: ${err}`);
+        console.log(`[${record.id}] Error closing incoming socket: ${err}`);
         try {
           if (!record.incoming.destroyed) {
             record.incoming.destroy();
           }
         } catch (destroyErr) {
-          console.log(`Error destroying incoming socket: ${destroyErr}`);
+          console.log(`[${record.id}] Error destroying incoming socket: ${destroyErr}`);
         }
       }
       
@@ -236,7 +507,7 @@ export class PortProxy {
                 record.outgoing.destroy();
               }
             } catch (err) {
-              console.log(`Error destroying outgoing socket: ${err}`);
+              console.log(`[${record.id}] Error destroying outgoing socket: ${err}`);
             }
           }, 1000);
           
@@ -246,13 +517,13 @@ export class PortProxy {
           }
         }
       } catch (err) {
-        console.log(`Error closing outgoing socket: ${err}`);
+        console.log(`[${record.id}] Error closing outgoing socket: ${err}`);
         try {
           if (record.outgoing && !record.outgoing.destroyed) {
             record.outgoing.destroy();
           }
         } catch (destroyErr) {
-          console.log(`Error destroying outgoing socket: ${destroyErr}`);
+          console.log(`[${record.id}] Error destroying outgoing socket: ${destroyErr}`);
         }
       }
       
@@ -263,15 +534,27 @@ export class PortProxy {
       // Remove the record from the tracking map
       this.connectionRecords.delete(record.id);
       
-      const remoteIP = record.incoming.remoteAddress || 'unknown';
-      console.log(`Connection from ${remoteIP} terminated (${reason}). Active connections: ${this.connectionRecords.size}`);
+      // Log connection details
+      if (this.settings.enableDetailedLogging) {
+        console.log(`[${record.id}] Connection from ${record.remoteIP} on port ${record.localPort} terminated (${reason}).` +
+                  ` Duration: ${plugins.prettyMs(duration)}, Bytes IN: ${bytesReceived}, OUT: ${bytesSent}, ` +
+                  `HTTP Requests: ${httpRequests}, Protocol: ${record.protocolType}, Pooled: ${record.isPooledConnection}`);
+      } else {
+        console.log(`[${record.id}] Connection from ${record.remoteIP} terminated (${reason}). Active connections: ${this.connectionRecords.size}`);
+      }
     }
   }
 
+  /**
+   * Update connection activity timestamp
+   */
   private updateActivity(record: IConnectionRecord): void {
     record.lastActivity = Date.now();
   }
 
+  /**
+   * Get target IP with round-robin support
+   */
   private getTargetIP(domainConfig: IDomainConfig): string {
     if (domainConfig.targetIPs && domainConfig.targetIPs.length > 0) {
       const currentIndex = this.domainTargetIndices.get(domainConfig) || 0;
@@ -282,12 +565,16 @@ export class PortProxy {
     return this.settings.targetIP!;
   }
 
+  /**
+   * Main method to start the proxy
+   */
   public async start() {
     // Don't start if already shutting down
     if (this.isShuttingDown) {
       console.log("Cannot start PortProxy while it's shutting down");
       return;
     }
+    
     // Define a unified connection handler for all listening ports.
     const connectionHandler = (socket: plugins.net.Socket) => {
       if (this.isShuttingDown) {
@@ -297,12 +584,31 @@ export class PortProxy {
       }
 
       const remoteIP = socket.remoteAddress || '';
-      const localPort = socket.localPort; // The port on which this connection was accepted.
+      const localPort = socket.localPort || 0; // The port on which this connection was accepted.
+      
+      // Check rate limits
+      if (this.settings.maxConnectionsPerIP &&
+          this.getConnectionCountByIP(remoteIP) >= this.settings.maxConnectionsPerIP) {
+        console.log(`Connection rejected from ${remoteIP}: Maximum connections per IP (${this.settings.maxConnectionsPerIP}) exceeded`);
+        socket.end();
+        socket.destroy();
+        return;
+      }
+      
+      if (this.settings.connectionRateLimitPerMinute && !this.checkConnectionRate(remoteIP)) {
+        console.log(`Connection rejected from ${remoteIP}: Connection rate limit (${this.settings.connectionRateLimitPerMinute}/min) exceeded`);
+        socket.end();
+        socket.destroy();
+        return;
+      }
       
       // Apply socket optimizations
       socket.setNoDelay(this.settings.noDelay);
-      socket.setKeepAlive(this.settings.keepAlive, this.settings.keepAliveInitialDelay);
+      if (this.settings.keepAlive) {
+        socket.setKeepAlive(true, this.settings.keepAliveInitialDelay);
+      }
       
+      // Create a unique connection ID and record
       const connectionId = generateConnectionId();
       const connectionRecord: IConnectionRecord = {
         id: connectionId,
@@ -311,12 +617,28 @@ export class PortProxy {
         incomingStartTime: Date.now(),
         lastActivity: Date.now(),
         connectionClosed: false,
-        pendingData: [], // Initialize buffer for pending data
-        pendingDataSize: 0 // Initialize buffer size counter
+        pendingData: [],
+        pendingDataSize: 0,
+        
+        // Initialize enhanced tracking fields
+        protocolType: 'unknown',
+        isPooledConnection: false,
+        bytesReceived: 0,
+        bytesSent: 0,
+        remoteIP: remoteIP,
+        localPort: localPort,
+        httpRequests: 0
       };
+      
+      // Track connection by IP
+      this.trackConnectionByIP(remoteIP, connectionId);
       this.connectionRecords.set(connectionId, connectionRecord);
       
-      console.log(`New connection from ${remoteIP} on port ${localPort}. Active connections: ${this.connectionRecords.size}`);
+      if (this.settings.enableDetailedLogging) {
+        console.log(`[${connectionId}] New connection from ${remoteIP} on port ${localPort}. Active connections: ${this.connectionRecords.size}`);
+      } else {
+        console.log(`New connection from ${remoteIP} on port ${localPort}. Active connections: ${this.connectionRecords.size}`);
+      }
 
       let initialDataReceived = false;
       let incomingTerminationReason: string | null = null;
@@ -327,15 +649,21 @@ export class PortProxy {
         this.cleanupConnection(connectionRecord);
       };
       
-      // Define initiateCleanupOnce for compatibility with potential future improvements
+      // Define initiateCleanupOnce for compatibility
       const initiateCleanupOnce = (reason: string = 'normal') => {
-        console.log(`Connection cleanup initiated for ${remoteIP} (${reason})`);
+        if (this.settings.enableDetailedLogging) {
+          console.log(`[${connectionId}] Connection cleanup initiated for ${remoteIP} (${reason})`);
+        }
+        if (incomingTerminationReason === null) {
+          incomingTerminationReason = reason;
+          this.incrementTerminationStat('incoming', reason);
+        }
         cleanupOnce();
       };
 
       // Helper to reject an incoming connection
       const rejectIncomingConnection = (reason: string, logMessage: string) => {
-        console.log(logMessage);
+        console.log(`[${connectionId}] ${logMessage}`);
         socket.end();
         if (incomingTerminationReason === null) {
           incomingTerminationReason = reason;
@@ -349,7 +677,7 @@ export class PortProxy {
       if (this.settings.sniEnabled) {
         initialTimeout = setTimeout(() => {
           if (!initialDataReceived) {
-            console.log(`Initial data timeout (${this.settings.initialDataTimeout}ms) for connection from ${remoteIP} on port ${localPort}`);
+            console.log(`[${connectionId}] Initial data timeout (${this.settings.initialDataTimeout}ms) for connection from ${remoteIP} on port ${localPort}`);
             if (incomingTerminationReason === null) {
               incomingTerminationReason = 'initial_timeout';
               this.incrementTerminationStat('incoming', 'initial_timeout');
@@ -357,24 +685,75 @@ export class PortProxy {
             socket.end();
             cleanupOnce();
           }
-        }, this.settings.initialDataTimeout || 5000);
+        }, this.settings.initialDataTimeout);
       } else {
         initialDataReceived = true;
       }
 
       socket.on('error', (err: Error) => {
-        console.log(`Incoming socket error from ${remoteIP}: ${err.message}`);
+        console.log(`[${connectionId}] Incoming socket error from ${remoteIP}: ${err.message}`);
+      });
+
+      // Track data for bytes counting
+      socket.on('data', (chunk: Buffer) => {
+        connectionRecord.bytesReceived += chunk.length;
+        this.updateActivity(connectionRecord);
+        
+        // Detect protocol on first data chunk
+        if (connectionRecord.protocolType === 'unknown') {
+          this.detectProtocol(chunk, connectionRecord);
+          
+          // Update timeout based on protocol
+          if (connectionRecord.cleanupTimer) {
+            clearTimeout(connectionRecord.cleanupTimer);
+            
+            // Set new timeout based on protocol
+            const protocolTimeout = this.getProtocolTimeout(connectionRecord);
+            connectionRecord.cleanupTimer = setTimeout(() => {
+              console.log(`[${connectionId}] ${connectionRecord.protocolType} connection timeout after ${plugins.prettyMs(protocolTimeout)}`);
+              initiateCleanupOnce(`${connectionRecord.protocolType}_timeout`);
+            }, protocolTimeout);
+          }
+        } else if (connectionRecord.protocolType === 'http' && isHttpRequest(chunk)) {
+          // Additional HTTP request on the same connection
+          connectionRecord.httpRequests++;
+          connectionRecord.lastHttpRequest = Date.now();
+          
+          // Parse HTTP headers again for keep-alive changes
+          this.parseHttpHeaders(chunk, connectionRecord);
+          
+          // Update timeout based on new HTTP headers
+          if (connectionRecord.cleanupTimer) {
+            clearTimeout(connectionRecord.cleanupTimer);
+            
+            // Set new timeout based on updated HTTP info
+            const protocolTimeout = this.getProtocolTimeout(connectionRecord);
+            connectionRecord.cleanupTimer = setTimeout(() => {
+              console.log(`[${connectionId}] HTTP connection timeout after ${plugins.prettyMs(protocolTimeout)}`);
+              initiateCleanupOnce('http_timeout');
+            }, protocolTimeout);
+          }
+        }
       });
 
       const handleError = (side: 'incoming' | 'outgoing') => (err: Error) => {
         const code = (err as any).code;
         let reason = 'error';
+        
+        const now = Date.now();
+        const connectionDuration = now - connectionRecord.incomingStartTime;
+        const lastActivityAge = now - connectionRecord.lastActivity;
+        
         if (code === 'ECONNRESET') {
           reason = 'econnreset';
-          console.log(`ECONNRESET on ${side} side from ${remoteIP}: ${err.message}`);
+          console.log(`[${connectionId}] ECONNRESET on ${side} side from ${remoteIP}: ${err.message}. Duration: ${plugins.prettyMs(connectionDuration)}, Last activity: ${plugins.prettyMs(lastActivityAge)} ago`);
+        } else if (code === 'ETIMEDOUT') {
+          reason = 'etimedout';
+          console.log(`[${connectionId}] ETIMEDOUT on ${side} side from ${remoteIP}: ${err.message}. Duration: ${plugins.prettyMs(connectionDuration)}, Last activity: ${plugins.prettyMs(lastActivityAge)} ago`);
         } else {
-          console.log(`Error on ${side} side from ${remoteIP}: ${err.message}`);
+          console.log(`[${connectionId}] Error on ${side} side from ${remoteIP}: ${err.message}. Duration: ${plugins.prettyMs(connectionDuration)}, Last activity: ${plugins.prettyMs(lastActivityAge)} ago`);
         }
+        
         if (side === 'incoming' && incomingTerminationReason === null) {
           incomingTerminationReason = reason;
           this.incrementTerminationStat('incoming', reason);
@@ -382,11 +761,15 @@ export class PortProxy {
           outgoingTerminationReason = reason;
           this.incrementTerminationStat('outgoing', reason);
         }
+        
         initiateCleanupOnce(reason);
       };
 
       const handleClose = (side: 'incoming' | 'outgoing') => () => {
-        console.log(`Connection closed on ${side} side from ${remoteIP}`);
+        if (this.settings.enableDetailedLogging) {
+          console.log(`[${connectionId}] Connection closed on ${side} side from ${remoteIP}`);
+        }
+        
         if (side === 'incoming' && incomingTerminationReason === null) {
           incomingTerminationReason = 'normal';
           this.incrementTerminationStat('incoming', 'normal');
@@ -396,6 +779,7 @@ export class PortProxy {
           // Record the time when outgoing socket closed.
           connectionRecord.outgoingClosedTime = Date.now();
         }
+        
         initiateCleanupOnce('closed_' + side);
       };
 
@@ -413,6 +797,11 @@ export class PortProxy {
           initialTimeout = null;
         }
         
+        // Detect protocol if initial chunk is available
+        if (initialChunk && this.settings.enableProtocolDetection) {
+          this.detectProtocol(initialChunk, connectionRecord);
+        }
+        
         // If a forcedDomain is provided (port-based routing), use it; otherwise, use SNI-based lookup.
         const domainConfig = forcedDomain
           ? forcedDomain
@@ -455,11 +844,19 @@ export class PortProxy {
 
         // Temporary handler to collect data during connection setup
         const tempDataHandler = (chunk: Buffer) => {
+          // Track bytes received
+          connectionRecord.bytesReceived += chunk.length;
+          
+          // Detect protocol even during connection setup
+          if (this.settings.enableProtocolDetection && connectionRecord.protocolType === 'unknown') {
+            this.detectProtocol(chunk, connectionRecord);
+          }
+          
           // Check if adding this chunk would exceed the buffer limit
           const newSize = connectionRecord.pendingDataSize + chunk.length;
           
           if (this.settings.maxPendingDataSize && newSize > this.settings.maxPendingDataSize) {
-            console.log(`Buffer limit exceeded for connection from ${remoteIP}: ${newSize} bytes > ${this.settings.maxPendingDataSize} bytes`);
+            console.log(`[${connectionId}] Buffer limit exceeded for connection from ${remoteIP}: ${newSize} bytes > ${this.settings.maxPendingDataSize} bytes`);
             socket.end(); // Gracefully close the socket
             return initiateCleanupOnce('buffer_limit_exceeded');
           }
@@ -475,6 +872,7 @@ export class PortProxy {
 
         // Add initial chunk to pending data if present
         if (initialChunk) {
+          connectionRecord.bytesReceived += initialChunk.length;
           connectionRecord.pendingData.push(Buffer.from(initialChunk));
           connectionRecord.pendingDataSize = initialChunk.length;
         }
@@ -486,25 +884,27 @@ export class PortProxy {
         
         // Apply socket optimizations
         targetSocket.setNoDelay(this.settings.noDelay);
-        targetSocket.setKeepAlive(this.settings.keepAlive, this.settings.keepAliveInitialDelay);
+        if (this.settings.keepAlive) {
+          targetSocket.setKeepAlive(true, this.settings.keepAliveInitialDelay);
+        }
         
         // Setup specific error handler for connection phase
         targetSocket.once('error', (err) => {
           // This handler runs only once during the initial connection phase
           const code = (err as any).code;
-          console.log(`Connection setup error to ${targetHost}:${connectionOptions.port}: ${err.message} (${code})`);
+          console.log(`[${connectionId}] Connection setup error to ${targetHost}:${connectionOptions.port}: ${err.message} (${code})`);
           
           // Resume the incoming socket to prevent it from hanging
           socket.resume();
           
           if (code === 'ECONNREFUSED') {
-            console.log(`Target ${targetHost}:${connectionOptions.port} refused connection`);
+            console.log(`[${connectionId}] Target ${targetHost}:${connectionOptions.port} refused connection`);
           } else if (code === 'ETIMEDOUT') {
-            console.log(`Connection to ${targetHost}:${connectionOptions.port} timed out`);
+            console.log(`[${connectionId}] Connection to ${targetHost}:${connectionOptions.port} timed out`);
           } else if (code === 'ECONNRESET') {
-            console.log(`Connection to ${targetHost}:${connectionOptions.port} was reset`);
+            console.log(`[${connectionId}] Connection to ${targetHost}:${connectionOptions.port} was reset`);
           } else if (code === 'EHOSTUNREACH') {
-            console.log(`Host ${targetHost} is unreachable`);
+            console.log(`[${connectionId}] Host ${targetHost} is unreachable`);
           }
           
           // Clear any existing error handler after connection phase
@@ -528,15 +928,16 @@ export class PortProxy {
         
         // Handle timeouts
         socket.on('timeout', () => {
-          console.log(`Timeout on incoming side from ${remoteIP}`);
+          console.log(`[${connectionId}] Timeout on incoming side from ${remoteIP} after ${plugins.prettyMs(this.settings.socketTimeout || 300000)}`);
           if (incomingTerminationReason === null) {
             incomingTerminationReason = 'timeout';
             this.incrementTerminationStat('incoming', 'timeout');
           }
           initiateCleanupOnce('timeout_incoming');
         });
+        
         targetSocket.on('timeout', () => {
-          console.log(`Timeout on outgoing side from ${remoteIP}`);
+          console.log(`[${connectionId}] Timeout on outgoing side from ${remoteIP} after ${plugins.prettyMs(this.settings.socketTimeout || 300000)}`);
           if (outgoingTerminationReason === null) {
             outgoingTerminationReason = 'timeout';
             this.incrementTerminationStat('outgoing', 'timeout');
@@ -544,9 +945,15 @@ export class PortProxy {
           initiateCleanupOnce('timeout_outgoing');
         });
 
-        // Set appropriate timeouts
-        socket.setTimeout(120000);
-        targetSocket.setTimeout(120000);
+        // Set appropriate timeouts using the configured value
+        socket.setTimeout(this.settings.socketTimeout || 300000);
+        targetSocket.setTimeout(this.settings.socketTimeout || 300000);
+        
+        // Track outgoing data for bytes counting
+        targetSocket.on('data', (chunk: Buffer) => {
+          connectionRecord.bytesSent += chunk.length;
+          this.updateActivity(connectionRecord);
+        });
         
         // Wait for the outgoing connection to be ready before setting up piping
         targetSocket.once('connect', () => {
@@ -564,7 +971,7 @@ export class PortProxy {
             const combinedData = Buffer.concat(connectionRecord.pendingData);
             targetSocket.write(combinedData, (err) => {
               if (err) {
-                console.log(`Error writing pending data to target: ${err.message}`);
+                console.log(`[${connectionId}] Error writing pending data to target: ${err.message}`);
                 return initiateCleanupOnce('write_error');
               }
               
@@ -573,10 +980,18 @@ export class PortProxy {
               targetSocket.pipe(socket);
               socket.resume(); // Resume the socket after piping is established
               
-              console.log(
-                `Connection established: ${remoteIP} -> ${targetHost}:${connectionOptions.port}` +
-                `${serverName ? ` (SNI: ${serverName})` : forcedDomain ? ` (Port-based for domain: ${forcedDomain.domains.join(', ')})` : ''}`
-              );
+              if (this.settings.enableDetailedLogging) {
+                console.log(
+                  `[${connectionId}] Connection established: ${remoteIP} -> ${targetHost}:${connectionOptions.port}` +
+                  `${serverName ? ` (SNI: ${serverName})` : forcedDomain ? ` (Port-based for domain: ${forcedDomain.domains.join(', ')})` : ''}` +
+                  ` Protocol: ${connectionRecord.protocolType}`
+                );
+              } else {
+                console.log(
+                  `Connection established: ${remoteIP} -> ${targetHost}:${connectionOptions.port}` +
+                  `${serverName ? ` (SNI: ${serverName})` : forcedDomain ? ` (Port-based for domain: ${forcedDomain.domains.join(', ')})` : ''}`
+                );
+              }
             });
           } else {
             // No pending data, so just set up piping
@@ -584,27 +999,25 @@ export class PortProxy {
             targetSocket.pipe(socket);
             socket.resume(); // Resume the socket after piping is established
             
-            console.log(
-              `Connection established: ${remoteIP} -> ${targetHost}:${connectionOptions.port}` +
-              `${serverName ? ` (SNI: ${serverName})` : forcedDomain ? ` (Port-based for domain: ${forcedDomain.domains.join(', ')})` : ''}`
-            );
+            if (this.settings.enableDetailedLogging) {
+              console.log(
+                `[${connectionId}] Connection established: ${remoteIP} -> ${targetHost}:${connectionOptions.port}` +
+                `${serverName ? ` (SNI: ${serverName})` : forcedDomain ? ` (Port-based for domain: ${forcedDomain.domains.join(', ')})` : ''}` +
+                ` Protocol: ${connectionRecord.protocolType}`
+              );
+            } else {
+              console.log(
+                `Connection established: ${remoteIP} -> ${targetHost}:${connectionOptions.port}` +
+                `${serverName ? ` (SNI: ${serverName})` : forcedDomain ? ` (Port-based for domain: ${forcedDomain.domains.join(', ')})` : ''}`
+              );
+            }
           }
           
           // Clear the buffer now that we've processed it
           connectionRecord.pendingData = [];
           connectionRecord.pendingDataSize = 0;
           
-          // Set up activity tracking
-          socket.on('data', () => {
-            connectionRecord.lastActivity = Date.now();
-          });
-          
-          targetSocket.on('data', () => {
-            connectionRecord.lastActivity = Date.now();
-          });
-          
-          // Add the renegotiation listener (we don't need setImmediate here anymore
-          // since we're already in the connect callback)
+          // Add the renegotiation listener for SNI validation
           if (serverName) {
             socket.on('data', (renegChunk: Buffer) => {
               if (renegChunk.length > 0 && renegChunk.readUInt8(0) === 22) {
@@ -612,26 +1025,30 @@ export class PortProxy {
                   // Try to extract SNI from potential renegotiation
                   const newSNI = extractSNI(renegChunk);
                   if (newSNI && newSNI !== connectionRecord.lockedDomain) {
-                    console.log(`Rehandshake detected with different SNI: ${newSNI} vs locked ${connectionRecord.lockedDomain}. Terminating connection.`);
+                    console.log(`[${connectionId}] Rehandshake detected with different SNI: ${newSNI} vs locked ${connectionRecord.lockedDomain}. Terminating connection.`);
                     initiateCleanupOnce('sni_mismatch');
-                  } else if (newSNI) {
-                    console.log(`Rehandshake detected with same SNI: ${newSNI}. Allowing.`);
+                  } else if (newSNI && this.settings.enableDetailedLogging) {
+                    console.log(`[${connectionId}] Rehandshake detected with same SNI: ${newSNI}. Allowing.`);
                   }
                 } catch (err) {
-                  console.log(`Error processing potential renegotiation: ${err}. Allowing connection to continue.`);
+                  console.log(`[${connectionId}] Error processing potential renegotiation: ${err}. Allowing connection to continue.`);
                 }
               }
             });
           }
-        });
-
-        // Initialize a cleanup timer for max connection lifetime
-        if (this.settings.maxConnectionLifetime) {
+          
+          // Set protocol-specific timeout based on detected protocol
+          if (connectionRecord.cleanupTimer) {
+            clearTimeout(connectionRecord.cleanupTimer);
+          }
+          
+          // Set timeout based on protocol
+          const protocolTimeout = this.getProtocolTimeout(connectionRecord, domainConfig);
           connectionRecord.cleanupTimer = setTimeout(() => {
-            console.log(`Connection from ${remoteIP} exceeded max lifetime (${this.settings.maxConnectionLifetime}ms), forcing cleanup.`);
-            initiateCleanupOnce('max_lifetime');
-          }, this.settings.maxConnectionLifetime);
-        }
+            console.log(`[${connectionId}] ${connectionRecord.protocolType} connection exceeded max lifetime (${plugins.prettyMs(protocolTimeout)}), forcing cleanup.`);
+            initiateCleanupOnce(`${connectionRecord.protocolType}_max_lifetime`);
+          }, protocolTimeout);
+        });
       };
 
       // --- PORT RANGE-BASED HANDLING ---
@@ -639,11 +1056,13 @@ export class PortProxy {
       if (this.settings.globalPortRanges && isPortInRanges(localPort, this.settings.globalPortRanges)) {
         if (this.settings.forwardAllGlobalRanges) {
           if (this.settings.defaultAllowedIPs && !isAllowed(remoteIP, this.settings.defaultAllowedIPs)) {
-            console.log(`Connection from ${remoteIP} rejected: IP ${remoteIP} not allowed in global default allowed list.`);
+            console.log(`[${connectionId}] Connection from ${remoteIP} rejected: IP ${remoteIP} not allowed in global default allowed list.`);
             socket.end();
             return;
           }
-          console.log(`Port-based connection from ${remoteIP} on port ${localPort} forwarded to global target IP ${this.settings.targetIP}.`);
+          if (this.settings.enableDetailedLogging) {
+            console.log(`[${connectionId}] Port-based connection from ${remoteIP} on port ${localPort} forwarded to global target IP ${this.settings.targetIP}.`);
+          }
           setupConnection('', undefined, {
             domains: ['global'],
             allowedIPs: this.settings.defaultAllowedIPs || [],
@@ -667,11 +1086,13 @@ export class PortProxy {
               ...(this.settings.defaultBlockedIPs || [])
             ];
             if (!isGlobIPAllowed(remoteIP, effectiveAllowedIPs, effectiveBlockedIPs)) {
-              console.log(`Connection from ${remoteIP} rejected: IP not allowed for domain ${forcedDomain.domains.join(', ')} on port ${localPort}.`);
+              console.log(`[${connectionId}] Connection from ${remoteIP} rejected: IP not allowed for domain ${forcedDomain.domains.join(', ')} on port ${localPort}.`);
               socket.end();
               return;
             }
-            console.log(`Port-based connection from ${remoteIP} on port ${localPort} matched domain ${forcedDomain.domains.join(', ')}.`);
+            if (this.settings.enableDetailedLogging) {
+              console.log(`[${connectionId}] Port-based connection from ${remoteIP} on port ${localPort} matched domain ${forcedDomain.domains.join(', ')}.`);
+            }
             setupConnection('', undefined, forcedDomain, localPort);
             return;
           }
@@ -693,7 +1114,10 @@ export class PortProxy {
           const serverName = extractSNI(chunk) || '';
           // Lock the connection to the negotiated SNI.
           connectionRecord.lockedDomain = serverName;
-          console.log(`Received connection from ${remoteIP} with SNI: ${serverName}`);
+          
+          if (this.settings.enableDetailedLogging) {
+            console.log(`[${connectionId}] Received connection from ${remoteIP} with SNI: ${serverName || '(empty)'}`);
+          }
           
           setupConnection(serverName, chunk);
         });
@@ -735,15 +1159,19 @@ export class PortProxy {
       this.netServers.push(server);
     }
 
-    // Log active connection count, longest running durations, and run parity checks every 10 seconds.
+    // Log active connection count, longest running durations, and run parity checks periodically
     this.connectionLogger = setInterval(() => {
       // Immediately return if shutting down
       if (this.isShuttingDown) return;
-      if (this.isShuttingDown) return;
       
       const now = Date.now();
       let maxIncoming = 0;
       let maxOutgoing = 0;
+      let httpConnections = 0;
+      let wsConnections = 0;
+      let tlsConnections = 0;
+      let unknownConnections = 0;
+      let pooledConnections = 0;
       
       // Create a copy of the keys to avoid modification during iteration
       const connectionIds = [...this.connectionRecords.keys()];
@@ -752,6 +1180,19 @@ export class PortProxy {
         const record = this.connectionRecords.get(id);
         if (!record) continue;
         
+        // Track connection stats by protocol
+        switch (record.protocolType) {
+          case 'http': httpConnections++; break;
+          case 'websocket': wsConnections++; break;
+          case 'tls':
+          case 'https': tlsConnections++; break;
+          default: unknownConnections++; break;
+        }
+        
+        if (record.isPooledConnection) {
+          pooledConnections++;
+        }
+        
         maxIncoming = Math.max(maxIncoming, now - record.incomingStartTime);
         if (record.outgoingStartTime) {
           maxOutgoing = Math.max(maxOutgoing, now - record.outgoingStartTime);
@@ -762,30 +1203,51 @@ export class PortProxy {
             !record.incoming.destroyed && 
             !record.connectionClosed && 
             (now - record.outgoingClosedTime > 30000)) {
-          const remoteIP = record.incoming.remoteAddress || 'unknown';
-          console.log(`Parity check: Incoming socket for ${remoteIP} still active ${plugins.prettyMs(now - record.outgoingClosedTime)} after outgoing closed.`);
+          const remoteIP = record.remoteIP;
+          console.log(`[${id}] Parity check: Incoming socket for ${remoteIP} still active ${plugins.prettyMs(now - record.outgoingClosedTime)} after outgoing closed.`);
           this.cleanupConnection(record, 'parity_check');
         }
         
-        // Inactivity check
-        const inactivityTime = now - record.lastActivity;
-        if (inactivityTime > 180000 && // 3 minutes
-            !record.connectionClosed) {
-          const remoteIP = record.incoming.remoteAddress || 'unknown';
-          console.log(`Inactivity check: No activity on connection from ${remoteIP} for ${plugins.prettyMs(inactivityTime)}.`);
-          this.cleanupConnection(record, 'inactivity');
+        // Skip inactivity check if disabled
+        if (!this.settings.disableInactivityCheck) {
+          // Inactivity check - use protocol-specific values
+          let inactivityThreshold = Math.floor(Math.random() * (1800000 - 1200000 + 1)) + 1200000; // random between 20 and 30 minutes
+          
+          // Set protocol-specific inactivity thresholds
+          if (record.protocolType === 'http' && record.isPooledConnection) {
+            inactivityThreshold = this.settings.httpKeepAliveTimeout || 1200000; // 20 minutes for pooled HTTP
+          } else if (record.protocolType === 'websocket') {
+            inactivityThreshold = this.settings.wsConnectionTimeout || 14400000; // 4 hours for WebSocket
+          } else if (record.protocolType === 'http') {
+            inactivityThreshold = this.settings.httpConnectionTimeout || 1800000; // 30 minutes for HTTP
+          }
+          
+          const inactivityTime = now - record.lastActivity;
+          if (inactivityTime > inactivityThreshold && !record.connectionClosed) {
+            console.log(`[${id}] Inactivity check: No activity on ${record.protocolType} connection from ${record.remoteIP} for ${plugins.prettyMs(inactivityTime)}.`);
+            this.cleanupConnection(record, 'inactivity');
+          }
         }
       }
       
+      // Log detailed stats periodically
       console.log(
-        `(Interval Log) Active connections: ${this.connectionRecords.size}. ` +
-        `Longest running incoming: ${plugins.prettyMs(maxIncoming)}, outgoing: ${plugins.prettyMs(maxOutgoing)}. ` +
-        `Termination stats (incoming): ${JSON.stringify(this.terminationStats.incoming)}, ` +
-        `(outgoing): ${JSON.stringify(this.terminationStats.outgoing)}`
+        `Active connections: ${this.connectionRecords.size}. ` +
+        `Types: HTTP=${httpConnections}, WS=${wsConnections}, TLS=${tlsConnections}, Unknown=${unknownConnections}, Pooled=${pooledConnections}. ` +
+        `Longest running: IN=${plugins.prettyMs(maxIncoming)}, OUT=${plugins.prettyMs(maxOutgoing)}. ` +
+        `Termination stats: ${JSON.stringify({IN: this.terminationStats.incoming, OUT: this.terminationStats.outgoing})}`
       );
-    }, 10000);
+    }, this.settings.inactivityCheckInterval || 30000);
+    
+    // Make sure the interval doesn't keep the process alive
+    if (this.connectionLogger.unref) {
+      this.connectionLogger.unref();
+    }
   }
 
+  /**
+   * Gracefully shut down the proxy
+   */
   public async stop() {
     console.log("PortProxy shutting down...");
     this.isShuttingDown = true;
@@ -874,13 +1336,11 @@ export class PortProxy {
       }
     }
     
-    // Clear the connection records map
+    // Clear all tracking maps
     this.connectionRecords.clear();
-    
-    // Clear the domain target indices map to prevent memory leaks
     this.domainTargetIndices.clear();
-    
-    // Clear any servers array
+    this.connectionsByIP.clear();
+    this.connectionRateByIP.clear();
     this.netServers = [];
     
     // Reset termination stats