WebSockets at Scale: Architecture, Reconnection, and the Mistakes I Keep Seeing

type ConnectionState =
  | "connecting" // Handshake in progress
  | "connected" // Open and healthy
  | "stale" // Open but no recent heartbeat
  | "reconnecting" // Actively trying to reconnect
  | "disconnected" // Clean close or max retries exceeded
  | "suspended"; // Tab backgrounded, connection paused

interface ConnectionConfig {
  url: string;
  protocols?: string[];
  heartbeatInterval: number; // How often to ping (ms)
  heartbeatTimeout: number; // How long to wait for pong (ms)
  reconnectBaseDelay: number; // Starting reconnect delay (ms)
  reconnectMaxDelay: number; // Cap on reconnect delay (ms)
  maxReconnectAttempts: number; // Give up after this many tries
}
 
class WebSocketManager {
  private ws: WebSocket | null = null;
  private state: ConnectionState = "disconnected";
  private reconnectAttempts = 0;
  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
  private heartbeatTimeoutTimer: ReturnType<typeof setTimeout> | null = null;
  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
  private messageQueue: string[] = [];
  private listeners = new Map<string, Set<Function>>();
 
  constructor(private config: ConnectionConfig) {
    // Handle tab visibility changes
    if (typeof document !== "undefined") {
      document.addEventListener("visibilitychange", () => {
        if (document.hidden) {
          this.suspend();
        } else {
          this.resume();
        }
      });
    }
  }
 
  connect(): void {
    if (this.state === "connecting" || this.state === "connected") return;
 
    this.setState("connecting");
 
    try {
      this.ws = new WebSocket(this.config.url, this.config.protocols);
    } catch (err) {
      this.handleConnectionFailure();
      return;
    }
 
    this.ws.onopen = () => {
      this.setState("connected");
      this.reconnectAttempts = 0;
      this.startHeartbeat();
      this.flushMessageQueue();
      this.emit("connected");
    };
 
    this.ws.onmessage = (event) => {
      // Any message resets the heartbeat timeout
      this.resetHeartbeatTimeout();
 
      if (event.data === "pong") return; // Heartbeat response
 
      try {
        const message = JSON.parse(event.data);
        this.emit("message", message);
        if (message.type) {
          this.emit(message.type, message.payload);
        }
      } catch {
        this.emit("message", event.data);
      }
    };
 
    this.ws.onclose = (event) => {
      this.cleanup();
 
      if (event.code === 1000 || event.code === 1001) {
        // Normal closure — don't reconnect
        this.setState("disconnected");
        this.emit("disconnected", { clean: true, code: event.code });
      } else {
        // Abnormal closure — attempt reconnect
        this.scheduleReconnect();
      }
    };
 
    this.ws.onerror = () => {
      // onerror always fires before onclose, so we don't
      // need to handle reconnection here. Just log it.
      this.emit("error", { state: this.state });
    };
  }
 
  // ...methods continued below
}

private startHeartbeat(): void {
  this.stopHeartbeat();
 
  this.heartbeatTimer = setInterval(() => {
    if (this.ws?.readyState === WebSocket.OPEN) {
      this.ws.send('ping');
      this.startHeartbeatTimeout();
    }
  }, this.config.heartbeatInterval);
}
 
private startHeartbeatTimeout(): void {
  this.clearHeartbeatTimeout();
 
  this.heartbeatTimeoutTimer = setTimeout(() => {
    // No pong received — connection is dead
    console.warn('[WS] Heartbeat timeout, closing connection');
    this.ws?.close(4000, 'Heartbeat timeout');
  }, this.config.heartbeatTimeout);
}
 
private resetHeartbeatTimeout(): void {
  // Any message from the server counts as proof of life
  this.clearHeartbeatTimeout();
}
 
private clearHeartbeatTimeout(): void {
  if (this.heartbeatTimeoutTimer) {
    clearTimeout(this.heartbeatTimeoutTimer);
    this.heartbeatTimeoutTimer = null;
  }
}
 
private stopHeartbeat(): void {
  if (this.heartbeatTimer) {
    clearInterval(this.heartbeatTimer);
    this.heartbeatTimer = null;
  }
  this.clearHeartbeatTimeout();
}

import { WebSocketServer, WebSocket } from "ws";
 
const wss = new WebSocketServer({ port: 8080 });
 
