@torrent-tv/proxy 2.102.3 → 2.103.0

package/package.json

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

package/services/torrent/piece-timing.js

@@ -38,6 +38,7 @@ export class PieceTimings {
    */
   asked(piece, offset, peer, now) {
     let record = this.#pieces.get(piece);
+    const firstAsk = !record;
     if (!record) {
       record = { firstAskAt: now, asks: 0, peers: new Set(), blocks: new Map(), arrived: new Set(), askedAgain: 0, arrivedTwice: 0,
         slowestMs: 0, slowestPeer: null, lastInFlightMs: 0, lastPeer: null };
@@ -47,6 +48,7 @@ export class PieceTimings {
     record.peers.add(peer);
     if (!record.blocks.has(offset)) record.blocks.set(offset, now);
     else record.askedAgain += 1;
+    return firstAsk;
   }
 
   /**

package/services/torrent/torrent-pool.js

@@ -26,6 +26,7 @@ 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";
 
 /**
  * The second-peer requests for the last blocks of a piece somebody waits for,
@@ -1544,6 +1545,7 @@ export class TorrentPool {
       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) {
@@ -1603,6 +1605,7 @@ export class TorrentPool {
     // its blocks were in flight, and from whom (`piece-timing.js`). One line
     // per piece: a 2.3 GB film is 563.
     const timings = new PieceTimings();
+    const waitTracePieceStarts = new Map();
     tailRepeats.set(torrent, new TailRepeat({ torrent, requiredPieces: () => demandFor(torrent).selection.requiredPieces(),
       log: (line) => logger.info(`download ${label()} ${line}`) }));
     torrent.on("wire", (wire) => {
@@ -1616,9 +1619,13 @@ export class TorrentPool {
         const queued = this.requests.length;
         const answer = request.call(this, index, offset, length, callback);
         if (this.requests.length > queued) {
-          trace("W8", "event", { moment: "block-requested", piece: index, offset, length, peer });
           const now = Date.now();
-          timings.asked(index, offset, peer, now);
+          const firstAsk = timings.asked(index, offset, peer, now);
+          if (firstAsk) {
+            const startedAt = performance.now();
+            waitTracePieceStarts.set(index, startedAt);
+            trace("W8", "begin", { piece: index, startedAt, firstOffset: offset, blockLength: length });
+          }
           // When this wire was asked for the block: how long it has held it is
           // what decides whether a second peer is asked (`duplicateTailFor`).
           this.requests.at(-1).askedAt = now;
@@ -1627,11 +1634,19 @@ export class TorrentPool {
       };
       wire.on("piece", (index, offset) => {
         timings.arrived(index, offset, peer, Date.now());
-        trace("W8", "event", { moment: "block-received", piece: index, offset, peer });
       });
     });
     torrent.on("verified", (piece) => {
-      logger.info(`download ${label()} verified piece=${piece}${describePieceTiming(timings.verified(piece, Date.now()))}`);
+      const pieceTiming = timings.verified(piece, Date.now());
+      const startedAt = waitTracePieceStarts.get(piece);
+      if (startedAt !== undefined) {
+        waitTracePieceStarts.delete(piece);
+        const endedAt = performance.now();
+        trace("W8", "end", { piece, startedAt, endedAt, durationMs: endedAt - startedAt,
+          outcome: "verified", asks: pieceTiming?.asks ?? null, peers: pieceTiming?.peers ?? null,
+          askedAgain: pieceTiming?.askedAgain ?? null, slowestBlockMs: pieceTiming?.slowestMs ?? null });
+      }
+      logger.info(`download ${label()} verified piece=${piece}${describePieceTiming(pieceTiming)}`);
     });
 
     // The first connected peer, said once, because the wait for it can BE the

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;
+}