@streamr/dht 103.6.0-rc.0 → 103.8.0-rc.3

package/dist/exports-browser.d.ts

@@ -344,8 +344,8 @@ declare class Timestamp$Type extends MessageType<Timestamp> {
  * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
  * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
  * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
- * is required. A ProtoJSON serializer should always use UTC (as indicated by
- * "Z") when printing the Timestamp type and a ProtoJSON parser should be
+ * is required. A proto3 JSON serializer should always use UTC (as indicated by
+ * "Z") when printing the Timestamp type and a proto3 JSON parser should be
  * able to accept both UTC and other timezones (as indicated by an offset).
  *
  * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
@@ -367,18 +367,17 @@ declare class Timestamp$Type extends MessageType<Timestamp> {
  */
 interface Timestamp {
     /**
-     * Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must
-     * be between -62135596800 and 253402300799 inclusive (which corresponds to
-     * 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z).
+     * Represents seconds of UTC time since Unix epoch
+     * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+     * 9999-12-31T23:59:59Z inclusive.
      *
      * @generated from protobuf field: int64 seconds = 1
      */
     seconds: number;
     /**
-     * Non-negative fractions of a second at nanosecond resolution. This field is
-     * the nanosecond portion of the duration, not an alternative to seconds.
-     * Negative second values with fractions must still have non-negative nanos
-     * values that count forward in time. Must be between 0 and 999,999,999
+     * Non-negative fractions of a second at nanosecond resolution. Negative
+     * second values with fractions must still have non-negative nanos values
+     * that count forward in time. Must be from 0 to 999,999,999
      * inclusive.
      *
      * @generated from protobuf field: int32 nanos = 2
@@ -1319,5 +1318,11 @@ declare class Handshaker extends EventEmitter<HandshakerEvents> {
 
 declare function installWebrtcBridge(worker: Worker): void;
 
-export { ConnectionManager, ConnectionType, DataEntry, DefaultConnectorFacade, DhtCallContext, DhtNode, EXISTING_CONNECTION_TIMEOUT, LatencyType, ListeningRpcCommunicator, ManagedConnection, Message, NodeType, PeerDescriptor, PendingConnection, RoutingRpcCommunicator, RpcRemote, Simulator, SimulatorTransport, WebsocketClientConnection, areEqualPeerDescriptors, createOutgoingHandshaker, getRandomRegion, getRegionDelayMatrix, installWebrtcBridge, randomDhtAddress, toDhtAddress, toDhtAddressRaw, toNodeId };
+declare function setGapDiagnosticsEnabled(val: boolean): void;
+declare function logGapDiagnosticSampled(layer: string, opts?: {
+    detail?: Record<string, unknown>;
+    outlierThresholdMs?: number;
+}): void;
+
+export { ConnectionManager, ConnectionType, DataEntry, DefaultConnectorFacade, DhtCallContext, DhtNode, EXISTING_CONNECTION_TIMEOUT, LatencyType, ListeningRpcCommunicator, ManagedConnection, Message, NodeType, PeerDescriptor, PendingConnection, RoutingRpcCommunicator, RpcRemote, Simulator, SimulatorTransport, WebsocketClientConnection, areEqualPeerDescriptors, createOutgoingHandshaker, getRandomRegion, getRegionDelayMatrix, installWebrtcBridge, logGapDiagnosticSampled, randomDhtAddress, setGapDiagnosticsEnabled, toDhtAddress, toDhtAddressRaw, toNodeId };
 export type { ConnectionLocker, ConnectionsView, DhtAddress, DhtAddressRaw, DhtNodeEvents, DhtNodeOptions, DhtRpcOptions, IConnection, ITransport, IceServer, LockID, PortRange, RingContacts, ServiceID, TlsCertificate, TransportEvents };

package/dist/exports-browser.js

@@ -240,6 +240,68 @@ class SendFailed extends Err {
     constructor(message, originalError) { super(ErrorCode.SEND_FAILED, message, originalError); }
 }
 
+let enabled = true;
+function setGapDiagnosticsEnabled(val) {
+    enabled = val;
+    globalThis.__dhtGapDiagEnabled = val;
+}
+function isGapDiagnosticsEnabled() {
+    return enabled;
+}
+const SUMMARY_INTERVAL_MS = 2000;
+const accumulators = new Map();
+function logGapDiagnosticSampled(layer, opts = {}) {
+    if (!enabled && !globalThis.__dhtGapDiagEnabled)
+        return;
+    const now = performance.now();
+    const threshold = opts.outlierThresholdMs ?? 30;
+    let acc = accumulators.get(layer);
+    if (acc === undefined) {
+        acc = { count: 0, sumDeltaMs: 0, maxDeltaMs: 0, outlierCount: 0, lastReportMs: now, lastEventMs: now };
+        accumulators.set(layer, acc);
+        return;
+    }
+    const deltaMs = now - acc.lastEventMs;
+    acc.lastEventMs = now;
+    acc.count++;
+    if (deltaMs > acc.maxDeltaMs)
+        acc.maxDeltaMs = deltaMs;
+    acc.sumDeltaMs += deltaMs;
+    if (deltaMs > threshold)
+        acc.outlierCount++;
+    if (deltaMs > threshold) {
+        const payload = {
+            layer,
+            timestampMs: now,
+            deltaMs: +deltaMs.toFixed(2),
+            detail: opts.detail,
+        };
+        // eslint-disable-next-line no-console
+        console.log('[gap-diagnostics]', JSON.stringify(payload));
+    }
+    if (now - acc.lastReportMs >= SUMMARY_INTERVAL_MS) {
+        const summaryDetail = {
+            count: acc.count,
+            meanDeltaMs: acc.count > 0 ? +(acc.sumDeltaMs / acc.count).toFixed(2) : 0,
+            maxDeltaMs: +acc.maxDeltaMs.toFixed(2),
+            outlierCount: acc.outlierCount,
+            periodMs: +(now - acc.lastReportMs).toFixed(1),
+        };
+        const summary = {
+            layer: `${layer}.summary`,
+            timestampMs: now,
+            detail: summaryDetail,
+        };
+        // eslint-disable-next-line no-console
+        console.log('[gap-diagnostics]', JSON.stringify(summary));
+        acc.count = 0;
+        acc.sumDeltaMs = 0;
+        acc.maxDeltaMs = 0;
+        acc.outlierCount = 0;
+        acc.lastReportMs = now;
+    }
+}
+
 // @generated message type with reflection information, may provide speed optimized methods
 class Empty$Type extends MessageType {
     constructor() {
@@ -2284,6 +2346,7 @@ class ConnectionManager extends EventEmitter {
         if ((this.state === ConnectionManagerState.STOPPED || this.state === ConnectionManagerState.STOPPING) && !opts.sendIfStopped) {
             return;
         }
+        logGapDiagnosticSampled('dht.connMgr.send');
         const peerDescriptor = message.targetDescriptor;
         if (this.isConnectionToSelf(peerDescriptor)) {
             throw new CannotConnectToSelf('Cannot send to self');
@@ -2359,6 +2422,7 @@ class ConnectionManager extends EventEmitter {
             this.rpcCommunicator?.handleMessageFromPeer(message);
         }
         else {
+            logGapDiagnosticSampled('dht.connMgr.emitMessage');
             logger$A.trace('emit "message" ' + toNodeId(message.sourceDescriptor)
                 + ' ' + message.serviceId + ' ' + message.messageId);
             this.emit('message', message);
@@ -2368,6 +2432,7 @@ class ConnectionManager extends EventEmitter {
         if (this.state === ConnectionManagerState.STOPPED) {
             return;
         }
+        logGapDiagnosticSampled('dht.connMgr.onData');
         this.metrics.receiveBytesPerSecond.record(data.byteLength);
         this.metrics.receiveMessagesPerSecond.record(1);
         let message;
@@ -2801,7 +2866,7 @@ const parseVersion = (version) => {
     }
 };
 
-var version = "103.6.0-rc.0";
+var version = "103.8.0-rc.3";
 
 const logger$y = new Logger('Handshaker');
 // Optimally the Outgoing and Incoming Handshakers could be their own separate classes
@@ -3259,6 +3324,9 @@ class DirectWebrtcConnection extends EventEmitter {
     }
     send(data) {
         if (this.lastState === 'connected') {
+            logGapDiagnosticSampled('dht.dc.send', {
+                detail: { bufferedAmount: this.dataChannel.bufferedAmount, queueLen: this.messageQueue.length }
+            });
             if (this.dataChannel.bufferedAmount > this.bufferThresholdHigh) {
                 this.messageQueue.push(data);
             }
@@ -3287,6 +3355,7 @@ class DirectWebrtcConnection extends EventEmitter {
         };
         dataChannel.onmessage = (msg) => {
             logger$v.trace('dc.onmessage');
+            logGapDiagnosticSampled('dht.dc.onmessage');
             this.emit('data', new Uint8Array(msg.data));
         };
         dataChannel.onbufferedamountlow = () => {
@@ -3499,6 +3568,69 @@ function installWebrtcBridge(worker) {
  * onbufferedamountlow) fire in the worker's event loop.  The main thread
  * is never involved in the data path.
  */
+// ── agent log: layer0-vs-layer2 contention probe ────────────────────
+// Every DHT connection's datachannel `onmessage` runs in THIS one worker, and
+// `emit('data')` synchronously drives the downstream routing / RPC dispatch.
+// So timing each emit captures the per-message synchronous processing cost —
+// and aggregating across ALL connections tells us how much of the worker's
+// event loop is consumed servicing GLOBAL-DHT layer0 traffic (routing for the
+// hundreds of nodes we forward for) vs our handful of media messages. If a
+// media arrival gap coincides with a window of high non-media processing, that
+// is layer0 starving layer2. Emitted in the same `[gap-diagnostics]` line
+// shape the analyzer already parses.
+let dcWinStart = performance.now();
+let dcWinCount = 0;
+let dcWinBusyMs = 0;
+let dcWinMaxMs = 0;
+function recordDcProcessing(procMs) {
+    if (!isGapDiagnosticsEnabled() && !globalThis.__dhtGapDiagEnabled) {
+        return;
+    }
+    dcWinCount++;
+    dcWinBusyMs += procMs;
+    if (procMs > dcWinMaxMs)
+        dcWinMaxMs = procMs;
+    // Individual event for a single message whose inline processing blocked the
+    // loop unusually long (one expensive routing/RPC dispatch).
+    if (procMs > 15) {
+        try {
+            console.log('[gap-diagnostics]', JSON.stringify({
+                layer: 'dht.dc.processing.slow',
+                timestampMs: performance.now(),
+                deltaMs: +procMs.toFixed(2),
+            }));
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    const now = performance.now();
+    const winElapsed = now - dcWinStart;
+    if (winElapsed >= 1000) {
+        try {
+            console.log('[gap-diagnostics]', JSON.stringify({
+                layer: 'dht.dc.processing.window',
+                timestampMs: now,
+                detail: {
+                    windowMs: +winElapsed.toFixed(0),
+                    count: dcWinCount,
+                    msgPerSec: +((dcWinCount / winElapsed) * 1000).toFixed(0),
+                    busyMs: +dcWinBusyMs.toFixed(1),
+                    occupancyPct: +((dcWinBusyMs / winElapsed) *
+                        100).toFixed(1),
+                    maxMs: +dcWinMaxMs.toFixed(1),
+                },
+            }));
+        }
+        catch {
+            /* ignore */
+        }
+        dcWinStart = now;
+        dcWinCount = 0;
+        dcWinBusyMs = 0;
+        dcWinMaxMs = 0;
+    }
+}
 // ── Module-level bridge client (initialized once per worker) ────────
 let resolveBridgeProxy;
 const bridgeProxyPromise = new Promise((resolve) => {
@@ -3541,6 +3673,19 @@ class WorkerWebrtcConnection extends EventEmitter {
     earlyTimeout;
     messageQueue = [];
     startPromise;
+    // agent log: PER-CONNECTION datachannel receive cadence. The global
+    // `dht.dc.onmessage` accumulator can't isolate one stream; this tracks
+    // inter-message arrival on THIS connection so we can pick the connection
+    // carrying the composite media (highest count/bytes) and compare its
+    // datachannel-level gaps against messageArrival (post-routing) and
+    // videoFrameArrival (post-decrypt) — i.e. localize WHERE the gap is born.
+    lastRecvMs;
+    recvWinStart = 0;
+    recvCount = 0;
+    recvSumDelta = 0;
+    recvMaxDelta = 0;
+    recvBytes = 0;
+    recvMaxBytes = 0;
     constructor(params) {
         super();
         this.connectionId = createRandomConnectionId();
@@ -3581,7 +3726,7 @@ class WorkerWebrtcConnection extends EventEmitter {
                 if (state === DisconnectedState.CLOSED ||
                     state === DisconnectedState.DISCONNECTED ||
                     state === DisconnectedState.FAILED) {
-                    this.doClose(false);
+                    this.doClose(false, `pcState=${state}`);
                 }
             },
             onDataChannel: (channel) => {
@@ -3634,6 +3779,9 @@ class WorkerWebrtcConnection extends EventEmitter {
     }
     send(data) {
         if (this.connected && this.dataChannel) {
+            logGapDiagnosticSampled('dht.dc.send', {
+                detail: { bufferedAmount: this.dataChannel.bufferedAmount, queueLen: this.messageQueue.length }
+            });
             if (this.dataChannel.bufferedAmount > this.bufferThresholdHigh) {
                 this.messageQueue.push(data);
             }
@@ -3653,6 +3801,62 @@ class WorkerWebrtcConnection extends EventEmitter {
         }
     }
     // ── DataChannel handling (runs entirely in the worker) ──────
+    recordRecv(bytes) {
+        if (!isGapDiagnosticsEnabled() && !globalThis.__dhtGapDiagEnabled) {
+            return;
+        }
+        const now = performance.now();
+        const conn = String(this.connectionId).slice(0, 8);
+        if (this.lastRecvMs !== undefined) {
+            const delta = now - this.lastRecvMs;
+            this.recvSumDelta += delta;
+            if (delta > this.recvMaxDelta)
+                this.recvMaxDelta = delta;
+            if (delta > 60) {
+                try {
+                    console.log('[gap-diagnostics]', JSON.stringify({
+                        layer: 'dht.dc.recvGap',
+                        timestampMs: now,
+                        deltaMs: +delta.toFixed(1),
+                        detail: { conn, bytes },
+                    }));
+                }
+                catch (_e) { /* ignore */ }
+            }
+        }
+        this.lastRecvMs = now;
+        this.recvCount++;
+        this.recvBytes += bytes;
+        if (bytes > this.recvMaxBytes)
+            this.recvMaxBytes = bytes;
+        if (this.recvWinStart === 0)
+            this.recvWinStart = now;
+        const elapsed = now - this.recvWinStart;
+        if (elapsed >= 1000) {
+            try {
+                console.log('[gap-diagnostics]', JSON.stringify({
+                    layer: 'dht.dc.recv',
+                    timestampMs: now,
+                    detail: {
+                        conn,
+                        count: this.recvCount,
+                        perSec: Math.round((this.recvCount / elapsed) * 1000),
+                        meanMs: +(this.recvSumDelta / Math.max(1, this.recvCount)).toFixed(1),
+                        maxMs: +this.recvMaxDelta.toFixed(1),
+                        bytesPerSec: Math.round((this.recvBytes / elapsed) * 1000),
+                        maxBytes: this.recvMaxBytes,
+                    },
+                }));
+            }
+            catch (_e) { /* ignore */ }
+            this.recvWinStart = now;
+            this.recvCount = 0;
+            this.recvSumDelta = 0;
+            this.recvMaxDelta = 0;
+            this.recvBytes = 0;
+            this.recvMaxBytes = 0;
+        }
+    }
     setupDataChannel(dataChannel) {
         this.dataChannel = dataChannel;
         this.dataChannel.binaryType = 'arraybuffer';
@@ -3663,14 +3867,18 @@ class WorkerWebrtcConnection extends EventEmitter {
         };
         dataChannel.onclose = () => {
             logger$u.trace('dc.onClosed (worker)');
-            this.doClose(false);
+            this.doClose(false, 'dataChannel.onclose');
         };
         dataChannel.onerror = (err) => {
             logger$u.warn('Data channel error (worker)', { err });
         };
         dataChannel.onmessage = (msg) => {
             logger$u.trace('dc.onmessage (worker)');
+            logGapDiagnosticSampled('dht.dc.onmessage');
+            this.recordRecv(msg.data instanceof ArrayBuffer ? msg.data.byteLength : 0);
+            const t0 = performance.now();
             this.emit('data', new Uint8Array(msg.data));
+            recordDcProcessing(performance.now() - t0);
         };
         dataChannel.onbufferedamountlow = () => {
             logger$u.trace('dc.onBufferedAmountLow (worker)');
@@ -5939,7 +6147,7 @@ class PeerDiscovery {
             logger$d.debug(`Ring join on ${this.options.serviceId} timed out`);
         }
         finally {
-            sessions.forEach((session) => this.ongoingDiscoverySessions.delete(session.id));
+            sessions.forEach((session) => this.ongoingRingDiscoverySessions.delete(session.id));
         }
     }
     async rejoinDht(entryPoint, contactedPeers = new Set(), distantJoinContactPeers = new Set()) {
@@ -8036,5 +8244,5 @@ class SimulatorTransport extends ConnectionManager {
     }
 }
 
-export { ConnectionManager, ConnectionType, DataEntry, DefaultConnectorFacade, DhtCallContext, DhtNode, EXISTING_CONNECTION_TIMEOUT, LatencyType, ListeningRpcCommunicator, ManagedConnection, Message, NodeType, PeerDescriptor, PendingConnection, RoutingRpcCommunicator, RpcRemote, Simulator, SimulatorTransport, WebsocketClientConnection, areEqualPeerDescriptors, createOutgoingHandshaker, getRandomRegion, getRegionDelayMatrix, installWebrtcBridge, randomDhtAddress, toDhtAddress, toDhtAddressRaw, toNodeId };
+export { ConnectionManager, ConnectionType, DataEntry, DefaultConnectorFacade, DhtCallContext, DhtNode, EXISTING_CONNECTION_TIMEOUT, LatencyType, ListeningRpcCommunicator, ManagedConnection, Message, NodeType, PeerDescriptor, PendingConnection, RoutingRpcCommunicator, RpcRemote, Simulator, SimulatorTransport, WebsocketClientConnection, areEqualPeerDescriptors, createOutgoingHandshaker, getRandomRegion, getRegionDelayMatrix, installWebrtcBridge, logGapDiagnosticSampled, randomDhtAddress, setGapDiagnosticsEnabled, toDhtAddress, toDhtAddressRaw, toNodeId };
 //# sourceMappingURL=exports-browser.js.map