@torrent-tv/proxy 2.80.11 → 2.80.13

package/routes/transcode/session-file/get.js

@@ -1,4 +1,5 @@
 import { logger } from "../../../utils/logger.js";
+import { bandOf, waits } from "../../../services/priority/WaitLedger.js";
 
 /**
  * How long a request for a not-yet-produced file is held before answering with
@@ -99,7 +100,20 @@ export async function serveSessionFile(req, reply, { hlsSessionManager, sessionI
     const outcome = clientAborted
       ? "client-aborted"
       : result.kind === "ok" ? "served" : result.kind;
-    logger.info(`[hold] ${fileName} ${outcome} after ${heldMs}ms`);
+    // AGAINST THE RANK THE MAP GAVE IT. A wait is the only thing that says
+    // whether the prioritisation is being used well, and this is the one place
+    // in the proxy where a viewer is measurably waiting for a named segment.
+    // Recorded even when the segment was served at once: a run of short waits
+    // at the top rank is what "the urgent zone is being served first" looks
+    // like, and without them the table would hold only the failures.
+    const ranked = result.ranked ?? null;
+    if (ranked) {
+      waits.note(ranked.address, heldMs, ranked.rank, ranked.topRank);
+    }
+    logger.info(
+      `[hold] ${fileName} ${outcome} after ${heldMs}ms` +
+      (ranked ? ` (the map wants it ${bandOf(ranked.rank, ranked.topRank)}, rank ${ranked.rank} of ${ranked.topRank})` : "")
+    );
   }
 
   if (result.kind === "not-found") {
@@ -180,6 +194,8 @@ export async function waitForSessionFile(hlsSessionManager, sessionId, fileName,
   // this wait, and the segment the viewer wanted took 15 ms once it was asked
   // for.
   let seekEpoch = hlsSessionManager.seekEpoch(sessionId);
+  /** @type {{ address: string, rank: number, topRank: number } | null} */
+  let lastRanked = null;
   while (Date.now() - startedAt < timeoutMs) {
     const result = await hlsSessionManager.getFileStream(sessionId, fileName, {
       requestSeq,
@@ -202,9 +218,13 @@ export async function waitForSessionFile(hlsSessionManager, sessionId, fileName,
       );
       seekEpoch = hlsSessionManager.seekEpoch(sessionId);
     }
+    // The rank the map last gave this segment, so a request that runs out of
+    // patience is still counted against what it was promised. Kept across the
+    // polls because the timeout path has no result of its own.
+    lastRanked = result.ranked ?? lastRanked;
     await delay(300);
   }
-  return { kind: "warming-up" };
+  return { kind: "warming-up", ranked: lastRanked };
 }
 
 /**

package/services/encode/SegmentDemand.js

@@ -58,4 +58,38 @@ export class SegmentDemand {
   mapOn(address) {
     return this.#maps.get(address) ?? [];
   }
+
+  /**
+   * What the map says about one segment, and about the map it sits in.
+   *
+   * Asked by whoever MEASURES how well the map is being served: a wait means
+   * one thing at the top rank and another at the bottom, and telling them apart
+   * needs both the segment's own rank and the highest rank stated — a rank is a
+   * position in this map, not an absolute number.
+   *
+   * AND AN EMPTY MAP IS NOT AN ANSWER, which is why the top rank comes back even
+   * when the segment's own is zero. A top rank of zero says the map has not been
+   * built yet — a session created a moment ago, before the first pass — and that
+   * is a different thing from "nobody is coming". Conflated, every request
+   * behind the run reads as absent for as long as a fresh session has no map.
+   *
+   * @param {string} address
+   * @param {number} index
+   * @returns {{ rank: number, topRank: number }} Rank zero for a number in
+   *   nobody's zone, which is a statement: nothing is coming for it.
+   */
+  rankOf(address, index) {
+    const zones = this.mapOn(address);
+    let rank = 0;
+    let topRank = 0;
+    for (const zone of zones) {
+      if (zone.priority > topRank) {
+        topRank = zone.priority;
+      }
+      if (index >= zone.from && index <= zone.to && zone.priority > rank) {
+        rank = zone.priority;
+      }
+    }
+    return { rank, topRank };
+  }
 }

