@torrent-tv/proxy 2.101.35 → 2.101.37

package/package.json

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

package/routes/api/sources/stats/get.js

@@ -1,4 +1,5 @@
 import { logger } from "../../../../utils/logger.js";
+import { performance } from "node:perf_hooks";
 
 /**
  * Return download statistics for a registered torrent source.
@@ -65,7 +66,13 @@ export async function handleApiSourceStatsGet(req, reply, { sourceRegistry, torr
   // Awaited: with the torrent on its own thread this is a round trip, not a
   // local lookup. Without the await the reply was the pending promise itself,
   // which serialises to `{}` — the empty stats seen in the field 2026-08-02.
-  const stats = await torrentPool.getFileStats(torrent, fileIndex);
+  const statsStartedAt = performance.now();
+  let stats;
+  try {
+    stats = await torrentPool.getFileStats(torrent, fileIndex);
+  } finally {
+    logger.info(`[stats] ${sourceKey.slice(0, 8)} getFileStatsMs=${(performance.now() - statsStartedAt).toFixed(1)}`);
+  }
   if (stats?.pending || !stats) {
     const waitEstimate = initialEstimate();
     return reply.code(202).send({ pending: true, ...(waitEstimate ? { waitEstimate } : {}) });

package/routes/api/transcode-sessions/post.js

@@ -10,6 +10,7 @@
  */
 
 import { logger } from "../../../utils/logger.js";
+import { performance } from "node:perf_hooks";
 import { OUTPUT_NO_CAPACITY, OUTPUT_UNAVAILABLE } from "../../../services/encode/output/index.js";
 import { replyNoCapacity, replyOutputUnavailable } from "../../../services/server/http-responses.js";
 import { waitForPlan } from "../../../services/media/await-plan.js";