const HEARTBEAT_INTERVAL = 30_000;
const CLIENT_TIMEOUT = 35_000;
 
wss.on("connection", (ws: WebSocket) => {
  let isAlive = true;
  let lastPong = Date.now();
 
  ws.on("message", (data) => {
    const message = data.toString();
 
    if (message === "ping") {
      ws.send("pong");
      isAlive = true;
      lastPong = Date.now();
      return;
    }
 
    // Handle other messages...
  });
 
  const interval = setInterval(() => {
    if (Date.now() - lastPong > CLIENT_TIMEOUT) {
      console.log("[WS] Client timed out, terminating");
      clearInterval(interval);
      ws.terminate(); // Hard close — don't wait for handshake
      return;
    }
 
    // Also send server-side ping as backup
    if (ws.readyState === WebSocket.OPEN) {
      ws.ping();
    }
  }, HEARTBEAT_INTERVAL);
 
  ws.on("close", () => {
    clearInterval(interval);
  });
});

private scheduleReconnect(): void {
  if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
    this.setState('disconnected');
    this.emit('disconnected', {
      clean: false,
      reason: 'max_retries_exceeded',
      attempts: this.reconnectAttempts,
    });
    return;
  }
 
  this.setState('reconnecting');
 
  // Exponential backoff: 1s, 2s, 4s, 8s, 16s, 30s (capped)
  const exponentialDelay = this.config.reconnectBaseDelay *
    Math.pow(2, this.reconnectAttempts);
 
  const cappedDelay = Math.min(
    exponentialDelay,
    this.config.reconnectMaxDelay
  );
 
  // Add jitter: +/- 25% randomization
  const jitter = cappedDelay * 0.25 * (Math.random() * 2 - 1);
  const delay = Math.max(0, cappedDelay + jitter);
 
  this.emit('reconnecting', {
    attempt: this.reconnectAttempts + 1,
    maxAttempts: this.config.maxReconnectAttempts,
    delay,
  });
 
  this.reconnectTimer = setTimeout(() => {
    this.reconnectAttempts++;
    this.connect();
  }, delay);
}

// In your React component
function ConnectionStatus() {
  const { state, reconnectInfo } = useWebSocket();
 
  if (state === 'connected') return null;
 
  if (state === 'reconnecting') {
    return (
      <div className="bg-yellow-900/50 text-yellow-200 px-4 py-2 text-sm">
        Reconnecting... (attempt {reconnectInfo.attempt}/
        {reconnectInfo.maxAttempts})
      </div>
    );
  }
 
  if (state === 'disconnected') {
    return (
      <div className="bg-red-900/50 text-red-200 px-4 py-2 text-sm">
        Connection lost.{' '}
        <button onClick={manualReconnect} className="underline">
          Try again
        </button>
      </div>
    );
  }
 
  return null;
}

send(data: unknown): void {
  const message = typeof data === 'string' ? data : JSON.stringify(data);
 
  if (this.ws?.readyState === WebSocket.OPEN) {
    this.ws.send(message);
  } else {
    // Queue for later delivery
    this.messageQueue.push(message);
 
    // Prevent unbounded queue growth
    if (this.messageQueue.length > 1000) {
      this.messageQueue.shift(); // Drop oldest
      console.warn('[WS] Message queue overflow, dropping oldest message');
    }
  }
}
 
private flushMessageQueue(): void {
  while (
    this.messageQueue.length > 0 &&
    this.ws?.readyState === WebSocket.OPEN
  ) {
    const message = this.messageQueue.shift()!;
    this.ws.send(message);
  }
}

import Redis from "ioredis";
 
const pubClient = new Redis({ host: "redis.internal", port: 6379 });
const subClient = new Redis({ host: "redis.internal", port: 6379 });
 
// Track which rooms each connection is in
const connectionRooms = new Map<WebSocket, Set<string>>();
const roomConnections = new Map<string, Set<WebSocket>>();
 
// Subscribe to room channels
async function joinRoom(ws: WebSocket, room: string): Promise<void> {
  // Track locally
  if (!connectionRooms.has(ws)) {
    connectionRooms.set(ws, new Set());
  }
  connectionRooms.get(ws)!.add(room);
 
  if (!roomConnections.has(room)) {
    roomConnections.set(room, new Set());
    // First local member — subscribe to Redis channel
    await subClient.subscribe(`room:${room}`);
  }
  roomConnections.get(room)!.add(ws);
}
 
