@realvare/based 2.5.2 → 2.5.6

package/lib/Socket/socket.js

@@ -48,6 +48,47 @@ const makeSocket = (config) => {
     let keepAliveReq;
     let qrTimer;
     let closed = false;
+    let reconnectAttempts = 0;
+    const performanceConfig = (0, Utils_1.getPerformanceConfig)();
+    
+    const handleReconnect = async () => {
+        if (closed) return;
+        
+        reconnectAttempts++;
+        const delay = Math.min(
+            performanceConfig.performance.retryDelay * Math.pow(
+                performanceConfig.performance.retryBackoffMultiplier, 
+                reconnectAttempts - 1
+            ),
+            performanceConfig.performance.maxRetryDelay
+        );
+        
+        logger?.info({ 
+            reconnectAttempts, 
+            delay 
+        }, 'Attempting to reconnect...');
+        
+        await (0, Utils_1.delay)(delay);
+        
+        if (reconnectAttempts <= performanceConfig.performance.maxRetries) {
+            try {
+                ws.connect();
+            } catch (error) {
+                logger?.error({ error }, 'Reconnection attempt failed');
+                handleReconnect();
+            }
+        } else {
+            logger?.error('Max reconnection attempts reached');
+            ev.emit('connection.update', {
+                connection: 'close',
+                lastDisconnect: {
+                    error: new boom_1.Boom('Max reconnection attempts reached', { 
+                        statusCode: Types_1.DisconnectReason.connectionClosed 
+                    })
+                }
+            });
+        }
+    };
     const uqTagId = (0, Utils_1.generateMdTagPrefix)();
     const generateMessageTag = () => `${uqTagId}${epoch++}`;
     const sendPromise = (0, util_1.promisify)(ws.send);
@@ -266,8 +307,10 @@ const makeSocket = (config) => {
             logger.trace({ trace: error === null || error === void 0 ? void 0 : error.stack }, 'connection already closed');
             return;
         }
-        closed = true;
-        logger.info({ trace: error === null || error === void 0 ? void 0 : error.stack }, error ? 'connection errored' : 'connection closed');
+        const statusCode = error?.output?.statusCode;
+        const shouldReconnect = statusCode !== Types_1.DisconnectReason.loggedOut;
+        logger.info({ trace: error === null || error === void 0 ? void 0 : error.stack, shouldReconnect }, error ? 'connection errored' : 'connection closed');
+        closed = !shouldReconnect;
         clearInterval(keepAliveReq);
         clearTimeout(qrTimer);
         ws.removeAllListeners('close');
@@ -287,7 +330,12 @@ const makeSocket = (config) => {
                 date: new Date()
             }
         });
-        ev.removeAllListeners('connection.update');
+        if (shouldReconnect) {
+            handleReconnect();
+        }
+        else {
+            ev.removeAllListeners('connection.update');
+        }
     };
     const waitForSocketOpen = async () => {
         if (ws.isOpen) {

package/lib/Utils/cache-manager.js

@@ -0,0 +1,73 @@
+"use strict";
+const NodeCache = require('node-cache');
+const { getPerformanceConfig } = require('./performance-config');
+
+class CacheManager {
+    constructor() {
+        const config = getPerformanceConfig();
+        this.caches = {};
+        this.memoryCheckInterval = null;
+        
+        // Inizializza le cache con TTL
+        Object.entries(config.cache).forEach(([name, options]) => {
+            this.caches[name] = new NodeCache({
+                stdTTL: options.ttl / 1000, // Converti da ms a secondi
+                checkperiod: options.cleanupInterval / 1000,
+                maxKeys: options.maxSize
+            });
+        });
+        
+        if (config.performance.enableMetrics) {
+            this.startMemoryMonitoring(config.performance.memoryThreshold);
+        }
+    }
+    
+    startMemoryMonitoring(threshold) {
+        this.memoryCheckInterval = setInterval(() => {
+            const used = process.memoryUsage().heapUsed;
+            const total = process.memoryUsage().heapTotal;
+            const ratio = used / total;
+            
+            if (ratio > threshold) {
+                this.evictLeastUsed();
+            }
+        }, 60000); // Controlla ogni minuto
+    }
+    
+    evictLeastUsed() {
+        Object.values(this.caches).forEach(cache => {
+            const stats = cache.getStats();
+            if (stats.keys > 100) { // Mantieni almeno 100 chiavi
+                const keys = cache.keys();
+                // Rimuovi il 20% delle chiavi meno usate
+                const toRemove = Math.floor(keys.length * 0.2);
+                keys.slice(0, toRemove).forEach(key => cache.del(key));
+            }
+        });
+    }
+    
+    get(cacheName, key) {
+        return this.caches[cacheName]?.get(key);
+    }
+    
+    set(cacheName, key, value, ttl = undefined) {
+        return this.caches[cacheName]?.set(key, value, ttl);
+    }
+    
+    del(cacheName, key) {
+        return this.caches[cacheName]?.del(key);
+    }
+    
+    getStats(cacheName) {
+        return this.caches[cacheName]?.getStats();
+    }
+    
+    shutdown() {
+        if (this.memoryCheckInterval) {
+            clearInterval(this.memoryCheckInterval);
+        }
+        Object.values(this.caches).forEach(cache => cache.close());
+    }
+}
+
+module.exports = new CacheManager();