@@ -81,38 +82,51 @@ export async function handleApiTranscodeSessionsPost(req, reply, { viewerRequest
   }
 
   const cancellation = new AbortController();
+  const timing = { startedAt: performance.now(), openMs: 0, openCalls: 0,
+    planWaitInclusiveMs: null, masterMs: null, offerMs: null, tracksMs: null };
+  const forwardedRequestId = typeof req.headers?.["x-ttv-forwarded-request-id"] === "string"
+    ? req.headers["x-ttv-forwarded-request-id"] : "unknown";
   const cancelled = () => cancellation.abort();
   reply.raw?.once?.("close", cancelled);
   if (reply.raw?.destroyed) cancelled();
   try {
-    const open = () => viewerRequests.createOrGetSession({
-      signal: cancellation.signal,
-      sourceKey,
-      fileIndex,
-      transcodeVideo,
-      transcodeAudio,
-      consumerId,
-      fileName,
-      targetWidth: Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : 0,
-      targetHeight: Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : 0,
-      exactSize,
-      visiblePicture,
-      audioRenditions,
-      startPositionSeconds:
-        Number.isFinite(startPositionSeconds) && startPositionSeconds > 0
-          ? startPositionSeconds
-          : 0,
-      viewerLinkMbps: Number.isFinite(viewerLinkMbps) && viewerLinkMbps > 0 ? viewerLinkMbps : null,
-      linkSampleMbps: Number.isFinite(linkSampleMbps) && linkSampleMbps > 0 ? linkSampleMbps : null,
-      linkSampleAt: Number.isFinite(linkSampleAt) && linkSampleAt > 0 ? linkSampleAt : null,
-      linkSampleAgeMs: Number.isFinite(linkSampleAgeMs) && linkSampleAgeMs >= 0 ? linkSampleAgeMs : null,
-      bufferedAheadSec: Number.isFinite(bufferedAheadSec) && bufferedAheadSec >= 0 ? bufferedAheadSec : 0,
-      bufferLimitSeconds:
-        Number.isFinite(bufferLimitSeconds) && bufferLimitSeconds > 0 ? bufferLimitSeconds : null,
-      audioTrackIndex:
-        Number.isInteger(audioTrackIndex) && audioTrackIndex > 0 ? audioTrackIndex : 0,
-      segmentFormatId
-    });
+    const open = async () => {
+      const openStartedAt = performance.now();
+      timing.openCalls += 1;
+      try {
+        return await viewerRequests.createOrGetSession({
+          signal: cancellation.signal,
+          sourceKey,
+          fileIndex,
+          transcodeVideo,
+          transcodeAudio,
+          consumerId,
+          fileName,
+          targetWidth: Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : 0,
+          targetHeight: Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : 0,
+          exactSize,
+          visiblePicture,
+          audioRenditions,
+          startPositionSeconds:
+            Number.isFinite(startPositionSeconds) && startPositionSeconds > 0
+              ? startPositionSeconds
+              : 0,
+          viewerLinkMbps: Number.isFinite(viewerLinkMbps) && viewerLinkMbps > 0 ? viewerLinkMbps : null,
+          linkSampleMbps: Number.isFinite(linkSampleMbps) && linkSampleMbps > 0 ? linkSampleMbps : null,
+          linkSampleAt: Number.isFinite(linkSampleAt) && linkSampleAt > 0 ? linkSampleAt : null,
+          linkSampleAgeMs: Number.isFinite(linkSampleAgeMs) && linkSampleAgeMs >= 0 ? linkSampleAgeMs : null,
+          bufferedAheadSec: Number.isFinite(bufferedAheadSec) && bufferedAheadSec >= 0 ? bufferedAheadSec : 0,
+          bufferLimitSeconds:
+            Number.isFinite(bufferLimitSeconds) && bufferLimitSeconds > 0 ? bufferLimitSeconds : null,
+          audioTrackIndex:
+            Number.isInteger(audioTrackIndex) && audioTrackIndex > 0 ? audioTrackIndex : 0,
+          segmentFormatId
+        });
+      } finally {
+        timing.openMs += performance.now() - openStartedAt;
+      }
+    };
+    const planWaitStartedAt = performance.now();
     const session = subscribeSource ? (await waitForPlan({ signal: cancellation.signal,
       subscribe: listener => subscribeSource(sourceKey, fileIndex, listener),
       read: async () => {
@@ -123,13 +137,22 @@ export async function handleApiTranscodeSessionsPost(req, reply, { viewerRequest
         }
       }
     })).session : await open();
+    timing.planWaitInclusiveMs = performance.now() - planWaitStartedAt;
     // The index of quality variants, when this session has more than one to
     // offer. Its presence is what tells the browser it can change quality
     // without a new session: the player switches variants itself, appending the
     // new one after what is already buffered. Absent for a copied video, whose
     // segments are cut at the source's own keyframes and so cannot be spliced
     // with a re-encoded rung.
+    let stageStartedAt = performance.now();
     const hasVariants = renditions.buildMasterPlaylist(session.id) !== null;
+    timing.masterMs = performance.now() - stageStartedAt;
+    stageStartedAt = performance.now();
+    const offeredHeights = quality.offeredHeights(session);
+    timing.offerMs = performance.now() - stageStartedAt;
+    stageStartedAt = performance.now();
+    const tracks = renditions.declaredTracks(session);
+    timing.tracksMs = performance.now() - stageStartedAt;
     return reply.send({
       sessionId: session.id,
       playlistPath: `/transcode/${session.id}/index.m3u8`,
@@ -149,12 +172,12 @@ export async function handleApiTranscodeSessionsPost(req, reply, { viewerRequest
       // it, it fell back to a ladder of its own invention and offered rungs the
       // proxy had just refused, and picking one re-opened the session at a
       // height measured at a third of realtime.
-      offeredHeights: quality.offeredHeights(session),
+      offeredHeights,
       // What this session's output will carry, stated rather than left to be
       // discovered. The browser checks what it actually got against this: a
       // track that never arrives is otherwise noticed only by its absence,
       // minutes later, as a black picture with working sound.
-      tracks: renditions.declaredTracks(session),
+      tracks,
       // The soundtrack this viewer is sent and whether it is re-encoded — the
       // proxy's decision, which can differ from what the page asked for: a
       // track no figure states a rate for is re-encoded even for a browser that
@@ -196,5 +219,14 @@ export async function handleApiTranscodeSessionsPost(req, reply, { viewerRequest
     return reply.code(500).send({ error: `Failed to prepare transcode session: ${message}` });
   } finally {
     reply.raw?.removeListener?.("close", cancelled);
+    const elapsed = (key) => Number.isFinite(timing[key]) ? timing[key].toFixed(1) : "n/a";
+    logger.info(
+      `transcode-session timing outcome=${cancellation.signal.aborted ? "cancelled" : "handler-return"} ` +
+        `requestId=${forwardedRequestId} ` +
+        `consumer=${consumerId || "unknown"} file=${fileIndex} openCalls=${timing.openCalls} ` +
+        `openMs=${timing.openMs.toFixed(1)} planWaitInclusiveMs=${elapsed("planWaitInclusiveMs")} ` +
+        `masterMs=${elapsed("masterMs")} offerMs=${elapsed("offerMs")} tracksMs=${elapsed("tracksMs")} ` +
+        `handlerMs=${(performance.now() - timing.startedAt).toFixed(1)}`
+    );
   }
 }

package/server.js

@@ -11,6 +11,7 @@ import fastifyCors from "@fastify/cors";
 import fastifyHelmet from "@fastify/helmet";
 import getPort from "get-port";
 import { createRequire } from "node:module";
+import { performance } from "node:perf_hooks";
 import { handleHealthGet } from "./routes/health/get.js";
 import { handleMediaGet } from "./routes/media/get.js";
 import { ProbeRequests } from "./services/media/ProbeRequests.js";
@@ -170,6 +171,22 @@ export async function startProxyServer({
   app.addHook("onRequest", async (_req, reply) => {
     reply.header("Access-Control-Allow-Private-Network", "true");
   });
+  app.addHook("onRequest", async (req, reply) => {
+    const requestId = req.headers["x-ttv-forwarded-request-id"];
+    if (typeof requestId !== "string") return;
+    const startedAt = performance.now();
+    reply.raw.once("finish", () => {
+      logger.info(`[http-response] requestId=${requestId} method=${req.method} url=${req.url} ` +
+        `responseMs=${(performance.now() - startedAt).toFixed(1)} status=${reply.statusCode} ` +
+        `contentLength=${reply.raw.getHeader("content-length") ?? "unknown"}`);
+    });
+    reply.raw.once("close", () => {
+      if (!reply.raw.writableFinished) {
+        logger.warn(`[http-response] requestId=${requestId} method=${req.method} url=${req.url} ` +
+          `closedMs=${(performance.now() - startedAt).toFixed(1)} status=${reply.statusCode}`);
+      }
+    });
+  });
 
   const sourceRegistry = createSourceRegistry(200);
   // The torrent runs on its own thread. Profiling a live seek (2026-08-02)

package/services/encode/LocalObservations.js

@@ -276,13 +276,16 @@ export class LocalObservations {
    */
   noteFirstFrame({ seconds, features, featureSnapshots = null, stages = null }) {
     if (!Number.isFinite(seconds) || seconds < 0 || !features || typeof features !== "object") return;
+    const measuredStages = stagesOf(stages);
+    if (!measuredStages) return;
     const key = this.#firstFrameKey();
     const snapshots = [features, ...(Array.isArray(featureSnapshots) ? featureSnapshots : [])]
       .filter(value => value && typeof value === "object").slice(0, 2).map(firstFrameFeatures);
-    const readings = [...(this.#entries.firstFrame[key] ?? []), {
+    const usableReadings = (this.#entries.firstFrame[key] ?? []).filter(reading => stagesOf(reading.stages));
+    const readings = [...usableReadings, {
       ...snapshots[0],
       featureSnapshots: snapshots,
-      stages: stagesOf(stages),
+      stages: measuredStages,
       at: this.#now()
     }].slice(-READINGS_KEPT);
     this.#entries.firstFrame[key] = readings;

package/services/transport/data-channel-handler.js

@@ -1171,7 +1171,11 @@ export function createDataChannelHandler({
     log(`[dc] ${method} ${path}${queryInfo}${bodyInfo}`);
 
     const targetUrl = `http://127.0.0.1:${proxyPort}${path}${query ? `?${query}` : ""}`;
-    const requestHeaders = { ...(forwardedHeaders ?? {}), host: `127.0.0.1:${proxyPort}` };
+    const requestHeaders = {
+      ...(forwardedHeaders ?? {}),
+      host: `127.0.0.1:${proxyPort}`,
+      "x-ttv-forwarded-request-id": requestId
+    };
 
     let response;
     // [net-debug] TEMPORARY: time spent in the local fetch (waiting for the