WebSocket Protocol

Client-side Error Handling

Automatic Reconnection

class ResilientWebSocket {
    constructor(url, options = {}) {
        this.url = url;
        this.options = {
            maxReconnectAttempts: 10,
            reconnectDelay: 1000,
            maxReconnectDelay: 30000,
            backoffFactor: 1.5,
            ...options
        };

        this.reconnectAttempts = 0;
        this.connectionState = 'disconnected';
        this.messageQueue = [];
    }

    connect() {
        return new Promise((resolve, reject) => {
            this.ws = new WebSocket(this.url);
            this.connectionState = 'connecting';

            this.ws.onopen = (event) => {
                this.connectionState = 'connected';
                this.reconnectAttempts = 0;
                this.flushMessageQueue();
                resolve(event);
            };

            this.ws.onerror = (error) => {
                console.error('WebSocket error:', error);
                this.handleConnectionError();
            };

            this.ws.onclose = (event) => {
                this.connectionState = 'disconnected';
                if (!event.wasClean) {
                    this.scheduleReconnect();
                }
            };
        });
    }

    handleConnectionError() {
        if (this.reconnectAttempts < this.options.maxReconnectAttempts) {
            this.scheduleReconnect();
        } else {
            this.emit('max_reconnect_attempts_reached');
        }
    }

    scheduleReconnect() {
        const delay = Math.min(
            this.options.reconnectDelay * Math.pow(this.options.backoffFactor, this.reconnectAttempts),
            this.options.maxReconnectDelay
        );

        setTimeout(() => {
            this.reconnectAttempts++;
            this.connect();
        }, delay);
    }

    send(message) {
        if (this.connectionState === 'connected') {
            this.ws.send(JSON.stringify(message));
        } else {
            // Queue messages while disconnected
            this.messageQueue.push(message);
        }
    }

    flushMessageQueue() {
        while (this.messageQueue.length > 0) {
            const message = this.messageQueue.shift();
            this.ws.send(JSON.stringify(message));
        }
    }
}
                        

Message Acknowledgment

class ReliableMessageSender {
    constructor(wsManager) {
        this.wsManager = wsManager;
        this.pendingMessages = new Map();
        this.ackTimeout = 5000; // 5 seconds
    }

    sendReliable(message) {
        const messageId = this.generateMessageId();
        message.id = messageId;
        message.requiresAck = true;

        // Store for potential retry
        this.pendingMessages.set(messageId, {
            message,
            timestamp: Date.now(),
            retryCount: 0
        });

        // Send message
        this.wsManager.send(message);

        // Set timeout for acknowledgment
        setTimeout(() => {
            this.handleAckTimeout(messageId);
        }, this.ackTimeout);

        return messageId;
    }

    handleAck(ackMessage) {
        const messageId = ackMessage.ackId;
        if (this.pendingMessages.has(messageId)) {
            this.pendingMessages.delete(messageId);
        }
    }

    handleAckTimeout(messageId) {
        const pending = this.pendingMessages.get(messageId);
        if (pending && pending.retryCount < 3) {
            pending.retryCount++;
            this.wsManager.send(pending.message);

            // Reschedule timeout
            setTimeout(() => {
                this.handleAckTimeout(messageId);
            }, this.ackTimeout);
        } else {
            // Give up after 3 retries
            this.pendingMessages.delete(messageId);
            this.handleMessageFailed(messageId);
        }
    }
}
                        

Server-side Error Handling

Circuit Breaker for External Dependencies

class WebSocketCircuitBreaker:
    def __init__(self, failure_threshold=5, recovery_timeout=60):
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.failure_count = 0
        self.last_failure_time = None
        self.state = 'closed'  # closed, open, half-open

    async def call_protected(self, func, *args, **kwargs):
        if self.state == 'open':
            if self.should_attempt_reset():
                self.state = 'half-open'
            else:
                raise CircuitBreakerOpenError("Circuit breaker is open")

        try:
            result = await func(*args, **kwargs)
            self.on_success()
            return result
        except Exception as e:
            self.on_failure()
            raise

    def on_success(self):
        self.failure_count = 0
        self.state = 'closed'

    def on_failure(self):
        self.failure_count += 1
        self.last_failure_time = time.time()

        if self.failure_count >= self.failure_threshold:
            self.state = 'open'

    def should_attempt_reset(self):
        return (time.time() - self.last_failure_time) >= self.recovery_timeout

# Usage in WebSocket handler
breaker = WebSocketCircuitBreaker()

async def send_to_external_service(data):
    try:
        await breaker.call_protected(external_api_call, data)
    except CircuitBreakerOpenError:
        # Use cached data or alternative approach
        await send_cached_response(data)
                        

Graceful Degradation

• Fallback to HTTP: When WebSocket fails, fall back to HTTP polling
• Reduced Functionality: Disable real-time features during high load
• Cached Responses: Serve cached data when live data unavailable
• Queue Overflow Handling: Drop low-priority messages when queues full