WebSockets in JavaScript: opnieuw verbinden, volgorde en wat verloren kan gaan

Een WebSocket in JavaScript is één regel, new WebSocket(url), en op een goed netwerk werkt hij gewoon: berichten komen aan in de volgorde waarin ze verstuurd zijn, in beide richtingen. Wat hij niet doet, is terugkomen na een onderbreking, een verbinding opmerken die stilletjes is gestorven, of je vertellen of een bericht is aangekomen. Elke app die er een openhoudt, schrijft die drie delen dus zelf.
Dit artikel laat zien wat de browser doet als een verbinding wegvalt, gemeten in Chromium 156, en daarna een client van ongeveer 60 regels die opnieuw verbindt, inhaalt wat hij gemist heeft en opnieuw verstuurt wat niet bevestigd is, met de kleine Node.js-server waarmee hij praat. Beide zijn getest tegen een server die werd afgesneden, herstart en stilgelegd. Aan het eind: hoe dezelfde drie delen eruitzien als een realtime cloud de verbinding vasthoudt.
Wat de browser je geeft
De WebSocket-API heeft in elke browser vier events, open, message, error en close, een methode send() en een readyState:
// De hele API: openen, versturen, horen, sluiten.
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);Binnen één verbinding raakt niets door elkaar: het protocol loopt over één TCP-verbinding (RFC 6455), en TCP levert bytes af in de volgorde waarin ze verstuurd zijn. De problemen beginnen waar die ene verbinding eindigt.
Wat er gebeurt als de verbinding wegvalt
We openden een verbinding van Chromium 156 naar een Node.js-server, verbraken die aan de kant van de server en riepen daarna send() erop aan:
| Wat we deden | Wat de browser deed |
|---|---|
send() vóór open |
gooide InvalidStateError |
| De server verbrak de verbinding | close met code 1006, wasClean false |
send() na het sluiten |
geen fout, bufferedAmount 12 bytes hoger, niets verstuurd |
De laatste rij is die waar data verloren gaat. Een bericht dat na het sluiten van de verbinding wordt verstuurd, geeft geen enkele fout: de WHATWG-standaard zegt dat bufferedAmount na het sluiten „alleen toeneemt bij elke aanroep” (WebSockets Standard), en het bericht zelf gaat nergens heen. Code die send() aanroept zonder readyState te controleren, gooit alles weg wat ze verstuurt tussen de onderbreking en het moment dat ze die opmerkt.
Nog drie gaten:
- Geen nieuwe verbinding. Een gesloten WebSocket blijft gesloten. Niets in de standaard opent hem opnieuw.
- Geen ping vanuit je code. Het protocol heeft ping- en pongframes, en elk eindpunt mag op elk moment een ping sturen, maar de standaard zegt ronduit dat die niet in de API beschikbaar zijn. De browser kan ze om eigen redenen sturen. Je pagina kan dat niet, en kan dus niet vragen of de andere kant er nog is.
- Geen ontvangstbewijs.
send()geeft niets terug. Een bericht kan de pagina verlaten, in een buffer blijven hangen en met de verbinding verloren gaan, zonder dat de pagina er ooit van hoort.
Code 1006 betekent dat de verbinding eindigde zonder close-frame: RFC 6455 verbiedt het om 1006 in een close-frame te sturen, dus is het de browser die zegt wat er gebeurde, nooit een code die je server stuurde. Wat de andere codes zeggen, en hoe je een adres test dat helemaal niet verbindt, staat in WebSocket-verbinding mislukt.
Een client die uit zichzelf terugkomt
De oplossing voor elk gat is klein, en samen vormen ze één module. Die:
- Verbindt opnieuw na een onderbreking, en wacht na elke mislukte poging langer, een willekeurig deel van de wachttijd, tot 30 seconden.
- Haalt in: hij geeft de server het id van het nieuwste event dat hij heeft, en de server stuurt wat daarna kwam.
- Verstuurt opnieuw elk bericht dat de server niet heeft bevestigd, elk met een eigen id (
ref), zodat een bericht dat twee keer wordt verstuurd toch één keer wordt aangenomen. - Merkt stilte op: de server stuurt elke 20 seconden een tik, en als er 45 seconden niets is gehoord, opent de pagina een nieuwe verbinding in plaats van op een dode te wachten.
// socket.js: een websocket naar je eigen server die uit zichzelf terugkomt
export function connect(url, { onEvent, onGap, quiet = 45000 }) {
let ws, retry, silence;
let lastId = 0; // het nieuwste event dat deze pagina heeft
let attempt = 0; // mislukte pogingen sinds de laatste goede verbinding
const unconfirmed = new Map(); // ref → data, tot de server het bevestigt
function open() {
clearTimeout(retry);
const mine = (ws = new WebSocket(`${url}?after=${lastId}`));
mine.onopen = () => {
if (mine !== ws) return mine.close(); // vervangen terwijl hij verbond
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; // een tik, of een event dat al getoond is
lastId = msg.id;
onEvent(msg);
};
mine.onclose = () => {
if (mine !== ws) return;
// Tot 0,5 s, 1 s, 2 s… hoogstens 30 s, elk een willekeurig deel ervan, zodat een menigte niet tegelijk terugkomt.
const delay = Math.random() * Math.min(30000, 500 * 2 ** attempt++);
retry = setTimeout(open, delay);
};
}
// Te lang niets gehoord: de verbinding is dood, ook als de browser het nog niet gemerkt heeft.
function heard(mine) {
clearTimeout(silence);
silence = setTimeout(() => {
if (mine === ws) { open(); mine.close(); }
}, quiet);
}
// Weer op het netwerk: probeer het nu in plaats van wanneer de timer het zegt.
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 }));
},
};
}Een pagina gebruikt hem zo:
import { connect } from './socket.js';
const live = connect('wss://example.com/live', {
onEvent: ({ id, data }) => showMessage(data),
onGap: () => reloadFromApi(), // te lang weg: de server heeft niet meer alles
});
live.send({ text: 'Hi' });Elke socket controleert mine !== ws voordat hij iets doet, en dat is belangrijker dan het lijkt. De stiltetimer en het event online openen allebei een nieuwe socket terwijl de oude misschien nog aan het sluiten is. Zonder die controle zou een oude socket die laat sluit een tweede nieuwe verbinding inplannen, of zou een socket die laat opent over de nieuwe heen versturen.
Het willekeurige deel van de wachttijd is er voor je server, niet voor de pagina. Als een server herstart, ziet elke pagina die hij vasthield de onderbreking in dezelfde seconde. Met een vaste wachttijd komen ze ook allemaal in dezelfde seconde terug, keer op keer. Een willekeurig deel van een groeiende wachttijd spreidt ze.
De server waarmee hij praat
De server geeft elk event een id, bewaart de laatste 500 en stuurt een pagina die terugkomt alles na het id dat ze noemt. In Node.js met het package ws:
// server.mjs: elk event krijgt een id, de laatste 500 worden bewaard, en een pagina die terugkomt krijgt wat ze gemist heeft
import { WebSocketServer } from 'ws';
const KEEP = 500;
const log = []; // de laatste KEEP events, oudste eerst
const seen = new Set(); // refs die al zijn aangenomen: bewaar ze een dag in Redis, niet voor altijd in het geheugen
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;
// Langer weg dan de log reikt: zeg het, en de pagina laadt opnieuw vanuit je 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; // opnieuw verstuurd na een onderbreking, en al aangenomen
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));
});
});
// Elke 20 seconden een tik, zodat een pagina een stille verbinding van een dode kan onderscheiden.
setInterval(() => {
for (const client of wss.clients) client.send('{"beat":1}');
}, 20000);De log en de set refs staan hier in het geheugen, dus een herstart vergeet ze. In productie gaan ze in Redis of je database, en met meer dan één server moet elke server dezelfde log lezen. Dat behandelt websockets in Node.js met meer dan één server.
Wat de test liet zien
We draaiden deze client in twee pagina’s in Chromium 156, Ann en Ben, tegen deze server, en maakten met opzet dingen kapot:
| Wat we kapotmaakten | Wat de pagina’s zagen |
|---|---|
| Ann afgesneden nadat de server haar bericht had aangenomen, maar voordat hij het bevestigde | Ann verstuurde het opnieuw, de server nam het één keer aan |
| De server gestopt, Ann verstuurde twee berichten, daarna de server weer gestart | Beide kwamen aan, elk één keer |
| De server werd stil zonder te sluiten | Beide pagina’s openden een nieuwe verbinding toen de stilte voorbij was (3 seconden in de test, 45 in de code) |
| Een derde pagina, offline terwijl er meer binnenkwam dan de log bewaarde | Die kreeg wat de log nog had, en daarna onGap |
Eén uitkomst verdient een tweede blik. Ann verstuurde haar twee berichten terwijl de server uit stond, en Ben verstuurde het zijne net nadat hij weer draaide. Dat van Ben kwam eerst: toen Ann opnieuw verbond, had het zijne al een lager id. Er ging niets verloren en elke pagina zag dezelfde volgorde, maar het was de volgorde van de server, niet de volgorde waarin die twee op versturen drukten. Dat is de volgorde die een realtime app over nieuwe verbindingen heen kan beloven: één volgorde, op één plek bepaald, voor iedereen dezelfde. Een chat die berichten moet tonen op het moment dat ze geschreven zijn, sorteert op een tijd die elke pagina meegeeft, niet op wanneer ze aankwamen.
Wat deze client nog altijd niet redt: een bericht dat getypt is in een tabblad dat sluit voordat het opnieuw verbindt. De map unconfirmed leeft in de pagina. Wil je die bewaren, zet ze dan in IndexedDB en verstuur ze bij het volgende bezoek.
Als een realtime cloud de verbinding vasthoudt
Alles hierboven is werk dat je app zelf doet: het opnieuw verbinden, de id’s, de log, de refs, de tik, en een log die servers delen zodra er meer dan één is. WordPlus Cloud houdt in plaats daarvan de verbindingen vast, en het package @wordplus/realtime doet die delen op de pagina. Je server legt een ruimte één keer vast, met een regel over wie mag deelnemen en hoeveel events ze bewaart voor pagina’s die terugkomen:
// server.mjs, naast je routes: het bord van een team, board:7
realtime.room('board:{id}', async (user, { id }) => {
return user !== null && (await db.boards.isMember(id, user));
}, {
emit: ['card', 'cursor'], // wat de pagina's mogen versturen
history: 100, // de laatste 100 bewaard voor pagina's die opnieuw verbinden
});import { connect } from '@wordplus/realtime';
const rt = await connect({ app: 's1500000007' });
const board = rt.join('board:7');
// Gemiste events komen eerst, op volgorde, gemarkeerd als replayed, daarna de nieuwe.
board.on('card', (card, meta) => drawCard(card, meta.replayed));
board.on('error', (e) => e.code === 'gap' && reloadBoard());
// Wacht tot WordPlus Cloud het event heeft gecontroleerd, bewaard en doorgestuurd.
const { id } = await board.emitWithAck('card', { title: 'Ship it' });
// Een cursor is niets meer waard als hij te laat komt: offline weggegooid, nooit bewaard.
board.volatile.emit('cursor', { x: 120, y: 80 });- Opnieuw verbinden gebeurt vanzelf, ook naar een andere van onze servers, en
rt.on('disconnected')enrt.on('connected')vertellen de pagina wanneer. - Inhalen: een pagina die binnen 5 minuten terug is, krijgt eerst de events die ze gemist heeft, op volgorde, met
meta.replayed, uit de geschiedenis van de ruimte (tot 1.000 events per ruimte, elk tot 64 KB). Is ze langer weg, dan krijgt zegapen vraagt ze het aan je eigen API, zoals bij de server hierboven. - Bevestigd versturen:
emitWithAcklevert het id en de tijd die het event kreeg, of wordt afgewezen met de reden, zoalsnot_allowed. - Elk tabblad: de tabbladen van één browser delen één verbinding.
Hoe ruimtes geschiedenis bewaren en wat elke optie doet: rooms en events in de documentatie. Voordat je je eigen client schrijft, kun je je eigen server proberen in de WebSocket-test, een websocketclient in de browser die elk verstuurd en ontvangen bericht logt en zegt wat een close-code betekent. Op serverless hosting, waar een functie helemaal geen verbinding kan vasthouden, laat websockets in Next.js hetzelfde model zien.
Websockets voor je app
WordPlus Cloud for Apps is geprijsd op gelijktijdige verbindingen, vanaf 1.000, maandelijks of jaarlijks gefactureerd, zonder iets dat op je eigen servers hoeft te draaien. Bekijk websockets voor apps, of de prijzen voor apps. Vragen over je integratie? Schrijf ons.