Timeouts and Heartbeats

{ "method": "ping" }

{ "method": "pong" }

class GxWebSocket {
  private ws: WebSocket;
  private pingInterval: NodeJS.Timeout | null = null;
  private reconnectDelay = 1000;
  private maxReconnectDelay = 30000;
  private url: string;
 
  constructor(url: string) {
    this.url = url;
    this.ws = this.connect();
  }
 
  private connect(): WebSocket {
    const ws = new WebSocket(this.url);
 
    ws.onopen = () => {
      console.log("Connected");
      this.reconnectDelay = 1000; // Reset backoff
      this.startHeartbeat();
    };
 
    ws.onclose = (event) => {
      console.log(`Disconnected: code=${event.code} reason=${event.reason}`);
      this.stopHeartbeat();
      this.scheduleReconnect();
    };
 
    ws.onerror = (error) => {
      console.error("WebSocket error:", error);
    };
 
    ws.onmessage = (event) => {
      const msg = JSON.parse(event.data);
      if (msg.method === "pong") return; // Heartbeat response
      this.handleMessage(msg);
    };
 
    return ws;
  }
 
  private startHeartbeat() {
    this.pingInterval = setInterval(() => {
      if (this.ws.readyState === WebSocket.OPEN) {
        this.ws.send(JSON.stringify({ method: "ping" }));
      }
    }, 50000); // 50 seconds
  }
 
  private stopHeartbeat() {
    if (this.pingInterval) {
      clearInterval(this.pingInterval);
      this.pingInterval = null;
    }
  }
 
  private scheduleReconnect() {
    console.log(`Reconnecting in ${this.reconnectDelay}ms...`);
    setTimeout(() => {
      this.ws = this.connect();
      // Re-subscribe to channels after reconnect
      this.resubscribe();
    }, this.reconnectDelay);
 
    // Exponential backoff with cap
    this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
  }
 
  private resubscribe() {
    // Re-subscribe to all previously active channels
  }
 
  private handleMessage(msg: any) {
    // Process incoming data
  }
}

import asyncio
import json
import websockets
 
class GxWebSocket:
    def __init__(self, url: str):
        self.url = url
        self.subscriptions: list[dict] = []
        self.reconnect_delay = 1.0
        self.max_reconnect_delay = 30.0
 
    async def connect(self):
        while True:
            try:
                async with websockets.connect(self.url) as ws:
                    self.reconnect_delay = 1.0  # Reset backoff
                    await self._resubscribe(ws)
 
                    # Run heartbeat and message handler concurrently
                    await asyncio.gather(
                        self._heartbeat(ws),
                        self._receive(ws),
                    )
            except (websockets.ConnectionClosed, ConnectionError) as e:
                print(f"Disconnected: {e}. Reconnecting in {self.reconnect_delay}s...")
                await asyncio.sleep(self.reconnect_delay)
                self.reconnect_delay = min(
                    self.reconnect_delay * 2,
                    self.max_reconnect_delay,
                )
 
    async def _heartbeat(self, ws):
        while True:
            await ws.send(json.dumps({"method": "ping"}))
            await asyncio.sleep(50)  # 50 seconds
 
    async def _receive(self, ws):
        async for message in ws:
            msg = json.loads(message)
            if msg.get("method") == "pong":
                continue
            self.handle_message(msg)
 
    async def _resubscribe(self, ws):
        for sub in self.subscriptions:
            await ws.send(json.dumps({
                "method": "subscribe",
                "subscription": sub,
            }))
 
    def handle_message(self, msg: dict):
        print(f"[{msg.get('channel')}] {msg.get('data')}")