@livedesk/hub 0.1.27 → 0.1.29

package/src/transport/relay-hub-control.js

@@ -10,6 +10,7 @@ export const RELAY_CONTROL_DIRECTIONS = Object.freeze({
 });
 
 const RELAY_MAX_LINE_BYTES = 768 * 1024;
+const RELAY_MAX_RECEIVE_CHUNKS = 256;
 const RELAY_NONCE_BYTES = 12;
 const RELAY_TAG_BYTES = 16;
 const RELAY_PUBLIC_KEY_BYTES = 65;
@@ -40,7 +41,7 @@ function boundedInteger(value, minimum, maximum, fallback) {
 }
 
 function encodeBase64Url(value) {
-    return Buffer.from(value).toString('base64url');
+    return (Buffer.isBuffer(value) ? value : Buffer.from(value)).toString('base64url');
 }
 
 function decodeCanonicalBase64Url(value, expectedBytes = 0, maximumBytes = 1024) {
@@ -112,7 +113,9 @@ function requireSequence(sequence) {
 }
 
 function normalizeSessionKey(sessionKey) {
-    const key = Buffer.from(sessionKey || []);
+    const key = Buffer.isBuffer(sessionKey)
+        ? sessionKey
+        : Buffer.from(sessionKey || []);
     if (key.length !== 32) {
         throw relayError('relay-session-key-invalid');
     }
@@ -224,18 +227,31 @@ export function encryptRelayControlPayload({
     nonce = crypto.randomBytes(RELAY_NONCE_BYTES)
 } = {}) {
     const key = normalizeSessionKey(sessionKey);
-    const cleartext = Buffer.from(plaintext || []);
+    const cleartext = Buffer.isBuffer(plaintext)
+        ? plaintext
+        : Buffer.from(plaintext || []);
     if (cleartext.length < 1 || cleartext.length > RELAY_CONTROL_MAX_PLAINTEXT_BYTES) {
         throw relayError('relay-plaintext-size-invalid');
     }
-    const nonceBytes = Buffer.from(nonce || []);
+    const nonceBytes = Buffer.isBuffer(nonce)
+        ? nonce
+        : Buffer.from(nonce || []);
     if (nonceBytes.length !== RELAY_NONCE_BYTES) {
         throw relayError('relay-nonce-invalid');
     }
     const cipher = crypto.createCipheriv('aes-256-gcm', key, nonceBytes, { authTagLength: RELAY_TAG_BYTES });
     cipher.setAAD(controlAad(roomId, peerId, direction, sequence));
-    const ciphertext = Buffer.concat([cipher.update(cleartext), cipher.final()]);
-    return encodeBase64Url(Buffer.concat([nonceBytes, ciphertext, cipher.getAuthTag()]));
+    const update = cipher.update(cleartext);
+    const final = cipher.final();
+    const ciphertext = final.length > 0
+        ? Buffer.concat([update, final], update.length + final.length)
+        : update;
+    const tag = cipher.getAuthTag();
+    const envelope = Buffer.allocUnsafe(nonceBytes.length + ciphertext.length + tag.length);
+    nonceBytes.copy(envelope, 0);
+    ciphertext.copy(envelope, nonceBytes.length);
+    tag.copy(envelope, nonceBytes.length + ciphertext.length);
+    return encodeBase64Url(envelope);
 }
 
 export function decryptRelayControlPayload({
@@ -266,7 +282,11 @@ export function decryptRelayControlPayload({
         const decipher = crypto.createDecipheriv('aes-256-gcm', key, nonce, { authTagLength: RELAY_TAG_BYTES });
         decipher.setAAD(controlAad(roomId, peerId, direction, sequence));
         decipher.setAuthTag(tag);
-        const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+        const update = decipher.update(ciphertext);
+        const final = decipher.final();
+        const plaintext = final.length > 0
+            ? Buffer.concat([update, final], update.length + final.length)
+            : update;
         if (plaintext.length < 1 || plaintext.length > RELAY_CONTROL_MAX_PLAINTEXT_BYTES) {
             throw relayError('relay-plaintext-size-invalid');
         }
@@ -356,7 +376,13 @@ export class HubRelayVirtualSocket extends EventEmitter {
     }
 
     _deliver(plaintext) {
-        if (!this.destroyed) this.emit('data', Buffer.from(plaintext));
+        if (this.destroyed) return;
+        if (Buffer.isBuffer(plaintext)) {
+            this.emit('data', plaintext);
+            return;
+        }
+        this.owner.recordPlaintextDeliveryCopy();
+        this.emit('data', Buffer.from(plaintext));
     }
 
     _drain() {
@@ -437,7 +463,9 @@ export function createHubRelayControl({
         DEFAULT_CONNECT_TIMEOUT_MS);
     const peers = new Map();
     const retiredPeerIds = new Map();
+    const connectionOwners = new Map();
     const sendQueue = [];
+    let sendQueueHead = 0;
     const peerQueueStats = new Map();
     const counters = {
         connections: 0,
@@ -446,7 +474,17 @@ export function createHubRelayControl({
         rejectedPeers: 0,
         encryptedMessagesReceived: 0,
         encryptedMessagesSent: 0,
-        queueDrops: 0
+        queueDrops: 0,
+        receiveLineAssemblyCopies: 0,
+        receiveLineAssemblyBytes: 0,
+        plaintextDeliveryCopies: 0,
+        peerQueuePurges: 0,
+        peerQueuePurgedBytes: 0,
+        staleConnectionEventDrops: 0,
+        socketOwnersCreated: 0,
+        socketOwnersClosed: 0,
+        peerOwnersCreated: 0,
+        peerOwnersClosed: 0
     };
 
     let desired = false;
@@ -456,11 +494,24 @@ export function createHubRelayControl({
     let connectionGeneration = 0;
     let reconnectTimer = null;
     let connectAttemptTimer = null;
+    let closeSocketTimer = null;
+    let closeTimedOut = false;
     let reconnectAttempt = 0;
-    let receiveBuffer = Buffer.alloc(0);
+    let receiveChunks = [];
+    let receiveBytes = 0;
+    let receiveChunkHighWater = 0;
+    let receiveByteHighWater = 0;
     let queuedBytes = 0;
+    let queuedMessageHighWater = 0;
+    let queuedByteHighWater = 0;
+    let socketWritableByteHighWater = 0;
+    let totalOutboundByteHighWater = 0;
+    let socketOwnerHighWater = 0;
+    let peerOwnerHighWater = 0;
+    let timerOwnerHighWater = 0;
     let awaitingDrain = false;
     let lastError = '';
+    let lastDisconnectReason = '';
     let lastConnectedAt = '';
     let lastTransitionAt = '';
     let state = enabled ? 'idle' : 'disabled';
@@ -471,6 +522,40 @@ export function createHubRelayControl({
         if (error) lastError = safeText(error, 120);
     }
 
+    function activeTimerCount() {
+        return Number(Boolean(reconnectTimer))
+            + Number(Boolean(connectAttemptTimer))
+            + Number(Boolean(closeSocketTimer));
+    }
+
+    function recordTimerOwnerHighWater() {
+        timerOwnerHighWater = Math.max(
+            timerOwnerHighWater,
+            activeTimerCount());
+    }
+
+    function addConnectionOwner(socket, generation) {
+        if (connectionOwners.has(socket)) {
+            throw relayError('relay-socket-owner-duplicate');
+        }
+        connectionOwners.set(socket, {
+            socket,
+            generation,
+            phase: 'current'
+        });
+        counters.socketOwnersCreated += 1;
+        socketOwnerHighWater = Math.max(
+            socketOwnerHighWater,
+            connectionOwners.size);
+    }
+
+    function markConnectionOwnerClosing(socket, generation) {
+        const owner = connectionOwners.get(socket);
+        if (!owner || owner.generation !== generation) return false;
+        owner.phase = 'closing';
+        return true;
+    }
+
     function queueStats(peerId) {
         if (!peerId) return { messages: 0, bytes: 0, backpressured: false };
         let stats = peerQueueStats.get(peerId);
@@ -490,13 +575,73 @@ export function createHubRelayControl({
         stats.bytes = Math.max(0, stats.bytes - item.buffer.length);
     }
 
+    function queuedMessageCount() {
+        return sendQueue.length - sendQueueHead;
+    }
+
+    function socketWritableBytes(socket = connection) {
+        const value = Number(socket?.writableLength);
+        return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+    }
+
+    function recordOutboundHighWater(socket = connection) {
+        const writableBytes = socketWritableBytes(socket);
+        socketWritableByteHighWater = Math.max(
+            socketWritableByteHighWater,
+            writableBytes);
+        totalOutboundByteHighWater = Math.max(
+            totalOutboundByteHighWater,
+            queuedBytes + writableBytes);
+    }
+
+    function dequeueQueuedItem() {
+        if (queuedMessageCount() <= 0) return null;
+        const item = sendQueue[sendQueueHead];
+        sendQueue[sendQueueHead] = null;
+        sendQueueHead += 1;
+        if (sendQueueHead >= 64 && sendQueueHead * 2 >= sendQueue.length) {
+            sendQueue.splice(0, sendQueueHead);
+            sendQueueHead = 0;
+        }
+        return item;
+    }
+
     function clearQueue() {
         sendQueue.length = 0;
+        sendQueueHead = 0;
         queuedBytes = 0;
         awaitingDrain = false;
         peerQueueStats.clear();
     }
 
+    function purgePeerQueue(peerId) {
+        if (!peerId || queuedMessageCount() === 0) return;
+        let writeIndex = 0;
+        let purgedBytes = 0;
+        for (let readIndex = sendQueueHead; readIndex < sendQueue.length; readIndex += 1) {
+            const item = sendQueue[readIndex];
+            if (item.peerId === peerId) {
+                purgedBytes += item.buffer.length;
+                releaseQueuedItem(item);
+                continue;
+            }
+            sendQueue[writeIndex] = item;
+            writeIndex += 1;
+        }
+        for (let index = writeIndex; index < sendQueue.length; index += 1) {
+            sendQueue[index] = null;
+        }
+        if (purgedBytes > 0) {
+            sendQueue.length = writeIndex;
+            sendQueueHead = 0;
+            counters.peerQueuePurges += 1;
+            counters.peerQueuePurgedBytes += purgedBytes;
+        } else if (sendQueueHead > 0) {
+            sendQueue.splice(0, sendQueueHead);
+            sendQueueHead = 0;
+        }
+    }
+
     function emitPeerDrains() {
         if (awaitingDrain) return;
         for (const [peerId, stats] of peerQueueStats) {
@@ -513,8 +658,9 @@ export function createHubRelayControl({
     function flushQueue() {
         const socket = connection;
         if (!socket || socket.destroyed || !socket.writable || awaitingDrain) return;
-        while (sendQueue.length > 0 && !awaitingDrain) {
-            const item = sendQueue.shift();
+        while (queuedMessageCount() > 0 && !awaitingDrain) {
+            const item = dequeueQueuedItem();
+            if (!item) break;
             releaseQueuedItem(item);
             let writable = false;
             try {
@@ -524,6 +670,7 @@ export function createHubRelayControl({
                 return;
             }
             if (!writable) awaitingDrain = true;
+            recordOutboundHighWater(socket);
         }
         emitPeerDrains();
     }
@@ -538,8 +685,9 @@ export function createHubRelayControl({
         }
         if (buffer.length > RELAY_MAX_LINE_BYTES) return false;
         const stats = queueStats(peerId);
-        if (sendQueue.length >= maxQueueMessages
-            || queuedBytes + buffer.length > maxQueueBytes
+        const writableBytes = socketWritableBytes();
+        if (queuedMessageCount() >= maxQueueMessages
+            || queuedBytes + writableBytes + buffer.length > maxQueueBytes
             || (peerId && (stats.messages >= maxPeerQueueMessages
                 || stats.bytes + buffer.length > maxPeerQueueBytes))) {
             counters.queueDrops += 1;
@@ -548,6 +696,9 @@ export function createHubRelayControl({
         }
         sendQueue.push({ buffer, peerId });
         queuedBytes += buffer.length;
+        queuedMessageHighWater = Math.max(queuedMessageHighWater, queuedMessageCount());
+        queuedByteHighWater = Math.max(queuedByteHighWater, queuedBytes);
+        recordOutboundHighWater();
         if (peerId) {
             stats.messages += 1;
             stats.bytes += buffer.length;
@@ -594,7 +745,9 @@ export function createHubRelayControl({
             return false;
         }
         peers.delete(id);
+        counters.peerOwnersClosed += 1;
         rememberRetiredPeer(id);
+        purgePeerQueue(id);
         peerQueueStats.delete(id);
         if (notify) sendRelayClose(id, reason);
         if (Buffer.isBuffer(peer.sessionKey)) peer.sessionKey.fill(0);
@@ -620,7 +773,9 @@ export function createHubRelayControl({
     function sendPeerPlaintext(peerId, plaintext) {
         const peer = peers.get(String(peerId || ''));
         if (!peer || peer.socket.destroyed || peer.handshakeState !== 'established') return false;
-        const cleartext = Buffer.from(plaintext || []);
+        const cleartext = Buffer.isBuffer(plaintext)
+            ? plaintext
+            : Buffer.from(plaintext || []);
         if (cleartext.length < 1 || cleartext.length > RELAY_CONTROL_MAX_PLAINTEXT_BYTES) {
             rejectPeer(peer.peerId, 'relay-plaintext-size-invalid');
             return false;
@@ -725,6 +880,8 @@ export function createHubRelayControl({
             };
             peer.socket = new HubRelayVirtualSocket(api, peerId, remoteAddress, port);
             peers.set(peerId, peer);
+            counters.peerOwnersCreated += 1;
+            peerOwnerHighWater = Math.max(peerOwnerHighWater, peers.size);
             const sent = enqueueEnvelope({
                 type: 'relay.handshake',
                 protocol: RELAY_CONTROL_PROTOCOL,
@@ -763,7 +920,7 @@ export function createHubRelayControl({
     function handleClientData(message) {
         let peerId = '';
         try {
-            peerId = requirePeerId(message.peerId);
+            peerId = safeText(message.peerId, 64);
             const peer = peers.get(peerId);
             if (!peer || peer.handshakeState !== 'established') {
                 throw relayError('relay-handshake-required');
@@ -826,45 +983,117 @@ export function createHubRelayControl({
             return;
         }
         if (message.type === 'relay.close') {
+            const reason = safeText(message.reason, 80) || 'relay-server-closed';
+            if (!peerId) {
+                lastError = reason;
+                lastDisconnectReason = reason;
+                connection?.destroy();
+                return;
+            }
             try {
-                closePeer(requirePeerId(message.peerId), 'relay-client-closed', { notify: false });
+                closePeer(requirePeerId(message.peerId), reason, { notify: false });
             } catch {
                 // Invalid untrusted routing fields are ignored.
             }
         }
     }
 
-    function onConnectionData(chunk) {
+    function clearReceiveChunks() {
+        receiveChunks = [];
+        receiveBytes = 0;
+    }
+
+    function retainReceiveTail(incoming, offset) {
+        const tail = incoming.subarray(offset);
+        if (tail.length === 0) return true;
+        if (receiveBytes + tail.length > RELAY_MAX_LINE_BYTES) return false;
+        // A tail following a complete line must not retain the complete large
+        // TCP chunk. A chunk containing no line is already exact ownership and
+        // can be retained without copying.
+        const retained = offset > 0 ? Buffer.from(tail) : tail;
+        if (receiveChunks.length >= RELAY_MAX_RECEIVE_CHUNKS) return false;
+        receiveChunks.push(retained);
+        receiveBytes += retained.length;
+        receiveChunkHighWater = Math.max(receiveChunkHighWater, receiveChunks.length);
+        receiveByteHighWater = Math.max(receiveByteHighWater, receiveBytes);
+        return true;
+    }
+
+    function assembleReceiveLine(segment) {
+        if (receiveBytes === 0) return segment;
+        const totalBytes = receiveBytes + segment.length;
+        const line = Buffer.allocUnsafe(totalBytes);
+        let offset = 0;
+        for (const chunk of receiveChunks) {
+            chunk.copy(line, offset);
+            offset += chunk.length;
+        }
+        segment.copy(line, offset);
+        counters.receiveLineAssemblyCopies += 1;
+        counters.receiveLineAssemblyBytes += totalBytes;
+        clearReceiveChunks();
+        return line;
+    }
+
+    function isCurrentConnectionOwner(socket, generation) {
+        return desired
+            && !closing
+            && connection === socket
+            && generation === connectionGeneration
+            && !socket.destroyed;
+    }
+
+    function processRelayLine(socket, generation, line) {
+        if (!isCurrentConnectionOwner(socket, generation)) {
+            counters.staleConnectionEventDrops += 1;
+            return false;
+        }
+        if (line.length === 0) return true;
+        let message;
+        try {
+            message = JSON.parse(line.toString('utf8'));
+        } catch {
+            lastError = 'relay-invalid-json';
+            socket.destroy();
+            return false;
+        }
+        if (!isCurrentConnectionOwner(socket, generation)) {
+            counters.staleConnectionEventDrops += 1;
+            return false;
+        }
+        handleRelayEnvelope(message);
+        return true;
+    }
+
+    function onConnectionData(socket, generation, chunk) {
+        if (!isCurrentConnectionOwner(socket, generation)) {
+            counters.staleConnectionEventDrops += 1;
+            return;
+        }
         const incoming = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        receiveBuffer = receiveBuffer.length > 0
-            ? Buffer.concat([receiveBuffer, incoming])
-            : incoming;
-        while (true) {
-            const newline = receiveBuffer.indexOf(0x0a);
+        let offset = 0;
+        while (offset < incoming.length) {
+            if (!isCurrentConnectionOwner(socket, generation)) {
+                counters.staleConnectionEventDrops += 1;
+                return;
+            }
+            const newline = incoming.indexOf(0x0a, offset);
             if (newline < 0) {
-                if (receiveBuffer.length > RELAY_MAX_LINE_BYTES) {
+                if (!retainReceiveTail(incoming, offset)) {
                     lastError = 'relay-line-too-large';
-                    connection?.destroy();
+                    socket.destroy();
                 }
                 return;
             }
-            if (newline > RELAY_MAX_LINE_BYTES) {
+            const segmentLength = newline - offset;
+            if (receiveBytes + segmentLength > RELAY_MAX_LINE_BYTES) {
                 lastError = 'relay-line-too-large';
-                connection?.destroy();
-                return;
-            }
-            const line = receiveBuffer.subarray(0, newline);
-            receiveBuffer = receiveBuffer.subarray(newline + 1);
-            if (line.length === 0) continue;
-            let message;
-            try {
-                message = JSON.parse(line.toString('utf8'));
-            } catch {
-                lastError = 'relay-invalid-json';
-                connection?.destroy();
+                socket.destroy();
                 return;
             }
-            handleRelayEnvelope(message);
+            const line = assembleReceiveLine(incoming.subarray(offset, newline));
+            if (!processRelayLine(socket, generation, line)) return;
+            offset = newline + 1;
         }
     }
 
@@ -883,6 +1112,7 @@ export function createHubRelayControl({
             connectNow();
         }, delay);
         reconnectTimer.unref?.();
+        recordTimerOwnerHighWater();
     }
 
     function clearConnectAttemptTimer() {
@@ -891,10 +1121,21 @@ export function createHubRelayControl({
     }
 
     function handleConnectionClosed(socket, generation) {
+        const owner = connectionOwners.get(socket);
+        if (!owner || owner.generation !== generation) return;
+        connectionOwners.delete(socket);
+        counters.socketOwnersClosed += 1;
+        if (owner.phase === 'closing') return;
         if (connection !== socket || generation !== connectionGeneration) return;
         clearConnectAttemptTimer();
         connection = null;
-        receiveBuffer = Buffer.alloc(0);
+        const disconnectReason = safeText(lastError, 120) || 'relay-socket-closed';
+        lastDisconnectReason = disconnectReason;
+        logWarn(
+            'relay',
+            `Encrypted relay control disconnected reason=${disconnectReason} peers=${peers.size}`
+        );
+        clearReceiveChunks();
         clearQueue();
         closeAllPeers('relay-connection-lost');
         if (desired && !closing) scheduleReconnect();
@@ -914,6 +1155,7 @@ export function createHubRelayControl({
             return;
         }
         connection = socket;
+        addConnectionOwner(socket, generation);
         socket.setNoDelay?.(true);
         socket.setKeepAlive?.(true, 10_000);
         socket.once('connect', () => {
@@ -931,7 +1173,7 @@ export function createHubRelayControl({
             });
             if (!registered) socket.destroy();
         });
-        socket.on('data', onConnectionData);
+        socket.on('data', chunk => onConnectionData(socket, generation, chunk));
         socket.on('drain', () => {
             if (connection !== socket || generation !== connectionGeneration) return;
             awaitingDrain = false;
@@ -953,10 +1195,14 @@ export function createHubRelayControl({
             socket.destroy();
         }, connectTimeoutMs);
         connectAttemptTimer.unref?.();
+        recordTimerOwnerHighWater();
     }
 
     async function start() {
         if (!enabled || started) return getStatus();
+        if (closing || closeTimedOut || connectionOwners.size > 0) {
+            throw relayError('relay-close-nonterminal');
+        }
         started = true;
         desired = true;
         closing = false;
@@ -965,59 +1211,138 @@ export function createHubRelayControl({
     }
 
     async function close() {
+        const closeDeadlineAt = Date.now() + 1_000;
         desired = false;
         started = false;
         closing = true;
+        closeTimedOut = false;
+        transition('closing');
         if (reconnectTimer) clearTimeout(reconnectTimer);
         reconnectTimer = null;
         clearConnectAttemptTimer();
         closeAllPeers('hub-shutdown');
         clearQueue();
         const socket = connection;
+        const generation = connectionGeneration;
+        if (socket) markConnectionOwnerClosing(socket, generation);
         connection = null;
         connectionGeneration += 1;
-        receiveBuffer = Buffer.alloc(0);
-        if (socket && !socket.destroyed) {
-            await new Promise(resolve => {
+        clearReceiveChunks();
+        const closingOwners = [...connectionOwners.values()];
+        if (closingOwners.length > 0) {
+            const ownersClosed = new Promise((resolve, reject) => {
                 let settled = false;
+                const onClose = () => {
+                    if (connectionOwners.size === 0) settle();
+                };
                 const settle = () => {
                     if (settled) return;
                     settled = true;
-                    clearTimeout(timer);
+                    if (closeSocketTimer) clearTimeout(closeSocketTimer);
+                    closeSocketTimer = null;
+                    for (const owner of closingOwners) {
+                        owner.socket.off?.('close', onClose);
+                    }
                     resolve();
                 };
-                const timer = setTimeout(() => {
-                    socket.destroy();
-                    settle();
-                }, 250);
-                timer.unref?.();
-                socket.once('close', settle);
+                const fail = () => {
+                    if (settled) return;
+                    settled = true;
+                    closeSocketTimer = null;
+                    for (const owner of closingOwners) {
+                        owner.socket.off?.('close', onClose);
+                    }
+                    reject(relayError('relay-close-timeout'));
+                };
+                for (const owner of closingOwners) {
+                    owner.phase = 'closing';
+                    owner.socket.once('close', onClose);
+                }
+                closeSocketTimer = setTimeout(() => {
+                    fail();
+                }, Math.max(1, closeDeadlineAt - Date.now()));
+                recordTimerOwnerHighWater();
+                if (connectionOwners.size === 0) settle();
+            });
+            for (const owner of closingOwners) {
                 try {
-                    socket.end();
+                    owner.socket.end();
                 } catch {
-                    socket.destroy();
-                    settle();
+                    // The exact owner remains in the ledger until close.
                 }
-            });
+                try {
+                    owner.socket.destroy();
+                } catch {
+                    // Timeout remains explicit and nonterminal.
+                }
+            }
+            try {
+                await ownersClosed;
+            } catch (error) {
+                closeTimedOut = true;
+                lastError = 'relay-close-timeout';
+                transition('close-timeout', lastError);
+                throw error;
+            }
+        }
+        if (connectionOwners.size !== 0) {
+            closeTimedOut = true;
+            lastError = 'relay-close-nonterminal';
+            transition('close-timeout', lastError);
+            throw relayError(lastError);
         }
+        closeTimedOut = false;
         closing = false;
+        lastError = '';
         transition(enabled ? 'idle' : 'disabled');
     }
 
     function getStatus() {
+        const writableBytes = socketWritableBytes();
+        recordOutboundHighWater();
         return {
             enabled,
             started,
             state,
             connected: !!connection && !connection.destroyed && state === 'registered',
+            closing,
+            closeTimedOut,
+            activeSocketCount: connectionOwners.size,
+            currentSocketCount: connection && connectionOwners.has(connection) ? 1 : 0,
+            closingSocketCount: [...connectionOwners.values()]
+                .filter(owner => owner.phase === 'closing').length,
+            activeTimerCount: activeTimerCount(),
+            timerOwnerHighWater,
+            socketOwnerHighWater,
+            socketOwnersCreated: counters.socketOwnersCreated,
+            socketOwnersClosed: counters.socketOwnersClosed,
             protocol: RELAY_CONTROL_PROTOCOL,
             endpoint: `${host}:${port}`,
             host,
             port,
             peerCount: peers.size,
+            peerOwnerHighWater,
+            peerOwnersCreated: counters.peerOwnersCreated,
+            peerOwnersClosed: counters.peerOwnersClosed,
             peerQueueCount: peerQueueStats.size,
-            queuedMessages: sendQueue.length,
+            queuedMessages: queuedMessageCount(),
             queuedBytes,
+            socketWritableBytes: writableBytes,
+            totalOutboundBufferedBytes: queuedBytes + writableBytes,
+            queuedMessageHighWater,
+            queuedByteHighWater,
+            socketWritableByteHighWater,
+            totalOutboundByteHighWater,
+            receiveBufferedChunks: receiveChunks.length,
+            receiveBufferedBytes: receiveBytes,
+            receiveChunkHighWater,
+            receiveByteHighWater,
+            receiveLineAssemblyCopyCount: counters.receiveLineAssemblyCopies,
+            receiveLineAssemblyBytes: counters.receiveLineAssemblyBytes,
+            plaintextDeliveryCopyCount: counters.plaintextDeliveryCopies,
+            peerQueuePurgeCount: counters.peerQueuePurges,
+            peerQueuePurgedBytes: counters.peerQueuePurgedBytes,
+            staleConnectionEventDropCount: counters.staleConnectionEventDrops,
             maxPeers,
             maxQueueMessages,
             maxQueueBytes,
@@ -1029,17 +1354,23 @@ export function createHubRelayControl({
             queueDropCount: counters.queueDrops,
             lastConnectedAt,
             lastTransitionAt,
+            lastDisconnectReason,
             lastError
         };
     }
 
+    function recordPlaintextDeliveryCopy() {
+        counters.plaintextDeliveryCopies += 1;
+    }
+
     const api = {
         start,
         close,
         getStatus,
         sendPeerPlaintext,
         closePeer,
-        isPeerBackpressured
+        isPeerBackpressured,
+        recordPlaintextDeliveryCopy
     };
     return api;
 }