Is it possible to have a webserver and a socket server with the socket.io adapter using Redis-streams-adapter?

[jimbglenn]

Whenever I tried to add the redis-streams-adapter, my webserver stops responding.
I'm using redis-streams-adapter to use Valkey.

I assume I'm putting the adapter code in the right place.

Any guidance?

const io = new Server(http, {
        // commenting this line out, i get my webserver response to http://localhost:3000
        // with the line not commented out, my webserver response to http://localhost:3000 hangs forever
        adapter: createStreamsAdapter(pubClient),
    });

Full example:

import {logger} from '../logging/logger.js';
import express from 'express';
import {createServer} from 'node:http';
import {Server} from 'socket.io';
import {dirname, join} from 'node:path';
import {fileURLToPath} from 'node:url';
import {createClient} from 'redis';
import {getRedisConfig} from '../redis/redisConfig.js';
import {createAdapter as createStreamsAdapter} from '@socket.io/redis-streams-adapter';

export const startServer = async () => {
    const port = process.env.PORT || 3000;
    const app = express();
    const __dirname = dirname(fileURLToPath(import.meta.url));

    app.get('/', (req, res) => {
        res.sendFile(join(__dirname, '/../../public', 'index.html'));
    });
    app.use(express.static('public'));
    const http = createServer(app);
    http.listen(port, () => {
        console.log(`Server running on port ${port}`);
        console.log(`http://localhost:${port}`);
    });

    const pubClient = createClient(getRedisConfig());

    pubClient.on('error', (err) => logger.error('Pub Client Error', err));
    pubClient.on('connect', () => console.log('🔄 Redis connecting...'));
    pubClient.on('ready', () => console.log('✅ Redis ready!'));
    pubClient.on('end', () => console.log('🔚 Redis connection ended'));
    await pubClient.connect();

    logger.info('Using Redis Streams Adapter');

    const io = new Server(http, {
        // commenting this line out, i get my webserver response to http://localhost:3000
        // with the line not commented out, my webserver response to http://localhost:3000 hangs forever
        adapter: createStreamsAdapter(pubClient),
    });
    io.on('connection', function (socket) {
        console.log('Client connected to the WebSocket');

        socket.on('disconnect', () => {
            console.log('Client disconnected');
        });

        socket.on('chat message', function (msg) {
            console.log('Received a chat message');
            io.emit('chat message', msg);
        });
    });
    logger.info('Finished creating server');
};

[sunnypatell]

@jimbglenn two things going on here:

1. upgrade to @socket.io/redis-streams-adapter@0.3.0

the older v0.2.x uses commandOptions({ isolated: true }) to run XREAD BLOCK 5000 on node-redis's internal isolation pool. if you're on redis@5 (node-redis v5), that API changed and the blocking read ends up running on the main client connection instead of an isolated one. that means your single redis client is stuck in XREAD BLOCK and can't process anything else, which cascades into the socket.io handshake hanging, which makes the browser think the page is still loading.

v0.3.0 fixes this by using client.duplicate() to create dedicated connections for polling, and also added PUB/SUB for inter-node requests:

npm install @socket.io/redis-streams-adapter@latest

related fixes: #31, #32

2. move http.listen() after creating the socket.io server

engine.io hooks into the listening event to set up WebSocket handling. since you call http.listen() before new Server(http, ...), that event already fired and WS upgrades never initialize:

const http = createServer(app);

// create socket.io FIRST
const io = new Server(http, {
    adapter: createStreamsAdapter(pubClient),
});

io.on('connection', function (socket) {
    // ...
});

// THEN listen
http.listen(port, () => {
    console.log(`Server running on port ${port}`);
});

for reference, the regular @socket.io/redis-adapter (pub/sub based) explicitly requires two separate clients for this same reason:

const pubClient = createClient({ url: '...' });
const subClient = pubClient.duplicate();

the streams adapter v0.3.0 handles this internally now via duplicateClient().

ref: redis-streams-adapter changelog | socket.io redis adapter docs | node-redis isolation pool issue

[SX110903]

el problema tipico con redis-streams-adapter es que el servidor se queda colgado esperando la conexion a redis antes de arrancar. asegurate de que el adapter esta inicializado antes de pasar al listen:

import { createClient } from "redis"
import { createAdapter } from "@socket.io/redis-streams-adapter"

const redisClient = createClient({ url: "redis://localhost:6379" })
await redisClient.connect() // esto es clave, esperar a que conecte

const io = new Server(http)
io.adapter(createAdapter(redisClient))

http.listen(3000) // solo escucha cuando ya esta todo listo

si el cliente de redis no ha conectado antes de crear el adapter peta o se queda pillado. ponlo todo con async/await en un main() y llamas a listen al final