@torrent-tv/proxy 2.104.0 → 2.104.2

package/package.json

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

package/services/torrent/torrent-pool.js

@@ -1520,6 +1520,11 @@ export class TorrentPool {
       const context = this.#waitTraceByTorrent.get(torrent);
       if (context?.trace === true) context.emitWaitTrace?.(context.sourceKey, process, phase, fields);
     };
+    if (waitTrace?.trace === true) {
+      // WebTorrent assigns the store during _onStore, after client.add first
+      // returns. Revisit this hook when its ready callback calls us.
+      tracePieceStorePut(pieceStoreOf(torrent), trace);
+    }
     const pool = this;
     const wrap = (method, process) => {
       const original = torrent[method];
@@ -1564,16 +1569,28 @@ export class TorrentPool {
       this.#waitTraceHooks.add(torrent);
       wrap("_startDiscovery", "W2");
       wrap("_onStore", "W6");
-      tracePieceStorePut(pieceStoreOf(torrent), trace);
       const verify = torrent._verifyPieces;
       if (typeof verify === "function") {
         torrent._verifyPieces = function (callback, ...args) {
           const startedAt = performance.now();
           trace("W5", "begin", { startedAt });
-          return verify.call(this, (...results) => {
-            trace("W5", "end", { startedAt, endedAt: performance.now(), outcome: "verified" });
-            callback?.(...results);
-          }, ...args);
+          let finished = false;
+          const finish = (outcome, fields = {}) => {
+            if (finished) return;
+            finished = true;
+            const endedAt = performance.now();
+            trace("W5", "end", { startedAt, endedAt, durationMs: endedAt - startedAt, outcome, ...fields });
+          };
+          try {
+            return verify.call(this, (...results) => {
+              const error = results[0];
+              finish(error ? "error" : "verified", error ? { error: String(error?.message ?? error) } : {});
+              callback?.(...results);
+            }, ...args);
+          } catch (error) {
+            finish("error", { error: String(error?.message ?? error) });
+            throw error;
+          }
         };
       }
       const timing = this.#swarmTimingByTorrent.get(torrent);

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

@@ -1,7 +1,9 @@
 /** Record the torrent worker's verified-piece storage write without changing its callback API. */
+const tracedStores = new WeakSet();
+
 export function tracePieceStorePut(store, trace, now = () => performance.now()) {
   const put = store?.put;
-  if (typeof put !== "function") return false;
+  if (!store || tracedStores.has(store) || typeof put !== "function") return false;
 
   store.put = function (index, bytes, callback) {
     const startedAt = now();
@@ -24,5 +26,6 @@ export function tracePieceStorePut(store, trace, now = () => performance.now())
       throw error;
     }
   };
+  tracedStores.add(store);
   return true;
 }

package/services/torrent/worker/worker.js

@@ -494,46 +494,63 @@ async function runCommand(command, params, id) {
       const statsStartedAt = performance.now();
       emitWaitTrace(params.sourceKey, "W10", "begin", { startedAt: statsStartedAt,
         fileIndex: params.fileIndex, forecast: params.forecast === true });
-      const torrent = await knownTorrent(params.sourceKey);
-      if (!torrent) {
-        const whole = wholeSources.fileOf(params.sourceKey, params.fileIndex);
-        emitWaitTrace(params.sourceKey, "W10", "end", { startedAt: statsStartedAt,
-          endedAt: performance.now(), outcome: whole ? "whole-file" : "pending", fileIndex: params.fileIndex });
-        return whole ? wholeFileStats(whole.length) : { pending: true };
-      }
-      // What this file's own interruptions demand, measured by the reader in
-      // this thread. It travels with the stats because the caller asking for
-      // them is the one that has to decide with them — the browser's smallest
-      // safe buffer, and the speed a quality step must sustain. Null until a
-      // second interruption has been seen: one wait shows no interval, and an
-      // interval invented from one point is exactly what this work removes.
-      const file = Array.isArray(torrent?.files) ? torrent.files[params.fileIndex] : null;
-      const forecastAt = performance.now();
-      const forecast = file && params.forecast === true ? downloadForecastOf(torrent) : null;
-      const forecastMs = params.forecast === true ? performance.now() - forecastAt : 0;
-      const stats = pool.getFileStats(torrent, params.fileIndex);
-      const ranges = [];
-      if (forecast) for (const [piece, availableAt] of forecast.arrivals) {
-        const start = piece * torrent.pieceLength;
-        const end = Math.min(torrent.length, (piece + 1) * torrent.pieceLength);
-        if (end > start) ranges.push({ start, end, availableAt });
-      }
-      emitWaitTrace(params.sourceKey, "W10", "end", { startedAt: statsStartedAt,
-        endedAt: performance.now(), outcome: "ok", fileIndex: params.fileIndex,
-        forecast: params.forecast === true });
-      return {
-        ...stats,
-        ...(params.forecast === true ? { downloadForecast: {
-          measuredAt: forecast?.measuredAt ?? Date.now(), global: true, ranges
-        } } : {}),
-        supply: supplyFiguresFor(torrent?.infoHash, file?.name, params.segmentSeconds ?? 4),
-        // How long this answer waited for the arrival forecast, which the
-        // caller says beside its own time (ViewerRequests, torrent-tv/meta#178).
-        forecastMs
+      const finishStatsTrace = (outcome, fields = {}) => {
+        const endedAt = performance.now();
+        emitWaitTrace(params.sourceKey, "W10", "end", { startedAt: statsStartedAt, endedAt,
+          durationMs: endedAt - statsStartedAt, outcome, fileIndex: params.fileIndex, ...fields });
       };
+      try {
+        const torrent = await knownTorrent(params.sourceKey);
+        if (!torrent) {
+          const whole = wholeSources.fileOf(params.sourceKey, params.fileIndex);
+          finishStatsTrace(whole ? "whole-file" : "pending");
+          return whole ? wholeFileStats(whole.length) : { pending: true };
+        }
+        // What this file's own interruptions demand, measured by the reader in
+        // this thread. It travels with the stats because the caller asking for
+        // them is the one that has to decide with them — the browser's smallest
+        // safe buffer, and the speed a quality step must sustain. Null until a
+        // second interruption has been seen: one wait shows no interval, and an
+        // interval invented from one point is exactly what this work removes.
+        const file = Array.isArray(torrent?.files) ? torrent.files[params.fileIndex] : null;
+        const forecastAt = performance.now();
+        const forecast = file && params.forecast === true ? downloadForecastOf(torrent) : null;
+        const forecastMs = params.forecast === true ? performance.now() - forecastAt : 0;
+        const stats = pool.getFileStats(torrent, params.fileIndex);
+        const ranges = [];
+        if (forecast) for (const [piece, availableAt] of forecast.arrivals) {
+          const start = piece * torrent.pieceLength;
+          const end = Math.min(torrent.length, (piece + 1) * torrent.pieceLength);
+          if (end > start) ranges.push({ start, end, availableAt });
+        }
+        finishStatsTrace("ok", { forecast: params.forecast === true });
+        return {
+          ...stats,
+          ...(params.forecast === true ? { downloadForecast: {
+            measuredAt: forecast?.measuredAt ?? Date.now(), global: true, ranges
+          } } : {}),
+          supply: supplyFiguresFor(torrent?.infoHash, file?.name, params.segmentSeconds ?? 4),
+          // How long this answer waited for the arrival forecast, which the
+          // caller says beside its own time (ViewerRequests, torrent-tv/meta#178).
+          forecastMs
+        };
+      } catch (error) {
+        finishStatsTrace("error", { error: String(error?.message ?? error) });
+        throw error;
+      }
     }
 
     case Command.PRIORITY_MAP: {
+      const startedAt = performance.now();
+      emitWaitTrace(params.sourceKey, "W7", "begin", { startedAt, fileIndex: params.fileIndex });
+      let traceFinished = false;
+      const finishPriorityTrace = (outcome, fields = {}) => {
+        if (traceFinished) return;
+        traceFinished = true;
+        const endedAt = performance.now();
+        emitWaitTrace(params.sourceKey, "W7", "end", { startedAt, endedAt,
+          durationMs: endedAt - startedAt, outcome, fileIndex: params.fileIndex, ...fields });
+      };
       // When this handler began, on the clock the main thread posted by: the
       // post to here holds the transfer and this thread's queue together
       // (torrent-tv/meta#177).
@@ -542,20 +559,23 @@ async function runCommand(command, params, id) {
       // only update an existing source, never revive one after its viewer left.
       const zones = Array.isArray(params.zones) ? params.zones : [];
       // Nor may one for a file held whole, which has nothing left to fetch.
-      const torrent = await knownTorrent(params.sourceKey);
-      if (!torrent) {
-        return { appliedMs: null, receivedAt, repliedAt: performance.timeOrigin + performance.now() };
+      try {
+        const torrent = await knownTorrent(params.sourceKey);
+        if (!torrent) {
+          finishPriorityTrace("source-not-ready");
+          return { appliedMs: null, receivedAt, repliedAt: performance.timeOrigin + performance.now() };
+        }
+        // What applying a map costs this thread, told to whoever sent it: every
+        // zone becomes a window of the register and the swarm is told again
+        // (torrent-tv/meta#166).
+        ensureArrivalsWired(params.sourceKey, torrent);
+        pool.applyPriorityMap(torrent, params.fileIndex, zones, params.durationSeconds);
+        torrent.emit("priority-map-changed", params.fileIndex);
+        finishPriorityTrace("applied");
+      } catch (error) {
+        finishPriorityTrace("error", { error: String(error?.message ?? error) });
+        throw error;
       }
-      // What applying a map costs this thread, told to whoever sent it: every
-      // zone becomes a window of the register and the swarm is told again
-      // (torrent-tv/meta#166).
-      const startedAt = performance.now();
-      emitWaitTrace(params.sourceKey, "W7", "begin", { fileIndex: params.fileIndex });
-      ensureArrivalsWired(params.sourceKey, torrent);
-      pool.applyPriorityMap(torrent, params.fileIndex, zones, params.durationSeconds);
-      torrent.emit("priority-map-changed", params.fileIndex);
-      emitWaitTrace(params.sourceKey, "W7", "end", { startedAt, endedAt: performance.now(),
-        fileIndex: params.fileIndex });
       return { appliedMs: performance.now() - startedAt, receivedAt, repliedAt: performance.timeOrigin + performance.now() };
     }