redweb 0.7.6 → 0.8.0

package/src/serverLifecycle.js

@@ -0,0 +1,46 @@
+function listenServer(server, { port, bind, callback, logger = console, name = 'Server' }) {
+    const onListening = callback || (() => logger?.log?.(`RedWeb ${name} listening on ${bind}:${port}`));
+    server.listen(port, bind, onListening);
+}
+
+function validateListenerOptions(options) {
+    if (!Number.isInteger(options.port) || options.port < 0 || options.port > 65535) {
+        throw new TypeError('`port` must be an integer between 0 and 65535.');
+    }
+    if (typeof options.bind !== 'string' || !options.bind) {
+        throw new TypeError('`bind` must be a non-empty string.');
+    }
+    if (typeof options.listen !== 'boolean') {
+        throw new TypeError('`listen` must be a boolean.');
+    }
+    if (options.listenCallback !== undefined && typeof options.listenCallback !== 'function') {
+        throw new TypeError('`listenCallback` must be a function.');
+    }
+}
+
+async function settleTasks(tasks) {
+    const results = await Promise.allSettled(tasks.map(task => Promise.resolve().then(task)));
+    return results.filter(result => result.status === 'rejected').map(result => result.reason);
+}
+
+function throwCleanupErrors(errors, message) {
+    if (!errors.length) return;
+    const aggregate = new Error(message);
+    aggregate.errors = errors;
+    throw aggregate;
+}
+
+function closeServer(server) {
+    return new Promise((resolve, reject) => {
+        if (!server?.listening) return resolve();
+        server.close((error) => error ? reject(error) : resolve());
+    });
+}
+
+module.exports = {
+    listenServer,
+    closeServer,
+    settleTasks,
+    throwCleanupErrors,
+    validateListenerOptions,
+};

package/src/ws/BaseHandler.js

