vantiv.io 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vantiv.io",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Enterprise WebSocket infrastructure for Highrise featuring spatial intelligence systems, memory-optimized architecture, and production-grade reliability for scalable application development",
   "keywords": [
     "highrise",

package/src/classes/Handlers/WebSocketHandlers.js

@@ -1,53 +1,133 @@
-const WebSocketConstants = require('vantiv.io/src/constants/WebSocketConstants');
-
 class WebSocketHandlers {
+    static RESET   = '\x1b[0m';
+    static ERROR   = '\x1b[31m';      
+    static WARN    = '\x1b[33m';      
+    static INFO    = '\x1b[36m';      
+    static MODULE  = '\x1b[95m';      
+
+    static prefix(levelColor, level) {
+        return `${WebSocketHandlers.MODULE}[WebSocketHandlers]${WebSocketHandlers.RESET} ${levelColor}${level}${WebSocketHandlers.RESET}`;
+    }
+
     constructor(server) {
         this.server = server;
-        this.logger = server.logger;
+        this.isShuttingDown = false;
     }
-    
+
     setupErrorHandlers() {
         const handlers = {
             uncaughtException: this._handleUncaughtException.bind(this),
             unhandledRejection: this._handleUnhandledRejection.bind(this),
             SIGINT: this._handleSIGINT.bind(this),
-            SIGTERM: this._handleSIGTERM.bind(this)
+            SIGTERM: this._handleSIGTERM.bind(this),
+            SIGUSR2: this._handleSIGUSR2.bind(this)
         };
-        
-        process.on('uncaughtException', handlers.uncaughtException);
-        process.on('unhandledRejection', handlers.unhandledRejection);
-        process.on('SIGINT', handlers.SIGINT);
-        process.on('SIGTERM', handlers.SIGTERM);
-        
+
+        this.activeHandlers = handlers;
+
+        Object.entries(handlers).forEach(([event, handler]) => {
+            process.on(event, handler);
+        });
+
         return handlers;
     }
-    
+
     _handleUncaughtException(error) {
-        this.logger.error('WebSocketHandlers', `Uncaught exception: ${error.message}`);
+        console.error(
+            `${this.constructor.prefix(this.constructor.ERROR, 'ERROR')}: Uncaught exception — shutting down`,
+            '\n',
+            {
+                message: error.message,
+                name: error.name,
+                stack: error.stack
+            }
+        );
+
+        this._gracefulShutdown('uncaughtException').catch(err => {
+            console.error(
+                `${this.constructor.prefix(this.constructor.ERROR, 'ERROR')}: Shutdown failed after uncaught exception:`,
+                err.message
+            );
+            process.exit(1);
+        });
     }
-    
-    _handleUnhandledRejection(reason, promise) {
-        this.logger.error('WebSocketHandlers', `Unhandled promise rejection: ${reason}`);
+
+    _handleUnhandledRejection(reason, _promise) {
+        const reasonDetail = reason instanceof Error
+            ? { message: reason.message, name: reason.name, stack: reason.stack }
+            : reason;
+
+        console.error(
+            `${this.constructor.prefix(this.constructor.ERROR, 'ERROR')}: Unhandled promise rejection`,
+            '\n',
+            { reason: reasonDetail }
+        );
     }
-    
-    _handleSIGINT() {
-        this.logger.info('WebSocketHandlers', 'Received SIGINT, shutting down gracefully');
-        this.server.disconnect();
-        setTimeout(() => process.exit(0), 1000);
+
+    async _handleSIGINT() {
+        await this._gracefulShutdown('SIGINT');
     }
-    
-    _handleSIGTERM() {
-        this.logger.info('WebSocketHandlers', 'Received SIGTERM, shutting down gracefully');
-        this.server.disconnect();
-        setTimeout(() => process.exit(0), 1000);
+
+    async _handleSIGTERM() {
+        await this._gracefulShutdown('SIGTERM');
+    }
+
+    async _handleSIGUSR2() {
+        await this._gracefulShutdown('SIGUSR2');
     }
-    
+
+    async _gracefulShutdown(signal) {
+        if (this.isShuttingDown) {
+            console.warn(
+                `${this.constructor.prefix(this.constructor.WARN, 'WARN')}: Shutdown already in progress for ${signal}`
+            );
+            return;
+        }
+
+        this.isShuttingDown = true;
+        console.info(
+            `\n${this.constructor.prefix(this.constructor.INFO, 'INFO')}: Starting graceful shutdown for ${signal}`
+        );
+
+        try {
+            this.removeErrorHandlers(this.activeHandlers);
+
+            if (typeof this.server.disconnect === 'function') {
+                await Promise.race([
+                    this.server.disconnect(),
+                    new Promise((_, reject) =>
+                        setTimeout(() => reject(new Error('Disconnect timeout')), 10000)
+                    )
+                ]);
+            }
+
+            console.info(
+                `${this.constructor.prefix(this.constructor.INFO, 'INFO')}: Graceful shutdown completed for ${signal}`
+            );
+
+        } catch (error) {
+            console.error(
+                `${this.constructor.prefix(this.constructor.ERROR, 'ERROR')}: Failed to shut down gracefully (${signal}):`,
+                error.message
+            );
+        } finally {
+            await new Promise(resolve => setTimeout(resolve, 100));
+            process.exit(0);
+        }
+    }
+
     removeErrorHandlers(handlers) {
         if (!handlers) return;
-        
+
         Object.entries(handlers).forEach(([event, handler]) => {
             process.removeListener(event, handler);
         });
+
+        this.activeHandlers = null;
+    }
+
+    isShutdownInProgress() {
+        return this.isShuttingDown;
     }
 }
 

package/src/classes/Managers/ChannelManager.js

@@ -44,11 +44,6 @@ class ChannelManager {
                     sent: true
                 });
 
-                this.logger.debug(method, 'Channel message sent', {
-                    tags: normalizedTags,
-                    messageLength: message.length
-                });
-
                 return true;
             }
 
@@ -95,11 +90,6 @@ class ChannelManager {
                 this._tagIndex.get(tag).add(listenerId);
             });
 
-            this.logger.debug(method, 'Listener registered', {
-                listenerId,
-                tags: normalizedTags
-            });
-
             return listenerId;
 
         } catch (error) {
@@ -138,7 +128,6 @@ class ChannelManager {
 
             this._listeners.delete(listenerId);
 
-            this.logger.debug(method, 'Listener removed', { listenerId });
             return true;
 
         } catch (error) {
@@ -296,7 +285,6 @@ class ChannelManager {
         this._messageHistory = [];
         this._listeners.clear();
         this._tagIndex.clear();
-        this.logger.info('ChannelManager', 'Cleared channel history and listeners');
     }
 }
 

package/src/classes/Managers/Networking/ConnectionManager.js

@@ -1,6 +1,6 @@
-const WebSocketConstants = require('vantiv.io/src/constants/WebSocketConstants');
 const EventEmitter = require('events');
 const WebSocket = require('ws');
+const WebSocketConstants = require('vantiv.io/src/constants/WebSocketConstants')
 
 class ConnectionManager extends EventEmitter {
     constructor(server, logger, options = {}) {
@@ -10,8 +10,9 @@ class ConnectionManager extends EventEmitter {
         this.logger = logger;
         this.ws = null;
 
-        this.autoReconnect = options.autoReconnect ?? true;
-        this.reconnectDelay = options.reconnectDelay ?? WebSocketConstants.DEFAULT_RECONNECT_DELAY;
+        this.autoReconnect = options.autoReconnect ?? WebSocketConstants.DEFAULT_AUTO_RECONNECT;
+        this.reconnectDelay = WebSocketConstants.DEFAULT_RECONNECT_DELAY;
+        this.logger.info('ConnectionManager', `Reconnect delay set to ${this.reconnectDelay}ms`);
 
         this.reconnectAttempts = 0;
         this.reconnectTimeout = null;
@@ -23,12 +24,21 @@ class ConnectionManager extends EventEmitter {
     }
 
     connect(token, roomId, events) {
+        if (!token || !roomId || !Array.isArray(events) || events.length === 0) {
+            throw new Error('Invalid connection parameters: token, roomId, and events array are required');
+        }
+
         this.connectionAuth = { token, roomId, events };
         this.isManualDisconnect = false;
         this._establishConnection();
     }
 
     _establishConnection() {
+        if (this.reconnecting || this.connected) {
+            this.logger.debug('ConnectionManager', 'Connection attempt already in progress — skipping');
+            return;
+        }
+
         if (!this.connectionAuth) {
             throw new Error('No connection authentication available');
         }
@@ -48,7 +58,8 @@ class ConnectionManager extends EventEmitter {
             headers: {
                 [WebSocketConstants.HEADERS.API_TOKEN]: token,
                 [WebSocketConstants.HEADERS.ROOM_ID]: roomId
-            }
+            },
+            handshakeTimeout: WebSocketConstants.DEFAULT_HANDSHAKE_TIMEOUT
         });
 
         this._setupWebSocketHandlers();
@@ -60,7 +71,7 @@ class ConnectionManager extends EventEmitter {
 
             if (this.ws.readyState !== WebSocket.CLOSED &&
                 this.ws.readyState !== WebSocket.CLOSING) {
-                this.ws.close();
+                this.ws.close(1000, 'Cleanup');
             }
 
             this.ws = null;
@@ -69,7 +80,15 @@ class ConnectionManager extends EventEmitter {
 
     _setupWebSocketHandlers() {
         this.ws.on('open', () => this._handleOpen());
-        this.ws.on('message', (data) => this.emit('message', data));
+        this.ws.on('message', (data) => {
+            try {
+                this.emit('message', data);
+            } catch (error) {
+                this.logger.error('ConnectionManager', 'Error emitting message event', {
+                    error: error.message
+                });
+            }
+        });
         this.ws.on('close', (code, reason) => this._handleClose(code, reason));
         this.ws.on('error', (error) => this._handleError(error));
     }
@@ -87,27 +106,24 @@ class ConnectionManager extends EventEmitter {
         this._clearReconnectTimeout();
 
         this.emit('connected');
-        this.logger.success('ConnectionManager', 'WebSocket connection established');
+        this.logger.info('ConnectionManager', 'WebSocket connection established');
     }
 
     _handleClose(code, reason) {
-        if (this.connected) {
-            this.connected = false;
-        }
+        this.connected = false;
+        const wasReconnecting = this.reconnecting;
+        this.reconnecting = false;
 
-        const reasonStr = reason.toString();
+        const reasonStr = reason?.toString('utf8') || `Binary reason (length: ${reason?.length || 0})`;
         this.emit('disconnected', { code, reason: reasonStr });
-        this.logger.warn('ConnectionManager', `Connection closed`, {
+
+        this.logger.warn('ConnectionManager', 'Connection closed', {
             code,
             reason: reasonStr,
-            reconnectAttempts: this.reconnectAttempts,
             autoReconnect: this.autoReconnect,
-            reconnecting: this.reconnecting
+            manual: this.isManualDisconnect,
+            attempt: this.reconnectAttempts
         });
-
-        const wasReconnecting = this.reconnecting;
-        this.reconnecting = false;
-
         if (this.autoReconnect && !this.isManualDisconnect && !wasReconnecting) {
             this._scheduleReconnect();
         }
@@ -137,20 +153,17 @@ class ConnectionManager extends EventEmitter {
 
         this._clearReconnectTimeout();
 
-        const delay = Math.min(
-            this.reconnectDelay * Math.pow(WebSocketConstants.RECONNECT_BACKOFF_FACTOR, this.reconnectAttempts),
-            WebSocketConstants.MAX_RECONNECT_DELAY
-        );
-
         this.reconnectAttempts++;
         this.reconnecting = true;
 
-        this.server.metrics.increment('reconnects');
+        if (this.server?.metrics) {
+            this.server.metrics.increment('reconnects');
+        }
 
         this.logger.info('ConnectionManager', `Scheduling reconnect...`, {
             attempt: this.reconnectAttempts,
-            delay: `${delay}ms (${Math.round(delay / 1000)}s)`,
-            maxDelay: `${WebSocketConstants.MAX_RECONNECT_DELAY}ms`
+            delay: `${this.reconnectDelay}ms (5s)`,
+            maxDelay: '5s'
         });
 
         this.reconnectTimeout = setTimeout(() => {
@@ -160,10 +173,10 @@ class ConnectionManager extends EventEmitter {
             } else {
                 this.reconnecting = false;
             }
-        }, delay);
+        }, this.reconnectDelay);
     }
 
-    disconnect(code = WebSocketConstants.ERROR_CODES.NORMAL_CLOSURE, reason = 'Manual disconnect') {
+    disconnect(code = 1000, reason = 'Manual disconnect') {
         this.autoReconnect = false;
         this.isManualDisconnect = true;
         this.reconnecting = false;
@@ -183,12 +196,19 @@ class ConnectionManager extends EventEmitter {
             throw new Error('WebSocket is not connected');
         }
 
-        const payload = typeof data === 'string' ? data : JSON.stringify(data);
-        this.ws.send(payload);
+        try {
+            const payload = typeof data === 'string' ? data : JSON.stringify(data);
+            this.ws.send(payload);
 
-        this.server.metrics.increment('messagesSent');
+            if (this.server?.metrics) {
+                this.server.metrics.increment('messagesSent');
+            }
 
-        return true;
+            return true;
+        } catch (error) {
+            this.logger.error('ConnectionManager', 'Failed to send message', { error: error.message });
+            throw error;
+        }
     }
 
     isConnected() {
@@ -204,7 +224,8 @@ class ConnectionManager extends EventEmitter {
             attempts: this.reconnectAttempts,
             reconnecting: this.reconnecting,
             autoReconnect: this.autoReconnect,
-            isManualDisconnect: this.isManualDisconnect
+            isManualDisconnect: this.isManualDisconnect,
+            connected: this.connected
         };
     }
 
@@ -213,6 +234,12 @@ class ConnectionManager extends EventEmitter {
         this.removeAllListeners();
         this.connectionAuth = null;
         this._cleanupWebSocket();
+        this._clearReconnectTimeout();
+    }
+
+    resetStats() {
+        this.reconnectAttempts = 0;
+        this.reconnecting = false;
     }
 }
 

package/src/constants/WebSocketConstants.js

@@ -1,11 +1,10 @@
 const WebSocketConstants = {
     // Connection
     KEEPALIVE_INTERVAL: 15000,
-    MAX_RECONNECT_DELAY: 300000, // 5 minutes
-    RECONNECT_BACKOFF_FACTOR: 1.1,
-    DEFAULT_RECONNECT_DELAY: 5000,
+    DEFAULT_RECONNECT_DELAY: 10000,
     DEFAULT_AUTO_RECONNECT: true,
     MAX_RECONNECT_ATTEMPTS: 10,
+    DEFAULT_HANDSHAKE_TIMEOUT: 10000,
 
     // Logger Options
     DEFAULT_LOGGER_OPTIONS: {