async function leaveRoom(ws: WebSocket, room: string): Promise<void> {
  connectionRooms.get(ws)?.delete(room);
  roomConnections.get(room)?.delete(ws);
 
  if (roomConnections.get(room)?.size === 0) {
    roomConnections.delete(room);
    // No more local members — unsubscribe from Redis
    await subClient.unsubscribe(`room:${room}`);
  }
}
 
// Broadcast to a room (publishes to Redis so all servers receive it)
function broadcastToRoom(room: string, message: object): void {
  pubClient.publish(`room:${room}`, JSON.stringify(message));
}
 
// Handle messages from Redis
subClient.on("message", (channel, rawMessage) => {
  const room = channel.replace("room:", "");
  const connections = roomConnections.get(room);
 
  if (!connections) return;
 
  for (const ws of connections) {
    if (ws.readyState === WebSocket.OPEN) {
      ws.send(rawMessage);
    }
  }
});

// Publish already-serialized JSON — don't parse on the receiving end
function broadcastToRoom(room: string, payload: string): void {
  pubClient.publish(`room:${room}`, payload);
}
 
subClient.on("message", (channel, rawMessage) => {
  const room = channel.replace("room:", "");
  const connections = roomConnections.get(room);
  if (!connections) return;
 
  // Forward the raw string directly — no parsing
  for (const ws of connections) {
    if (ws.readyState === WebSocket.OPEN) {
      ws.send(rawMessage);
    }
  }
});

upstream websocket_backend {
  ip_hash;  # Simple but breaks behind CDN/proxy
 
  # Better: use a cookie
  # sticky cookie srv_id expires=1h domain=.example.com path=/;
 
  server 10.0.0.1:8080;
  server 10.0.0.2:8080;
  server 10.0.0.3:8080;
}
 
server {
  listen 443 ssl;
  server_name ws.example.com;
 
  location /ws {
    proxy_pass http://websocket_backend;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
 
    # Critical: increase timeouts for long-lived connections
    proxy_read_timeout 86400s;
    proxy_send_timeout 86400s;
 
    # Don't buffer WebSocket frames
    proxy_buffering off;
  }
}

interface Room {
  id: string;
  type: "public" | "private" | "direct";
  members: Map<string, MemberInfo>;
  metadata: Record<string, unknown>;
  createdAt: number;
  lastActivity: number;
}
 
interface MemberInfo {
  userId: string;
  connectionId: string;
  ws: WebSocket;
  joinedAt: number;
  role: "owner" | "admin" | "member" | "spectator";
}
 
class RoomManager {
  private rooms = new Map<string, Room>();
  private userConnections = new Map<string, Set<string>>(); // userId -> roomIds
 
  createRoom(id: string, type: Room["type"], ownerId: string): Room {
    if (this.rooms.has(id)) {
      throw new Error(`Room ${id} already exists`);
    }
 
    const room: Room = {
      id,
      type,
      members: new Map(),
      metadata: {},
      createdAt: Date.now(),
      lastActivity: Date.now(),
    };
 
    this.rooms.set(id, room);
    return room;
  }
 
  join(roomId: string, member: MemberInfo): void {
    const room = this.rooms.get(roomId);
    if (!room) throw new Error(`Room ${roomId} not found`);
 
    room.members.set(member.userId, member);
    room.lastActivity = Date.now();
 
    if (!this.userConnections.has(member.userId)) {
      this.userConnections.set(member.userId, new Set());
    }
    this.userConnections.get(member.userId)!.add(roomId);
 
    // Notify other members
    this.broadcastToRoom(
      roomId,
      {
        type: "member_joined",
        payload: {
          userId: member.userId,
          role: member.role,
          memberCount: room.members.size,
        },
      },
      member.userId,
    ); // Exclude the joining user
  }
 
  leave(roomId: string, userId: string): void {
    const room = this.rooms.get(roomId);
    if (!room) return;
 
    room.members.delete(userId);
    this.userConnections.get(userId)?.delete(roomId);
 
    if (room.members.size === 0) {
      // Auto-cleanup empty rooms
      this.rooms.delete(roomId);
    } else {
      this.broadcastToRoom(roomId, {
        type: "member_left",
        payload: { userId, memberCount: room.members.size },
      });
    }
  }
 
