@torrent-tv/proxy 2.101.36 → 2.101.38

package/package.json

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

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

@@ -84,6 +84,8 @@ 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();
@@ -217,13 +219,16 @@ 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 handlerReturnAt = performance.now();
     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)}`
+        `handlerReturnAtMs=${handlerReturnAt.toFixed(3)} ` +
+        `handlerMs=${(handlerReturnAt - 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";
@@ -152,6 +153,15 @@ export async function startProxyServer({
     // receives torrent source payloads that may be arbitrarily large.
     bodyLimit: 256 * 1024 * 1024 // 256 MB
   });
+  const forwardedSessionResponseStarts = new WeakMap();
+  const logForwardedSessionResponseStage = (stage, req) => {
+    const startedAt = forwardedSessionResponseStarts.get(req);
+    const requestId = req.headers["x-ttv-forwarded-request-id"];
+    if (startedAt === undefined || typeof requestId !== "string") return;
+    const at = performance.now();
+    logger.info(`[forecast-http] stage=${stage} requestId=${requestId} atMs=${at.toFixed(3)} ` +
+      `elapsedMs=${(at - startedAt).toFixed(3)}`);
+  };
 
   await app.register(fastifyHelmet, {
     // Proxy serves media to a different origin (registry UI), so CORP must allow cross-origin usage.
@@ -170,6 +180,34 @@ 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" || req.method !== "POST" || req.url !== "/api/transcode-sessions") return;
+    const startedAt = performance.now();
+    forwardedSessionResponseStarts.set(req, startedAt);
+    logForwardedSessionResponseStage("onRequest", req);
+    reply.raw.once("finish", () => {
+      logForwardedSessionResponseStage("finish", req);
+      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) {
+        logForwardedSessionResponseStage("close", req);
+        logger.warn(`[http-response] requestId=${requestId} method=${req.method} url=${req.url} ` +
+          `closedMs=${(performance.now() - startedAt).toFixed(1)} status=${reply.statusCode}`);
+      }
+    });
+  });
+  app.addHook("preSerialization", async (req, _reply, payload) => {
+    logForwardedSessionResponseStage("preSerialization", req);
+    return payload;
+  });
+  app.addHook("onSend", async (req, _reply, payload) => {
+    logForwardedSessionResponseStage("onSend", req);
+    return payload;
+  });
 
   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,13 +1171,24 @@ 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
     // route to return a response — e.g. long-polling until an HLS segment is
     // finalized by ffmpeg) vs. the body transfer over the data channel.
     const fetchStartedAt = Date.now();
+    const traceSessionResponse = method === "POST" && path === "/api/transcode-sessions" &&
+      typeof requestId === "string";
+    const fetchStartedAtMonotonic = traceSessionResponse ? performance.now() : null;
+    if (traceSessionResponse) {
+      log(`[forecast-http] stage=local-fetch-start requestId=${requestId} ` +
+        `atMs=${fetchStartedAtMonotonic.toFixed(3)}`);
+    }
     try {
       response = await fetch(targetUrl, {
         method,
@@ -1193,6 +1204,12 @@ export function createDataChannelHandler({
       send(channel, { type: "response-error", requestId, error: fetchError?.message ?? String(fetchError) });
       return;
     }
+    if (traceSessionResponse) {
+      const headersAt = performance.now();
+      log(`[forecast-http] stage=local-fetch-headers requestId=${requestId} ` +
+        `atMs=${headersAt.toFixed(3)} elapsedMs=${(headersAt - fetchStartedAtMonotonic).toFixed(3)} ` +
+        `status=${response.status}`);
+    }
 
     if (response.status !== 200 && response.status !== 206) {
       log(`[dc] ${method} ${path}${queryInfo} → ${response.status}`);