@push.rocks/smartproxy 27.19.0 → 27.21.0

package/readme.metrics.md

@@ -4,12 +4,18 @@
 
 Two-tier design separating the data plane from the observation plane:
 
-**Hot path (per-chunk, lock-free):** All recording in the proxy data plane touches only `AtomicU64` counters. No `Mutex` is ever acquired on the forwarding path. `CountingBody` batches flushes every 64KB to reduce DashMap shard contention.
+**Byte recording (per-chunk):** Byte recording uses `AtomicU64` counters. `CountingBody` batches flushes every 64KB to reduce DashMap shard contention. Per-domain HTTP request recording uses a short tracker mutex; admitting a new domain also takes an admission mutex.
 
 **Cold path (1Hz sampling):** A background tokio task drains pending atomics into `ThroughputTracker` circular buffers (Mutex-guarded), producing per-second throughput history. Same task prunes orphaned entries and cleans up rate limiter state.
 
 **Read path (on-demand):** `snapshot()` reads all atomics and locks ThroughputTrackers to build a serializable `Metrics` struct. TypeScript polls this at 1s intervals via IPC.
 
+Metrics polling allows one outstanding snapshot RPC. Slow polls coalesce; stopping drains the outstanding poll and clears the snapshot/history caches. Native shutdown awaits confirmed child and stdio closure through SmartRust.
+
+Global HTTP domain rates retain at most 4,096 canonical domain keys, each at most 253 bytes. Idle trackers expire after their 60 completed one-second samples become empty. `requests.byDomain()` contains individually tracked domains. `requests.domainOverflow?.()` returns `{ perSecond, lastMinute }` for requests that could not receive an individual bucket. Overflow is separate from domain attribution; global request totals remain unchanged. Overflow requests are not retroactively assigned when a bucket later becomes available.
+
+Active connection pages retain the smallest `limit + 1` matching IDs in a bounded heap, then clone metadata for those IDs. Work remains a scan of active connections, with O(page size) temporary storage rather than cloning/sorting the full registry. Connections closing during a scan may leave a short page; cursor order and filtering remain best effort under concurrent changes.
+
 ```
 Data Plane (lock-free)                Background (1Hz)              Read Path
 ─────────────────────                 ──────────────────             ─────────

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartproxy',
-  version: '27.19.0',
+  version: '27.21.0',
   description: 'A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.'
 }

package/ts/core/models/route-context.ts

@@ -1,4 +1,5 @@
 import * as plugins from '../../plugins.js';
+import type { TIngressOrigin } from '../../proxies/smart-proxy/models/route-types.js';
 
 /**
  * Shared Route Context Interface
@@ -16,6 +17,7 @@ export interface IRouteContext {
   domain?: string;       // The domain from SNI or Host header
   clientIp: string;      // The client's IP address
   serverIp: string;      // The server's IP address
+  ingressOrigin?: TIngressOrigin; // Trusted connection-origin classification
   vpn?: {                // Authenticated VPN identity from trusted PROXY v2 metadata
     clientId: string;
     assignedIp: string;

package/ts/proxies/smart-proxy/datagram-handler-server.ts

@@ -13,8 +13,17 @@ interface IDatagramRelayMessage {
   routeKey: string;
   sourceIp: string;
   sourcePort: number;
+  clientIp?: string;
+  clientPort?: number;
   destPort: number;
   payloadBase64: string;
+  ingressOrigin?: 'direct' | 'trustedProxy' | 'smartVpn';
+  vpn?: {
+    clientId: string;
+    assignedIp: string;
+    transportType?: string;
+    remoteAddr?: string;
+  };
 }
 
 /**
@@ -179,8 +188,10 @@ export class DatagramHandlerServer {
     const context: IRouteContext = {
       port: msg.destPort,
       domain: undefined,
-      clientIp: msg.sourceIp,
+      clientIp: msg.clientIp || msg.sourceIp,
       serverIp: '0.0.0.0',
+      ingressOrigin: msg.ingressOrigin,
+      vpn: msg.vpn,
       path: undefined,
       isTls: false,
       tlsVersion: undefined,
@@ -191,8 +202,8 @@ export class DatagramHandlerServer {
     };
 
     const info: IDatagramInfo = {
-      sourceIp: msg.sourceIp,
-      sourcePort: msg.sourcePort,
+      sourceIp: msg.clientIp || msg.sourceIp,
+      sourcePort: msg.clientPort ?? msg.sourcePort,
       destPort: msg.destPort,
       context,
     };

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

@@ -101,6 +101,8 @@ export interface IMetrics {
     perMinute(): number;
     total(): number;
     byDomain(): Map<string, IRequestRateMetrics>;
+    /** Requests beyond the 4096-domain/253-byte key budget, without individual attribution. */
+    domainOverflow?(): IRequestRateMetrics;
   };
   
   // Cumulative totals

package/ts/proxies/smart-proxy/models/route-types.ts

@@ -24,6 +24,11 @@ export type TTlsMode = 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
  */
 export type TTransportProtocol = 'tcp' | 'udp' | 'all';
 
+/**
+ * Trusted transport path established by SmartProxy for an accepted connection.
+ */
+export type TIngressOrigin = 'direct' | 'trustedProxy' | 'smartVpn';
+
 /**
  * Inbound PROXY protocol handling for a listener.
  */
@@ -197,6 +202,11 @@ export interface IRouteSecurity {
     allowedAssignedIps?: string[];
   };
 
+  ingress?: {
+    /** Omit ingress entirely for legacy all-origin behavior. */
+    allowedOrigins: TIngressOrigin[];
+  };
+
   /** Browser-facing challenge policy. SmartProxy enforces this in the HTTP path. */
   challenge?: plugins.smartchallenge.IRouteChallengeConfig;
 }

package/ts/proxies/smart-proxy/models/rust-types.ts

@@ -178,6 +178,7 @@ export interface IRustMetricsSnapshot {
   httpRequestsPerSec: number;
   httpRequestsPerSecRecent: number;
   httpDomainRequests: Record<string, IRustHttpDomainRequestMetrics>;
+  httpDomainRequestsOverflow?: IRustHttpDomainRequestMetrics;
   activeUdpSessions: number;
   totalUdpSessions: number;
   totalDatagramsIn: number;

package/ts/proxies/smart-proxy/rust-metrics-adapter.ts

@@ -89,6 +89,9 @@ export class RustMetricsAdapter implements IMetrics {
   private historyCache: IRustMetricsHistory | null = null;
   private pollTimer: ReturnType<typeof setInterval> | null = null;
   private pollIntervalMs: number;
+  private pollPromise: Promise<void> | null = null;
+  private generation = 0;
+  private stopped = false;
 
   constructor(bridge: RustProxyBridge, pollIntervalMs = 1000) {
     this.bridge = bridge;
@@ -98,20 +101,29 @@ export class RustMetricsAdapter implements IMetrics {
   /**
    * Poll Rust for metrics once. Can be awaited to ensure cache is fresh.
    */
-  public async poll(): Promise<void> {
-    try {
-      this.cache = await this.bridge.getMetrics();
-    } catch {
-      // Ignore poll errors (bridge may be shutting down)
-    }
+  public poll(): Promise<void> {
+    if (this.stopped) return Promise.resolve();
+    if (this.pollPromise) return this.pollPromise;
+    const generation = this.generation;
+    this.pollPromise = (async () => {
+      try {
+        const metrics = await this.bridge.getMetrics();
+        if (!this.stopped && generation === this.generation) this.cache = metrics;
+      } catch {
+        // A failed poll leaves the last successful snapshot available until stop.
+      }
+    })().finally(() => { this.pollPromise = null; });
+    return this.pollPromise;
   }
 
   /**
    * Fetch histories only when an observer needs them; regular polling stays lightweight.
    */
   public async refreshHistory(seconds: number): Promise<IMetricsHistory> {
+    if (this.stopped) throw new Error('Metrics adapter is stopped');
+    const generation = this.generation;
     const history = await this.bridge.getMetricsHistory(seconds);
-    this.historyCache = history;
+    if (!this.stopped && generation === this.generation) this.historyCache = history;
     return {
       throughputHistory: history.throughputHistory.map((point) => ({
         timestamp: point.timestampMs,
@@ -129,6 +141,7 @@ export class RustMetricsAdapter implements IMetrics {
 
   public startPolling(): void {
     if (this.pollTimer) return;
+    this.stopped = false;
     // Immediate first poll so cache is populated ASAP
     this.poll();
     this.pollTimer = setInterval(() => {
@@ -139,11 +152,16 @@ export class RustMetricsAdapter implements IMetrics {
     }
   }
 
-  public stopPolling(): void {
+  public async stopPolling(): Promise<void> {
+    this.stopped = true;
+    this.generation++;
     if (this.pollTimer) {
       clearInterval(this.pollTimer);
       this.pollTimer = null;
     }
+    this.cache = null;
+    this.historyCache = null;
+    await this.pollPromise;
   }
 
   // --- IMetrics implementation ---
@@ -322,6 +340,10 @@ export class RustMetricsAdapter implements IMetrics {
     total: (): number => {
       return this.cache?.totalHttpRequests ?? this.cache?.totalConnections ?? 0;
     },
+    domainOverflow: (): IRequestRateMetrics => ({
+      perSecond: this.cache?.httpDomainRequestsOverflow?.requestsPerSecond ?? 0,
+      lastMinute: this.cache?.httpDomainRequestsOverflow?.requestsLastMinute ?? 0,
+    }),
     byDomain: (): Map<string, IRequestRateMetrics> => {
       const result = new Map<string, IRequestRateMetrics>();
       if (this.cache?.httpDomainRequests) {

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

@@ -141,6 +141,11 @@ export class RustProxyBridge extends plugins.EventEmitter {
     this.bridge.kill();
   }
 
+  /** Resolve only when the owned native child and its stdio handles have closed. */
+  public async terminate(): Promise<void> {
+    await this.bridge.terminate();
+  }
+
   /**
    * Whether the bridge is currently running.
    */

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

@@ -319,7 +319,7 @@ export class SmartProxy extends plugins.EventEmitter {
     }
 
     // Stop metrics polling
-    this.metricsAdapter.stopPolling();
+    await this.metricsAdapter.stopPolling();
 
     // Remove exit listener before killing to avoid spurious error events
     this.bridge.removeAllListeners('exit');
@@ -330,7 +330,7 @@ export class SmartProxy extends plugins.EventEmitter {
     } catch {
       // Ignore if already stopped
     }
-    this.bridge.kill();
+    await this.bridge.terminate();
 
     // Stop socket handler relay
     if (this.socketHandlerServer) {
@@ -582,7 +582,7 @@ export class SmartProxy extends plugins.EventEmitter {
   // --- Private helpers ---
 
   private async cleanupRuntimeResourcesAfterStartFailure(didSpawn: boolean): Promise<void> {
-    this.metricsAdapter.stopPolling();
+    await this.metricsAdapter.stopPolling();
 
     if (this.nftablesManager) {
       await this.nftablesManager.cleanup().catch((err) => {
@@ -616,7 +616,7 @@ export class SmartProxy extends plugins.EventEmitter {
     if (didSpawn) {
       this.bridge.removeAllListeners('exit');
       await this.bridge.stopProxy().catch(() => undefined);
-      this.bridge.kill();
+      await this.bridge.terminate();
     }
   }
 

package/ts/proxies/smart-proxy/socket-handler-server.ts

@@ -169,6 +169,7 @@ export class SocketHandlerServer {
       domain: metadata.domain,
       clientIp: metadata.remoteIP || 'unknown',
       serverIp: '0.0.0.0',
+      ingressOrigin: metadata.ingressOrigin,
       vpn: metadata.vpn,
       path: metadata.path,
       isTls: metadata.isTLS || false,

package/ts/proxies/smart-proxy/utils/route-validator.ts

@@ -269,6 +269,34 @@ export class RouteValidator {
         }
       }
 
+      if (route.security.ingress) {
+        const origins = route.security.ingress.allowedOrigins;
+        if (!Array.isArray(origins) || origins.length === 0) {
+          errors.push('security.ingress.allowedOrigins must be a non-empty array');
+        } else {
+          const supportedOrigins = new Set(['direct', 'trustedProxy', 'smartVpn']);
+          const uniqueOrigins = new Set(origins);
+          if (uniqueOrigins.size !== origins.length) {
+            errors.push('security.ingress.allowedOrigins must not contain duplicates');
+          }
+          for (const origin of origins) {
+            if (!supportedOrigins.has(origin)) {
+              errors.push(`Invalid security ingress origin: ${origin}`);
+            }
+          }
+
+          const inboundMode = route.match.inboundProxyProtocol?.mode;
+          const allowsDirect = origins.includes('direct');
+          const allowsTrustedProxy = origins.includes('trustedProxy') || origins.includes('smartVpn');
+          if (allowsDirect && inboundMode === 'required') {
+            errors.push('inboundProxyProtocol.required conflicts with the allowed direct ingress origin');
+          }
+          if (allowsTrustedProxy && inboundMode === 'reject') {
+            errors.push('inboundProxyProtocol.reject conflicts with trustedProxy or smartVpn ingress origins');
+          }
+        }
+      }
+
       // Validate connection limits
       if (route.security.maxConnections && route.security.maxConnections < 0) {
         errors.push('Max connections must be positive');