  broadcastToRoom(roomId: string, message: object, excludeUserId?: string): void {
    const room = this.rooms.get(roomId);
    if (!room) return;
 
    const data = JSON.stringify(message);
 
    for (const [userId, member] of room.members) {
      if (userId === excludeUserId) continue;
      if (member.ws.readyState === WebSocket.OPEN) {
        member.ws.send(data);
      }
    }
  }
 
  // Clean up all rooms for a disconnected user
  handleDisconnect(userId: string): void {
    const rooms = this.userConnections.get(userId);
    if (!rooms) return;
 
    for (const roomId of rooms) {
      this.leave(roomId, userId);
    }
 
    this.userConnections.delete(userId);
  }
}

// Shared between client and server
enum MessageType {
  POSITION_UPDATE = 1,
  PLAYER_ACTION = 2,
  GAME_STATE = 3,
  CHAT = 4,
}
 
// Encode a position update into a compact binary format
function encodePositionUpdate(playerId: number, x: number, y: number, angle: number, health: number): ArrayBuffer {
  const buffer = new ArrayBuffer(16);
  const view = new DataView(buffer);
 
  view.setUint8(0, MessageType.POSITION_UPDATE); // 1 byte: type
  view.setUint8(1, playerId); // 1 byte: player ID
  view.setFloat32(2, x, true); // 4 bytes: x position
  view.setFloat32(6, y, true); // 4 bytes: y position
  view.setFloat32(10, angle, true); // 4 bytes: angle
  view.setUint16(14, health, true); // 2 bytes: health
 
  return buffer;
}
 
function decodeMessage(data: ArrayBuffer): object {
  const view = new DataView(data);
  const type = view.getUint8(0);
 
  switch (type) {
    case MessageType.POSITION_UPDATE:
      return {
        type: "position_update",
        playerId: view.getUint8(1),
        x: view.getFloat32(2, true),
        y: view.getFloat32(6, true),
        angle: view.getFloat32(10, true),
        health: view.getUint16(14, true),
      };
    // ... other message types
    default:
      throw new Error(`Unknown message type: ${type}`);
  }
}
 
// Client-side usage
ws.binaryType = "arraybuffer"; // Important! Default is 'blob'
 
ws.onmessage = (event) => {
  if (event.data instanceof ArrayBuffer) {
    const message = decodeMessage(event.data);
    handleGameMessage(message);
  } else {
    // Text frame — JSON
    const message = JSON.parse(event.data);
    handleControlMessage(message);
  }
};

ws.onerror = (err) => {
  console.log("WebSocket error:", err);
};

wss.on("connection", (ws, req) => {
  const clientIp = req.headers["x-forwarded-for"] || req.socket.remoteAddress;
  const connectionId = crypto.randomUUID();
 
  ws.on("error", (err) => {
    // Don't log ECONNRESET as errors — it's just a disconnect
    if ((err as NodeJS.ErrnoException).code === "ECONNRESET") {
      console.debug(`[WS] Client ${connectionId} disconnected abruptly`);
      return;
    }
 
    // EPIPE means we tried to write to a dead socket
    if ((err as NodeJS.ErrnoException).code === "EPIPE") {
      console.debug(`[WS] Broken pipe for ${connectionId}`);
      return;
    }
 
    // Anything else is unexpected
    console.error(`[WS] Unexpected error for ${connectionId}:`, {
      code: (err as NodeJS.ErrnoException).code,
      message: err.message,
      clientIp,
    });
  });
 
  ws.on("message", (rawData) => {
    try {
      // Guard against oversized messages
      if (rawData.length > 1_048_576) {
        // 1 MB
        ws.close(1009, "Message too large");
        return;
      }
 
      const message = JSON.parse(rawData.toString());
 
      // Validate message structure
      if (!message.type || typeof message.type !== "string") {
        ws.send(
          JSON.stringify({
            type: "error",
            payload: { code: "INVALID_MESSAGE", message: "Missing type field" },
          }),
        );
        return;
      }
 
      handleMessage(ws, connectionId, message);
    } catch (err) {
      if (err instanceof SyntaxError) {
        ws.send(
          JSON.stringify({
            type: "error",
            payload: { code: "INVALID_JSON", message: "Failed to parse message" },
          }),
        );
        return;
      }
      throw err;
    }
  });
});

