WebSocket in JavaScript: riconnessioni, ordine e cosa si può perdere

Un WebSocket in JavaScript è una riga sola, new WebSocket(url), e su una buona rete funziona e basta: i messaggi arrivano nell’ordine in cui sono stati inviati, in entrambe le direzioni. Quello che non fa è tornare dopo una caduta, accorgersi di una connessione morta in silenzio, o dirti se un messaggio è arrivato, quindi ogni app che ne tiene uno aperto scrive da sé queste tre parti.
Questo articolo mostra cosa fa il browser quando una connessione cade, misurato in Chromium 156, poi un client di circa 60 righe che si riconnette, recupera ciò che si è perso e invia di nuovo ciò che non è stato confermato, con il piccolo server Node.js con cui parla. Entrambi sono stati provati contro un server che veniva scollegato, riavviato e messo a tacere. Alla fine: come appaiono le stesse tre parti quando è un cloud in tempo reale a tenere la connessione.
Cosa ti dà il browser
L’API WebSocket di ogni browser ha quattro eventi, open, message, error e close, un metodo send() e un readyState:
// Tutta l’API: aprire, inviare, ascoltare, chiudere.
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);Su una sola connessione nulla cambia di ordine: il protocollo passa su un’unica connessione TCP (RFC 6455), e TCP consegna i byte nell’ordine in cui sono stati inviati. I guai cominciano dove quella connessione finisce.
Cosa succede quando la connessione cade
Abbiamo aperto una connessione da Chromium 156 verso un server Node.js, l’abbiamo interrotta dal lato del server, e poi abbiamo chiamato send() su di essa:
| Cosa abbiamo fatto | Cosa ha fatto il browser |
|---|---|
send() prima di open |
ha lanciato InvalidStateError |
| Il server ha interrotto la connessione | close con codice 1006, wasClean false |
send() dopo la chiusura |
nessun errore, bufferedAmount cresciuto di 12 byte, nulla inviato |
L’ultima riga è quella che perde dati. Un messaggio inviato dopo la chiusura della connessione non solleva nulla: lo standard WHATWG dice che, a connessione chiusa, bufferedAmount «aumenterà soltanto a ogni chiamata» (WebSockets Standard), e il messaggio stesso non va da nessuna parte. Il codice che chiama send() senza controllare readyState butta via tutto ciò che invia tra la caduta e il momento in cui se ne accorge.
Altre tre lacune:
- Nessuna riconnessione. Un WebSocket chiuso resta chiuso. Nulla nello standard lo riapre.
- Nessun ping dal tuo codice. Il protocollo ha frame di ping e pong, e ciascuna delle due parti può inviare un ping in qualsiasi momento, ma lo standard li lascia fuori dall’API di proposito. Il browser può inviarli per motivi suoi. La tua pagina no, quindi non può chiedere se l’altra parte c’è ancora.
- Nessuna ricevuta.
send()non restituisce nulla. Un messaggio può lasciare la pagina, restare in un buffer e perdersi con la connessione, e la pagina non lo viene mai a sapere.
Il codice 1006 significa che la connessione è finita senza un frame di chiusura: RFC 6455 vieta di inviare 1006 dentro un frame, quindi è il browser che dice cosa è successo, mai un codice inviato dal tuo server. Cosa dicono gli altri codici, e come provare un indirizzo che non si collega affatto, è in WebSocket connection failed.
Un client che torna da solo
La soluzione a ogni lacuna è piccola, e insieme formano un unico modulo. Questo:
- Si riconnette dopo una caduta, aspettando di più dopo ogni tentativo fallito, una parte casuale dell’attesa, fino a 30 secondi.
- Recupera: dice al server l’id dell’evento più recente che ha, e il server invia ciò che è venuto dopo.
- Invia di nuovo ogni messaggio che il server non ha confermato, ciascuno con un id proprio (
ref), così un messaggio inviato due volte viene comunque accolto una volta sola. - Si accorge del silenzio: il server invia un battito ogni 20 secondi, e se per 45 non si sente nulla la pagina apre una nuova connessione invece di aspettarne una morta.
// socket.js: un websocket verso il tuo server che torna da solo
export function connect(url, { onEvent, onGap, quiet = 45000 }) {
let ws, retry, silence;
let lastId = 0; // l’evento più recente che questa pagina ha
let attempt = 0; // tentativi falliti dall’ultima connessione riuscita
const unconfirmed = new Map(); // ref → data, finché il server non lo conferma
function open() {
clearTimeout(retry);
const mine = (ws = new WebSocket(`${url}?after=${lastId}`));
mine.onopen = () => {
if (mine !== ws) return mine.close(); // sostituito mentre si collegava
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 battito, o un evento già mostrato
lastId = msg.id;
onEvent(msg);
};
mine.onclose = () => {
if (mine !== ws) return;
// Fino a 0,5 s, 1 s, 2 s… al massimo 30 s, ogni volta una parte casuale, così una folla non torna tutta insieme.
const delay = Math.random() * Math.min(30000, 500 * 2 ** attempt++);
retry = setTimeout(open, delay);
};
}
// Nulla sentito per troppo tempo: la connessione è morta, anche se il browser non se n’è accorto.
function heard(mine) {
clearTimeout(silence);
silence = setTimeout(() => {
if (mine === ws) { open(); mine.close(); }
}, quiet);
}
// Di nuovo in rete: prova subito invece di quando lo dice il timer.
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 }));
},
};
}Una pagina lo usa così:
import { connect } from './socket.js';
const live = connect('wss://example.com/live', {
onEvent: ({ id, data }) => showMessage(data),
onGap: () => reloadFromApi(), // via troppo a lungo: il server non ha più tutto
});
live.send({ text: 'Hi' });Ogni socket controlla mine !== ws prima di agire, e conta più di quanto sembri. Il timer del silenzio e l’evento online aprono entrambi un nuovo socket mentre quello vecchio può essere ancora in chiusura, e senza il controllo un vecchio socket che si chiude in ritardo programmerebbe una seconda riconnessione, oppure uno che si apre in ritardo invierebbe sopra quello nuovo.
La parte casuale dell’attesa c’è per il tuo server, non per la pagina. Quando un server si riavvia, ogni pagina che teneva vede la caduta nello stesso secondo. Con un’attesa fissa tornano tutte anche nello stesso secondo, ancora e ancora. Una quota casuale di un’attesa che cresce le distribuisce nel tempo.
Il server con cui parla
Il server dà un id a ogni evento, conserva gli ultimi 500, e a una pagina che torna invia tutto ciò che viene dopo l’id che indica. In Node.js con il pacchetto ws:
// server.mjs: ogni evento riceve un id, gli ultimi 500 vengono conservati, e una pagina che torna riceve ciò che si è persa
import { WebSocketServer } from 'ws';
const KEEP = 500;
const log = []; // gli ultimi KEEP eventi, dal più vecchio
const seen = new Set(); // ref già accolti: tienili per un giorno in Redis, non per sempre in memoria
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;
// Via più a lungo di quanto arrivi il log: dillo, e la pagina ricarica dalla tua 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; // inviato di nuovo dopo una caduta, e già accolto
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 battito ogni 20 secondi, così una pagina distingue una connessione tranquilla da una morta.
setInterval(() => {
for (const client of wss.clients) client.send('{"beat":1}');
}, 20000);Qui il log e l’insieme dei ref vivono in memoria, quindi un riavvio li dimentica. In produzione vanno in Redis o nel tuo database, e con più di un server ogni server deve leggere lo stesso log, come spiega websocket in Node.js oltre un solo server.
Cosa ha mostrato la prova
Abbiamo fatto girare questo client in due pagine di Chromium 156, Ann e Ben, contro questo server, e abbiamo rotto le cose apposta:
| Cosa abbiamo rotto | Cosa hanno visto le pagine |
|---|---|
| Ann scollegata dopo che il server aveva accolto il suo messaggio ma prima di confermarlo | Ann lo ha inviato di nuovo, il server lo ha accolto una volta |
| Server fermato, Ann ha inviato due messaggi, poi il server è ripartito | Sono arrivati entrambi, una volta ciascuno |
| Il server è rimasto in silenzio senza chiudere | Entrambe le pagine hanno aperto una nuova connessione allo scadere del silenzio (3 secondi nella prova, 45 nel codice) |
| Una terza pagina, offline mentre arrivava più di quanto il log conservasse | Ha ricevuto ciò che il log aveva ancora, poi onGap |
Un risultato merita una seconda occhiata. Ann ha inviato i suoi due messaggi mentre il server era fermo, e Ben ha inviato il suo appena il server è tornato. Quello di Ben è arrivato per primo: quando Ann si è riconnessa, il suo aveva già un id più basso. Nulla si è perso e ogni pagina ha visto lo stesso ordine, ma era l’ordine del server, non quello in cui i due hanno premuto invio. È l’ordine che un’app in tempo reale può promettere attraverso le riconnessioni: un solo ordine, deciso in un solo posto, uguale per tutti. Una chat che deve mostrare i messaggi in base a quando sono stati scritti li ordina per un orario che ogni pagina allega, non per quando sono arrivati.
Cosa questo client non può ancora salvare: un messaggio scritto in una scheda che si chiude prima di riconnettersi. La mappa unconfirmed vive nella pagina. Per conservarli, mettili in IndexedDB e inviali alla visita successiva.
Quando è un cloud in tempo reale a tenere la connessione
Tutto quello che c’è sopra è lavoro che spetta alla tua app: le riconnessioni, gli id, il log, i ref, il battito, e un log condiviso tra i server appena ce n’è più di uno. WordPlus Cloud tiene invece le connessioni, e il suo pacchetto @wordplus/realtime fa quelle parti nella pagina. Il tuo server dichiara una stanza una volta sola, con una regola su chi può entrare e quanti eventi conserva per le pagine che tornano:
// server.mjs, accanto alle tue route: la bacheca di un team, board:7
realtime.room('board:{id}', async (user, { id }) => {
return user !== null && (await db.boards.isMember(id, user));
}, {
emit: ['card', 'cursor'], // ciò che le pagine possono inviare
history: 100, // gli ultimi 100 conservati per le pagine che si riconnettono
});import { connect } from '@wordplus/realtime';
const rt = await connect({ app: 's1500000007' });
const board = rt.join('board:7');
// Prima gli eventi persi, in ordine, segnati come replayed, poi quelli nuovi.
board.on('card', (card, meta) => drawCard(card, meta.replayed));
board.on('error', (e) => e.code === 'gap' && reloadBoard());
// Aspetta finché WordPlus Cloud ha controllato l’evento, l’ha conservato e l’ha inoltrato.
const { id } = await board.emitWithAck('card', { title: 'Ship it' });
// Un cursore in ritardo non vale nulla: scartato quando si è offline, mai conservato.
board.volatile.emit('cursor', { x: 120, y: 80 });- Le riconnessioni avvengono da sole, anche verso un altro dei nostri server, e
rt.on('disconnected')ert.on('connected')dicono alla pagina quando. - Il recupero: una pagina che torna entro 5 minuti riceve prima gli eventi che si è persa, in ordine, con
meta.replayed, dalla cronologia della stanza (fino a 1.000 eventi per stanza, ciascuno fino a 64 KB). Se resta via più a lungo, ricevegape chiede alla tua API, come fa il server qui sopra. - Invii confermati:
emitWithAcksi risolve con l’id e l’orario che l’evento ha ricevuto, oppure viene rifiutato con il motivo, comenot_allowed. - Ogni scheda: le schede di un browser condividono un’unica connessione.
Come le stanze conservano la cronologia e cosa fa ogni opzione: stanze ed eventi nella documentazione. Prima di scrivere il tuo client, puoi provare il tuo server nel test WebSocket, un client websocket nel browser che registra ogni messaggio inviato e ricevuto e spiega cosa significa un codice di chiusura. Su hosting serverless, dove una funzione non può tenere affatto una connessione, i websocket in Next.js mostrano lo stesso modello.
Websocket per la tua app
WordPlus Cloud for Apps ha un prezzo in base alle connessioni simultanee, a partire da 1.000, con fatturazione mensile o annuale, e senza nulla da far girare sui tuoi server. Scopri i websocket per le app, oppure i prezzi per le app. Domande sulla tua integrazione? Scrivici.