@push.rocks/smartproxy 19.5.26 → 19.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "19.5.26",
+  "version": "19.6.1",
   "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",
@@ -8,6 +8,12 @@
   "type": "module",
   "author": "Lossless GmbH",
   "license": "MIT",
+  "scripts": {
+    "test": "(tstest test/**/test*.ts --verbose --timeout 60 --logfile)",
+    "build": "(tsbuild tsfolders --allowimplicitany)",
+    "format": "(gitzone format)",
+    "buildDocs": "tsdoc"
+  },
   "devDependencies": {
     "@git.zone/tsbuild": "^2.6.4",
     "@git.zone/tsrun": "^1.2.44",
@@ -25,6 +31,7 @@
     "@push.rocks/smartnetwork": "^4.0.2",
     "@push.rocks/smartpromise": "^4.2.3",
     "@push.rocks/smartrequest": "^2.1.0",
+    "@push.rocks/smartrx": "^3.0.10",
     "@push.rocks/smartstring": "^4.0.15",
     "@push.rocks/taskbuffer": "^3.1.7",
     "@tsclass/tsclass": "^9.2.0",
@@ -74,10 +81,13 @@
   "bugs": {
     "url": "https://code.foss.global/push.rocks/smartproxy/issues"
   },
-  "scripts": {
-    "test": "(tstest test/**/test*.ts --verbose --timeout 60 --logfile)",
-    "build": "(tsbuild tsfolders --allowimplicitany)",
-    "format": "(gitzone format)",
-    "buildDocs": "tsdoc"
-  }
-}
+  "pnpm": {
+    "overrides": {},
+    "onlyBuiltDependencies": [
+      "esbuild",
+      "mongodb-memory-server",
+      "puppeteer"
+    ]
+  },
+  "packageManager": "pnpm@10.10.0+sha512.d615db246fe70f25dcfea6d8d73dee782ce23e2245e3c4f6f888249fb568149318637dca73c2c5c8ef2a4ca0d5657fb9567188bfab47f566d1ee6ce987815c39"
+}

package/readme.md