package/services/hls-session-manager.js

@@ -1563,7 +1563,11 @@ export class HlsSessionManager {
         ).catch(() => {});
       },
       viewersOf: (session) => viewersOf(session),
-      watchedBy: (session, viewer) => this.liveOutputs.watchedBy(session, viewer),
+      // WHERE THE TWO FACTS MEET, and this is the only place that holds both.
+      // Which step is on somebody's screen belongs to the person; which output
+      // a step supersedes belongs to the film's shape. Neither layer is handed
+      // the other — one gets a plain id, the other is read for one field.
+      watchedBy: (session, viewer) => !this.liveOutputs.supersededBy(session, viewer.activeVariantId ?? null),
       allowanceFor: (session) => minimumBufferFrom({
         segmentSeconds: this.segmentDurationSec,
         worstSupplyWaitSec: session.supplyFigures?.worstWaitSec
@@ -9644,6 +9648,8 @@ export class HlsSessionManager {
 
 
   #holdForProduction(session, fileName, isPlaylist, options) {
+    /** @type {{ address: string, rank: number, topRank: number } | null} */
+    let ranked = null;
     if (!isPlaylist) {
       this.#explainHold(session, fileName, "the file is not on disk");
     }
@@ -9663,20 +9669,16 @@ export class HlsSessionManager {
       // failed did the player move to the segment it actually needed — 63 s of
       // spinner after a track that had been made ready in 7.
       //
-      // WHETHER ANYBODY IS COMING FOR IT, asked of the priority map rather than
-      // measured in segments. The distance used to decide, against the reach of
-      // a repair that moved the encoder from a request — both are gone. A
-      // number inside somebody's zone will be made, so holding it is holding it
-      // for a viewer; a number in nobody's zone will not, and holding it spends
-      // the player's patience for nothing.
-      // AN EMPTY MAP IS NOT AN ANSWER. It says the map has not been built yet —
-      // a session created a moment ago, before the first pass — and that is a
-      // different thing from "nobody is coming", which is what this refusal
-      // needs. Told apart, because conflating them answers every behind-head
-      // request as absent for as long as a fresh session has no map.
-      const zones = this.encodeOrchestrator.demand.mapOn(session.outputKey ?? "");
-      const nobodyIsComing = zones.length > 0 &&
-        !zones.some((zone) => requestedIndex >= zone.from && requestedIndex <= zone.to);
+      // WHETHER ANYBODY IS COMING FOR IT, asked of the map (`SegmentDemand.rankOf`,
+      // which also tells "in nobody's zone" from "no map yet"). The same walk
+      // was written out here and could answer only yes or no, so the RANK was
+      // discarded at the one point where a viewer measurably waits for a named
+      // segment; it goes back out with the answer, because the wait is measured
+      // by whoever holds the request.
+      const address = session.outputKey ?? "";
+      const { rank, topRank } = this.encodeOrchestrator.demand.rankOf(address, requestedIndex);
+      ranked = { address, rank, topRank };
+      const nobodyIsComing = topRank > 0 && rank === 0;
       if (
         Number.isFinite(requestedIndex) &&
         requestedIndex < (earliestRunStart(session) ?? 0) &&
@@ -9687,7 +9689,7 @@ export class HlsSessionManager {
           `transcode ${session.id} segment #${requestedIndex} is ${(earliestRunStart(session) ?? 0) - requestedIndex} ` +
           "segments behind the run and in nobody's zone; answered as absent rather than held"
         );
-        return { kind: "not-found" };
+        return { kind: "not-found", ranked };
       }
       this.#ensureEncodingFor(
         session,
@@ -9695,7 +9697,7 @@ export class HlsSessionManager {
         Number.isFinite(options?.requestSeq) ? options.requestSeq : Number.MAX_SAFE_INTEGER
       );
     }
-    return { kind: "warming-up" };
+    return { kind: "warming-up", ranked };
   }
 
   /**