WebSockets in JavaScript: Neuverbindungen, Reihenfolge und was verloren gehen kann

Ein WebSocket in JavaScript ist eine Zeile, new WebSocket(url), und in einem guten Netz funktioniert er einfach: Nachrichten kommen in beide Richtungen in der Reihenfolge an, in der sie gesendet wurden. Was er nicht tut: nach einem Abbruch zurückkommen, eine Verbindung bemerken, die still gestorben ist, oder Ihnen sagen, ob eine Nachricht angekommen ist. Jede App, die einen offen hält, schreibt diese drei Teile also selbst.
Dieser Beitrag zeigt, was der Browser tut, wenn eine Verbindung abbricht, gemessen in Chromium 156, dann einen Client von etwa 60 Zeilen, der sich neu verbindet, nachholt, was er verpasst hat, und erneut sendet, was nicht bestätigt wurde, mit dem kleinen Node.js-Server, mit dem er spricht. Beide liefen gegen einen Server, der getrennt, neu gestartet und stumm geschaltet wurde. Am Ende: wie dieselben drei Teile aussehen, wenn eine Echtzeit-Cloud die Verbindung hält.
Was der Browser Ihnen gibt
Die WebSocket-API hat in jedem Browser vier Events, open, message, error und close, eine Methode send() und einen readyState:
// Die ganze API: öffnen, senden, hören, schließen.
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);Innerhalb einer Verbindung wird nichts umsortiert: Das Protokoll läuft über eine einzige TCP-Verbindung (RFC 6455), und TCP liefert die Bytes in der Reihenfolge aus, in der sie gesendet wurden. Die Schwierigkeiten beginnen dort, wo diese eine Verbindung endet.
Was passiert, wenn die Verbindung abbricht
Wir haben aus Chromium 156 eine Verbindung zu einem Node.js-Server geöffnet, sie von der Serverseite getrennt und danach send() darauf aufgerufen:
| Was wir taten | Was der Browser tat |
|---|---|
send() vor open |
warf InvalidStateError |
| Der Server trennte die Verbindung | close mit Code 1006, wasClean false |
send() nach dem Schließen |
kein Fehler, bufferedAmount um 12 Bytes höher, nichts gesendet |
Die letzte Zeile ist die, bei der Daten verloren gehen. Eine Nachricht, die nach dem Schließen der Verbindung gesendet wird, löst nichts aus: Der WHATWG-Standard sagt, dass bufferedAmount nach dem Schließen „mit jedem Aufruf nur weiter steigt“ (WebSockets Standard), und die Nachricht selbst geht nirgendwohin. Code, der send() aufruft, ohne readyState zu prüfen, wirft alles weg, was er zwischen dem Abbruch und dem Moment sendet, in dem er ihn bemerkt.
Drei weitere Lücken:
- Keine Neuverbindung. Ein geschlossener WebSocket bleibt geschlossen. Nichts im Standard öffnet ihn wieder.
- Kein Ping aus Ihrem Code. Das Protokoll hat Ping- und Pong-Frames, und jede Seite darf jederzeit einen Ping senden, aber der Standard lässt sie mit Absicht aus der API heraus. Der Browser kann sie aus eigenen Gründen senden. Ihre Seite kann es nicht, also kann sie nicht fragen, ob die andere Seite noch da ist.
- Keine Empfangsbestätigung.
send()gibt nichts zurück. Eine Nachricht kann die Seite verlassen, in einem Puffer liegen und mit der Verbindung verloren gehen, ohne dass die Seite je davon erfährt.
Code 1006 bedeutet, dass die Verbindung ohne Close-Frame endete: RFC 6455 verbietet, 1006 in einem zu senden, also sagt damit der Browser, was passiert ist, und es ist nie ein Code, den Ihr Server gesendet hat. Was die anderen Codes sagen und wie Sie eine Adresse testen, die gar keine Verbindung aufbaut, steht in unserem Beitrag zum WebSocket-Fehler 1006.
Ein Client, der von selbst zurückkommt
Die Lösung für jede Lücke ist klein, und zusammen ergeben sie ein Modul. Es:
- Verbindet sich neu nach einem Abbruch und wartet nach jedem gescheiterten Versuch länger, einen zufälligen Teil der Wartezeit, bis zu 30 Sekunden.
- Holt nach: Es nennt dem Server die ID des neuesten Events, das es hat, und der Server sendet, was danach kam.
- Sendet erneut jede Nachricht, die der Server nicht bestätigt hat, jede mit einer eigenen ID (
ref), sodass eine doppelt gesendete Nachricht trotzdem nur einmal angenommen wird. - Bemerkt Stille: Der Server sendet alle 20 Sekunden einen Takt, und hat die Seite 45 Sekunden lang nichts gehört, öffnet sie eine neue Verbindung, statt auf einer toten zu warten.
// socket.js: ein WebSocket zu Ihrem eigenen Server, der von selbst zurückkommt
export function connect(url, { onEvent, onGap, quiet = 45000 }) {
let ws, retry, silence;
let lastId = 0; // das neueste Event, das diese Seite hat
let attempt = 0; // gescheiterte Versuche seit der letzten guten Verbindung
const unconfirmed = new Map(); // ref → data, bis der Server es bestätigt
function open() {
clearTimeout(retry);
const mine = (ws = new WebSocket(`${url}?after=${lastId}`));
mine.onopen = () => {
if (mine !== ws) return mine.close(); // ersetzt, während er sich verband
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; // ein Takt oder ein schon gezeigtes Event
lastId = msg.id;
onEvent(msg);
};
mine.onclose = () => {
if (mine !== ws) return;
// Bis zu 0,5 s, 1 s, 2 s… höchstens 30 s, jeweils ein zufälliger Teil davon, damit nicht alle auf einmal zurückkommen.
const delay = Math.random() * Math.min(30000, 500 * 2 ** attempt++);
retry = setTimeout(open, delay);
};
}
// Zu lange nichts gehört: Die Verbindung ist tot, auch wenn der Browser es nicht bemerkt hat.
function heard(mine) {
clearTimeout(silence);
silence = setTimeout(() => {
if (mine === ws) { open(); mine.close(); }
}, quiet);
}
// Wieder im Netz: jetzt versuchen, nicht erst, wenn der Timer es sagt.
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 }));
},
};
}Eine Seite nutzt es so:
import { connect } from './socket.js';
const live = connect('wss://example.com/live', {
onEvent: ({ id, data }) => showMessage(data),
onGap: () => reloadFromApi(), // zu lange weg: Der Server hat nicht mehr alles davon
});
live.send({ text: 'Hi' });Jeder Socket prüft mine !== ws, bevor er handelt, und das ist wichtiger, als es aussieht. Der Stille-Timer und das Event online öffnen beide einen neuen Socket, während der alte vielleicht noch schließt, und ohne diese Prüfung würde ein alter Socket, der spät schließt, eine zweite Neuverbindung einplanen, oder einer, der spät öffnet, über den neuen hinweg senden.
Der zufällige Teil der Wartezeit ist für Ihren Server da, nicht für die Seite. Wenn ein Server neu startet, sieht jede Seite, die er hielt, den Abbruch in derselben Sekunde. Mit einer festen Wartezeit kommen sie auch alle in derselben Sekunde zurück, immer wieder. Ein zufälliger Anteil an einer wachsenden Wartezeit verteilt sie.
Der Server, mit dem er spricht
Der Server gibt jedem Event eine ID, hebt die letzten 500 auf und sendet einer Seite, die zurückkommt, alles nach der ID, die sie nennt. In Node.js mit dem Paket ws:
// server.mjs: Jedes Event bekommt eine ID, die letzten 500 werden aufgehoben, und eine Seite, die zurückkommt, bekommt, was sie verpasst hat
import { WebSocketServer } from 'ws';
const KEEP = 500;
const log = []; // die letzten KEEP Events, das älteste zuerst
const seen = new Set(); // schon angenommene refs: einen Tag lang in Redis aufheben, nicht für immer im Speicher
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;
// Länger weg, als das Log zurückreicht: das sagen, und die Seite lädt neu aus Ihrer 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; // nach einem Abbruch erneut gesendet und schon angenommen
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));
});
});
// Alle 20 Sekunden ein Takt, damit eine Seite eine ruhige Verbindung von einer toten unterscheiden kann.
setInterval(() => {
for (const client of wss.clients) client.send('{"beat":1}');
}, 20000);Das Log und die Menge der refs liegen hier im Speicher, ein Neustart vergisst sie also. Im Betrieb gehören sie in Redis oder Ihre Datenbank, und mit mehr als einem Server muss jeder Server dasselbe Log lesen, was WebSockets in Node.js ab dem zweiten Server durchgeht.
Was der Test zeigte
Wir haben diesen Client in zwei Seiten in Chromium 156 laufen lassen, Ann und Ben, gegen diesen Server, und absichtlich Dinge kaputt gemacht:
| Was wir kaputt machten | Was die Seiten sahen |
|---|---|
| Ann getrennt, nachdem der Server ihre Nachricht angenommen, aber bevor er sie bestätigt hatte | Ann sendete sie erneut, der Server nahm sie einmal an |
| Den Server gestoppt, Ann sendete zwei Nachrichten, dann ihn wieder gestartet | Beide kamen an, jede einmal |
| Der Server verstummte, ohne zu schließen | Beide Seiten öffneten eine neue Verbindung, sobald die Stille abgelaufen war (3 Sekunden im Test, 45 im Code) |
| Eine dritte Seite, offline, während mehr kam, als das Log aufhob | Sie bekam, was das Log noch hatte, dann onGap |
Ein Ergebnis verdient einen zweiten Blick. Ann sendete ihre zwei Nachrichten, während der Server unten war, und Ben sendete seine kurz nachdem er zurück war. Bens kam zuerst: Als Ann sich wieder verband, hatte seine schon eine niedrigere ID. Nichts ging verloren, und jede Seite sah dieselbe Reihenfolge, aber es war die Reihenfolge des Servers, nicht die, in der die beiden auf Senden gedrückt hatten. Das ist die Reihenfolge, die eine Echtzeit-App über Neuverbindungen hinweg versprechen kann: eine Reihenfolge, an einer Stelle entschieden, für alle gleich. Ein Chat, der Nachrichten danach zeigen muss, wann sie geschrieben wurden, sortiert nach einer Zeit, die jede Seite anhängt, nicht danach, wann sie ankamen.
Was dieser Client trotzdem nicht retten kann: eine Nachricht, die in einen Tab getippt wurde, der sich schließt, bevor er sich neu verbindet. Die Map unconfirmed lebt in der Seite. Um diese Nachrichten zu behalten, legen Sie sie in IndexedDB ab und senden sie beim nächsten Besuch.
Wenn eine Echtzeit-Cloud die Verbindung hält
Alles oben ist Arbeit, die Ihrer App gehört: die Neuverbindungen, die IDs, das Log, die refs, der Takt und ein Log, das sich die Server teilen, sobald es mehr als einen gibt. WordPlus Cloud hält stattdessen die Verbindungen, und ihr Paket @wordplus/realtime übernimmt diese Teile auf der Seite. Ihr Server legt einen Raum einmal fest, mit einer Regel dafür, wer beitreten darf, und wie viele Events er für Seiten aufhebt, die zurückkommen:
// server.mjs, neben Ihren Routen: das Board eines Teams, board:7
realtime.room('board:{id}', async (user, { id }) => {
return user !== null && (await db.boards.isMember(id, user));
}, {
emit: ['card', 'cursor'], // was die Seiten senden dürfen
history: 100, // die letzten 100, aufgehoben für Seiten, die sich neu verbinden
});import { connect } from '@wordplus/realtime';
const rt = await connect({ app: 's1500000007' });
const board = rt.join('board:7');
// Verpasste Events kommen zuerst, der Reihe nach, als replayed markiert, dann die neuen.
board.on('card', (card, meta) => drawCard(card, meta.replayed));
board.on('error', (e) => e.code === 'gap' && reloadBoard());
// Wartet, bis WordPlus Cloud das Event geprüft, aufgehoben und weitergesendet hat.
const { id } = await board.emitWithAck('card', { title: 'Ship it' });
// Ein Cursor ist verspätet nichts wert: offline verworfen, nie aufgehoben.
board.volatile.emit('cursor', { x: 120, y: 80 });- Neuverbindungen geschehen von selbst, auch auf einen anderen unserer Server, und
rt.on('disconnected')undrt.on('connected')sagen der Seite, wann. - Nachholen: Eine Seite, die innerhalb von 5 Minuten zurück ist, bekommt zuerst die Events, die sie verpasst hat, der Reihe nach, mit
meta.replayed, aus dem Verlauf des Raums (bis zu 1.000 Events je Raum, jedes bis zu 64 KB). War sie länger weg, bekommt siegapund fragt Ihre eigene API, wie beim Server oben. - Bestätigtes Senden:
emitWithAckwird mit der ID und der Zeit erfüllt, die das Event bekam, oder mit dem Grund abgelehnt, etwanot_allowed. - Jeder Tab: Die Tabs eines Browsers teilen sich eine Verbindung.
Wie Räume ihren Verlauf aufheben und was jede Option tut: Räume und Events in der Dokumentation. Bevor Sie Ihren eigenen Client schreiben, können Sie Ihren eigenen Server im WebSocket-Test ausprobieren, einem WebSocket-Client im Browser, der jede gesendete und empfangene Nachricht protokolliert und sagt, was ein Close-Code bedeutet. Auf Serverless-Hosting, wo eine Funktion überhaupt keine Verbindung halten kann, zeigt WebSockets in Next.js dasselbe Modell.
WebSockets für Ihre App
Für WordPlus Cloud for Apps gelten Preise nach gleichzeitigen Verbindungen, ab 1.000, monatlich oder jährlich abgerechnet, und auf Ihren Servern läuft nichts zusätzlich. Sehen Sie sich WebSockets für Apps an oder die Preise für Apps. Fragen zu Ihrer Integration? Schreiben Sie uns.