@torrent-tv/proxy 2.89.16 → 2.89.17

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.89.17
+
+- **Fix**: Every browser log line the proxy keeps names the page's send it came in, as `batch=<n>`, and the server prints the same number. A send that reached neither side, or a batch the proxy took over a connection that could no longer carry its answer back, is now visible by comparing the two (torrent-tv/meta#77).
+
 ## 2.89.16
 
 - **Fix**: A proxy started without `--log-file` keeps the browser's log. The page sends its log to the proxy for most of a viewing, and the proxy wrote it only to per-session files beside its own log file; with no log file named, which is every run from npm or Docker other than the Home Assistant addon, the browser's half of every viewing was dropped. It now goes to the console, beside the proxy's lines, each prefixed `client <sessionId>`. `docs/logs.md` states where the log goes for each way of starting the proxy (torrent-tv/meta#96).

package/docs/logs.md

@@ -98,6 +98,19 @@ The split is by PHASE, and neither half is the whole session:
 3. **At unload** it goes to the server again: `navigator.sendBeacon` is the only
    thing a page that is going away can use, and a data channel is not;
 4. **A batch that cannot reach the proxy** falls back to the server.
+5. **A batch nobody took** goes back into the page's queue and leaves with the
+   next send. What the page lost — lines pushed out by its 500-line queue — and
+   every refused send, by route and cause, are written into the log itself as
+   one line, `[client-logger] since <time>: …`, which travels with the next
+   batch that is delivered.
+
+Every line carries the number of the page's send it came in, as `batch=<n>`,
+on both sides: `[Windows/Chrome batch=12]` here, `[client Windows/Chrome
+<sessionId> batch=12]` on the droplet. A number on neither side is a send no
+route took: its lines went out again under a later number, and the report line
+says why. A number on both is a batch the proxy took but whose answer never
+reached the page — a connection wedged in the proxy-to-page direction still
+carries requests the other way — which the page then sent to the server too.
 
 So a session that failed while connecting is on the droplet, a session that
 failed while playing is on the addon host, and a complete reading of a long

package/package.json

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

package/routes/api/client-logs/post.js

@@ -53,7 +53,13 @@ function sanitizeLine(value) {
  * `POST /api/client-logs`
  *
  * Body: `{ sessionId, startedAt, torrentName, infoHash, tag, signalSessionId,
- * lines: [{ level, ts, msg }] }`.
+ * seq, lines: [{ level, ts, msg }] }`.
+ *
+ * `seq` numbers the page's sends and is printed as `batch=<seq>`. The server
+ * prints the same number, so a batch that reached neither side shows as a gap,
+ * and one taken here whose answer never reached the page — a wedged connection
+ * still carries the request — shows on both, because the page then sends it to
+ * the server too.
  *
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
@@ -69,6 +75,7 @@ export async function handleApiClientLogsPost(req, reply, { clientLogs }) {
     infoHash: safeString(body.infoHash, 40)
   };
   const tag = sanitizeLine(safeString(body.tag, MAX_TAG_LEN)) || "Unknown/Unknown";
+  const batch = Number.isSafeInteger(body.seq) && body.seq > 0 ? ` batch=${body.seq}` : "";
   const rows = Array.isArray(body.lines) ? body.lines.slice(0, MAX_LINES) : [];
 
   const lines = rows.map((row) => {
@@ -76,7 +83,7 @@ export async function handleApiClientLogsPost(req, reply, { clientLogs }) {
     const level = safeString(entry.level, 8) || "log";
     const at = sanitizeLine(safeString(entry.ts, 16));
     const message = sanitizeLine(safeString(entry.msg, MAX_MSG_LEN));
-    return `[${tag}] ${at} ${level}: ${message}`;
+    return `[${tag}${batch}] ${at} ${level}: ${message}`;
   });
 
   if (lines.length > 0) {

package/test/client-logs-route.test.js

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { handleApiClientLogsPost } from "../routes/api/client-logs/post.js";
+
+/**
+ * Post one body and return the lines the route wrote.
+ *
+ * @param {object} body
+ * @returns {Promise<string[]>}
+ */
+async function linesWrittenFor(body) {
+  /** @type {string[]} */
+  const written = [];
+  const reply = { code: () => reply, send: () => reply };
+  await handleApiClientLogsPost({ body }, reply, {
+    clientLogs: { write: (_session, lines) => written.push(...lines) }
+  });
+  return written;
+}
+
+const line = { level: "info", ts: "12:00:00.000", msg: "hello" };
+
+test("each line names the page's send it came in, so the two receivers can be compared", async () => {
+  assert.deepEqual(await linesWrittenFor({ tag: "Windows/Chrome", seq: 12, lines: [line] }), [
+    "[Windows/Chrome batch=12] 12:00:00.000 info: hello"
+  ]);
+});
+
+test("a page that numbers nothing is written as before", async () => {
+  assert.deepEqual(await linesWrittenFor({ tag: "Windows/Chrome", seq: "12", lines: [line] }), [
+    "[Windows/Chrome] 12:00:00.000 info: hello"
+  ]);
+});