const wss = new WebSocketServer({
  port: 8080,
  verifyClient: (info, callback) => {
    const origin = info.origin || info.req.headers.origin;
    const allowedOrigins = ["https://example.com", "https://www.example.com"];
 
    if (process.env.NODE_ENV === "development") {
      allowedOrigins.push("http://localhost:3000");
    }
 
    if (!origin || !allowedOrigins.includes(origin)) {
      callback(false, 403, "Forbidden");
      return;
    }
 
    callback(true);
  },
});

const AUTHENTICATION_TIMEOUT = 5_000; // 5 seconds to authenticate
 
wss.on("connection", (ws, req) => {
  let authenticated = false;
  let userId: string | null = null;
 
  // Start the auth countdown
  const authTimer = setTimeout(() => {
    if (!authenticated) {
      ws.close(4001, "Authentication timeout");
    }
  }, AUTHENTICATION_TIMEOUT);
 
  ws.on("message", async (rawData) => {
    const message = JSON.parse(rawData.toString());
 
    if (!authenticated) {
      if (message.type !== "authenticate") {
        ws.close(4002, "Must authenticate first");
        return;
      }
 
      try {
        const user = await verifyToken(message.payload.token);
        authenticated = true;
        userId = user.id;
        clearTimeout(authTimer);
 
        ws.send(
          JSON.stringify({
            type: "authenticated",
            payload: { userId: user.id },
          }),
        );
      } catch {
        ws.close(4003, "Invalid token");
      }
      return;
    }
 
    // Normal message handling (only reached after authentication)
    handleAuthenticatedMessage(ws, userId!, message);
  });
});

class MessageRateLimiter {
  private buckets = new Map<string, { tokens: number; lastRefill: number }>();
 
  constructor(
    private maxTokens: number = 50,
    private refillRate: number = 10, // tokens per second
  ) {}
 
  consume(userId: string): boolean {
    const now = Date.now();
    let bucket = this.buckets.get(userId);
 
    if (!bucket) {
      bucket = { tokens: this.maxTokens, lastRefill: now };
      this.buckets.set(userId, bucket);
    }
 
    // Refill tokens based on elapsed time
    const elapsed = (now - bucket.lastRefill) / 1000;
    bucket.tokens = Math.min(this.maxTokens, bucket.tokens + elapsed * this.refillRate);
    bucket.lastRefill = now;
 
    if (bucket.tokens < 1) {
      return false; // Rate limited
    }
 
    bucket.tokens--;
    return true;
  }
}
 
const rateLimiter = new MessageRateLimiter(50, 10);
 
// In your message handler:
if (!rateLimiter.consume(userId)) {
  ws.send(
    JSON.stringify({
      type: "error",
      payload: {
        code: "RATE_LIMITED",
        message: "Too many messages. Slow down.",
      },
    }),
  );
  return;
}

// Server (Express/Node.js)
app.get("/events", (req, res) => {
  res.writeHead(200, {
    "Content-Type": "text/event-stream",
    "Cache-Control": "no-cache",
    Connection: "keep-alive",
    "X-Accel-Buffering": "no", // Disable Nginx buffering
  });
 
  const sendEvent = (event: string, data: object) => {
    res.write(`event: ${event}\n`);
    res.write(`data: ${JSON.stringify(data)}\n\n`);
  };
 
  // Send initial state
  sendEvent("connected", { timestamp: Date.now() });
 
  // Heartbeat to keep connection alive
  const heartbeat = setInterval(() => {
    res.write(": heartbeat\n\n"); // SSE comment, keeps connection open
  }, 25_000);
 
  // Subscribe to events (your application logic here)
  const unsubscribe = eventBus.subscribe((event) => {
    sendEvent(event.type, event.data);
  });
 
  req.on("close", () => {
    clearInterval(heartbeat);
    unsubscribe();
  });
});
 
// Client
const eventSource = new EventSource("/events");
 
eventSource.addEventListener("notification", (event) => {
  const data = JSON.parse(event.data);
  showNotification(data);
});
 
// Automatic reconnection is built in!
// EventSource will reconnect with Last-Event-ID header

# Increase file descriptor limit (Linux)
# /etc/security/limits.conf
* soft nofile 1000000
* hard nofile 1000000
 
# Or for the current process
ulimit -n 1000000
 
# Increase ephemeral port range
echo "10000 65535" > /proc/sys/net/ipv4/ip_local_port_range
 
# Increase socket backlog
echo 65535 > /proc/sys/net/core/somaxconn