@@ -919,6 +919,124 @@ Available helper functions:
     })
     ```
 
+## Metrics and Monitoring
+
+SmartProxy includes a comprehensive metrics collection system that provides real-time insights into proxy performance, connection statistics, and throughput data.
+
+### Getting Metrics
+
+```typescript
+const proxy = new SmartProxy({ /* config */ });
+await proxy.start();
+
+// Access metrics through the getStats() method
+const stats = proxy.getStats();
+
+// Get current active connections
+console.log(`Active connections: ${stats.getActiveConnections()}`);
+
+// Get total connections since start
+console.log(`Total connections: ${stats.getTotalConnections()}`);
+
+// Get requests per second (RPS)
+console.log(`Current RPS: ${stats.getRequestsPerSecond()}`);
+
+// Get throughput data
+const throughput = stats.getThroughput();
+console.log(`Bytes received: ${throughput.bytesIn}`);
+console.log(`Bytes sent: ${throughput.bytesOut}`);
+
+// Get connections by route
+const routeConnections = stats.getConnectionsByRoute();
+for (const [route, count] of routeConnections) {
+  console.log(`Route ${route}: ${count} connections`);
+}
+
+// Get connections by IP address
+const ipConnections = stats.getConnectionsByIP();
+for (const [ip, count] of ipConnections) {
+  console.log(`IP ${ip}: ${count} connections`);
+}
+```
+
+### Available Metrics
+
+The `IProxyStats` interface provides the following methods:
+
+- `getActiveConnections()`: Current number of active connections
+- `getTotalConnections()`: Total connections handled since proxy start
+- `getRequestsPerSecond()`: Current requests per second (1-minute average)
+- `getThroughput()`: Total bytes transferred (in/out)
+- `getConnectionsByRoute()`: Connection count per route
+- `getConnectionsByIP()`: Connection count per client IP
+
+### Monitoring Example
+
+```typescript
+// Create a monitoring loop
+setInterval(() => {
+  const stats = proxy.getStats();
+  
+  // Log key metrics
+  console.log({
+    timestamp: new Date().toISOString(),
+    activeConnections: stats.getActiveConnections(),
+    rps: stats.getRequestsPerSecond(),
+    throughput: stats.getThroughput()
+  });
+  
+  // Check for high connection counts from specific IPs
+  const ipConnections = stats.getConnectionsByIP();
+  for (const [ip, count] of ipConnections) {
+    if (count > 100) {
+      console.warn(`High connection count from ${ip}: ${count}`);
+    }
+  }
+}, 10000); // Every 10 seconds
+```
+
+### Exporting Metrics
+
+You can export metrics in various formats for external monitoring systems:
+
+```typescript
+// Export as JSON
+app.get('/metrics.json', (req, res) => {
+  const stats = proxy.getStats();
+  res.json({
+    activeConnections: stats.getActiveConnections(),
+    totalConnections: stats.getTotalConnections(),
+    requestsPerSecond: stats.getRequestsPerSecond(),
+    throughput: stats.getThroughput(),
+    connectionsByRoute: Object.fromEntries(stats.getConnectionsByRoute()),
+    connectionsByIP: Object.fromEntries(stats.getConnectionsByIP())
+  });
+});
+
+// Export as Prometheus format
+app.get('/metrics', (req, res) => {
+  const stats = proxy.getStats();
+  res.set('Content-Type', 'text/plain');
+  res.send(`
+# HELP smartproxy_active_connections Current active connections
+# TYPE smartproxy_active_connections gauge
+smartproxy_active_connections ${stats.getActiveConnections()}
+
+# HELP smartproxy_requests_per_second Current requests per second
+# TYPE smartproxy_requests_per_second gauge
+smartproxy_requests_per_second ${stats.getRequestsPerSecond()}
+
+# HELP smartproxy_bytes_in Total bytes received
+# TYPE smartproxy_bytes_in counter
+smartproxy_bytes_in ${stats.getThroughput().bytesIn}
+
+# HELP smartproxy_bytes_out Total bytes sent
+# TYPE smartproxy_bytes_out counter
+smartproxy_bytes_out ${stats.getThroughput().bytesOut}
+`);
+});
+```
+
 ## Other Components
 
 While SmartProxy provides a unified API for most needs, you can also use individual components:

package/readme.memory-leaks-fixed.md

@@ -0,0 +1,45 @@
+# Memory Leaks Fixed in SmartProxy
+
+## Summary of Issues Found and Fixed
+
+### 1. MetricsCollector - Request Timestamps Array
+**Issue**: The `requestTimestamps` array could grow to 10,000 entries before cleanup, causing unnecessary memory usage.
+**Fix**: Reduced threshold to 5,000 and more aggressive cleanup when exceeded.
+
+### 2. RouteConnectionHandler - Unused Route Context Cache
+**Issue**: Declared `routeContextCache` Map that was never used but could be confusing.
+**Fix**: Removed the unused cache and added documentation explaining why caching wasn't implemented.
+
+### 3. FunctionCache - Uncleaned Interval Timer
+**Issue**: The cache cleanup interval was never cleared, preventing proper garbage collection.
+**Fix**: Added `destroy()` method to properly clear the interval timer.
+
+### 4. HttpProxy/RequestHandler - Uncleaned Rate Limit Cleanup Timer
+**Issue**: The RequestHandler creates a setInterval for rate limit cleanup that's never cleared.
+**Status**: Needs fix - add destroy method and call it from HttpProxy.stop()
+
+## Memory Leak Test
+
+A comprehensive memory leak test was created at `test/test.memory-leak-check.node.ts` that:
+- Tests with 1000 requests to same routes
+- Tests with 1000 requests to different routes (cache growth)
+- Tests rapid 10,000 requests (timestamp array growth)
+- Monitors memory usage throughout
+- Verifies specific data structures don't grow unbounded
+
+## Recommendations
+
+1. Always use `unref()` on intervals that shouldn't keep the process alive
+2. Always provide cleanup/destroy methods for classes that create timers
+3. Implement size limits on all caches and Maps
+4. Consider using WeakMap for caches where appropriate
+5. Run memory leak tests regularly, especially after adding new features
+
+## Running the Memory Leak Test
+
+```bash
+# Run with garbage collection exposed for accurate measurements
+node --expose-gc test/test.memory-leak-check.node.ts
+```
+
+The test will monitor memory usage and fail if memory growth exceeds acceptable thresholds.