Les WebSockets en JavaScript : reconnexions, ordre et ce qui peut se perdre

Un WebSocket en JavaScript tient en une ligne, new WebSocket(url), et sur un bon réseau tout fonctionne : les messages arrivent dans l’ordre où ils ont été envoyés, dans les deux sens. Ce qu’il ne fait pas, c’est revenir après une coupure, remarquer une connexion morte sans bruit, ou vous dire si un message est bien arrivé, si bien que chaque application qui en garde un ouvert écrit elle-même ces trois parties.
Cet article montre ce que fait le navigateur quand une connexion tombe, mesuré dans Chromium 156, puis un client d’une soixantaine de lignes qui se reconnecte, rattrape ce qu’il a manqué et renvoie ce qui n’a pas été confirmé, avec le petit serveur Node.js auquel il parle. Les deux ont tourné face à un serveur coupé, redémarré et réduit au silence. À la fin : à quoi ressemblent ces trois parties quand un cloud temps réel tient la connexion.
Ce que le navigateur vous donne
L’API WebSocket de chaque navigateur a quatre événements, open, message, error et close, une méthode send() et un readyState :
// Toute l’API : ouvrir, envoyer, écouter, fermer.
const ws = new WebSocket('wss://example.com/live');
ws.onopen = () => ws.send(JSON.stringify({ hello: 'server' }));
ws.onmessage = ({ data }) => console.log('got', data);
ws.onclose = ({ code, reason }) => console.log('closed', code, reason);Sur une même connexion, rien n’est remis dans le désordre : le protocole passe par une seule connexion TCP (RFC 6455), et TCP livre les octets dans l’ordre où ils ont été envoyés. Les ennuis commencent là où cette connexion prend fin.
Ce qui se passe quand la connexion tombe
Nous avons ouvert une connexion depuis Chromium 156 vers un serveur Node.js, l’avons coupée côté serveur, puis avons appelé send() dessus :
| Ce que nous avons fait | Ce qu’a fait le navigateur |
|---|---|
send() avant open |
a levé InvalidStateError |
| Le serveur a coupé la connexion | close avec le code 1006, wasClean à false |
send() après la fermeture |
aucune erreur, bufferedAmount monté de 12 octets, rien d’envoyé |
C’est la dernière ligne qui perd des données. Un message envoyé après la fermeture de la connexion ne lève rien : le standard du WHATWG dit que bufferedAmount « ne fera qu’augmenter à chaque appel » une fois la connexion fermée (WebSockets Standard), et le message lui-même ne va nulle part. Un code qui appelle send() sans vérifier readyState jette tout ce qu’il envoie entre la coupure et le moment où il s’en aperçoit.
Trois autres manques :
- Pas de reconnexion. Un WebSocket fermé reste fermé. Rien dans le standard ne le rouvre.
- Pas de ping depuis votre code. Le protocole a des trames ping et pong, et chaque extrémité peut envoyer un ping à tout moment, mais le standard les laisse hors de l’API à dessein. Le navigateur peut en envoyer pour ses propres raisons. Votre page ne le peut pas, elle ne peut donc pas demander si l’autre côté est toujours là.
- Pas d’accusé de réception.
send()ne renvoie rien. Un message peut quitter la page, attendre dans un tampon et se perdre avec la connexion, sans que la page n’en sache jamais rien.
Le code 1006 signifie que la connexion s’est terminée sans trame de fermeture : la RFC 6455 interdit de l’envoyer dans l’une d’elles, c’est donc le navigateur qui dit ce qui s’est passé, jamais un code envoyé par votre serveur. Ce que disent les autres codes, et comment tester une adresse qui refuse toute connexion, se trouve dans la connexion WebSocket a échoué.
Un client qui revient de lui-même
La réponse à chaque manque est petite, et ensemble elles forment un seul module. Il :
- Se reconnecte après une coupure, en attendant plus longtemps après chaque essai raté, une part aléatoire de l’attente, jusqu’à 30 secondes.
- Rattrape : il donne au serveur l’id du dernier événement qu’il possède, et le serveur envoie ce qui est venu après.
- Renvoie chaque message que le serveur n’a pas confirmé, chacun avec son propre id (
ref), si bien qu’un message envoyé deux fois n’est pris qu’une fois. - Remarque le silence : le serveur envoie un battement toutes les 20 secondes, et sans rien entendre pendant 45, la page ouvre une nouvelle connexion plutôt que d’attendre sur une connexion morte.
// socket.js : un websocket vers votre propre serveur, qui revient de lui-même
export function connect(url, { onEvent, onGap, quiet = 45000 }) {
let ws, retry, silence;
let lastId = 0; // le dernier événement que possède cette page
let attempt = 0; // les essais ratés depuis la dernière bonne connexion
const unconfirmed = new Map(); // ref → data, jusqu’à ce que le serveur le confirme
function open() {
clearTimeout(retry);
const mine = (ws = new WebSocket(`${url}?after=${lastId}`));
mine.onopen = () => {
if (mine !== ws) return mine.close(); // remplacé pendant qu’il se connectait
attempt = 0;
heard(mine);
for (const [ref, data] of unconfirmed) mine.send(JSON.stringify({ ref, data }));
};
mine.onmessage = ({ data }) => {
if (mine !== ws) return;
heard(mine);
const msg = JSON.parse(data);
if (msg.ack) return void unconfirmed.delete(msg.ack);
if (msg.gap) return void onGap?.();
if (!msg.id || msg.id <= lastId) return; // un battement, ou un événement déjà affiché
lastId = msg.id;
onEvent(msg);
};
mine.onclose = () => {
if (mine !== ws) return;
// Jusqu’à 0,5 s, 1 s, 2 s… 30 s au plus, chaque fois une part aléatoire, pour que la foule ne revienne pas d’un coup.
const delay = Math.random() * Math.min(30000, 500 * 2 ** attempt++);
retry = setTimeout(open, delay);
};
}
// Rien entendu depuis trop longtemps : la connexion est morte, même si le navigateur ne l’a pas remarqué.
function heard(mine) {
clearTimeout(silence);
silence = setTimeout(() => {
if (mine === ws) { open(); mine.close(); }
}, quiet);
}
// De retour sur le réseau : essayer maintenant plutôt qu’à l’heure du minuteur.
addEventListener('online', () => {
if (ws.readyState === WebSocket.CLOSED) open();
});
open();
return {
send(data) {
const ref = crypto.randomUUID();
unconfirmed.set(ref, data);
if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ ref, data }));
},
};
}Une page s’en sert ainsi :
import { connect } from './socket.js';
const live = connect('wss://example.com/live', {
onEvent: ({ id, data }) => showMessage(data),
onGap: () => reloadFromApi(), // absent trop longtemps : le serveur n’a plus tout
});
live.send({ text: 'Hi' });Chaque socket vérifie mine !== ws avant d’agir, et cela compte plus qu’il n’y paraît. Le minuteur de silence et l’événement online ouvrent tous deux une nouvelle socket alors que l’ancienne est peut-être encore en train de se fermer, et sans cette vérification, une ancienne socket qui se ferme en retard programmerait une seconde reconnexion, ou une qui s’ouvre en retard enverrait par-dessus la nouvelle.
La part aléatoire de l’attente est là pour votre serveur, pas pour la page. Quand un serveur redémarre, chaque page qu’il tenait voit la coupure dans la même seconde. Avec une attente fixe, elles reviennent toutes dans la même seconde, encore et encore. Une part aléatoire d’une attente qui grandit les étale.
Le serveur auquel il parle
Le serveur donne un id à chaque événement, garde les 500 derniers, et envoie à une page qui revient tout ce qui suit l’id qu’elle donne. En Node.js avec le paquet ws :
// server.mjs : chaque événement reçoit un id, les 500 derniers sont gardés, et une page qui revient reçoit ce qu’elle a manqué
import { WebSocketServer } from 'ws';
const KEEP = 500;
const log = []; // les KEEP derniers événements, du plus ancien au plus récent
const seen = new Set(); // les refs déjà prises : gardez-les un jour dans Redis, pas pour toujours en mémoire
let lastId = 0;
const wss = new WebSocketServer({ port: 8080 });
wss.on('connection', (ws, req) => {
const after = Number(new URL(req.url, 'http://localhost').searchParams.get('after')) || 0;
// Absente plus longtemps que ce que couvre le journal : le dire, et la page recharge depuis votre API.
if (after && log.length && log[0].id > after + 1) ws.send(JSON.stringify({ gap: true }));
for (const event of log) if (event.id > after) ws.send(JSON.stringify(event));
ws.on('message', (raw) => {
const { ref, data } = JSON.parse(raw);
ws.send(JSON.stringify({ ack: ref }));
if (seen.has(ref)) return; // renvoyé après une coupure, et déjà pris
seen.add(ref);
const event = { id: ++lastId, data };
log.push(event);
if (log.length > KEEP) log.shift();
for (const client of wss.clients) client.send(JSON.stringify(event));
});
});
// Un battement toutes les 20 secondes, pour qu’une page distingue une connexion calme d’une connexion morte.
setInterval(() => {
for (const client of wss.clients) client.send('{"beat":1}');
}, 20000);Le journal et l’ensemble des refs vivent ici en mémoire, si bien qu’un redémarrage les oublie. En production, ils vont dans Redis ou dans votre base de données, et avec plus d’un serveur, chaque serveur doit lire le même journal, ce que détaille les websockets avec Node.js au-delà d’un serveur.
Ce qu’a montré le test
Nous avons fait tourner ce client dans deux pages Chromium 156, Ann et Ben, face à ce serveur, et cassé des choses exprès :
| Ce que nous avons cassé | Ce qu’ont vu les pages |
|---|---|
| Ann coupée après que le serveur a pris son message mais avant qu’il le confirme | Ann l’a renvoyé, le serveur l’a pris une fois |
| Serveur arrêté, deux messages envoyés par Ann, puis serveur relancé | Les deux sont arrivés, une fois chacun |
| Le serveur s’est tu sans fermer | Les deux pages ont ouvert une nouvelle connexion une fois le silence écoulé (3 secondes dans le test, 45 dans le code) |
| Une troisième page, hors ligne pendant qu’il en venait plus que le journal n’en gardait | Elle a reçu ce que le journal avait encore, puis onGap |
Un résultat mérite qu’on s’y arrête. Ann a envoyé ses deux messages pendant que le serveur était arrêté, et Ben a envoyé le sien juste après son retour. Celui de Ben est arrivé en premier : quand Ann s’est reconnectée, le sien avait déjà un id plus petit. Rien n’a été perdu et chaque page a vu le même ordre, mais c’était l’ordre du serveur, pas l’ordre dans lequel tous deux avaient appuyé sur envoyer. C’est l’ordre qu’une application temps réel peut promettre d’une reconnexion à l’autre : un seul ordre, décidé en un seul endroit, le même pour tout le monde. Un chat qui doit afficher les messages selon le moment où ils ont été écrits les trie par une heure que chaque page y joint, pas selon leur arrivée.
Ce que ce client ne peut toujours pas sauver : un message tapé dans un onglet qui se ferme avant de se reconnecter. La map unconfirmed vit dans la page. Pour garder ces messages, placez-les dans IndexedDB et envoyez-les à la visite suivante.
Quand un cloud temps réel tient la connexion
Tout ce qui précède est un travail qui revient à votre application : les reconnexions, les ids, le journal, les refs, le battement, et un journal partagé entre serveurs dès qu’il y en a plus d’un. WordPlus Cloud tient les connexions à la place, et son paquet @wordplus/realtime fait ces parties sur la page. Votre serveur déclare un salon une fois, avec une règle qui dit qui peut le rejoindre et combien d’événements il garde pour les pages qui reviennent :
// server.mjs, à côté de vos routes : le tableau d’une équipe, board:7
realtime.room('board:{id}', async (user, { id }) => {
return user !== null && (await db.boards.isMember(id, user));
}, {
emit: ['card', 'cursor'], // ce que les pages peuvent envoyer
history: 100, // les 100 derniers, gardés pour les pages qui se reconnectent
});import { connect } from '@wordplus/realtime';
const rt = await connect({ app: 's1500000007' });
const board = rt.join('board:7');
// Les événements manqués d’abord, dans l’ordre, marqués comme rejoués, puis les nouveaux.
board.on('card', (card, meta) => drawCard(card, meta.replayed));
board.on('error', (e) => e.code === 'gap' && reloadBoard());
// Attend que WordPlus Cloud ait vérifié l’événement, l’ait gardé et l’ait transmis.
const { id } = await board.emitWithAck('card', { title: 'Ship it' });
// Un curseur ne vaut rien en retard : abandonné hors ligne, jamais gardé.
board.volatile.emit('cursor', { x: 120, y: 80 });- Les reconnexions se font d’elles-mêmes, y compris vers un autre de nos serveurs, et
rt.on('disconnected')etrt.on('connected')disent à la page quand. - Le rattrapage : une page de retour en moins de 5 minutes reçoit d’abord les événements qu’elle a manqués, dans l’ordre, avec
meta.replayed, depuis l’historique du salon (jusqu’à 1 000 événements par salon, chacun jusqu’à 64 Ko). Absente plus longtemps, elle reçoitgapet interroge votre propre API, comme le fait le serveur ci-dessus. - Des envois confirmés :
emitWithAckse résout avec l’id et l’heure qu’a reçus l’événement, ou se rejette avec la raison, commenot_allowed. - Chaque onglet : les onglets d’un même navigateur partagent une seule connexion.
Comment les salons gardent leur historique et ce que fait chaque option : les salons et les événements dans la documentation. Avant d’écrire votre propre client, vous pouvez essayer votre propre serveur dans le test WebSocket, un client websocket dans le navigateur qui consigne chaque message envoyé et reçu et explique ce que signifie un code de fermeture. Sur un hébergement serverless, où une fonction ne peut garder aucune connexion, les websockets avec Next.js montrent le même modèle.
Des websockets pour votre application
WordPlus Cloud for Apps a un prix selon les connexions simultanées, à partir de 1 000, facturé au mois ou à l’année, sans rien à faire tourner sur vos serveurs. Découvrez les websockets pour les applications, ou les tarifs pour les applications. Des questions sur votre intégration ? Écrivez-nous.