@torrent-tv/proxy 2.102.4 → 2.104.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.102.4",
+  "version": "2.104.0",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

package/services/torrent/torrent-pool.js

@@ -26,6 +26,8 @@ import { deriveSourceKey } from "../../utils/torrent-source-key.js";
 import { noteTorrentDestroyed } from "./destroyed-torrents.js";
 import { PieceTimings, describePieceTiming } from "./piece-timing.js";
 import { TailRepeat } from "./worker/tail-repeat.js";
+import { tracePieceStorePut } from "./worker/trace-piece-store-put.js";
+import { beginSwarmLifecycleTrace, noteSwarmDiscovery, noteSwarmMetadata, noteSwarmPeer } from "./worker/trace-swarm-lifecycle.js";
 
 /**
  * The second-peer requests for the last blocks of a piece somebody waits for,
@@ -966,7 +968,8 @@ export class TorrentPool {
   /**
    * When each torrent was added, and when its first peer connected.
    *
-   * @type {WeakMap<import("webtorrent").Torrent, { addedAt: number, firstPeerAt: number | null }>}
+   * @type {WeakMap<import("webtorrent").Torrent, { addedAt: number, addedAtMonotonic: number, firstPeerAt: number | null,
+   *   firstPeerAtMonotonic: number | null, metadataWaitStartedAt: number | null }>}
    */
   #swarmTimingByTorrent = new WeakMap();
   #waitTraceByTorrent = new WeakMap();
@@ -1508,10 +1511,16 @@ export class TorrentPool {
     if (waitTrace?.trace === true && typeof waitTrace.sourceKey === "string") {
       this.#waitTraceByTorrent.set(torrent, waitTrace);
     }
+    const alreadyTracked = this.#swarmTimingByTorrent.has(torrent);
+    if (!alreadyTracked) {
+      this.#swarmTimingByTorrent.set(torrent, { addedAt: Date.now(), addedAtMonotonic: performance.now(),
+        firstPeerAt: null, firstPeerAtMonotonic: null, peerWaitStartedAt: null, metadataWaitStartedAt: null });
+    }
     const trace = (process, phase, fields = {}) => {
       const context = this.#waitTraceByTorrent.get(torrent);
       if (context?.trace === true) context.emitWaitTrace?.(context.sourceKey, process, phase, fields);
     };
