vantiv.io 1.0.0

package/src/classes/Managers/Helpers/LoggerManager.js

@@ -0,0 +1,171 @@
+const chalk = require('chalk'); 
+
+class Logger {
+    constructor(bot, options = {}) {
+        this.bot = bot;
+        this.options = {
+            showTimestamp: true,
+            showMethodName: true,
+            colors: true,
+            ...options
+        };
+        
+        this.chalk = this.options.colors ? chalk : new chalk.Instance({ level: 0 });
+    }
+
+    getMessageText(levelColor, message) {
+        if (!this.options.colors) return message;
+        
+        switch (levelColor) {
+            case 'green':
+                return this.chalk.green(message);
+            case 'red':
+                return this.chalk.red(message);
+            case 'yellow':
+                return this.chalk.yellow(message);
+            case 'blue':
+                return this.chalk.blue(message);
+            case 'magenta':
+                return this.chalk.magenta(message);
+            default:
+                return message; 
+        }
+    }
+
+    _formatMessage(level, method, message = '', data = null) {
+        const parts = [];
+        
+        let header = '┌─ ';
+        
+        if (this.options.showTimestamp) {
+            header += this.chalk.magenta(`[${new Date().toISOString()}] `);
+        }
+        
+        let levelColor;
+        switch (level) {
+            case 'SUCCESS':
+                header += this.chalk.green('[SUCCESS]');
+                levelColor = 'green';
+                break;
+            case 'ERROR':
+                header += this.chalk.red('[ERROR]');
+                levelColor = 'red';
+                break;
+            case 'WARN':
+                header += this.chalk.yellow('[WARN]');
+                levelColor = 'yellow';
+                break;
+            case 'INFO':
+                header += this.chalk.blue('[INFO]');
+                levelColor = 'blue';
+                break;
+            case 'DEBUG':
+                header += this.chalk.magenta('[DEBUG]');
+                levelColor = 'magenta';
+                break;
+            default:
+                header += `[${level}]`;
+                levelColor = 'default';
+        }
+        
+        if (this.options.showMethodName && method) {
+            header += ' ' + this.chalk.white('─') + ' ' + this.chalk.cyan(`[${method}]`);
+        }
+        
+        parts.push(header);
+        
+        
+        if (data) {
+            const dataStr = typeof data === 'object' ? JSON.stringify(data) : String(data);
+            parts.push('├─ ' + this.chalk.yellow('Data:') + ' ' + this.chalk.gray(dataStr));
+        }
+        
+        
+        const connector = data ? '└─ ' : '└─ ';
+        const coloredMessage = this.getMessageText(levelColor, String(message));
+        parts.push(connector + this.chalk.yellow('Message:') + ' ' + coloredMessage);
+        
+        return parts.join('\n');
+    }
+
+    _formatErrorMessage(error, method, data = null) {
+        const parts = [];
+        
+        
+        let header = '┌─ ';
+        
+        if (this.options.showTimestamp) {
+            header += this.chalk.magenta(`[${new Date().toISOString()}] `);
+        }
+        
+        header += this.chalk.red('[ERROR]');
+        
+        if (this.options.showMethodName && method) {
+            header += ' ' + this.chalk.white('─') + ' ' + this.chalk.cyan(`[${method}]`);
+        }
+        
+        parts.push(header);
+        
+        
+        if (data) {
+            const dataStr = typeof data === 'object' ? JSON.stringify(data) : String(data);
+            parts.push('├─ ' + this.chalk.yellow('Data:') + ' ' + this.chalk.gray(dataStr));
+        }
+        
+        
+        const errorMsg = error.message || String(error);
+        const messageLines = errorMsg.split('\n');
+        const hasPreviousLines = parts.length > 1;
+        
+        parts.push('├─ ' + this.chalk.yellow('Message:') + ' ' + this.chalk.red(messageLines[0]));
+        
+        for (let i = 1; i < messageLines.length; i++) {
+            const prefix = hasPreviousLines ? '│  ' : '   ';
+            parts.push(prefix + ' ' + this.chalk.red(messageLines[i]));
+        }
+        
+        
+        const stack = error.stack || '';
+        const callerLine = stack.split('\n')
+            .find(line => line.includes('Highrise.<anonymous>') || line.includes(method))
+            ?.trim() || 'Unknown location';
+            
+        const location = callerLine.match(/\((.*):(\d+):(\d+)\)/)?.[0] || callerLine;
+        parts.push('└─ ' + this.chalk.yellow('Caller:') + ' ' + this.chalk.gray(location));
+        
+        return parts.join('\n');
+    }
+
+    log(level, method, message, data = null) {
+        const formatted = this._formatMessage(level, method, message, data);
+        console.log(this.options.colors ? formatted : this._stripColors(formatted));
+    }
+
+    success(method, message, data = null) {
+        this.log('SUCCESS', method, message, data);
+    }
+
+    error(method, message, data = null, errorInstance = null) {
+        const error = errorInstance instanceof Error ? errorInstance : new Error(String(message));
+        const formatted = this._formatErrorMessage(error, method, data);
+        console.log(this.options.colors ? formatted : this._stripColors(formatted));
+    }
+
+    warn(method, message, data = null) {
+        this.log('WARN', method, message, data);
+    }
+
+    info(method, message, data = null) {
+        this.log('INFO', method, message, data);
+    }
+
+    debug(method, message, data = null) {
+        this.log('DEBUG', method, message, data);
+    }
+
+    _stripColors(text) {
+        return text.replace(/\x1b\[\d+m/g, '');
+    }
+}
+
+module.exports = { Logger };

package/src/classes/Managers/Helpers/MetricsManager.js

@@ -0,0 +1,83 @@
+const WebSocketConstants = require('highrise-core/src/constants/WebSocketConstants');
+
+class MetricsManager {
+    constructor() {
+        this.startTime = Date.now();
+        this.messagesReceived = 0;
+        this.messagesSent = 0;
+        this.eventsProcessed = 0;
+        this.errors = 0;
+        this.reconnects = 0;
+        this.cacheStats = {
+            lastUpdate: 0,
+            activeUsers: 0,
+            inactiveUsers: 0,
+            memoryUsage: 0,
+            changesProcessed: 0
+        };
+    }
+    
+    increment(metric, value = 1) {
+        if (this[metric] !== undefined) {
+            this[metric] += value;
+        }
+    }
+    
+    updateCacheStats(stats) {
+        this.cacheStats = {
+            ...this.cacheStats,
+            ...stats,
+            lastUpdate: Date.now()
+        };
+    }
+    
+    getUptime() {
+        const uptime = Date.now() - this.startTime;
+        
+        const weeks = Math.floor(uptime / (7 * 24 * 60 * 60 * 1000));
+        const days = Math.floor((uptime % (7 * 24 * 60 * 60 * 1000)) / (24 * 60 * 60 * 1000));
+        const hours = Math.floor((uptime % (24 * 60 * 60 * 1000)) / (60 * 60 * 1000));
+        const minutes = Math.floor((uptime % (60 * 60 * 1000)) / (60 * 1000));
+        const seconds = Math.floor((uptime % (60 * 1000)) / 1000);
+        
+        const parts = [];
+        if (weeks > 0) parts.push(`${weeks}w`);
+        if (days > 0) parts.push(`${days}d`);
+        if (hours > 0) parts.push(`${hours}h`);
+        if (minutes > 0) parts.push(`${minutes}m`);
+        if (seconds > 0 || parts.length === 0) parts.push(`${seconds}s`);
+        
+        return parts.join(' ');
+    }
+    
+    formatBytes(bytes) {
+        if (bytes === 0) return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+    
+    getSnapshot() {
+        return {
+            uptime: this.getUptime(),
+            messagesReceived: this.messagesReceived,
+            messagesSent: this.messagesSent,
+            eventsProcessed: this.eventsProcessed,
+            errors: this.errors,
+            reconnects: this.reconnects,
+            cacheStats: { ...this.cacheStats }
+        };
+    }
+    
+    reset() {
+        this.startTime = Date.now();
+        this.messagesReceived = 0;
+        this.messagesSent = 0;
+        this.eventsProcessed = 0;
+        this.errors = 0;
+        this.reconnects = 0;
+    }
+}
+
+module.exports = MetricsManager;

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

@@ -0,0 +1,259 @@
+const WebSocketConstants = require('highrise-core/src/constants/WebSocketConstants');
+const EventEmitter = require('events');
+const WebSocket = require('ws');
+
+class ConnectionManager extends EventEmitter {
+    constructor(server, logger, options = {}) {
+        super();
+
+        this.server = server;
+        this.logger = logger;
+        this.ws = null;
+
+        this.autoReconnect = options.autoReconnect ?? true;
+        this.reconnectDelay = options.reconnectDelay ?? WebSocketConstants.DEFAULT_RECONNECT_DELAY;
+
+        this.reconnectAttempts = 0;
+        this.reconnectTimeout = null;
+        this.connected = false;
+        this.reconnecting = false;
+        this.isManualDisconnect = false;
+
+        this.connectionAuth = null;
+    }
+
+    connect(token, roomId, events) {
+        this.connectionAuth = { token, roomId, events };
+        this.isManualDisconnect = false;
+        this._establishConnection();
+    }
+
+    _establishConnection() {
+        if (!this.connectionAuth) {
+            throw new Error('No connection authentication available');
+        }
+
+        this._clearReconnectTimeout();
+        this.reconnecting = true;
+
+        const { token, roomId, events } = this.connectionAuth;
+        const eventsParam = events.join(',');
+        const endpoint = `${WebSocketConstants.BASE_WS_URL}?events=${eventsParam}`;
+
+        if (this.ws) {
+            this._cleanupWebSocket();
+        }
+
+        this.ws = new WebSocket(endpoint, {
+            headers: {
+                [WebSocketConstants.HEADERS.API_TOKEN]: token,
+                [WebSocketConstants.HEADERS.ROOM_ID]: roomId
+            }
+        });
+
+        this._setupWebSocketHandlers();
+    }
+
+    _cleanupWebSocket() {
+        if (this.ws) {
+            this.ws.removeAllListeners();
+
+            if (this.ws.readyState !== WebSocket.CLOSED &&
+                this.ws.readyState !== WebSocket.CLOSING) {
+                this.ws.close();
+            }
+
+            this.ws = null;
+        }
+    }
+
+    _setupWebSocketHandlers() {
+        this.ws.on('open', () => this._handleOpen());
+        this.ws.on('message', (data) => this.emit('message', data));
+        this.ws.on('close', (code, reason) => this._handleClose(code, reason));
+        this.ws.on('error', (error) => this._handleError(error));
+    }
+
+    _handleOpen() {
+        if (!this.connected) {
+            this.connected = true;
+        }
+
+        if (!this.reconnecting) {
+            this.reconnectAttempts = 0;
+        }
+
+        this.reconnecting = false;
+        this._clearReconnectTimeout();
+
+        this.emit('connected');
+        this.logger.success('ConnectionManager', 'WebSocket connection established');
+    }
+
+    _handleClose(code, reason) {
+        if (this.connected) {
+            this.connected = false;
+        }
+
+        const reasonStr = reason.toString();
+        this.emit('disconnected', { code, reason: reasonStr });
+        this.logger.warn('ConnectionManager', `Connection closed`, {
+            code,
+            reason: reasonStr,
+            reconnectAttempts: this.reconnectAttempts,
+            autoReconnect: this.autoReconnect,
+            reconnecting: this.reconnecting
+        });
+
+        const wasReconnecting = this.reconnecting;
+        this.reconnecting = false;
+
+        if (this.autoReconnect && !this.isManualDisconnect && !wasReconnecting) {
+            const shouldReconnect = this._shouldReconnect(code, reasonStr);
+            
+            if (shouldReconnect) {
+                this._scheduleReconnect();
+            } else {
+                this.logger.warn('ConnectionManager', 'Not reconnecting due to close code or reason', {
+                    code,
+                    reason: reasonStr
+                });
+            }
+        }
+    }
+
+    _shouldReconnect(code, reason) {
+        if (code === 1000 && reason.includes('Manual disconnect')) {
+            return false;
+        }
+        
+        if (code === 4001 || code === 4003 || code === 4004) {
+            this.logger.error('ConnectionManager', 'Authentication failed, not reconnecting', { code, reason });
+            return false;
+        }
+        
+        if (code === 4009 || code === 4029) {
+            this.logger.error('ConnectionManager', 'Rate limited or banned, not reconnecting', { code, reason });
+            return false;
+        }
+        
+        return true;
+    }
+
+    _handleError(error) {
+        this.emit('error', error);
+        this.logger.error('ConnectionManager', 'WebSocket error', {
+            error: error.message,
+            reconnectAttempts: this.reconnectAttempts,
+            reconnecting: this.reconnecting
+        });
+    }
+
+    _clearReconnectTimeout() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+    }
+
+    _scheduleReconnect() {
+        if (this.reconnecting) {
+            this.logger.debug('ConnectionManager', 'Already reconnecting, skipping duplicate');
+            return;
+        }
+
+        const maxAttempts = WebSocketConstants.MAX_RECONNECT_ATTEMPTS || 10;
+        if (this.reconnectAttempts >= maxAttempts) {
+            this.logger.error('ConnectionManager', 'Max reconnection attempts reached', {
+                attempts: this.reconnectAttempts,
+                maxAttempts
+            });
+            this.emit('reconnectFailed', {
+                attempts: this.reconnectAttempts,
+                maxAttempts
+            });
+            return;
+        }
+
+        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');
+
+        this.logger.info('ConnectionManager', `Scheduling reconnect...`, {
+            attempt: this.reconnectAttempts,
+            delay: `${delay}ms (${Math.round(delay / 1000)}s)`,
+            maxDelay: `${WebSocketConstants.MAX_RECONNECT_DELAY}ms`
+        });
+
+        this.reconnectTimeout = setTimeout(() => {
+            if (this.connectionAuth && !this.isManualDisconnect) {
+                this.logger.info('ConnectionManager', `Attempting reconnection (attempt ${this.reconnectAttempts})...`);
+                this._establishConnection();
+            } else {
+                this.reconnecting = false;
+            }
+        }, delay);
+    }
+
+    disconnect(code = WebSocketConstants.ERROR_CODES.NORMAL_CLOSURE, reason = 'Manual disconnect') {
+        this.autoReconnect = false;
+        this.isManualDisconnect = true;
+        this.reconnecting = false;
+
+        this._clearReconnectTimeout();
+
+        if (this.ws && this.ws.readyState !== WebSocket.CLOSED && this.ws.readyState !== WebSocket.CLOSING) {
+            this.ws.close(code, reason);
+        }
+
+        this.connected = false;
+        this.emit('disconnected', { code, reason, manual: true });
+    }
+
+    send(data) {
+        if (!this.isConnected() || !this.ws) {
+            throw new Error('WebSocket is not connected');
+        }
+
+        const payload = typeof data === 'string' ? data : JSON.stringify(data);
+        this.ws.send(payload);
+
+        this.server.metrics.increment('messagesSent');
+
+        return true;
+    }
+
+    isConnected() {
+        return this.ws && this.ws.readyState === WebSocket.OPEN;
+    }
+
+    getWebSocket() {
+        return this.ws;
+    }
+
+    getReconnectStats() {
+        return {
+            attempts: this.reconnectAttempts,
+            reconnecting: this.reconnecting,
+            autoReconnect: this.autoReconnect,
+            isManualDisconnect: this.isManualDisconnect
+        };
+    }
+
+    cleanup() {
+        this.disconnect();
+        this.removeAllListeners();
+        this.connectionAuth = null;
+        this._cleanupWebSocket();
+    }
+}
+
+module.exports = ConnectionManager;