@torrent-tv/proxy 2.99.21 → 2.100.0

package/bin/cli.js

@@ -89,7 +89,7 @@ program
   .option("--no-port-mapping", "Disable automatic UPnP/NAT-PMP port mapping")
   .option("--delivery-sink", "Serve /api/delivery-sink, a torrent-free byte stream for delivery testing")
   .option("--pin-preset <name>", "Encode every software picture at this libx264 preset only, for runs that must be compared at one quality (off by default)")
-  .option("--profile-start <seconds>", "Profile the main thread's CPU for this many seconds from the first source opened, written beside the state (off by default)")
+  .option("--profile-start <seconds>", "Profile the CPU of the main thread and the torrent thread for this many seconds from the first source opened, written beside the state (off by default)")
   .option(
     "--send-chunk-bytes <bytes>",
     "Size of one data-channel message when sending a response body (0 = whatever the body read hands over, ~64KB). For measuring whether the delivery wedge depends on that size."

package/package.json

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

package/server.js

@@ -1099,7 +1099,8 @@ export async function startProxyServer({
     seconds: profileStartSeconds,
     dir: stateDir || "",
     log: (line) => logger.info(line),
-    mayKeep: (bytes) => diagnostics?.mayKeep?.({ what: "a CPU profile", bytes }) ?? true
+    mayKeep: (bytes) => diagnostics?.mayKeep?.({ what: "a CPU profile", bytes }) ?? true,
+    torrentThread: (seconds) => torrentPool.cpuProfile?.(seconds) ?? Promise.resolve(null)
   });
   startProcessorReport({
     log: (line) => logger.info(line),

package/services/storage/cpu-profile.js

@@ -1,17 +1,23 @@
 /**
- * @file A CPU profile of the main thread at a cold start, asked for by the
- * operator and never taken otherwise (torrent-tv/meta#177).
+ * @file CPU profiles of the main thread and of the torrent thread, asked for
+ * by the operator and never taken otherwise (torrent-tv/meta#177, #178).
  *
  * At a cold start on the addon host (#166 run 12) the picture's first input
  * waited 29.5 s, 20.2 s of it inside a budget revision, while the main thread
  * ran at 83-108 % of a core; what it was doing is not in any log. A profile of
  * that thread names it.
  *
+ * The torrent thread is profiled beside it. After a seek on Home Assistant
+ * (r60, #178) a soundtrack's input waited 23.3 s, every read of held bytes took
+ * 1.5-6 s in that thread, its loop ran up to 2.7 s late and it drew three
+ * quarters of a core; what it spent them on is in no log either.
+ *
  * In-process, through `node:inspector`: the sampling profiler runs beside the
  * thread and does not stop it — unlike the debugger that stopped every thread
- * of this process on 2026-09-05 (torrent-tv/meta#77). It begins at the first
- * source opened, which is where a cold start begins, runs for the seconds the
- * operator named, and writes `cpu-start-<time>.cpuprofile` beside the log,
+ * of this process on 2026-09-05 (torrent-tv/meta#77). Both begin at the first
+ * source opened, which is where a cold start begins, run for the seconds the
+ * operator named, and are written by this thread under the one storage budget
+ * as `cpu-start-<time>.cpuprofile` (main) and `cpu-torrent-<time>.cpuprofile`,
  * readable in Chrome's DevTools (Performance, "Load profile").
  */
 
@@ -19,50 +25,72 @@ import { Session } from "node:inspector/promises";
 import { writeFile } from "node:fs/promises";
 import path from "node:path";
 
+/**
+ * Profile the thread this runs on for `seconds`.
+ *
+ * @param {number} seconds
+ * @returns {Promise<object>} The profile, as `Profiler.stop` gives it.
+ */
+export async function profileThisThread(seconds) {
+  const session = new Session();
+  session.connect();
+  try {
+    await session.post("Profiler.enable");
+    await session.post("Profiler.start");
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, seconds * 1000);
+      if (typeof timer.unref === "function") timer.unref();
+    });
+    const { profile } = await session.post("Profiler.stop");
+    return profile;
+  } finally {
+    session.disconnect();
+  }
+}
+
 /**
  * @param {object} params
  * @param {number} params.seconds - How long to profile; nothing happens unless positive.
  * @param {string} params.dir - Where to write the profile.
  * @param {(line: string) => void} params.log
  * @param {(bytes: number) => boolean} [params.mayKeep] - Whether the storage budget lets it be kept.
+ * @param {(seconds: number) => Promise<string | null>} [params.torrentThread] - The torrent thread's
+ *   profile over the same seconds, as JSON text, or null when it could not be taken.
  * @returns {{ begin: () => void, active: () => boolean }}
  */
