Websocket transport reliability (Socket.io data loss during reconnection)

Question

Used

NodeJS, Socket.io

Problem

Imagine there are 2 users U1 & U2, connected to an app via Socket.io. The al

Answer 1

As already written in another answer, I also believe you should look at the realtime as a bonus : the system should be able to work also with no realtime.

I’m developing an enterprise chat for a large company (ios, android, web frontend and .net core + postGres backend) and after having developed a way for the websocket to re-establish connection (through a socket uuid) and get undelivered messages (stored in a queue) I understood there was a better solution: resync via rest API.

Basically I ended up by using websocket just for realtime, with an integer tag on each realtime message (user online, typers, chat message and so on) for monitoring lost messages.

When the client gets an id which is not monolithic (+1) then it understands it is out of sync so it drops all the socket messages and asks a resync of all its observers through REST api.

This way we can handle many variations in the state of the application during the offline period without having to parse tons of websocket messages in a row on reconnection and we are sure to be synced (because the last sync date is set just by the REST api, not from the socket).

The only tricky part is monitoring for realtime messages from the moment you call REST api to the moment the server replies because what is read from the db takes time to get back to the client and in the meanwhile variations could happen so they need to be cached and took into account.

We are going into production in a couple of months, I hope to get back sleeping by then :)

Answer 2

Others have hinted at this in other answers and comments, but the root problem is that Socket.IO is just a delivery mechanism, and you cannot depend on it alone for reliable delivery. The only person who knows for sure that a message has been successfully delivered to the client is the client itself. For this kind of system, I would recommend making the following assertions:

1. Messages aren't sent directly to clients; instead, they get sent to the server and stored in some kind of data store.
2. Clients are responsible for asking "what did I miss" when they reconnect, and will query the stored messages in the data store to update their state.
3. If a message is sent to the server while the recipient client is connected, that message will be sent in real time to the client.

Of course, depending on your application's needs, you can tune pieces of this--for example, you can use, say, a Redis list or sorted set for the messages, and clear them out if you know for a fact a client is up to date.

---

Here are a couple of examples:

Happy path:

• U1 and U2 are both connected to the system.
• U2 sends a message to the server that U1 should receive.
• The server stores the message in some kind of persistent store, marking it for U1 with some kind of timestamp or sequential ID.
• The server sends the message to U1 via Socket.IO.
• U1's client confirms (perhaps via a Socket.IO callback) that it received the message.
• The server deletes the persisted message from the data store.

Offline path:

• U1 looses internet connectivity.
• U2 sends a message to the server that U1 should receive.
• The server stores the message in some kind of persistent store, marking it for U1 with some kind of timestamp or sequential ID.
• The server sends the message to U1 via Socket.IO.
• U1's client does not confirm receipt, because they are offline.
• Perhaps U2 sends U1 a few more messages; they all get stored in the data store in the same fashion.
• When U1 reconnects, it asks the server "The last message I saw was X / I have state X, what did I miss."
• The server sends U1 all the messages it missed from the data store based on U1's request
• U1's client confirms receipt and the server removes those messages from the data store.

---

If you absolutely want guaranteed delivery, then it's important to design your system in such a way that being connected doesn't actually matter, and that realtime delivery is simply a bonus; this almost always involves a data store of some kind. As user568109 mentioned in a comment, there are messaging systems that abstract away the storage and delivery of said messages, and it may be worth looking into such a prebuilt solution. (You will likely still have to write the Socket.IO integration yourself.)

If you're not interested in storing the messages in the database, you may be able to get away with storing them in a local array; the server tries to send U1 the message, and stores it in a list of "pending messages" until U1's client confirms that it received it. If the client is offline, then when it comes back it can tell the server "Hey I was disconnected, please send me anything I missed" and the server can iterate through those messages.

Luckily, Socket.IO provides a mechanism that allows a client to "respond" to a message that looks like native JS callbacks. Here is some pseudocode:

// server
pendingMessagesForSocket = [];

function sendMessage(message) {
  pendingMessagesForSocket.push(message);
  socket.emit('message', message, function() {
    pendingMessagesForSocket.remove(message);
  }
};

socket.on('reconnection', function(lastKnownMessage) {
  // you may want to make sure you resend them in order, or one at a time, etc.
  for (message in pendingMessagesForSocket since lastKnownMessage) {
    socket.emit('message', message, function() {
      pendingMessagesForSocket.remove(message);
    }
  }
});

// client
socket.on('connection', function() {
  if (previouslyConnected) {
    socket.emit('reconnection', lastKnownMessage);
  } else {
    // first connection; any further connections means we disconnected
    previouslyConnected = true;
  }
});

socket.on('message', function(data, callback) {
  // Do something with `data`
  lastKnownMessage = data;
  callback(); // confirm we received the message
});

This is quite similar to the last suggestion, simply without a persistent data store.

---

You may also be interested in the concept of event sourcing.