记一次WebSocket连接异常与心跳机制故障的完整排查实录

// HeartbeatManager.js (简化版)
class HeartbeatManager {
    constructor() {
        this.clients = new Map();
        this.checkInterval = setInterval(() => this.checkAll(), 10000);
    }
    
    recordPong(clientId) {
        const client = this.clients.get(clientId);
        if (client) {
            client.lastPongTime = Date.now();
            client.missedCount = 0;
        }
    }
    
    checkAll() {
        const now = Date.now();
        for (const [clientId, client] of this.clients) {
            const elapsed = now - client.lastPongTime;
            if (elapsed > this.config.timeout) {
                this.handleTimeout(clientId);
            }
        }
    }
    
    handleTimeout(clientId) {
        // 问题：这里直接关闭连接，但没有检查 client.missedCount
        this.closeConnection(clientId, 'heartbeat_timeout');
    }
}

// WebSocketClient.js (简化版)
class WebSocketClient {
    constructor(url, options) {
        this.ws = new WebSocket(url);
        this.heartbeatInterval = options.heartbeatInterval || 30000;
        
        this.ws.onopen = () => {
            this.startHeartbeat();
        };
        
        this.ws.onpong = () => {
            this.lastPongTime = Date.now();
        };
    }
    
    startHeartbeat() {
        this.heartbeatTimer = setInterval(() => {
            if (this.ws.readyState === WebSocket.OPEN) {
                this.ws.ping();  // 问题：ping()不是标准WebSocket API
                this.lastPingTime = Date.now();
            }
        }, this.heartbeatInterval);
    }
}

// HeartbeatManager.js (修复后)
handleTimeout(clientId) {
    const client = this.clients.get(clientId);
    if (!client) return;
    
    client.missedCount++;
    
    if (client.missedCount >= this.config.maxMissed) {
        // 只有连续丢失maxMissed次心跳才关闭连接
        this.closeConnection(clientId, 'heartbeat_timeout');
        this.emit('client:timeout', { clientId, missedCount: client.missedCount });
    } else {
        // 还有机会，继续等待
        this.emit('client:heartbeat_missed', { 
            clientId, 
            missedCount: client.missedCount,
            maxMissed: this.config.maxMissed
        });
    }
}

// WebSocketClient.js (修复后)
class WebSocketClient {
    startHeartbeat() {
        this.heartbeatTimer = setInterval(() => {
            if (this.ws.readyState === WebSocket.OPEN) {
                // 使用JSON格式的应用层心跳消息
                this.ws.send(JSON.stringify({
                    type: 'ping',
                    timestamp: Date.now(),
                    clientId: this.clientId
                }));
                this.lastPingTime = Date.now();
            }
        }, this.heartbeatInterval);
    }
}

// 心跳响应处理
this.ws.onmessage = (event) => {
    const data = JSON.parse(event.data);
    if (data.type === 'pong') {
        this.lastPongTime = Date.now();
        this.missedCount = 0;
    }
};

// WebSocketClient.js (带重连逻辑)
class WebSocketClient {
    constructor(url, options) {
        // ... 初始化
        this.maxReconnectAttempts = 5;
        this.reconnectDelay = 1000;  // 初始重连延迟
    }
    
    handleClose(event) {
        if (this.reconnectAttempts < this.maxReconnectAttempts) {
            // 指数退避重连
            const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts);
            console.log(`Connection closed, reconnecting in ${delay}ms...`);
            
            setTimeout(() => {
                this.reconnectAttempts++;
                this.connect();
            }, delay);
        } else {
            this.emit('reconnect_failed', { attempts: this.reconnectAttempts });
        }
    }
}