How to properly cleanup and avoid namespace memory leaks in Socket.IO

[emanuelef]

Hi all,

I am encountering an issue where dynamically created namespaces in Socket.IO are not being fully garbage collected, even after all connections have been closed and manual garbage collection has been triggered.
Once all clients disconnect from a namespace, I expect it to be completely removed from memory, with no lingering references preventing garbage collection.
Is there something I'm missing?
Even after all connections are closed and garbage collection runs, namespaces still appear in heap snapshots.
I include the code where I managed to replicate that.

Node version: v22.12.0
socket.io: ^4.8.1
socket.io-client: ^4.8.1

Thanks for any help.

server.js

const socketio = require('socket.io');
const v8 = require('v8');

setInterval(() => {
    console.log('Garbage collection triggered');
    global.gc();
}, 2 * 60000);

function startServer() {
    const io = socketio(3000, {
        pingTimeout: 60000,
        allowEIO3: true,
    });

    const tokenNamespace = io.of(/^\/[a-z0-9]{10}$/);

    tokenNamespace.on('connection', (socket) => {
        const token = socket.nsp.name.substring(1);
        console.log('Client connected to namespace');

        socket.on('disconnect', (reason) => {
            console.log(`Client disconnected from namespace: ${reason}`);
            socket.removeAllListeners();

            // Check if the namespace is empty and clean it up
            if (socket.nsp.sockets.size === 0) {
                console.log(`Cleaning up empty namespace: ${socket.nsp.name}`);
                for (const sock of socket.nsp.sockets.values()) {
                    sock.disconnect(true);
                    sock.removeAllListeners();
                    sock.nsp = null;
                }
                socket.nsp.removeAllListeners();

                if (socket.nsp.adapter) {
                    console.log('Clearing adapter rooms and socket IDs');
                    socket.nsp.adapter.rooms.clear();
                    socket.nsp.adapter.sids.clear();
                    socket.nsp.adapter = null;
                }

                socket.nsp.server = null;
                socket.nsp._events = null;
                socket.nsp.sockets = null;

                socket.nsp.middleware = [];

                io._nsps.set(socket.nsp.name, undefined);
                io._nsps.delete(socket.nsp.name);
                delete io._nsps.get(socket.nsp.name);

                socket.nsp = null;
            } else {
                console.log(`Namespace ${socket.nsp.name} still has active sockets.`);
            }

            socket = null;

            console.log('Remaining namespaces:', Array.from(io._nsps.keys()));
            console.log('Remaining sockets:', Object.keys(io.sockets.sockets));
        });

        socket.on('message', (data) => {
            console.log(`Received message in namespace: ${data}`);
        });
    });

    console.log('Server started on port 3000');

    return io;
}

const io = startServer();

client.js

const io = require('socket.io-client');
const crypto = require('crypto');

function startClient(clientId, token) {
    const socket = io(`http://localhost:3000/${token}`);

    socket.on('connect', () => {
        console.log(`Client ${clientId} connected to namespace: ${socket.nsp.name}, socket.id: ${socket.id}`);
        socket.emit('message', `Hello from Client ${clientId} in ${socket.nsp.name}`);

        // Simulate some activity
        setInterval(() => {
            socket.emit('message', `Heartbeat from Client ${clientId}`);
        }, 1000);

        // Simulate disconnection
        setTimeout(() => {
            console.log(`Client ${clientId} disconnecting from ${socket.nsp.name}`);
            socket.disconnect();
        }, 5000);
    });

    socket.on('disconnect', (reason) => {
        console.log(`Client ${clientId} disconnected from ${socket.nsp.name}: ${reason}`);
    });

    socket.on('message', (data) => {
        console.log(`Client ${clientId} in ${socket.nsp.name} received: ${data}`);
    });
}

// Start multiple clients with different (but valid) tokens
startClient(1, 'abcdefghij');
startClient(2, 'klmnopqrst');
startClient(3, 'uvwxyzabcd');

function generateRandomToken(length) {
    return crypto.randomBytes(length).toString('hex').slice(0, length);
}

for (let i = 4; i <= 1003; i++) {
    const randomToken = generateRandomToken(10); // Generate a random 10-character token
    startClient(i, randomToken);
}

Procedure:

node --expose-gc --inspect server-basic.js

In the logs I see:

Remaining namespaces: [ '/' ]
Remaining sockets: []

node client.js

[emanuelef]

Could it be that namespaces aren't designed to be manually cleaned up?
What is the recommended approach for removing unused namespaces?

[darrachequesne]

Hi! You can use the cleanupEmptyChildNamespaces option:

const io = socketio(3000, {
  pingTimeout: 60000,
  allowEIO3: true,
  cleanupEmptyChildNamespaces: true,
});

This way, when all sockets leave the dynamic namespace, then it gets closed and cleaned up properly.

Reference: https://socket.io/docs/v4/server-options/#cleanupemptychildnamespaces

[emanuelef]

Thank you @darrachequesne, I'll try that.
Is there any side effect by enabling that considering is disabled by default ?

[emanuelef]

And what if for any reason I need to do the cleaning manually ?

[emanuelef]

Hello,
I tried adding cleanupEmptyChildNamespaces: true and no longer seeing Namespace in the heap.
But I think there is still something leaking because the memory used increases, in the heap snapshots I see many Array with the namespace token I generated.

Is there anything else that I need to do to make sure that the memory is freed ?
Thanks again.