-export function startupCpuProfile({ seconds, dir, log, mayKeep = () => true }) {
+export function startupCpuProfile({ seconds, dir, log, mayKeep = () => true, torrentThread = null }) {
   let begun = false;
-  let running = false;
+  let running = 0;
   const wanted = Number.isFinite(seconds) && seconds > 0 && typeof dir === "string" && dir.length > 0;
-  const take = async () => {
-    const session = new Session();
-    session.connect();
+  const keep = async (name, text) => {
+    const bytes = Buffer.byteLength(text);
+    if (!mayKeep(bytes)) {
+      log(`cpu profile: ${name} not kept, ${bytes} bytes refused by the storage budget`);
+      return;
+    }
+    const file = path.join(dir, `cpu-${name}-${new Date().toISOString().replace(/[:.]/g, "-")}.cpuprofile`);
+    await writeFile(file, text);
+    log(`cpu profile: written to ${file} (${bytes} bytes)`);
+  };
+  const take = async (name, profile) => {
+    running += 1;
     try {
-      await session.post("Profiler.enable");
-      await session.post("Profiler.start");
-      running = true;
-      log(`cpu profile: the main thread is profiled for ${seconds}s from the first source opened`);
-      await new Promise((resolve) => {
-        const timer = setTimeout(resolve, seconds * 1000);
-        if (typeof timer.unref === "function") timer.unref();
-      });
-      const { profile } = await session.post("Profiler.stop");
-      const text = JSON.stringify(profile);
-      if (!mayKeep(Buffer.byteLength(text))) {
-        log(`cpu profile: not kept, ${Buffer.byteLength(text)} bytes refused by the storage budget`);
-        return;
-      }
-      const file = path.join(dir, `cpu-start-${new Date().toISOString().replace(/[:.]/g, "-")}.cpuprofile`);
-      await writeFile(file, text);
-      log(`cpu profile: written to ${file} (${Buffer.byteLength(text)} bytes)`);
+      const text = await profile();
+      if (text) await keep(name, text);
+    } catch (error) {
+      log(`cpu profile: ${name} failed — ${error.message}`);
     } finally {
-      running = false;
-      session.disconnect();
+      running -= 1;
     }
   };
   return {
     begin() {
       if (!wanted || begun) return;
       begun = true;
-      void take().catch((error) => log(`cpu profile: failed — ${error.message}`));
+      log(`cpu profile: the main thread${torrentThread ? " and the torrent thread are" : " is"} profiled for ${seconds}s from the first source opened`);
+      void take("start", async () => JSON.stringify(await profileThisThread(seconds)));
+      if (torrentThread) void take("torrent", () => torrentThread(seconds));
     },
-    active: () => running
+    active: () => running > 0
   };
 }

package/services/torrent/worker/client.js

@@ -744,6 +744,17 @@ export class TorrentWorkerClient {
     return this.wholeFileBytes ?? 0;
   }
 
+  /**
+   * A processor profile of the torrent thread over `seconds`, as JSON text.
+   *
+   * @param {number} seconds
+   * @returns {Promise<string | null>}
+   */
+  async cpuProfile(seconds) {
+    const text = await this.#caller.call(Command.CPU_PROFILE, { seconds });
+    return typeof text === "string" ? text : null;
+  }
+
   /**
    * Say how much disk the spilled pieces on this thread may take between them.
    *

package/services/torrent/worker/pool-adapter.js

@@ -278,6 +278,11 @@ export class WorkerTorrentPool {
    *
    * @returns {Promise<{ infoHash: string, progress: number, bytes: number }[]>}
    */
+  /** A processor profile of the torrent thread, as JSON text (`TorrentWorkerClient.cpuProfile`). */
+  async cpuProfile(seconds) {
+    return this.#client.cpuProfile(seconds);
+  }
+
   async heldTorrents() {
     const answer = await this.#client.heldTorrents();
     return Array.isArray(answer?.held) ? answer.held : [];

package/services/torrent/worker/protocol.js

@@ -107,6 +107,8 @@ export const Command = {
   SPILL_ALLOWANCE: "spill-allowance",
   WHOLE_FILES_ALLOWANCE: "whole-files-allowance",
   MEMORY_ALLOWANCE: "memory-allowance",
+  /** Profile this thread's processor for some seconds and answer with the profile as JSON text (opt-in, torrent-tv/meta#178). */
+  CPU_PROFILE: "cpu-profile",
   DESTROY_ALL: "destroy-all"
 };
 

package/services/torrent/worker/worker.js

@@ -39,6 +39,7 @@ import { wholeFileStats } from "./whole-file-stats.js";
 import { describeHeldObjects, readUtpOpenCount } from "./held-objects.js";
 import { destroyedTorrents } from "../destroyed-torrents.js";
 import { startMemoryReport, WORKER_MEMORY_SAMPLE_MS } from "../../storage/memory-report.js";
+import { profileThisThread } from "../../storage/cpu-profile.js";
 import { forwardLogsTo, logger } from "../../../utils/logger.js";
 
 /**
@@ -603,6 +604,12 @@ async function runCommand(command, params, id) {
       return after.bytes;
     }
 
+    case Command.CPU_PROFILE: {
+      // The operator's profile of this thread, written by the main thread under
+      // the storage budget there (`storage/cpu-profile.js`).
+      return JSON.stringify(await profileThisThread(Number(params.seconds)));
+    }
+
     case Command.DESTROY_ALL: {
       torrentsByKey.clear();
       resolvedTorrents.clear();