1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

CLIENT REQUEST:
───────────────
GET /chat HTTP/1.1
Host: messaging.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==    # Random base64 value
Sec-WebSocket-Version: 13
Origin: https://app.example.com
 
SERVER RESPONSE:
────────────────
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=   # Hash of key + magic string
 
[Connection now speaks WebSocket protocol, not HTTP]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len |    Extended payload length    |
|I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
|N|V|V|V|       |S|             |   (if payload len==126/127)   |
| |1|2|3|       |K|             |                               |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
|     Extended payload length continued, if payload len == 127  |
+ - - - - - - - - - - - - - - - +-------------------------------+
|                               |Masking-key, if MASK set to 1  |
+-------------------------------+-------------------------------+
| Masking-key (continued)       |          Payload Data         |
+-------------------------------- - - - - - - - - - - - - - - - +
:                     Payload Data continued ...                :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
|                     Payload Data continued ...                |
+---------------------------------------------------------------+
 
Opcode values:
  0x0 = Continuation frame
  0x1 = Text frame (UTF-8)
  0x2 = Binary frame
  0x8 = Connection close
  0x9 = Ping (keep-alive)
  0xA = Pong (response to ping)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

┌─────────────────────────────────────────────────────────────────────┐
│                       CONNECTION SERVER                              │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                    NETWORK I/O LAYER                         │    │
│  │  • epoll/kqueue for efficient I/O multiplexing              │    │
│  │  • Non-blocking I/O for all operations                      │    │
│  │  • Zero-copy buffer management                              │    │
│  │  • Connection: 500K-2M connections per server               │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                              │                                       │
│                              ▼                                       │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                   CONNECTION STATE STORE                     │    │
│  │  • User ID → Connection mapping (in-memory hash table)      │    │
│  │  • Connection → User metadata                                │    │
│  │  • Last activity timestamp (for idle detection)             │    │
│  │  • Authentication state                                      │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                              │                                       │
│                              ▼                                       │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                    MESSAGE ROUTER                            │    │
│  │  • Inbound: Parse, validate, route to backend services      │    │
│  │  • Outbound: Receive from message queue, push to client     │    │
│  │  • Heartbeat: Ping/pong for connection health               │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘
 
Key Metrics per Server:
• Connections: 500K - 2M (depending on message activity)
• Memory: 4-16 GB (connection state + buffers)
• CPU: Minimal (I/O bound, not CPU bound)
• Network: 1-10 Gbps

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

interface HeartbeatConfig {
    // How often to send heartbeat (client-initiated)
    intervalMs: number;           // Typically 30-60 seconds
    
    // How long to wait for response before considering dead
    timeoutMs: number;            // Typically 10-30 seconds
    
    // How many missed heartbeats before forced reconnect
    maxMissedBeats: number;       // Typically 2-3
    
    // Adaptive interval: reduce when device is active
    activeIntervalMs: number;     // 15-30 seconds when actively chatting
    
    // Longer interval when device is idle (battery saving)
    idleIntervalMs: number;       // 60-120 seconds when app backgrounded
}
 
// Protocol:
// 1. Client sends Ping every intervalMs
// 2. Server responds with Pong immediately
// 3. If no Pong received within timeoutMs:
//    - Increment missedBeats counter
//    - If missedBeats >= maxMissedBeats: reconnect
// 4. Any message (not just Pong) resets the timeout
 
class ConnectionHealthMonitor {
    private lastPongReceived: number;
    private missedBeats: number = 0;
    private heartbeatTimer: NodeJS.Timer;
    
    constructor(private ws: WebSocket, private config: HeartbeatConfig) {
        this.startHeartbeat();
    }
    
    private startHeartbeat() {
        this.heartbeatTimer = setInterval(() => {
            this.sendPing();
        }, this.config.intervalMs);
    }
    
    private async sendPing() {
        this.ws.send(PING_FRAME);
        
        // Set timeout for Pong response
        setTimeout(() => {
            if (Date.now() - this.lastPongReceived > this.config.timeoutMs) {
                this.missedBeats++;
                console.log(`Missed heartbeat #${this.missedBeats}`);
                
                if (this.missedBeats >= this.config.maxMissedBeats) {
                    this.reconnect();
                }
            }
        }, this.config.timeoutMs);
    }
    
    onPongReceived() {
        this.lastPongReceived = Date.now();
        this.missedBeats = 0;  // Reset counter on successful pong
    }
    
