A Socket.IO connection can close for several reasons.

Examples include:

• The user closes the browser tab.
• The network connection disappears.
• The server shuts down.
• A reverse proxy closes an inactive connection.
• The client explicitly disconnects.
• A transport error occurs.

The server receives the disconnect event when a socket connection closes.

The event callback provides a reason describing why the disconnection happened.

Use this event to clean up connection-specific resources and update application presence information.

io.on('connection', (socket) => {
  console.log('Connected:', socket.id);

  socket.on('disconnect', (reason) => {
    console.log('Disconnected:', socket.id);
    console.log('Reason:', reason);
  });
});

The Socket.IO client automatically attempts to reconnect after certain unexpected connection failures.

For example:

1. A user opens the chat application.
2. The connection is established.
3. The network becomes temporarily unavailable.
4. The connection closes.
5. The browser attempts to reconnect.
6. When the network becomes available, the client may reconnect successfully.

The server receives a new connection when reconnection succeeds.

A reconnection does not mean that the original connection has remained alive. The new connection may receive a different socket ID.

Automatic reconnection does not apply to every disconnection. For example, a deliberate client disconnect does not automatically trigger reconnection.

Socket.IO allows you to customize reconnection behavior when initializing the client.

Important options include:

• reconnection: Enables or disables automatic reconnection.
• reconnectionAttempts: Maximum number of reconnection attempts.
• reconnectionDelay: Initial delay between attempts.
• reconnectionDelayMax: Maximum delay between attempts.
• randomizationFactor: Adds randomness to retry delays.

The client uses backoff behavior to avoid repeatedly reconnecting at an excessive rate.

const socket = io({
  reconnection: true,
  reconnectionAttempts: 10,
  reconnectionDelay: 1000,
  reconnectionDelayMax: 5000,
  randomizationFactor: 0.5
});

The Socket.IO client exposes lifecycle events that help monitor reconnection attempts.

Useful events include:

• connect.
• disconnect.
• connect_error.
• reconnect_attempt.
• reconnect.
• reconnect_failed.

Some reconnection-related events are emitted by the Socket.IO Manager rather than the individual Socket instance.

You can access the Manager through socket.io.

socket.on('disconnect', (reason) => {
  console.log('Connection lost:', reason);
});

socket.on('connect_error', (error) => {
  console.error('Connection error:', error.message);
});

socket.io.on('reconnect_attempt', (attempt) => {
  console.log('Reconnection attempt:', attempt);
});

socket.io.on('reconnect', (attempt) => {
  console.log('Reconnected after attempts:', attempt);
});

socket.io.on('reconnect_failed', () => {
  console.error('Reconnection attempts exhausted');
});

Socket.IO supports connection state recovery, which can restore certain session details and missed packets after a temporary disconnection.

The feature is useful when a client loses connectivity briefly and reconnects within the configured recovery window.

However, recovery is not guaranteed in every situation. The server may be unable to recover a session after a process restart, expired recovery window, or unsupported adapter configuration.

Connection state recovery does not replace persistent application storage.

Important considerations:

• Configure an appropriate recovery duration.
• Decide whether middleware should be skipped during recovery.
• Verify the recovered session and permissions.
• Handle cases where recovery fails.
• Persist important messages in a database.

import { Server } from 'socket.io';

const io = new Server(httpServer, {
  connectionStateRecovery: {
    maxDisconnectionDuration: 2 * 60 * 1000,
    skipMiddlewares: false
  }
});