+    const pool = this;
     const wrap = (method, process) => {
       const original = torrent[method];
       if (typeof original !== "function") return;
@@ -1520,20 +1529,32 @@ export class TorrentPool {
         trace(process, "begin", { startedAt });
         try {
           const result = original.apply(this, args);
+          const noteDiscoveryEnd = () => {
+            if (process === "W2" && result !== false) {
+              const timing = pool.#swarmTimingByTorrent.get(torrent);
+              if (timing) noteSwarmDiscovery(timing, trace, performance.now());
+            }
+          };
           if (result && typeof result.then === "function") {
             return result.then(value => {
-              trace(process, "end", { startedAt, endedAt: performance.now(), outcome: "resolved" });
+              noteDiscoveryEnd();
+              const endedAt = performance.now();
+              trace(process, "end", { startedAt, endedAt, durationMs: endedAt - startedAt, outcome: "resolved" });
               return value;
             }, error => {
-              trace(process, "end", { startedAt, endedAt: performance.now(), outcome: "error",
+              const endedAt = performance.now();
+              trace(process, "end", { startedAt, endedAt, durationMs: endedAt - startedAt, outcome: "error",
                 error: String(error?.message ?? error) });
               throw error;
             });
           }
-          trace(process, "end", { startedAt, endedAt: performance.now(), outcome: "returned" });
+          noteDiscoveryEnd();
+          const endedAt = performance.now();
+          trace(process, "end", { startedAt, endedAt, durationMs: endedAt - startedAt, outcome: "returned" });
           return result;
         } catch (error) {
-          trace(process, "end", { startedAt, endedAt: performance.now(), outcome: "error",
+          const endedAt = performance.now();
+          trace(process, "end", { startedAt, endedAt, durationMs: endedAt - startedAt, outcome: "error",
             error: String(error?.message ?? error) });
           throw error;
         }
@@ -1541,9 +1562,9 @@ export class TorrentPool {
     };
     if (waitTrace?.trace === true && !this.#waitTraceHooks.has(torrent)) {
       this.#waitTraceHooks.add(torrent);
-      wrap("_onListening", "W1");
       wrap("_startDiscovery", "W2");
       wrap("_onStore", "W6");
+      tracePieceStorePut(pieceStoreOf(torrent), trace);
       const verify = torrent._verifyPieces;
       if (typeof verify === "function") {
         torrent._verifyPieces = function (callback, ...args) {
@@ -1555,8 +1576,17 @@ export class TorrentPool {
           }, ...args);
         };
       }
-      torrent.on("metadata", metadata => trace("W4", "event", { files: metadata?.files?.length ?? null }));
-      torrent.on("wire", wire => trace("W3", "event", { peer: String(wire?.remoteAddress ?? "?") }));
+      const timing = this.#swarmTimingByTorrent.get(torrent);
+      if (timing) beginSwarmLifecycleTrace(timing, trace, Boolean(torrent.metadata));
+      torrent.on("metadata", metadata => {
+        const current = this.#swarmTimingByTorrent.get(torrent);
+        if (current) noteSwarmMetadata(current, trace, metadata?.files?.length ?? null);
+      });
+      torrent.on("wire", wire => {
+        trace("W3", "event", { peer: String(wire?.remoteAddress ?? "?") });
+        const current = this.#swarmTimingByTorrent.get(torrent);
+        if (current) noteSwarmPeer(current, trace, Boolean(torrent.metadata));
+      });
     }
     // Attached ONCE per torrent. WebTorrent answers a duplicate add by handing
     // back the torrent it already has, and this used to run again on it: a
@@ -1567,7 +1597,7 @@ export class TorrentPool {
     // once as a .torrent and once as a magnet is exactly that case, and the
     // roadmap already records it happening. Trace hooks above are installed
     // separately and only for an explicitly traced source.
-    if (this.#swarmTimingByTorrent.has(torrent)) {
+    if (alreadyTracked) {
       return;
     }
     // A torrent nobody has asked for yet does not exist: this is called the
@@ -1588,9 +1618,6 @@ export class TorrentPool {
     // for the whole life of the torrent, which is the same fault as three
     // different hashes with the hash removed.
     const label = () => String(torrent.infoHash ?? "?").slice(0, 8);
-    const addedAt = Date.now();
-    this.#swarmTimingByTorrent.set(torrent, { addedAt, firstPeerAt: null });
-
     torrent.on("download-request-cancelled", ({ piece, offset, length, reason, requestId }) => {
       logger.info(`download request=${requestId ?? `${torrent.infoHash ?? "unknown"}:${piece}:${offset}`} cancel bytes=${length} reason=${reason}`);
     });
@@ -1655,6 +1682,7 @@ export class TorrentPool {
         return;
       }
       timing.firstPeerAt = Date.now();
+      timing.firstPeerAtMonotonic ??= performance.now();
       const waited = secondsToFirstPeer(timing.addedAt, timing.firstPeerAt);
       const byTracker = this.#lastAnnounceByTorrent.get(torrent);
       const offered = bestAnnounce(byTracker ? byTracker.values() : []);

package/services/torrent/worker/trace-piece-store-put.js

@@ -0,0 +1,28 @@
+/** Record the torrent worker's verified-piece storage write without changing its callback API. */
+export function tracePieceStorePut(store, trace, now = () => performance.now()) {
+  const put = store?.put;
+  if (typeof put !== "function") return false;
+
+  store.put = function (index, bytes, callback) {
+    const startedAt = now();
+    const fields = { piece: index, bytes: bytes?.byteLength ?? bytes?.length ?? null, startedAt };
+    trace("W9", "begin", fields);
+    let finished = false;
+    const finish = error => {
+      if (finished) return;
+      finished = true;
+      const endedAt = now();
+      trace("W9", "end", { ...fields, endedAt, durationMs: endedAt - startedAt,
+        outcome: error ? "error" : "stored", ...(error ? { error: String(error?.message ?? error) } : {}) });
+      callback?.(error);
+    };
+
+    try {
+      return put.call(this, index, bytes, finish);
+    } catch (error) {
+      finish(error);
+      throw error;
+    }
+  };
+  return true;
+}

package/services/torrent/worker/trace-swarm-lifecycle.js

@@ -0,0 +1,49 @@
+/** Record first-peer and metadata waits on the torrent worker's monotonic clock. */
+export function beginSwarmLifecycleTrace(timing, trace, metadataAvailable, now = () => performance.now()) {
+  if (timing.firstPeerAtMonotonic !== null) {
+    trace("W3", "event", { outcome: "peer-already-connected" });
+  } else if (timing.peerWaitStartedAt !== null) {
+    trace("W3", "begin", { startedAt: timing.peerWaitStartedAt });
+  }
+
+  if (metadataAvailable) {
+    trace("W4", "event", { outcome: "already-available" });
+  } else if (timing.firstPeerAtMonotonic !== null) {
+    timing.metadataWaitStartedAt = now();
+    trace("W4", "begin", { startedAt: timing.metadataWaitStartedAt });
+  }
+}
+
+export function noteSwarmDiscovery(timing, trace, endedAt) {
+  if (timing.firstPeerAtMonotonic !== null || timing.peerWaitStartedAt !== null) return;
+  timing.peerWaitStartedAt = endedAt;
+  trace("W3", "begin", { startedAt: endedAt });
+}
+
+export function noteSwarmPeer(timing, trace, metadataAvailable, now = () => performance.now()) {
+  if (timing.firstPeerAtMonotonic !== null) return;
+  const endedAt = now();
+  timing.firstPeerAtMonotonic = endedAt;
+  if (timing.peerWaitStartedAt !== null) {
+    trace("W3", "end", { startedAt: timing.peerWaitStartedAt, endedAt,
+      durationMs: endedAt - timing.peerWaitStartedAt, outcome: "peer-connected" });
+  } else {
+    trace("W3", "event", { outcome: "peer-connected-before-trace" });
+  }
+  if (!metadataAvailable) {
+    timing.metadataWaitStartedAt = endedAt;
+    trace("W4", "begin", { startedAt: endedAt });
+  }
+}
+
+export function noteSwarmMetadata(timing, trace, files, now = () => performance.now()) {
+  const endedAt = now();
+  if (timing.metadataWaitStartedAt !== null) {
+    const startedAt = timing.metadataWaitStartedAt;
+    timing.metadataWaitStartedAt = null;
+    trace("W4", "end", { startedAt, endedAt, durationMs: endedAt - startedAt,
+      outcome: "available", files });
+  } else {
+    trace("W4", "event", { outcome: "available", files });
+  }
+}

package/services/torrent/worker/worker.js

@@ -345,8 +345,10 @@ async function runCommand(command, params, id) {
       // Reusing the same promise for a repeated add also collapses two callers
       // racing to open the same torrent into one.
       let pending = torrentsByKey.get(params.sourceKey);
+      let addStartedAt = null;
       if (!pending) {
-        emitWaitTrace(params.sourceKey, "W1", "event", { moment: "add-request" });
+        addStartedAt = performance.now();
+        emitWaitTrace(params.sourceKey, "W1", "begin", { startedAt: addStartedAt, moment: "add-request" });
         pending = pool.getTorrent(params.sourceType, params.source, {
           sourceKey: params.sourceKey, trace: params.trace === true, emitWaitTrace
         });
@@ -366,7 +368,22 @@ async function runCommand(command, params, id) {
       // empty list, and rebuilding it here would bring it back on every stream
       // and stats request, which all come through this command. Any other
       // destroyed torrent is rebuilt, because its files still need it.
-      const added = await pending;
+      let added;
+      try {
+        added = await pending;
+        if (params.trace === true && addStartedAt !== null) {
+          const endedAt = performance.now();
+          emitWaitTrace(params.sourceKey, "W1", "end", { endedAt, durationMs: endedAt - addStartedAt,
+            outcome: "ready" });
+        }
+      } catch (error) {
+        if (params.trace === true && addStartedAt !== null) {
+          const endedAt = performance.now();
+          emitWaitTrace(params.sourceKey, "W1", "end", { endedAt, durationMs: endedAt - addStartedAt,
+            outcome: "error", error: String(error?.message ?? error) });
+        }
+        throw error;
+      }
       const described = isUsableTorrentHandle(added) ? null : wholeSources.describe(params.sourceKey);
       if (described) {
         announceWholeFiles(params.sourceKey, described);