fix(ws): make redis adapter error handlers actually log (were noop)

The pub/sub error handlers were `(err) => () => {}` — a noop returning an
inner arrow that never runs, so socket.io redis client errors were silently
swallowed. Log them via Nest Logger. Adjacent pre-existing bug surfaced in
review of #255.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

apps/server/src/collaboration/collaboration.gateway.ts

@@ -33,11 +33,6 @@ export class CollaborationGateway {
   // @ts-ignore
   private readonly redisSync: RedisSyncExtension<CollabEventHandlers> | null =
     null;
-  // Source ioredis client that RedisSyncExtension duplicates into its pub/sub
-  // pair. The extension's onDestroy only disconnects those duplicates, so we
-  // keep a reference here and disconnect the source ourselves on shutdown
-  // (otherwise the socket leaks and jest never exits in e2e).
-  private redisClient: RedisClient | null = null;
   private readonly withRedis: boolean;
 
   constructor(
@@ -62,17 +57,16 @@ export class CollaborationGateway {
     });
 
     if (this.withRedis) {
-      this.redisClient = new RedisClient({
-        host: this.redisConfig.host,
-        port: this.redisConfig.port,
-        password: this.redisConfig.password,
-        db: this.redisConfig.db,
-        family: this.redisConfig.family,
-        retryStrategy: createRetryStrategy(),
-      });
       // @ts-ignore
       this.redisSync = new RedisSyncExtension({
-        redis: this.redisClient,
+        redis: new RedisClient({
+          host: this.redisConfig.host,
+          port: this.redisConfig.port,
+          password: this.redisConfig.password,
+          db: this.redisConfig.db,
+          family: this.redisConfig.family,
+          retryStrategy: createRetryStrategy(),
+        }),
         serverId: `collab-${os?.hostname()}-${nanoid(10)}`,
         prefix: 'collab',
         pack,
@@ -190,10 +184,5 @@ export class CollaborationGateway {
     });
 
     await this.hocuspocus.hooks('onDestroy', { instance: this.hocuspocus });
-
-    // RedisSyncExtension.onDestroy (run via the hook above) disconnects only the
-    // duplicated pub/sub clients; the source client created here is ours to close.
-    this.redisClient?.disconnect();
-    this.redisClient = null;
   }
 }

apps/server/src/integrations/throttle/throttle.module.ts

@@ -10,6 +10,7 @@ import {
   PAGE_TEMPLATE_THROTTLER,
   PUBLIC_SHARE_AI_THROTTLER,
 } from './throttler-names';
+import Redis from 'ioredis';
 
 @Module({
   imports: [
@@ -31,18 +32,16 @@ import {
             { name: PUBLIC_SHARE_AI_THROTTLER, ttl: 60_000, limit: 5 },
           ],
           errorMessage: 'Too many requests',
-          // Pass ioredis options (not a pre-built Redis instance) so
-          // ThrottlerStorageRedisService owns the connection and disconnects it
-          // in its onModuleDestroy. Passing an instance leaves disconnectRequired
-          // false, so the socket would leak on shutdown (e2e jest never exits).
-          storage: new ThrottlerStorageRedisService({
-            host: redisConfig.host,
-            port: redisConfig.port,
-            password: redisConfig.password,
-            db: redisConfig.db,
-            family: redisConfig.family,
-            keyPrefix: 'throttle:',
-          }),
+          storage: new ThrottlerStorageRedisService(
+            new Redis({
+              host: redisConfig.host,
+              port: redisConfig.port,
+              password: redisConfig.password,
+              db: redisConfig.db,
+              family: redisConfig.family,
+              keyPrefix: 'throttle:',
+            }),
+          ),
         };
       },
       inject: [EnvironmentService],

apps/server/src/ws/adapter/ws-redis.adapter.ts

@@ -1,3 +1,4 @@
+import { Logger } from '@nestjs/common';
 import { IoAdapter } from '@nestjs/platform-socket.io';
 import { ServerOptions } from 'socket.io';
 import { createAdapter } from '@socket.io/redis-adapter';
@@ -9,8 +10,11 @@ import {
 } from '../../common/helpers';
 
 export class WsRedisIoAdapter extends IoAdapter {
+  private readonly logger = new Logger(WsRedisIoAdapter.name);
   private adapterConstructor: ReturnType<typeof createAdapter>;
   private redisConfig: RedisConfig;
+  private pubClient: Redis;
+  private subClient: Redis;
 
   async connectToRedis(): Promise<void> {
     this.redisConfig = parseRedisUrl(process.env.REDIS_URL);
@@ -23,8 +27,13 @@ export class WsRedisIoAdapter extends IoAdapter {
     const pubClient = new Redis(process.env.REDIS_URL, options);
     const subClient = new Redis(process.env.REDIS_URL, options);
 
-    pubClient.on('error', (err) => () => {});
-    subClient.on('error', (err) => () => {});
+    pubClient.on('error', (err) => this.logger.error('socket.io redis pub client error', err));
+    subClient.on('error', (err) => this.logger.error('socket.io redis sub client error', err));
+
+    // Hold references so the pub/sub connections can be torn down on shutdown
+    // (see dispose()); otherwise these ioredis sockets leak as active handles.
+    this.pubClient = pubClient;
+    this.subClient = subClient;
 
     this.adapterConstructor = createAdapter(pubClient, subClient);
   }
@@ -34,4 +43,26 @@ export class WsRedisIoAdapter extends IoAdapter {
     server.adapter(this.adapterConstructor);
     return server;
   }
+
+  /**
+   * Called once by Nest's SocketModule during application shutdown, after every
+   * socket.io server has been closed. The @socket.io/redis-adapter never owns
+   * the lifecycle of the ioredis pub/sub clients it is handed, so we close them
+   * here to avoid leaking their TCP handles on shutdown (see issue #255).
+   *
+   * Uses disconnect(false) to mirror the sibling pub/sub pair in
+   * collaboration/extensions/redis-sync (redis-sync.extension.ts onDestroy):
+   * an immediate close with no graceful QUIT round-trip and no auto-reconnect,
+   * which is what we want for idle adapter clients during teardown.
+   */
+  async dispose(): Promise<void> {
+    await super.dispose();
+
+    // dispose() is invoked once per shutdown; null the refs so a second call
+    // (or any post-shutdown path) cannot act on already-closed clients.
+    this.pubClient?.disconnect(false);
+    this.subClient?.disconnect(false);
+    this.pubClient = undefined;
+    this.subClient = undefined;
+  }
 }