@torrent-tv/proxy 2.105.13 → 2.106.0

package/package.json

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

package/routes/api/playback-plan/post.js

@@ -24,7 +24,7 @@ function getPayload(body) {
   return {};
 }
 
-export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, sourceRegistry, torrentPool, ffmpegBin, localBaseUrl, viewers }) {
+export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, sourceRegistry, torrentPool, ffmpegBin, localBaseUrl, viewers, observeWait }) {
   const payload = getPayload(req.body);
   const sourceKey = typeof payload.sourceKey === "string" ? payload.sourceKey.trim() : "";
   const fileIndex = Number(payload.fileIndex);
@@ -38,10 +38,13 @@ export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, s
   if (typeof payload.positionSeconds === "number" && Number.isFinite(payload.positionSeconds) && payload.positionSeconds >= 0) selection.positionSeconds = payload.positionSeconds;
   if (typeof payload.wantsToPlay === "boolean") selection.wantsToPlay = payload.wantsToPlay;
   if (consumerId) viewers?.selectsFile(consumerId, sourceKey, fileIndex, Date.now(), selection);
+  const startedAt = performance.now();
 
   // Interface delegates to PlaybackController (orchestrator + domain). Keeps route thin.
   const { PlaybackController } = await import("../../../services/server/controllers/PlaybackController.js");
   const controller = new PlaybackController({ torrentPool, sourceRegistry, ffmpegBin, localBaseUrl, playbackPlanner });
+  const waitFields = { process: "P3", sourceKey, fileIndex };
+  observeWait?.(sourceKey, "process", { ...waitFields, phase: "begin", at: startedAt });
   const cancellation = new AbortController();
   const aborted = () => cancellation.abort();
   const closed = () => { if (!reply.raw?.writableEnded) aborted(); };
@@ -52,8 +55,14 @@ export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, s
     const params = { sourceKey, fileIndex, userAgent };
     const plan = payload.waitForReady === true
       ? await controller.getReadyPlan(params, { signal: cancellation.signal }) : await controller.getPlan(params);
+    const endedAt = performance.now();
+    observeWait?.(sourceKey, "process", { ...waitFields, phase: "end", at: endedAt, startedAt,
+      endedAt, durationMs: endedAt - startedAt, outcome: "plan-ready" });
     return reply.send(plan);
   } catch (error) {
+    const endedAt = performance.now();
+    observeWait?.(sourceKey, "process", { ...waitFields, phase: "end", at: endedAt, startedAt,
+      endedAt, durationMs: endedAt - startedAt, outcome: cancellation.signal.aborted ? "cancelled" : "error" });
     if (cancellation.signal.aborted) return;
     if (error instanceof Error && error.code === "SOURCE_NOT_FOUND") {
       return reply.code(404).send({ error: error.message });

package/server.js

@@ -1614,7 +1614,8 @@ export async function startProxyServer({
     handleApiClientLogsPost(req, reply, { clientLogs, viewerRequests: outputParts.viewerRequests })
   );
   app.post("/api/playback-plan", async (req, reply) =>
-    handleApiPlaybackPlanPost(req, reply, { playbackPlanner, viewers: outputParts.viewers })
+    handleApiPlaybackPlanPost(req, reply, { playbackPlanner, viewers: outputParts.viewers,
+      observeWait: (sourceKey, event, fields) => waitTrace.source(sourceKey, event, fields) })
   );
   app.post("/api/playback-plan/audio-tracks", async (req, reply) =>
     handleApiPlaybackPlanAudioTracksPost(req, reply, { playbackPlanner })

package/services/encode/EncodeRuns.js

@@ -1234,7 +1234,21 @@ export class EncodeRuns {
         if (mediaRanges === false && tentative) return null;
         if (mediaRanges === false) throw Object.assign(new Error(`Closed piece #${index} has incomplete media.`),
           { code: "ERR_INCOMPLETE_MEDIA" });
-        const published = this.#host.segmentFiles.publish(address, name, session.segmentFormat, { mediaRanges, bytes });
+        const publishStartedAt = performance.now();
+        const publishProcess = session.spec?.carries === "audio-only" ? "P11.a" : "P11.v";
+        this.#host.observeWait?.(session.file.sourceKey, "process", { process: publishProcess, phase: "begin",
+          output: address, segment: index, at: publishStartedAt });
+        let published;
+        let publishOutcome = "error";
+        try {
+          published = this.#host.segmentFiles.publish(address, name, session.segmentFormat, { mediaRanges, bytes });
+          publishOutcome = published ? "published" : "not-published";
+        } finally {
+          const publishEndedAt = performance.now();
+          this.#host.observeWait?.(session.file.sourceKey, "process", { process: publishProcess, phase: "end",
+            output: address, segment: index, at: publishEndedAt, startedAt: publishStartedAt, endedAt: publishEndedAt,
+            durationMs: publishEndedAt - publishStartedAt, outcome: publishOutcome });
+        }
         if (!published) throw new Error(`Closed piece #${index} could not be stored.`);
         if (index === safeIndex) this.#host.observeWait?.(session.file.sourceKey, "first-piece-published", {
           output: address, segment: index, startedAt: observedStart, endedAt: performance.now(),

package/services/server/ViewerRequests.js

@@ -865,6 +865,11 @@ export class ViewerRequests {
   }
 
   async #playbackReadinessFor(session, consumerId, progress, outputMbps) {
+    const waitStartedAt = performance.now();
+    const waitFields = { process: "P14", sessionId: session.id, consumerId };
+    this.#host.observeWait?.(session.file.sourceKey, "process", { ...waitFields, phase: "begin", at: waitStartedAt });
+    let waitOutcome = "error";
+    try {
     const now = Date.now();
     // WHERE AN ANSWER'S TIME GOES, said with each answer. On Home Assistant a
     // held viewer's answer took 11.2 s while its forecast took 0.1-0.4 s and
@@ -1116,7 +1121,14 @@ export class ViewerRequests {
     this.#host.noteViewerWaiting?.(consumerId || session.id,
       holding?.kind === "production" ? { address: holding.track, index: holding.segment } : null);
     delete forecast.firstRequiredStages;
+    waitOutcome = "forecast-ready";
     return forecast;
+    } finally {
+      const waitEndedAt = performance.now();
+      this.#host.observeWait?.(session.file.sourceKey, "process", { ...waitFields, phase: "end", at: waitEndedAt,
+        startedAt: waitStartedAt, endedAt: waitEndedAt, durationMs: waitEndedAt - waitStartedAt,
+        outcome: waitOutcome });
+    }
   }
 
   /**

package/utils/wait-trace.js

@@ -53,8 +53,9 @@ export class SourceWaitTrace {
         !Number.isSafeInteger(attempt) || attempt < 0) return;
       const context = { wait, attempt, operation, startedAt: this.now() };
       this.requests.set(req, context);
-      const process = typeof statedProcess === "string" && /^[A-Z][0-9]+(?:\.(?:[0-9]+[a-z]?|[va]))?$/.test(statedProcess)
-        ? statedProcess : processForRequest(req.url);
+      const endpointProcess = processForRequest(req.url);
+      const process = endpointProcess ?? (typeof statedProcess === "string" &&
+        /^[A-Z][0-9]+(?:\.(?:[0-9]+[a-z]?|[va]))?$/.test(statedProcess) ? statedProcess : null);
       this.write(context, "http-start", { process, phase: "begin", method: req.method, path: req.url,
         requestId: req.headers["x-ttv-forwarded-request-id"] ?? req.id });
       let finished = false;
@@ -92,11 +93,11 @@ export class SourceWaitTrace {
 }
 
 function processForRequest(path) {
+  if (/^\/api\/transcode-sessions\/[^/?]+\/progress(?:\?|$)/.test(path)) return "P14";
   if (path.startsWith("/api/transcode-sessions")) return "P6.v";
   if (path.startsWith("/api/playback-plan")) return "P3";
   if (/\/transcode\/.*\.m3u8(?:\?|$)/.test(path)) return "P12";
   if (/\/transcode\/.*(?:init|\.mp4)(?:\?|$)/.test(path)) return "P12";
   if (/\/transcode\/.*(?:\.m4s|\.ts)(?:\?|$)/.test(path)) return "P12";
-  if (path.startsWith("/api/session-progress")) return "P14";
   return null;
 }