@push.rocks/smartproxy 25.9.2 → 25.10.2

package/changelog.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 2026-03-12 - 25.10.2 - fix(repo)
+no code changes to release
+
+
+## 2026-03-12 - 25.10.1 - fix(repo)
+no changes to commit
+
+
+## 2026-03-12 - 25.10.0 - feat(metrics)
+add per-backend connection, error, protocol, and pool metrics with stale backend pruning
+
+- tracks backend connection lifecycle, connect timing, protocol detection, pool hit/miss rates, handshake/request errors, and h2 fallback failures in Rust metrics
+- exposes backend metrics through the TypeScript metrics adapter with backend listings, protocol lookup, and top error summaries
+- prunes backend metrics for backends no longer referenced by active routes, including preserved-port targets expanded across listening ports
+
+## 2026-03-11 - 25.9.3 - fix(rustproxy-http)
+Evict stale HTTP/2 pooled senders and retry bodyless requests with fresh backend connections to avoid 502s
+
+- Introduce MAX_H2_AGE (120s) and evict HTTP/2 senders older than this or closed
+- Check MAX_H2_AGE on checkout and during background eviction to prevent reuse of stale h2 connections
+- Add connection_pool.remove_h2() to explicitly remove dead H2 senders from the pool
+- When a pooled H2 request returns a 502 and the original request had an empty body, retry using a fresh H2 connection (retry_h2_with_fresh_connection)
+- On H2 auto-detect failures, retry as HTTP/1.1 for bodyless requests via forward_h1_empty_body; return 502 for requests with bodies
+- Evict dead H2 senders on backend request failures in reconnect_backend so subsequent attempts create fresh connections
+
 ## 2026-03-08 - 25.9.2 - fix(protocol-cache)
 Include requested_host in protocol detection cache key to avoid cache oscillation when multiple frontend domains share the same backend
 

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartproxy',
-    version: '25.9.2',
+    version: '25.10.2',
     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.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHFQQUFxUDtDQUNuUSxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFNBQVM7SUFDbEIsV0FBVyxFQUFFLHFQQUFxUDtDQUNuUSxDQUFBIn0=

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

@@ -59,6 +59,14 @@ export interface IMetrics {
         bytesOut(): number;
         connections(): number;
     };
