Hey there, sorry to hear you're stuck with this frustrating WebSocket freeze issue—let's break this down into practical, actionable steps to diagnose and fix it, especially since you're still getting comfortable with Node.js and WebSockets.

1. Implement a Ping-Pong Heartbeat Mechanism #

The most likely culprit here is a silent disconnect: the server stops sending messages but doesn’t trigger a close event. This is super common with WebSocket connections, and the fix is to add your own health check to detect and recover from it.

GDAX (now Coinbase Pro) supports native ping/pong frames, so you can set up regular pings to the server and listen for pong responses. If you don’t get a pong within a reasonable window, manually terminate the connection to trigger your existing reconnection logic.

Here’s a code snippet to add this:

const WebSocket = require('ws'); // Use the WebSocket instance from your GDAX library if available

let heartbeatInterval;
let heartbeatTimeout;

// After WebSocket connection opens
ws.on('open', () => {
  console.log('WebSocket connection established');
  
  // Send a ping every 30 seconds to check connection health
  heartbeatInterval = setInterval(() => {
    if (ws.readyState === WebSocket.OPEN) {
      ws.ping(); // Send native WebSocket ping frame
      console.log('Sent ping to GDAX server');
    }
  }, 30000);

  // Reset timeout when we receive a pong response
  ws.on('pong', () => {
    console.log('Received pong - connection is healthy');
    clearTimeout(heartbeatTimeout);
    // Set a new timeout to catch missing pongs
    heartbeatTimeout = setTimeout(() => {
      console.log('No pong received in 10s - terminating frozen connection');
      ws.terminate(); // Force close to trigger reconnection
    }, 10000);
  });
});

// Clean up intervals when connection closes
ws.on('close', () => {
  clearInterval(heartbeatInterval);
  clearTimeout(heartbeatTimeout);
  console.log('WebSocket closed, initiating reconnection...');
  // Trigger your existing reconnection logic here
});

2. Expand Event Listening Beyond close #

WebSocket connections can fail silently without firing a close event. Make sure you’re listening for other critical events that might hint at underlying issues:

// Catch errors that might not trigger a close event
ws.on('error', (error) => {
  console.error('WebSocket error detected:', error);
  ws.terminate(); // Force close to trigger reconnection
});

// Catch unexpected HTTP responses during handshake
ws.on('unexpected-response', (req, res) => {
  console.error(`Unexpected server response: ${res.statusCode} - ${res.statusMessage}`);
  ws.terminate();
});

// Log every message with a timestamp to spot when the stream stops
ws.on('message', (data) => {
  console.log(`[${new Date().toISOString()}] Received message:`, data);
  // Your existing message processing logic here
});

3. Check Your GDAX Library Version & Subscription Config #

Outdated versions of the GDAX library might have known WebSocket bugs. First, check your current version:

npm list gdax

If it’s not the latest, upgrade it with:

npm install gdax@latest

Also, double-check your subscription parameters—if you’re only subscribing to low-activity product or event types, the server might stop sending messages temporarily. Ensure your subscription includes the heartbeat channel to get regular server messages:

ws.send(JSON.stringify({
  type: 'subscribe',
  product_ids: ['BTC-USD'], // Your target trading pair
  channels: ['ticker', 'heartbeat'] // Heartbeat ensures regular server pings
}));

4. Test Your Reconnection Logic Manually #

To confirm your reconnection works for silent disconnects, simulate the issue:

• Use your OS firewall to block outgoing traffic to the GDAX WebSocket endpoint (wss://ws-feed.pro.coinbase.com)
• Wait 30-60 seconds to see if your heartbeat timeout triggers a reconnection
• Unblock the traffic and verify the bot reconnects successfully

5. Add Detailed Logging #

Logging every connection state change and message timestamp will help you pinpoint exactly when the freeze happens. This is crucial for intermittent issues—look for gaps in message logs to confirm when the server stopped sending data.

内容的提问来源于stack exchange，提问作者Phillip Wilkinson