wss.on("connection", (ws) => {
  const userId = authenticate(ws);
 
  // Register
  connections.set(userId, ws);
  roomManager.addConnection(userId, ws);
 
  ws.on("close", () => {
    // Always clean up ALL references
    connections.delete(userId);
    roomManager.handleDisconnect(userId);
    rateLimiter.cleanup(userId);
    // Any other Maps, Sets, or arrays holding this ws or userId
  });
});

import { WebSocketServer } from "ws";
import { describe, it, expect, beforeAll, afterAll } from "vitest";
 
function createTestServer(port: number): WebSocketServer {
  return new WebSocketServer({ port });
}
 
function connectClient(port: number): Promise<WebSocket> {
  return new Promise((resolve, reject) => {
    const ws = new WebSocket(`ws://localhost:${port}`);
    ws.onopen = () => resolve(ws);
    ws.onerror = reject;
  });
}
 
function waitForMessage(ws: WebSocket): Promise<any> {
  return new Promise((resolve) => {
    ws.onmessage = (event) => {
      resolve(JSON.parse(event.data.toString()));
    };
  });
}
 
describe("WebSocket Room Broadcasting", () => {
  let server: WebSocketServer;
  const PORT = 9876;
 
  beforeAll(() => {
    server = createTestServer(PORT);
    setupRoomHandlers(server);
  });
 
  afterAll(() => {
    server.close();
  });
 
  it("should broadcast to all room members except sender", async () => {
    const client1 = await connectClient(PORT);
    const client2 = await connectClient(PORT);
    const client3 = await connectClient(PORT);
 
    // All join the same room
    client1.send(JSON.stringify({ type: "join", room: "test-room" }));
    client2.send(JSON.stringify({ type: "join", room: "test-room" }));
    client3.send(JSON.stringify({ type: "join", room: "test-room" }));
 
    // Wait for join confirmations
    await waitForMessage(client1); // join ack
    await waitForMessage(client2);
    await waitForMessage(client3);
 
    // Client 1 sends a message
    const messagePromise2 = waitForMessage(client2);
    const messagePromise3 = waitForMessage(client3);
 
    client1.send(
      JSON.stringify({
        type: "chat",
        room: "test-room",
        text: "Hello everyone",
      }),
    );
 
    const msg2 = await messagePromise2;
    const msg3 = await messagePromise3;
 
    expect(msg2.type).toBe("chat");
    expect(msg2.text).toBe("Hello everyone");
    expect(msg3.type).toBe("chat");
    expect(msg3.text).toBe("Hello everyone");
 
    // Cleanup
    client1.close();
    client2.close();
    client3.close();
  });
});

it("should reconnect after server restart", async () => {
  let server = createTestServer(PORT);
  const manager = new WebSocketManager({
    url: `ws://localhost:${PORT}`,
    reconnectBaseDelay: 100,
    reconnectMaxDelay: 1000,
    maxReconnectAttempts: 5,
    heartbeatInterval: 5000,
    heartbeatTimeout: 3000,
  });
 
  // Connect
  const connected = new Promise((r) => manager.on("connected", r));
  manager.connect();
  await connected;
 
  // Kill the server
  server.close();
 
  // Wait for reconnection attempts
  const reconnecting = new Promise((r) => manager.on("reconnecting", r));
  await reconnecting;
 
  // Restart the server
  server = createTestServer(PORT);
 
  // Wait for reconnection success
  const reconnected = new Promise((r) => manager.on("connected", r));
  await reconnected;
 
  expect(manager.getState()).toBe("connected");
 
  server.close();
  manager.disconnect();
});

interface WebSocketMetrics {
  // Connection metrics
  activeConnections: number;
  totalConnectionsToday: number;
  connectionRate: number; // New connections per minute
  disconnectionRate: number;
 
  // Message metrics
  messagesInPerSecond: number;
  messagesOutPerSecond: number;
  averageMessageSize: number;
  largestMessageSize: number;
 
  // Health metrics
  heartbeatTimeoutRate: number; // % of connections timing out
  reconnectionRate: number; // Reconnections per minute
  averageConnectionDuration: number;
 
  // Error metrics
  authenticationFailures: number;
  rateLimitHits: number;
  invalidMessages: number;
 
  // Room metrics
  activeRooms: number;
  averageRoomSize: number;
  largestRoom: number;
}