What are the best practices for managing WebSocket connections?

Managing WebSocket connections requires consideration of connection lifecycle, resource optimization, error handling, and other aspects. Here are best practices:

Connection Management Strategies

1. Connection Establishment and Initialization

Client Side:

javascript
const ws = new WebSocket('wss://example.com/socket');

ws.onopen = () => {
  console.log('WebSocket connected');
  // Send initialization message
  ws.send(JSON.stringify({ type: 'init', data: userData }));
};

ws.onerror = (error) => {
  console.error('WebSocket error:', error);
  // Implement error handling logic
};

Server Side:

• Verify legitimacy of connection requests
• Set reasonable connection timeout
• Record connection metadata (user ID, device info, etc.)

2. Heartbeat Mechanism

Implement heartbeat to keep connection active:

javascript
// Client heartbeat
let heartbeatInterval;

function startHeartbeat() {
  heartbeatInterval = setInterval(() => {
    if (ws.readyState === WebSocket.OPEN) {
      ws.send(JSON.stringify({ type: 'ping' }));
    }
  }, 30000); // Send every 30 seconds
}

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  if (data.type === 'pong') {
    // Received server response, connection normal
  }
};

Server Heartbeat:

• Monitor client activity status
• Close connection if timeout without response
• Reduce resource usage by invalid connections

3. Connection Reconnection Strategy

Exponential Backoff Reconnection Algorithm:

javascript
function reconnect() {
  let retryCount = 0;
  const maxRetries = 5;
  const baseDelay = 1000; // 1 second

  function attemptReconnect() {
    if (retryCount >= maxRetries) {
      console.error('Max reconnection attempts reached');
      return;
    }

    const delay = Math.min(baseDelay * Math.pow(2, retryCount), 30000);
    setTimeout(() => {
      try {
        ws = new WebSocket('wss://example.com/socket');
        retryCount++;
      } catch (error) {
        console.error('Reconnection failed:', error);
        attemptReconnect();
      }
    }, delay);
  }

  attemptReconnect();
}

4. Connection Pool Management

Server-side Connection Pool Optimization:

• Use in-memory database (like Redis) to store connection mappings
• Implement connection grouping and routing
• Set maximum connection limit
• Implement connection load balancing

javascript
// Connection pool example
const connectionPool = new Map();

function addConnection(userId, ws) {
  connectionPool.set(userId, ws);
}

function getConnection(userId) {
  return connectionPool.get(userId);
}

function removeConnection(userId) {
  connectionPool.delete(userId);
}

5. Resource Cleanup

Graceful Connection Closure:

javascript
function closeConnection() {
  if (ws && ws.readyState === WebSocket.OPEN) {
    // Send close frame
    ws.send(JSON.stringify({ type: 'close', reason: 'user_logout' }));
    // Wait for server acknowledgment
    setTimeout(() => {
      ws.close(1000, 'Normal closure');
    }, 1000);
  }
  
  // Clear timers
  if (heartbeatInterval) {
    clearInterval(heartbeatInterval);
  }
}

6. Monitoring and Logging

Key Monitoring Metrics:

• Connection count and trends
• Message send/receive rate
• Connection failure rate
• Average connection duration
• Memory and CPU usage

Logging:

• Connection establishment and disconnection events
• Message transmission statistics
• Errors and exceptions

Performance Optimization Recommendations

1. Message Batching: Combine multiple small messages for sending
2. Compression: Enable permessage-deflate extension
3. Binary Data: Use binary format for large data transmission
4. Connection Reuse: Avoid frequent creation and destruction of connections
5. Rate Limiting: Prevent message flooding