@@ -18,8 +18,16 @@ class BaseHandler {
      * @param {WebSocket & {sendJson: (message: Object) => void, broadcast: (message: Object) => void}} socket - The WebSocket connection that sent the message.
      * @param {any} message - The incoming message in parsed JSON.
      */
-    handleMessage(socket, message) {
-        this.onMessage(socket, message);
+    async handleMessage(socket, message) {
+        const validationResult = await this.validateMessage(message, socket);
+        if (validationResult === false) {
+            throw new Error('Invalid message');
+        }
+        return this.onMessage(socket, message);
+    }
+
+    validateMessage() {
+        return true;
     }
 
     /**
@@ -27,8 +35,8 @@ class BaseHandler {
      * @param {WebSocket & {sendJson: (message: Object) => void}} socket - The WebSocket connection that sent the message.
      * @param {Buffer} buffer - The incoming binary message.
      */
-    handleBinaryMessage(socket, buffer) {
-        this.onBinaryMessage(socket, buffer);
+    async handleBinaryMessage(socket, buffer) {
+        return this.onBinaryMessage(socket, buffer);
     }
 
     /**
@@ -37,7 +45,7 @@ class BaseHandler {
      * @param {any} message - The incoming message in parsed JSON.
      */
     onMessage(socket, message) {
-        throw "Not yet implemented!";
+        throw new Error('onMessage must be implemented by the handler.');
     }
 
     /**

package/src/ws/BaseSocketServer.js

@@ -6,13 +6,25 @@
  * @property {Array<new () => import('./SocketRoute').SocketRoute>} [routes]
  */
 
-const DefaultRoute = require('./DefaultRoute');
+const DefaultRoute = require('./DefaultRoute');
+const {
+  listenServer,
+  closeServer,
+  settleTasks,
+  throwCleanupErrors,
+  validateListenerOptions,
+} = require('../serverLifecycle');
 
-const SOCKET_OPTIONS = {
+const SOCKET_OPTIONS = {
   port: 3000,
+  bind: '0.0.0.0',
   ssl:  null,
   listen: true,
-  routes: []
+  routes: [],
+  fallbackToRoot: false,
+  closeServerOnShutdown: undefined,
+  logger: console,
+  listenCallback: undefined,
 };
 
 /**
@@ -23,17 +35,54 @@ class BaseSocketServer {
    * @param {import('http').Server} server
    * @param {SocketServerOptions}  [options]
    */
-  constructor(server, options = {}) {
-    this.clients = new Map();
-    Object.assign(this, { ...SOCKET_OPTIONS, ...options });
-    this.server = server;
+  constructor(server, options = {}, ownsServer = false, name = 'SocketServer') {
+    if (!server || typeof server.on !== 'function') throw new TypeError('A Node HTTP(S) server is required.');
+    Object.assign(this, { ...SOCKET_OPTIONS, ...options });
+    validateListenerOptions(this);
+    if (!Array.isArray(this.routes)) throw new TypeError('`routes` must be an array.');
+    this.server = server;
+    this.ownsServer = ownsServer;
+    this.closeServerOnShutdown = options.closeServerOnShutdown ?? ownsServer;
 
     /* ─── ROUTE INITIALISATION ─────────────────────────── */
-    if (!options.routes?.length) options.routes = [DefaultRoute];
-    this.routes = options.routes.map(RouteClass => new RouteClass(server));
-
-    this.server.on('upgrade', this.handleUpgrade.bind(this));
-  }
+    const RouteClasses = options.routes?.length ? [...options.routes] : [DefaultRoute];
+    this.routes = [];
+    try {
+      for (const RouteClass of RouteClasses) {
+        const route = new RouteClass(server, { logger: this.logger });
+        if (this.routes.some(existing => existing.path === route.path)) {
+          this.disposeRoutes([route]);
+          throw new Error('WebSocket route paths must be unique.');
+        }
+        this.routes.push(route);
+      }
+    } catch (error) {
+      this.disposeRoutes(this.routes);
+      throw error;
+    }
+
+    this._upgradeHandler = this.handleUpgrade.bind(this);
+    this.server.on('upgrade', this._upgradeHandler);
+
+    const shouldListen = (ownsServer && this.listen !== false) || (!ownsServer && options.listen === true);
+    if (shouldListen) {
+      listenServer(this.server, {
+        port: this.port,
+        bind: this.bind,
+        callback: this.listenCallback,
+        logger: this.logger,
+        name,
+      });
+    }
+  }
+
+  disposeRoutes(routes) {
+    routes.forEach(route => {
+      Promise.resolve()
+        .then(() => route.shutdown?.())
+        .catch(error => this.logger?.error?.('Error shutting down route:', error));
+    });
+  }
 
   handleUpgrade(req, sock, head) {
     // Some websocket clients (e.g., certain UE plugins) are finicky about the
@@ -48,8 +97,8 @@ class BaseSocketServer {
     })();
 
     const route =
-      this.routes.find(r => r.path === path) ||
-      this.routes.find(r => r.path === '/');
+      this.routes.find(r => r.path === path) ||
+      (this.fallbackToRoot ? this.routes.find(r => r.path === '/') : undefined);
 
     if (!route) return sock.destroy();
 
@@ -62,17 +111,36 @@ class BaseSocketServer {
    * Dynamically attach a new route at runtime
    * @param {new () => import('./SocketRoute').SocketRoute} RouteClass
    */
-  addRoute(RouteClass) {
-    this.routes.push(new RouteClass(this.server));
+  addRoute(RouteClass) {
+    const route = new RouteClass(this.server, { logger: this.logger });
+    if (this.routes.some(existing => existing.path === route.path)) {
+      this.disposeRoutes([route]);
+      throw new Error(`A WebSocket route already exists at ${route.path}.`);
+    }
+    this.routes.push(route);
+    return route;
   }
 
   /**
    * Gracefully tear down all routes (and their services)
    */
-  shutdown() {
-    this.routes.forEach(route => route.shutdown?.());
-    this.server.close();
-  }
-}
+  shutdown() {
+    if (!this._shutdownPromise) this._shutdownPromise = this.performShutdown();
+    return this._shutdownPromise;
+  }
+
+  async performShutdown() {
+    this.server.off?.('upgrade', this._upgradeHandler);
+    const errors = await settleTasks(this.routes.map(route => () => route.shutdown?.()));
+    if (this.closeServerOnShutdown && this.server.listening) {
+      try {
+        await closeServer(this.server);
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    throwCleanupErrors(errors, 'One or more WebSocket server cleanup operations failed.');
+  }
+}
 
 module.exports = { BaseSocketServer, SOCKET_OPTIONS };

package/src/ws/DefaultHandler.js

@@ -1,14 +1,13 @@
 const { BaseHandler } = require("./BaseHandler");
-const { sendJson } = require("./util");
 
 class DefaultHandler extends BaseHandler {
     constructor() {
         super("DefaultHandler");
     }
 
-    onMessage(socket, message) {
-        socket.send(sendJson(`I got your message of ${JSON.stringify(message)}`));
-    }
-}
+    onMessage(socket, message) {
+        socket.sendJson({ message: `I got your message of ${JSON.stringify(message)}` });
+    }
+}
 
-module.exports = DefaultHandler;
+module.exports = DefaultHandler;

package/src/ws/DefaultRoute.js

@@ -2,13 +2,14 @@ const SocketRoute  = require("./SocketRoute");
 const DefaultHandler = require('./DefaultHandler');
 
 class DefaultRoute extends SocketRoute {
-    constructor(server) {
-        super({
-            server,
-            path: "/",
-            handlers: [DefaultHandler]
-        })
+    constructor(server, options = {}) {
+        super({
+            server,
+            path: "/",
+            handlers: [DefaultHandler],
+            logger: options.logger,
+        })
     }
 }
 
-module.exports = DefaultRoute;
+module.exports = DefaultRoute;

package/src/ws/SecureSocketServer.js

@@ -8,14 +8,11 @@ const { BaseSocketServer } = require('./BaseSocketServer');
  * @return {Object} WebSocket server instance.
  */
 class SecureSocketServer extends BaseSocketServer {
-    constructor(options = {}) {
+    constructor(options) {
         const ownsServer = !options?.server;
-        const sslOptions = ownsServer ? loadSslConfig(options.ssl) : null;
+        const sslOptions = ownsServer ? loadSslConfig(options?.ssl) : null;
         const server = options?.server || https.createServer(sslOptions);
-        super(server, options);
-        if ((ownsServer && this.listen !== false) || (!ownsServer && options.listen === true)) {
-            server.listen(this.port, () => console.log(`RedWeb SecureSocketServer listening on port ${this.port}`));
-        }
+        super(server, options, ownsServer, 'SecureSocketServer');
         return this;
     }
 }

package/src/ws/SocketRoute.js

@@ -1,12 +1,23 @@
 const { WebSocketServer } = require("ws");
 const { sendJson, broadcast } = require("./util");
-const { randomUUID } = require("crypto");
+const { randomUUID } = require("crypto");
+const { settleTasks, throwCleanupErrors } = require('../serverLifecycle');
+const { closeWebSocketServer } = require('./shutdown');
+
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+
+function instantiate(ClassType, label) {
+    if (typeof ClassType !== 'function') throw new TypeError(`${label} entries must be constructor functions.`);
+    return new ClassType();
+}
 
 /**
  * Represents a WebSocket route configuration.
  * This class is used to define a specific WebSocket endpoint (`path`) and its associated handlers.
  */
-class SocketRoute {
+class SocketRoute {
     /**
      * Creates a new instance of `SocketRoute`.
      * @param {Object} options - Configuration options for the WebSocket route.
@@ -16,70 +27,135 @@ class SocketRoute {
      * @param {Array<new () => SocketService>} [options.services] 
      * @param {import('ws').ServerOptions} [options.websocketOptions] - Options passed to the underlying WebSocketServer.
     */
-    constructor({ path, handlers, services = [], allowDuplicateConnections, websocketOptions = {} } = {}) {
-        if (!path) {
-            throw new Error('A `path` must be specified for the SocketRoute.');
-        }
-        if (!handlers || !Array.isArray(handlers) || handlers.length === 0) {
-            throw new Error('At least one handler must be specified for the SocketRoute.');
-        }
+    constructor({
+        path,
+        handlers,
+        services = [],
+        allowDuplicateConnections = false,
+        websocketOptions = {},
+        trustProxy = false,
+        getClientKey,
+        exposeErrors = false,
+        logger = console,
+        shutdownTimeoutMs = 1000,
+    } = {}) {
+        if (typeof path !== 'string' || !path.startsWith('/')) {
+            throw new Error('A `path` beginning with "/" must be specified for the SocketRoute.');
+        }
+        if (!handlers || !Array.isArray(handlers) || handlers.length === 0) {
+            throw new Error('At least one handler must be specified for the SocketRoute.');
+        }
+        if (!Array.isArray(services)) throw new TypeError('`services` must be an array.');
+        if (!websocketOptions || typeof websocketOptions !== 'object' || Array.isArray(websocketOptions)) {
+            throw new TypeError('`websocketOptions` must be an object.');
+        }
+        if (getClientKey !== undefined && typeof getClientKey !== 'function') {
+            throw new TypeError('`getClientKey` must be a function.');
+        }
+        const reservedOption = ['noServer', 'path', 'server', 'port']
+            .find(option => Object.prototype.hasOwnProperty.call(websocketOptions, option));
+        if (reservedOption) throw new TypeError(`Redweb controls websocketOptions.${reservedOption}.`);
+        if (!Number.isInteger(shutdownTimeoutMs) || shutdownTimeoutMs < 0) {
+            throw new TypeError('`shutdownTimeoutMs` must be a non-negative integer.');
+        }
         /**
          * The path of the WebSocket route.
          * This determines the endpoint that clients must connect to (e.g., `ws://localhost:3000/chat`).
          * @type {string}
          */
         this.path = path;
-        this.websocketOptions = websocketOptions;
+        this.websocketOptions = { ...websocketOptions };
+        this.logger = logger || { log() {}, warn() {}, error() {} };
+        this.trustProxy = trustProxy;
+        this.getClientKey = getClientKey;
+        this.exposeErrors = exposeErrors;
+        this.shutdownTimeoutMs = shutdownTimeoutMs;
         /**
          * The array of handler instances associated with this route.
          * Each handler is responsible for managing WebSocket connections and message handling logic.
          * @type {import('./BaseHandler').BaseHandler[]}
          */
-        this.handlers = handlers.map(HandlerClass => new HandlerClass());
+        this.handlers = handlers.map(HandlerClass => instantiate(HandlerClass, 'Handler'));
+        const handlerNames = this.handlers.map(handler => handler.name);
+        if (handlerNames.some(name => typeof name !== 'string' || !name)) {
+            throw new TypeError('Every handler must have a non-empty name.');
+        }
+        if (new Set(handlerNames).size !== handlerNames.length) {
+            throw new Error('Handler names must be unique within a route.');
+        }
         this.clients = new Map();
-        this.server = new WebSocketServer({ noServer: true, path, ...websocketOptions });
+        this.server = new WebSocketServer({ ...websocketOptions, noServer: true });
         this.server.on('connection', this.handleConnection.bind(this));
-        this.allowDuplicateConnections = allowDuplicateConnections;
+        this.allowDuplicateConnections = Boolean(allowDuplicateConnections);
 
         /* ─── ROUTE‑SCOPED SERVICES ─────────────────────────── */
-        this.services = services.map(SvcClass => {
-            const svc = new SvcClass();
-            if (typeof svc.onInit === 'function') svc.onInit(this);
-            return svc;
-        });
-    }
+        this.services = [];
+        try {
+            services.forEach(SvcClass => {
+                const svc = instantiate(SvcClass, 'Service');
+                this.services.push(svc);
+                if (typeof svc.onInit !== 'function') return;
+                const result = svc.onInit(this);
+                if (result && typeof result.then === 'function') {
+                    result.catch(() => {});
+                    throw new TypeError('SocketService.onInit must be synchronous.');
+                }
+            });
+        } catch (error) {
+            this.disposeServices();
+            this.server.close();
+            throw error;
+        }
+    }
+
+    disposeServices() {
+        this.services.forEach(service => {
+            Promise.resolve()
+                .then(() => service.onShutdown?.())
+                .catch(error => this.logger.error?.('Error shutting down service:', error));
+        });
+    }
     /**
      * Adds a new handler to the WebSocket server.
      * @param {new () => BaseHandler} HandlerClass - The handler class to add.
      */
-    addHandler(HandlerClass) {
-        const newHandler = new HandlerClass();
+    addHandler(HandlerClass) {
+        const newHandler = instantiate(HandlerClass, 'Handler');
         if (this.handlers.find(handler => handler.name === newHandler.name)) {
-            console.warn(`Handler with name '${newHandler.name}' already exists.`);
-            return;
-        }
-        this.handlers.push(newHandler);
-        console.log(`Handler '${newHandler.name}' added successfully.`);
-    }
+            this.logger.warn?.(`Handler with name '${newHandler.name}' already exists.`);
+            return false;
+        }
+        if (typeof newHandler.name !== 'string' || !newHandler.name) throw new TypeError('A handler must have a non-empty name.');
+        this.handlers.push(newHandler);
+        this.logger.log?.(`Handler '${newHandler.name}' added successfully.`);
+        return true;
+    }
+
+    resolveRemoteAddress(req) {
+        if (this.getClientKey) return String(this.getClientKey(req));
+        if (this.trustProxy) {
+            const forwarded = req?.headers?.['x-forwarded-for'];
+            if (typeof forwarded === 'string' && forwarded.trim()) return forwarded.split(',')[0].trim();
+        }
+        return req?.socket?.remoteAddress || 'unknown';
+    }
     /**
      * Handles a new WebSocket connection.
      * @param {WebSocket} socket - The WebSocket connection instance.
      * @param {import('http').IncomingMessage} req - The HTTP request object associated with the connection.
      */
     handleConnection(socket, req) {
-        const ip = req?.socket?.remoteAddress || 'unknown';
+        const ip = this.resolveRemoteAddress(req);
         const clientKey = this.allowDuplicateConnections ? randomUUID() : ip;
 
-        console.log(`New client connected: ${ip}`);
+        this.logger.log?.(`New client connected: ${ip}`);
 
         if (!this.allowDuplicateConnections) {
             const existing = this.clients.get(clientKey);
             if (existing) {
-                console.warn(`Client ${ip} already connected, disconnecting existing connection.`);
-                existing.send(
-                    JSON.stringify({ msg: 'You are being disconnected because a new client is connected with your IP address.' })
-                );
-                existing.close();
+                this.logger.warn?.(`Client ${ip} already connected, disconnecting existing connection.`);
+                sendJson(existing, { msg: 'You are being disconnected because a new client is connected with your IP address.' });
+                existing.close?.(1000, 'Replaced by a new connection');
             }
         }
 
@@ -91,67 +167,90 @@ class SocketRoute {
         socket.sendJson = (data) => sendJson(socket, data);
         socket.broadcast = (data) => broadcast([...this.clients.values()].filter(sock => sock !== socket), data);
 
-        this.connectionOpenCallback(socket);
         socket.on('close', () => this.handleClose(socket));
         socket.on('error', (error) => this.handleError(socket, error));
         socket.on('message', (message, isBinary) => {
             if (isBinary) {
-                this.handleBinaryMessage(socket, message);
+                void this.handleBinaryMessage(socket, message);
                 return;
             }
 
             try {
                 const parsed = JSON.parse(message);
-                this.handleMessage(socket, parsed);
+                void this.handleMessage(socket, parsed);
             } catch (error) {
-                console.error(`Error parsing message from ${ip}:`, error);
+                this.logger.error?.(`Error parsing message from ${ip}:`, error);
                 socket.sendJson({ error: 'Invalid JSON format' });
-                socket.close();
+                socket.close?.(1003, 'Invalid JSON');
                 return;
             }
         });
+
+        this.invokeLifecycleHook(socket, () => this.connectionOpenCallback(socket, req), true);
+        this.handlers.forEach((handler) => {
+            this.invokeLifecycleHook(socket, () => handler.onInitialContact?.(socket, req), true);
+        });
+    }
+
+    invokeLifecycleHook(socket, hook, closeOnError) {
+        Promise.resolve()
+            .then(hook)
+            .catch(error => {
+                this.handleError(socket, error);
+                if (!closeOnError) return;
+                sendJson(socket, { error: 'Connection initialization failed' });
+                socket.close?.(1011, 'Connection initialization failed');
+            });
     }
 
     connectionOpenCallback(socket) {
-        console.log(`Opening new connection: ${socket.remoteAddress}`);
+        this.logger.log?.(`Opening new connection: ${socket.remoteAddress}`);
     }
 
-    handleMessage(sock, data) {
-        const handler = this.handlers.find((handler) => handler.name == data.type);
-        if (!handler) {
-            sendJson(sock, { error: `No such handler ${data.type}` });
-            sock.close();
-        } else {
-            try {
-                handler.handleMessage(sock, data);
-            } catch (error) {
-                console.error(`Error handling message in handler ${handler.name}:`, error);
-                sendJson(sock, { error: `${error.message}` });
-                sock.close();
-            }
+    async handleMessage(sock, data) {
+        if (!data || typeof data !== 'object' || typeof data.type !== 'string' || !data.type) {
+            sendJson(sock, { error: 'Message must be an object with a non-empty string `type`' });
+            sock.close?.(1008, 'Invalid message');
+            return false;
         }
-    }
-
-    handleBinaryMessage(socket, buffer) {
-        const hasBinaryPredicate = this.handlers.some(handler => typeof handler.acceptsBinary === 'function');
-        const handler = hasBinaryPredicate
-            ? this.handlers.find(handler => handler.acceptsBinary?.(socket, buffer))
-            : this.handlers.find(handler => typeof handler.handleBinaryMessage === 'function');
-
-        if (handler) {
+        const handler = this.handlers.find((handler) => handler.name == data.type);
+        if (!handler) {
+            sendJson(sock, { error: `No such handler ${data.type}` });
+            sock.close?.(1008, 'Unknown handler');
+            return false;
+        } else {
             try {
-                handler.handleBinaryMessage(socket, buffer);
+                await handler.handleMessage(sock, data);
+                return true;
             } catch (error) {
-                console.error(`Error handling binary message in handler ${handler.name}:`, error);
-                sendJson(socket, { error: `${error.message}` });
-                socket.close();
+                this.logger.error?.(`Error handling message in handler ${handler.name}:`, error);
+                sendJson(sock, { error: this.exposeErrors ? errorMessage(error) : 'Handler failed' });
+                sock.close?.(1011, 'Handler failed');
+                return false;
             }
-            return;
         }
+    }
 
-        sendJson(socket, {
-            error: 'Binary messages are not supported on this route'
-        });
+    async handleBinaryMessage(socket, buffer) {
+        try {
+            const handlersWithPredicate = this.handlers.filter(handler => typeof handler.acceptsBinary === 'function');
+            const handler = handlersWithPredicate.length
+                ? handlersWithPredicate.find(handler => handler.acceptsBinary(socket, buffer))
+                : this.handlers.find(handler => handler.onBinaryMessage !== undefined);
+
+            if (!handler) {
+                sendJson(socket, { error: 'Binary messages are not supported on this route' });
+                return false;
+            }
+
+            await handler.handleBinaryMessage(socket, buffer);
+            return true;
+        } catch (error) {
+            this.logger.error?.('Error handling binary message:', error);
+            sendJson(socket, { error: this.exposeErrors ? errorMessage(error) : 'Binary handler failed' });
+            socket.close?.(1011, 'Binary handler failed');
+            return false;
+        }
     }
 
     /**
@@ -162,14 +261,33 @@ class SocketRoute {
     handleClose(socket) {
         const key = socket.clientKey || socket.__redwebClientKey;
         const ip = socket.remoteAddress || 'unknown';
-        console.log(`Client disconnected: ${ip}`);
-        if (key && this.clients.get(key) === socket) this.clients.delete(key);
-        if (this.connectionCloseCallback) this.connectionCloseCallback(socket);
+        this.logger.log?.(`Client disconnected: ${ip}`);
+        if (key !== undefined && key !== null && this.clients.get(key) === socket) this.clients.delete(key);
+        this.invokeLifecycleHook(socket, () => this.connectionCloseCallback?.(socket), false);
     }
 
-    shutdown() {
-        this.services.forEach(svc => svc.onShutdown && svc.onShutdown());
-        this.server.close();
+    shutdown() {
+        if (!this._shutdownPromise) this._shutdownPromise = this.performShutdown();
+        return this._shutdownPromise;
+    }
+
+    async performShutdown() {
+        const errors = await settleTasks(this.services.map(service => () => service.onShutdown?.()));
+        const clients = [...this.clients.values()];
+        clients.forEach(socket => {
+            try {
+                socket.close?.(1001, 'Server shutting down');
+            } catch (error) {
+                errors.push(error);
+            }
+        });
+        this.clients.clear();
+        try {
+            await closeWebSocketServer(this.server, clients, this.shutdownTimeoutMs);
+        } catch (error) {
+            errors.push(error);
+        }
+        throwCleanupErrors(errors, 'One or more WebSocket route cleanup operations failed.');
     }
 
     /**
@@ -180,7 +298,7 @@ class SocketRoute {
      */
     handleError(socket, error) {
         const ip = socket.remoteAddress || 'unknown';
-        console.error(`Socket error from ${ip}:`, error);
+        this.logger.error?.(`Socket error from ${ip}:`, error);
     }
 }