+    backends: {
+        byBackend(): Map<string, IBackendMetrics>;
+        protocols(): Map<string, string>;
+        topByErrors(limit?: number): Array<{
+            backend: string;
+            errors: number;
+        }>;
+    };
     percentiles: {
         connectionDuration(): {
             p50: number;
@@ -93,6 +101,20 @@ export interface IMetricsConfig {
     prometheusPath: string;
     prometheusPrefix: string;
 }
+/**
+ * Per-backend metrics
+ */
+export interface IBackendMetrics {
+    protocol: string;
+    activeConnections: number;
+    totalConnections: number;
+    connectErrors: number;
+    handshakeErrors: number;
+    requestErrors: number;
+    avgConnectTimeMs: number;
+    poolHitRate: number;
+    h2Failures: number;
+}
 /**
  * Internal interface for connection byte tracking
  */

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

@@ -1,4 +1,4 @@
-import type { IMetrics, IThroughputData, IThroughputHistoryPoint } from './models/metrics-types.js';
+import type { IMetrics, IBackendMetrics, IThroughputData, IThroughputHistoryPoint } from './models/metrics-types.js';
 import type { RustProxyBridge } from './rust-proxy-bridge.js';
 /**
  * Adapts Rust JSON metrics to the IMetrics interface.
@@ -52,6 +52,14 @@ export declare class RustMetricsAdapter implements IMetrics {
         bytesOut: () => number;
         connections: () => number;
     };
+    backends: {
+        byBackend: () => Map<string, IBackendMetrics>;
+        protocols: () => Map<string, string>;
+        topByErrors: (limit?: number) => Array<{
+            backend: string;
+            errors: number;
+        }>;
+    };
     percentiles: {
         connectionDuration: () => {
             p50: number;

package/dist_ts/proxies/smart-proxy/rust-metrics-adapter.js

@@ -125,6 +125,55 @@ export class RustMetricsAdapter {
                 return this.cache?.totalConnections ?? 0;
             },
         };
+        this.backends = {
+            byBackend: () => {
+                const result = new Map();
+                if (this.cache?.backends) {
+                    for (const [key, bm] of Object.entries(this.cache.backends)) {
+                        const m = bm;
+                        const totalTimeUs = m.totalConnectTimeUs ?? 0;
+                        const count = m.connectCount ?? 0;
+                        const poolHits = m.poolHits ?? 0;
+                        const poolMisses = m.poolMisses ?? 0;
+                        const poolTotal = poolHits + poolMisses;
+                        result.set(key, {
+                            protocol: m.protocol ?? 'unknown',
+                            activeConnections: m.activeConnections ?? 0,
+                            totalConnections: m.totalConnections ?? 0,
+                            connectErrors: m.connectErrors ?? 0,
+                            handshakeErrors: m.handshakeErrors ?? 0,
+                            requestErrors: m.requestErrors ?? 0,
+                            avgConnectTimeMs: count > 0 ? (totalTimeUs / count) / 1000 : 0,
+                            poolHitRate: poolTotal > 0 ? poolHits / poolTotal : 0,
+                            h2Failures: m.h2Failures ?? 0,
+                        });
+                    }
+                }
+                return result;
+            },
+            protocols: () => {
+                const result = new Map();
+                if (this.cache?.backends) {
+                    for (const [key, bm] of Object.entries(this.cache.backends)) {
+                        result.set(key, bm.protocol ?? 'unknown');
+                    }
+                }
+                return result;
+            },
+            topByErrors: (limit = 10) => {
+                const result = [];
+                if (this.cache?.backends) {
+                    for (const [key, bm] of Object.entries(this.cache.backends)) {
+                        const m = bm;
+                        const errors = (m.connectErrors ?? 0) + (m.handshakeErrors ?? 0) + (m.requestErrors ?? 0);
+                        if (errors > 0)
+                            result.push({ backend: key, errors });
+                    }
+                }
+                result.sort((a, b) => b.errors - a.errors);
+                return result.slice(0, limit);
+            },
+        };
         this.percentiles = {
             connectionDuration: () => {
                 return { p50: 0, p95: 0, p99: 0 };
@@ -169,4 +218,4 @@ export class RustMetricsAdapter {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-metrics-adapter.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/rust-metrics-adapter.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "25.9.2",
+  "version": "25.10.2",
   "private": false,
   "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.",
   "main": "dist_ts/index.js",

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartproxy',
-  version: '25.9.2',
+  version: '25.10.2',
   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/proxies/smart-proxy/models/metrics-types.ts

@@ -67,6 +67,13 @@ export interface IMetrics {
     connections(): number;
   };
   
+  // Backend metrics
+  backends: {
+    byBackend(): Map<string, IBackendMetrics>;
+    protocols(): Map<string, string>;
+    topByErrors(limit?: number): Array<{ backend: string; errors: number }>;
+  };
+
   // Performance metrics
   percentiles: {
     connectionDuration(): { p50: number; p95: number; p99: number };
@@ -98,6 +105,21 @@ export interface IMetricsConfig {
   prometheusPrefix: string;        // Default: smartproxy_
 }
 
+/**
+ * Per-backend metrics
+ */
+export interface IBackendMetrics {
+  protocol: string;
+  activeConnections: number;
+  totalConnections: number;
+  connectErrors: number;
+  handshakeErrors: number;
+  requestErrors: number;
+  avgConnectTimeMs: number;
+  poolHitRate: number;
+  h2Failures: number;
+}
+
 /**
  * Internal interface for connection byte tracking
  */

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

@@ -1,4 +1,4 @@
-import type { IMetrics, IThroughputData, IThroughputHistoryPoint } from './models/metrics-types.js';
+import type { IMetrics, IBackendMetrics, IThroughputData, IThroughputHistoryPoint } from './models/metrics-types.js';
 import type { RustProxyBridge } from './rust-proxy-bridge.js';
 
 /**
@@ -169,6 +169,55 @@ export class RustMetricsAdapter implements IMetrics {
     },
   };
 
+  public backends = {
+    byBackend: (): Map<string, IBackendMetrics> => {
+      const result = new Map<string, IBackendMetrics>();
+      if (this.cache?.backends) {
+        for (const [key, bm] of Object.entries(this.cache.backends)) {
+          const m = bm as any;
+          const totalTimeUs = m.totalConnectTimeUs ?? 0;
+          const count = m.connectCount ?? 0;
+          const poolHits = m.poolHits ?? 0;
+          const poolMisses = m.poolMisses ?? 0;
+          const poolTotal = poolHits + poolMisses;
+          result.set(key, {
+            protocol: m.protocol ?? 'unknown',
+            activeConnections: m.activeConnections ?? 0,
+            totalConnections: m.totalConnections ?? 0,
+            connectErrors: m.connectErrors ?? 0,
+            handshakeErrors: m.handshakeErrors ?? 0,
+            requestErrors: m.requestErrors ?? 0,
+            avgConnectTimeMs: count > 0 ? (totalTimeUs / count) / 1000 : 0,
+            poolHitRate: poolTotal > 0 ? poolHits / poolTotal : 0,
+            h2Failures: m.h2Failures ?? 0,
+          });
+        }
+      }
+      return result;
+    },
+    protocols: (): Map<string, string> => {
+      const result = new Map<string, string>();
+      if (this.cache?.backends) {
+        for (const [key, bm] of Object.entries(this.cache.backends)) {
+          result.set(key, (bm as any).protocol ?? 'unknown');
+        }
+      }
+      return result;
+    },
+    topByErrors: (limit: number = 10): Array<{ backend: string; errors: number }> => {
+      const result: Array<{ backend: string; errors: number }> = [];
+      if (this.cache?.backends) {
+        for (const [key, bm] of Object.entries(this.cache.backends)) {
+          const m = bm as any;
+          const errors = (m.connectErrors ?? 0) + (m.handshakeErrors ?? 0) + (m.requestErrors ?? 0);
+          if (errors > 0) result.push({ backend: key, errors });
+        }
+      }
+      result.sort((a, b) => b.errors - a.errors);
+      return result.slice(0, limit);
+    },
+  };
+
   public percentiles = {
     connectionDuration: (): { p50: number; p95: number; p99: number } => {
       return { p50: 0, p95: 0, p99: 0 };