Hi! 👋

I’m currently running an Express server with Socket.io, and now I want to add Redis to support horizontal scaling and keep multiple instances in sync.

"@socket.io/redis-streams-adapter": "^0.2.2",
"redis": "^4.7.0",
"socket.io": "^4.7.4",

SERVER CONSTRUCTOR

/ "server" is the Http server initiated in server.ts
 constructor(server: HttpServer) {
 ServerSocket.instance = this;
 const socketOptions = {
 serveClient: false,
 pingInterval: 5000, // Server sends PING every 5 seconds
 pingTimeout: 5000, // Client has 5 seconds to respond with PONG
 cookie: false,
 cors: {
 origin: process.env.CORS_ORIGIN || '*'
 },
 connectionStateRecovery: {
 maxDisconnectionDuration: DISCONNECT_TIMEOUT_MS,
 skipMiddlewares: true,
 },
 adapter: createAdapter(redisClient)
 };
 // Create the Socket.IO server instance with all options
 this.io = new Server(server, socketOptions);
 this.users = {};
 this.rooms = {
 private: {},
 public: {}
 }
 this.io.on('connect', this.StartListeners);
 ...

I’ve looked through the docs and found the basic setup, but I’m a bit confused about the best practices — especially around syncing custom state in servers.

For example, my Socket server maintains a custom this.rooms state. How would you typically keep that consistent across multiple servers? Is there a common pattern or example for this?

I’ve started pushing room metadata into Redis like this, so any server that’s out of sync can retrieve it:

private async saveRedisRoomMetadata(roomId: string, metadata: any) {
 try {
 await redisClient.set(
 `${ROOM_META_PREFIX}${roomId}`,
 JSON.stringify(metadata),
 { EX: ROOM_EXPIRY_SECONDS }
 );
 return true;
 } catch (err) {
 console.error(`Error saving Redis metadata for room ${roomId}:`, err);
 return false;
 }
}
...
 // Add new room to LOCAL SERVER rooms object
 this.rooms.private[newRoomId] = gameRoomInfo;
 ...
 // UPDATE REDIS STATE, so servers can fetch missing infos from redis
 const metadataSaved = await this.saveRedisRoomMetadata(newRoomId, gameRoomInfo);

If another server does not have the room data they could pull it

 // Helper methods for Redis operations
 private async getRedisRoomMetadata(roomId: string) {
 try {
 const json = await redisClient.get(`${ROOM_META_PREFIX}${roomId}`);
 return json ? JSON.parse(json) : null;
 } catch (err) {
 console.error(`Error getting Redis metadata for room ${roomId}:`, err);
 return null;
 }
 }

This kind of works, but it feels a bit hacky — I’m not sure if I’m approaching it the right way. It’s my first time building something like this, so I’d really appreciate any guidance! Especially if you could help paint the big picture in simple terms 🙏🏻

2. I kept working on it trying to figure it out.. and I got one more scenario to share... what above is my first trial but wjat follows here is where I am so far.. in terms of understanding.:

"""
Client 1 joins a room and connects to Server A. On join, Server A updates its internal state, updates the Redis state, and emits a message to everyone in the room that a new user has joined. Perfect — Redis is up to date, Server A’s state is correct, and the UI reflects the change.

But what about Server B and Server C, where other clients might be connected? Sure, the UI may still look fine if it’s relying on the Redis-driven broadcasts, but the internal state on Servers B and C is now out of sync.

How should I handle this? Do I even need to fix it? What’s the recommended pattern here?

For instance, if a user connected to Server B or C needs to access the room state — won’t that be stale or incorrect? How is this usually tackled in horizontally scaled, real-time systems using Redis?
"""

Thanks in advance!