    onAnyMessageReceived() {
        // Any message from server proves connection is alive
        this.lastPongReceived = Date.now();
        this.missedBeats = 0;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

┌──────────────────────────────────────────────────────────────────────────┐
│                          GLOBAL ROUTING ARCHITECTURE                      │
└──────────────────────────────────────────────────────────────────────────┘
 
                    ┌─────────────────────────────────┐
                    │         DNS / GeoDNS            │
                    │  (Routes to nearest region)     │
                    └───────────────┬─────────────────┘
                                    │
        ┌───────────────────────────┼───────────────────────────┐
        │                           │                           │
        ▼                           ▼                           ▼
┌───────────────┐           ┌───────────────┐           ┌───────────────┐
│  US-WEST      │           │  EU-WEST      │           │  ASIA-EAST    │
│  Data Center  │           │  Data Center  │           │  Data Center  │
└───────┬───────┘           └───────┬───────┘           └───────┬───────┘
        │                           │                           │
        ├────────────── GLOBAL MESSAGE BUS ─────────────────────┤
        │             (Kafka / RabbitMQ cluster)                │
        │                                                       │
┌───────┴───────────────────────────────────────────────────────┴───────┐
│                                                                        │
│   ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│   │ Conn Server  │ │ Conn Server  │ │ Conn Server  │ │ Conn Server  │ │
│   │   1(1M)      │ │   2 (1M)     │ │   3 (1M)     │ │   N (1M)     │ │
│   └──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘ │
│          │                │                │                │         │
│          ▼                ▼                ▼                ▼         │
│   ┌────────────────────────────────────────────────────────────────┐  │
│   │              USER → CONNECTION REGISTRY                        │  │
│   │  user_abc → conn_server_17, connection_id_42                   │  │
│   │  user_xyz → conn_server_42, connection_id_99                   │  │
│   │                     (Redis Cluster)                            │  │
│   └────────────────────────────────────────────────────────────────┘  │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

ALICE (US-West)                              BOB (EU-West)
     │                                              ▲
     │ 1. Send encrypted message                    │
     │    via WebSocket                             │
     ▼                                              │ 8. Push message
┌─────────────┐                              ┌─────────────┐
│ Conn Server │                              │ Conn Server │
│  (Alice's)  │                              │   (Bob's)   │
└──────┬──────┘                              └──────▲──────┘
       │                                            │
       │ 2. Validate auth,                          │ 7. Lookup Bob's conn,
       │    Forward to router                       │    Deliver to correct
       ▼                                            │    WebSocket
┌─────────────┐                              ┌─────────────┐
│   Message   │                              │   Message   │
│    Router   │                              │   Dispatch  │
└──────┬──────┘                              └──────▲──────┘
       │                                            │
       │ 3. Persist to DB,                          │ 6. Consume from
       │    Acknowledge to sender                   │    Bob's queue
       │                                            │
       │ 4. Determine recipient                     │
       │    region, enqueue                         │
       ▼                                            │
┌─────────────────────────────────────────────────────────────┐
│                     MESSAGE QUEUE (Kafka)                    │
│   Topic: messages.user.{bob_id}                              │
│         ──────────────────────────────────────►              │
│   Partition: hash(bob_id) % num_partitions                   │
└─────────────────────────────────────────────────────────────┘
       │
       │ 5. If Bob's region ≠ Alice's region,
       │    replicate to Bob's regional Kafka
       ▼
┌─────────────┐                              ┌─────────────┐
│  US-West    │     Cross-region sync        │  EU-West    │
│  Kafka      │ ◄───────────────────────────►│  Kafka      │
└─────────────┘                              └─────────────┘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

interface GroupMessage {
    messageId: string;
    groupId: string;
    senderId: string;
    content: EncryptedPayload;
    timestamp: number;
}
 
async function deliverGroupMessage(message: GroupMessage): Promise<void> {
    const group = await getGroup(message.groupId);
    const members = group.members.filter(m => m.id !== message.senderId);
    
    // Categorize members by online status
    const { online, offline } = await categorizeMembers(members);
    
    // Immediate push to online members (parallel)
    const pushPromises = online.map(member => 
        pushToConnection(member.connectionInfo, message)
    );
    
    // Queue for offline members (batch write)
    const queuePromises = offline.map(member =>
        enqueueForOfflineDelivery(member.id, message)
    );
    
    // For very large groups (>256 members), limit parallel pushes
    // to avoid overwhelming connection servers
    const BATCH_SIZE = 100;
    if (online.length > BATCH_SIZE) {
        // Process in batches with small delays
        for (let i = 0; i < pushPromises.length; i += BATCH_SIZE) {
            await Promise.all(pushPromises.slice(i, i + BATCH_SIZE));
            await delay(10);  // 10ms between batches
        }
    } else {
        await Promise.all([...pushPromises, ...queuePromises]);
    }
}
 
async function categorizeMembers(
    members: GroupMember[]
): Promise<{ online: OnlineMember[]; offline: OfflineMember[] }> {
    // Batch lookup in connection registry
    const connectionLookups = await connectionRegistry.multiGet(
        members.map(m => m.id)
    );
    
    const online: OnlineMember[] = [];
    const offline: OfflineMember[] = [];
    
    for (const member of members) {
        const conn = connectionLookups.get(member.id);
        if (conn && !isStale(conn)) {
            online.push({ ...member, connectionInfo: conn });
        } else {
            offline.push(member);
        }
    }
    
    return { online, offline };
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

class ConnectionManager {
    private reconnectAttempts: number = 0;
    private readonly maxReconnectAttempts: number = 10;
    
    async connect(): Promise<void> {
        while (this.reconnectAttempts < this.maxReconnectAttempts) {
            try {
                // Get server endpoint (load balancer will route to healthy server)
                const endpoint = await this.getConnectionEndpoint();
                
                this.ws = new WebSocket(endpoint);
                await this.waitForOpen();
                
                // Connection successful
                this.reconnectAttempts = 0;
                this.startHeartbeat();
                await this.syncMissedMessages();
                return;
                
            } catch (error) {
                this.reconnectAttempts++;
                
                // Exponential backoff with jitter
                const delay = this.calculateBackoff(this.reconnectAttempts);
                console.log(`Reconnect attempt ${this.reconnectAttempts} failed. Retrying in ${delay}ms`);
                await sleep(delay);
            }
        }
        
        // All attempts exhausted
        this.showPermanentErrorToUser();
    }
    
    private calculateBackoff(attempt: number): number {
        const base = 1000;  // 1 second
        const max = 30000;  // 30 seconds max
        const exponential = Math.min(base * Math.pow(2, attempt), max);
        const jitter = Math.random() * 0.3 * exponential;  // ±30%
        return exponential + jitter;
    }
    
    private async syncMissedMessages(): Promise<void> {
        // After reconnection, fetch any messages we may have missed
        const lastSeenTimestamp = await this.getLastSeenTimestamp();
        const missedMessages = await this.api.sync(lastSeenTimestamp);
        await this.processMessages(missedMessages);
    }
}