home-hosted 0.7.15 → 0.7.17

package/dist/cli.js

@@ -346,14 +346,95 @@ function withoutTrailingBlank(lines) {
 *
 * The current file plus its `.1` ancestor, so `logs` shows what happened just before a
 * rotation rather than starting blank. `lines <= 0` means the whole thing.
+*
+* Reads only the tail it needs. The log is capped at 5 MB per file *by rotation*, so a panel
+* that has been up a while keeps a 5 MB current file plus a 5 MB `.1` — and the old version
+* read both in full, split every line and threw all but the last fifty away: 24 ms and 28 MB
+* of heap to print fifty lines, on the *default* invocation of a diagnostic command. Most of
+* a tail is not looked at, so it is not read.
 */
 function readLog(file, lines) {
+	if (lines <= 0) return withoutTrailingBlank(readBoth(file).join("").split("\n"));
+	const tail = tailText(file, lines);
+	if (tail === null) return withoutTrailingBlank(readBoth(file).join("").split("\n")).slice(-lines);
+	return withoutTrailingBlank(tail.split("\n")).slice(-lines);
+}
+/** Both sides of the rotation, oldest first. Missing files contribute nothing. */
+function readBoth(file) {
 	const parts = [];
 	for (const candidate of [`${file}.1`, file]) try {
 		parts.push(fs.readFileSync(candidate, "utf8"));
 	} catch {}
-	const all = withoutTrailingBlank(parts.join("").split("\n"));
-	return lines > 0 ? all.slice(-lines) : all;
+	return parts;
+}
+/**
+* The text of the last `lines` lines across the rotation, joined the way concatenating the
+* two files would join it — or `null` when the tail cannot be reached within the block budget,
+* in which case the caller reads everything.
+*
+* Concatenating `.1` and the current file makes `.1`'s unterminated last line and the current
+* file's first line *one* line. Keeping the two tails as text and joining them reproduces that
+* for free: no gluing to arrange, and no line to lose. (An earlier draft spliced the arrays
+* instead and dropped that line.)
+*/
+function tailText(file, lines) {
+	const wanted = lines + 1;
+	const current = readTail(file, wanted);
+	if (current === null) return null;
+	if (countNewlines(current) >= wanted) return current;
+	const rotated = readTail(`${file}.1`, wanted);
+	if (rotated === null) return null;
+	return `${rotated}${current}`;
+}
+/**
+* The last `lines` lines of one file, as text — read backwards in blocks, stopping as soon as
+* enough line separators have been seen. `''` when there is nothing to contribute, `null` when
+* the file cannot be read at all (which the caller answers by reading everything).
+*
+* The first element may be a fragment: a block boundary lands mid-line. It is deliberately
+* left in place. The loop only exits once `lines + 1` separators are present, so at least
+* `lines` complete lines follow the fragment and the caller's `slice(-lines)` can never reach
+* it — trimming it would be code no test could make fail, and a randomised comparison against
+* the previous implementation confirmed removing it changes nothing.
+*/
+function readTail(file, lines) {
+	let handle;
+	try {
+		handle = fs.openSync(file, "r");
+	} catch {
+		return "";
+	}
+	try {
+		const size = fs.fstatSync(handle).size;
+		if (size === 0) return "";
+		const block = 65536;
+		let end = size;
+		let text = "";
+		while (end > 0 && countNewlines(text) < lines + 1) {
+			const start = Math.max(0, end - block);
+			const length = end - start;
+			const buffer = Buffer$1.alloc(length);
+			fs.readSync(handle, buffer, 0, length, start);
+			text = buffer.toString("utf8") + text;
+			end = start;
+		}
+		return text;
+	} catch {
+		return null;
+	} finally {
+		fs.closeSync(handle);
+	}
+}
+/**
+* The last `lines` lines of one file, without reading the whole of it.
+*
+* Reads backwards in blocks and stops as soon as it has enough newlines. A single line can
+* still be long, so the block grows rather than the read being capped at the exact byte.
+*/
+function countNewlines(text) {
+	let count = 0;
+	for (let index = 0; index < text.length; index += 1) if (text.charCodeAt(index) === 10) count += 1;
+	return count;
 }
 /**
 * Prints the last `lines` of the log, then keeps printing whatever is appended.
@@ -15009,6 +15090,15 @@ var init_log_files = __esmMin((() => {
 			}
 			if (fs.existsSync(this.currentPath(serverId))) fs.renameSync(this.currentPath(serverId), this.rotatedPath(serverId, 1));
 		}
+		/**
+		* The last `tail` parseable lines of one file.
+		*
+		* Reads backwards, growing the window until it has enough lines. It used to read exactly one
+		* fixed chunk, which silently truncated: a JSONL line here is a couple of hundred bytes, so
+		* one 256 KB chunk holds roughly 1500 of them, while the route accepts `tail=5000`. Asking
+		* for 5000 returned 1464 and dropped 3536 lines with no error — the oldest line handed back
+		* was not the oldest asked for.
+		*/
 		readTailChunk(file, tail) {
 			let handle;
 			try {
@@ -15018,15 +15108,24 @@ var init_log_files = __esmMin((() => {
 			}
 			try {
 				const size = fs.fstatSync(handle).size;
-				const length = Math.min(size, READ_CHUNK_BYTES);
-				const buffer = Buffer$1.alloc(length);
-				fs.readSync(handle, buffer, 0, length, size - length);
-				const raw = buffer.toString("utf8").split("\n").filter((entry) => entry.trim().length > 0);
-				const parsed = [];
-				for (const entry of raw.slice(size > length ? 1 : 0)) try {
-					parsed.push(JSON.parse(entry));
-				} catch {}
-				return parsed.slice(-tail);
+				if (size === 0) return [];
+				let start = Math.max(0, size - READ_CHUNK_BYTES);
+				let parsed = [];
+				while (true) {
+					const length = size - start;
+					const buffer = Buffer$1.alloc(length);
+					fs.readSync(handle, buffer, 0, length, start);
+					const raw = buffer.toString("utf8").split("\n");
+					parsed = [];
+					for (const entry of start > 0 ? raw.slice(1) : raw) {
+						if (entry.trim().length === 0) continue;
+						try {
+							parsed.push(JSON.parse(entry));
+						} catch {}
+					}
+					if (parsed.length >= tail || start === 0) return parsed.slice(-tail);
+					start = Math.max(0, start - READ_CHUNK_BYTES);
+				}
 			} finally {
 				fs.closeSync(handle);
 			}