WebSockets en JavaScript: reconexiones, orden y lo que se puede perder

Un WebSocket en JavaScript es una línea, new WebSocket(url), y en una buena red simplemente funciona: los mensajes llegan en el orden en que se enviaron, en los dos sentidos. Lo que no hace es volver tras un corte, darse cuenta de una conexión que murió en silencio ni decirte si un mensaje llegó, así que cada app que mantiene uno abierto escribe esas tres partes por su cuenta.
Este artículo muestra lo que hace el navegador cuando se corta una conexión, medido en Chromium 156, y después un cliente de unas 60 líneas que se reconecta, recupera lo que se perdió y vuelve a enviar lo que no se confirmó, con el pequeño servidor Node.js con el que habla. Los dos se probaron contra un servidor al que se le cortó la conexión, se reinició y se dejó en silencio. Al final, cómo se ven esas mismas tres partes cuando la conexión la mantiene una nube de tiempo real.
Lo que te da el navegador
La API de WebSocket de todos los navegadores tiene cuatro eventos, open, message, error y close, un método send() y un readyState:
// Toda la API: abrir, enviar, escuchar, cerrar.
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);Dentro de una conexión nada cambia de orden: el protocolo funciona sobre una sola conexión TCP (RFC 6455), y TCP entrega los bytes en el orden en que se enviaron. El problema empieza donde termina esa conexión.
Qué pasa cuando se corta la conexión
Abrimos una conexión desde Chromium 156 a un servidor Node.js, la cortamos desde el lado del servidor y después llamamos a send() sobre ella:
| Qué hicimos | Qué hizo el navegador |
|---|---|
send() antes de open |
lanzó InvalidStateError |
| El servidor cortó la conexión | close con el código 1006, wasClean false |
send() después del cierre |
ningún error, bufferedAmount sube 12 bytes, no se envía nada |
La última fila es la que pierde datos. Un mensaje enviado después de que la conexión se cerrara no provoca nada: el estándar de WHATWG dice que bufferedAmount «solo aumentará con cada llamada» una vez cerrada la conexión (WebSockets Standard), y el mensaje en sí no va a ninguna parte. El código que llama a send() sin mirar readyState tira todo lo que envía entre el corte y el momento en que se da cuenta.
Tres huecos más:
- No se reconecta. Un WebSocket cerrado se queda cerrado. Nada en el estándar lo vuelve a abrir.
- Tu código no puede hacer ping. El protocolo tiene tramas ping y pong, y cualquier extremo puede enviar un ping en cualquier momento, pero el estándar dice claramente que no están expuestas en la API por ahora. El navegador puede enviarlas por sus propios motivos. Tu página no puede, así que no puede preguntar si el otro lado sigue ahí.
- No hay acuse de recibo.
send()no devuelve nada. Un mensaje puede salir de la página, quedarse en un búfer y perderse con la conexión, y la página nunca se entera.
El código 1006 significa que la conexión terminó sin una trama de cierre: el RFC 6455 prohíbe enviar 1006 en una, así que es el navegador diciendo lo que pasó, nunca un código que haya enviado tu servidor. Qué dicen los demás códigos, y cómo probar una dirección que no llega a conectar, está en nuestro artículo sobre las conexiones WebSocket que fallan.
Un cliente que vuelve por sí solo
La solución de cada hueco es pequeña, y juntas forman un módulo. Este:
- Se reconecta tras un corte, esperando más después de cada intento fallido, una parte aleatoria de la espera, hasta 30 segundos.
- Se pone al día: le dice al servidor el id del evento más reciente que tiene, y el servidor le envía lo que vino después.
- Vuelve a enviar cada mensaje que el servidor no ha confirmado, cada uno con un id propio (
ref), así que un mensaje enviado dos veces se acepta una sola vez. - Detecta el silencio: el servidor envía un latido cada 20 segundos, y si no oye nada en 45, la página abre una conexión nueva en lugar de esperar a una muerta.
// socket.js: un websocket a tu propio servidor que vuelve por sí solo
export function connect(url, { onEvent, onGap, quiet = 45000 }) {
let ws, retry, silence;
let lastId = 0; // el evento más reciente que tiene esta página
let attempt = 0; // intentos fallidos desde la última conexión buena
const unconfirmed = new Map(); // ref → data, hasta que el servidor lo confirme
function open() {
clearTimeout(retry);
const mine = (ws = new WebSocket(`${url}?after=${lastId}`));
mine.onopen = () => {
if (mine !== ws) return mine.close(); // sustituido mientras conectaba
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 latido, o un evento ya mostrado
lastId = msg.id;
onEvent(msg);
};
mine.onclose = () => {
if (mine !== ws) return;
// Hasta 0,5 s, 1 s, 2 s… como mucho 30 s, cada vez una parte aleatoria, para que una multitud no vuelva a la vez.
const delay = Math.random() * Math.min(30000, 500 * 2 ** attempt++);
retry = setTimeout(open, delay);
};
}
// Demasiado tiempo sin oír nada: la conexión está muerta, aunque el navegador no se haya dado cuenta.
function heard(mine) {
clearTimeout(silence);
silence = setTimeout(() => {
if (mine === ws) { open(); mine.close(); }
}, quiet);
}
// De vuelta en la red: intentarlo ya en lugar de cuando diga el temporizador.
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 página lo usa así:
import { connect } from './socket.js';
const live = connect('wss://example.com/live', {
onEvent: ({ id, data }) => showMessage(data),
onGap: () => reloadFromApi(), // fuera demasiado tiempo: el servidor ya no lo tiene todo
});
live.send({ text: 'Hi' });Cada socket comprueba mine !== ws antes de actuar, y eso importa más de lo que parece. El temporizador de silencio y el evento online abren los dos un socket nuevo mientras el viejo puede estar cerrándose todavía, y sin la comprobación un socket viejo que se cierra tarde programaría una segunda reconexión, o uno que se abre tarde enviaría encima del nuevo.
La parte aleatoria de la espera está ahí por tu servidor, no por la página. Cuando un servidor se reinicia, todas las páginas que tenía ven el corte en el mismo segundo. Con una espera fija vuelven todas en el mismo segundo también, una y otra vez. Una parte aleatoria de una espera que crece las reparte.
El servidor con el que habla
El servidor da a cada evento un id, guarda los últimos 500 y envía a una página que vuelve todo lo que hay después del id que nombra. En Node.js con el paquete ws:
// server.mjs: cada evento recibe un id, se guardan los últimos 500, y una página que vuelve recibe lo que se perdió
import { WebSocketServer } from 'ws';
const KEEP = 500;
const log = []; // los últimos KEEP eventos, del más antiguo al más nuevo
const seen = new Set(); // refs ya aceptados: guárdalos un día en Redis, no para siempre en 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;
// Fuera más tiempo del que alcanza el registro: decirlo, y la página recarga desde tu 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; // reenviado tras un corte, y ya aceptado
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 latido cada 20 segundos, para que una página distinga una conexión tranquila de una muerta.
setInterval(() => {
for (const client of wss.clients) client.send('{"beat":1}');
}, 20000);El registro y el conjunto de refs viven aquí en memoria, así que un reinicio los olvida. En producción van en Redis o en tu base de datos, y con más de un servidor, todos tienen que leer el mismo registro, algo que repasa websockets en Node.js con más de un servidor.
Lo que mostró la prueba
Ejecutamos este cliente en dos páginas de Chromium 156, Ann y Ben, contra este servidor, y rompimos cosas a propósito:
| Qué rompimos | Qué vieron las páginas |
|---|---|
| Cortamos a Ann después de que el servidor aceptara su mensaje pero antes de confirmarlo | Ann lo volvió a enviar, el servidor lo aceptó una vez |
| Paramos el servidor, Ann envió dos mensajes y luego lo arrancamos otra vez | Llegaron los dos, una vez cada uno |
| El servidor se quedó en silencio sin cerrar | Las dos páginas abrieron una conexión nueva al acabarse el silencio (3 segundos en la prueba, 45 en el código) |
| Una tercera página, sin conexión mientras llegaban más de los que guardaba el registro | Recibió lo que el registro aún tenía, y luego onGap |
Un resultado merece una segunda mirada. Ann envió sus dos mensajes mientras el servidor estaba parado, y Ben envió el suyo justo después de que volviera. El de Ben llegó primero: cuando Ann se reconectó, el suyo ya tenía un id más bajo. No se perdió nada y todas las páginas vieron el mismo orden, pero era el orden del servidor, no el orden en que los dos pulsaron enviar. Ese es el orden que una app de tiempo real puede prometer a través de las reconexiones: un solo orden, decidido en un solo sitio, el mismo para todos. Un chat que tenga que mostrar los mensajes según cuándo se escribieron los ordena por una hora que añade cada página, no por cuándo llegaron.
Lo que este cliente sigue sin poder salvar: un mensaje escrito en una pestaña que se cierra antes de reconectar. El mapa unconfirmed vive en la página. Para conservarlos, guárdalos en IndexedDB y envíalos en la siguiente visita.
Cuando la conexión la mantiene una nube de tiempo real
Todo lo anterior es trabajo que es de tu app: las reconexiones, los ids, el registro, los refs, el latido, y un registro compartido entre servidores en cuanto hay más de uno. WordPlus Cloud mantiene las conexiones en su lugar, y su paquete @wordplus/realtime hace esas partes en la página. Tu servidor declara una sala una vez, con una regla sobre quién puede entrar y cuántos eventos guarda para las páginas que vuelven:
// server.mjs, junto a tus rutas: el tablero de un equipo, board:7
realtime.room('board:{id}', async (user, { id }) => {
return user !== null && (await db.boards.isMember(id, user));
}, {
emit: ['card', 'cursor'], // lo que pueden enviar las páginas
history: 100, // los últimos 100, guardados para las páginas que se reconectan
});import { connect } from '@wordplus/realtime';
const rt = await connect({ app: 's1500000007' });
const board = rt.join('board:7');
// Primero los eventos perdidos, en orden, marcados como replayed, luego los nuevos.
board.on('card', (card, meta) => drawCard(card, meta.replayed));
board.on('error', (e) => e.code === 'gap' && reloadBoard());
// Espera hasta que WordPlus Cloud haya comprobado el evento, lo haya guardado y lo haya reenviado.
const { id } = await board.emitWithAck('card', { title: 'Ship it' });
// Un cursor tarde no vale nada: se descarta sin conexión y nunca se guarda.
board.volatile.emit('cursor', { x: 120, y: 80 });- Las reconexiones ocurren por sí solas, también hacia otro de nuestros servidores, y
rt.on('disconnected')yrt.on('connected')le dicen a la página cuándo. - Ponerse al día: una página que vuelve en menos de 5 minutos recibe primero los eventos que se perdió, en orden, con
meta.replayed, del historial de la sala (hasta 1.000 eventos por sala, cada uno de hasta 64 KB). Si estuvo fuera más tiempo, recibegapy pregunta a tu propia API, como hace el servidor de arriba. - Envíos confirmados:
emitWithAckse resuelve con el id y la hora que recibió el evento, o se rechaza con el motivo, comonot_allowed. - Todas las pestañas: las pestañas de un navegador comparten una sola conexión.
Cómo guardan las salas su historial y qué hace cada opción: salas y eventos en la documentación. Antes de escribir tu propio cliente, puedes probar tu propio servidor en el test de WebSocket, un cliente websocket en el navegador que registra cada mensaje enviado y recibido y explica qué significa un código de cierre. En un hosting serverless, donde una función no puede mantener ninguna conexión, websockets en Next.js muestra el mismo modelo.
Websockets para tu app
WordPlus Cloud for Apps tiene un precio según las conexiones simultáneas, a partir de 1.000, con facturación mensual o anual, sin nada que ejecutar en tus servidores. Consulta los websockets para apps, o los precios para apps. ¿Preguntas sobre tu integración? Escríbenos.