Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

scripts/codegen/pi-ext-debug.test.ts

Raw
import {
	chmodSync,
	closeSync,
	existsSync,
	lstatSync,
	mkdirSync,
	mkdtempSync,
	openSync,
	readdirSync,
	readFileSync,
	renameSync,
	rmSync,
	symlinkSync,
	utimesSync,
	writeFileSync,
	writeSync,
} from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, describe, expect, it, vi } from "vitest";
import { sandboxEnv, withProcessEnv } from "../../test/fixture/env.ts";

vi.mock("node:fs", async (importOriginal) => {
	const fs = await importOriginal<typeof import("node:fs")>();
	return {
		...fs,
		openSync: vi.fn(fs.openSync),
		closeSync: vi.fn(fs.closeSync),
		renameSync: vi.fn(fs.renameSync),
		writeSync: vi.fn(fs.writeSync),
	};
});

// The template's own slug placeholder is the extension name under test.
const slug = "{{extension-slug}}";
const enable = `PI_${slug.toUpperCase().replaceAll("-", "_")}_DEBUG`;
const posix = process.platform !== "win32";

let root: string | undefined;
afterEach(() => {
	if (root) rmSync(root, { recursive: true, force: true });
	root = undefined;
	vi.useRealTimers();
	vi.resetAllMocks();
	vi.restoreAllMocks();
	vi.resetModules();
});

function sandbox() {
	root = mkdtempSync(join(tmpdir(), "pi-ext-debug-"));
	const env = sandboxEnv(root, { env: { [enable]: "1" } });
	const directory =
		process.platform === "darwin"
			? join(root, "Library", "Logs", "pi-ext", slug)
			: join(root, ".test-state", "pi-ext", "debug", slug);
	return {
		env,
		state:
			process.platform === "darwin"
				? join(root, "Library", "Logs")
				: join(root, ".test-state"),
		directory,
	};
}

/** Load a fresh template copy, log one event and one span, then close. */
function logOnce(env: NodeJS.ProcessEnv) {
	return withProcessEnv(env, async () => {
		vi.resetModules();
		const { defineDebug } = await import("./templates/pi-ext-debug.ts");
		const { dbg, span, closeDebug } = defineDebug({
			events: ["session.start"],
			spans: ["request"],
			fields: { count: "number" },
		} as const);
		expect(() => {
			dbg?.("session.start", { count: 1 });
			span?.("request")("finish", { count: 2 });
		}).not.toThrow();
		closeDebug();
	});
}

const records = (directory: string) =>
	readdirSync(directory).flatMap((file) =>
		readFileSync(join(directory, file), "utf8")
			.trim()
			.split("\n")
			.map((line) => JSON.parse(line)),
	);

describe("pi-ext-debug rolling retention", () => {
	it("rolls without losing the triggering event and retains three capped segments", async () => {
		const { env, directory } = sandbox();
		await withProcessEnv(env, async () => {
			const { defineDebug } = await import("./templates/pi-ext-debug.ts");
			const fields = Object.fromEntries(
				Array.from({ length: 23 }, (_, i) => [`field${i}`, ["a".repeat(127)]]),
			);
			const { dbg, closeDebug } = defineDebug({
				events: ["sample"],
				spans: [],
				fields: { ...fields, count: "number" },
			});
			const details = Object.fromEntries(
				Object.keys(fields).map((key) => [key, "a".repeat(127)]),
			);
			try {
				for (let count = 0; count < 3500; count++)
					dbg?.("sample", { ...details, count });
			} finally {
				closeDebug();
			}
		});
		const files = readdirSync(directory);
		expect(files).toHaveLength(3);
		for (const file of files) {
			expect(file).toMatch(/\.closed\.jsonl$/);
			expect(lstatSync(join(directory, file)).size).toBeLessThanOrEqual(
				2 * 1024 * 1024,
			);
		}
		const rows = records(directory);
		expect(rows.some((row) => row.event === "debug.roll")).toBe(true);
		const counts = rows
			.filter((row) => row.event === "sample")
			.map((row) => row.count)
			.sort((a, b) => a - b);
		expect(counts.at(-1)).toBe(3499);
		expect(counts).toEqual(
			Array.from({ length: counts.length }, (_, i) => counts[0] + i),
		);
	});

	it("retains recently modified segments despite clock rollback and equal filename timestamps", async () => {
		const { env, directory } = sandbox();
		mkdirSync(directory, { recursive: true, mode: 0o700 });
		const old = ["000000000003", "000000000002", "000000000001"].map(
			(suffix, i) => {
				const file = join(
					directory,
					`2099-01-01T00-00-00-000Z-1-${suffix}.closed.jsonl`,
				);
				writeFileSync(file, "old\n", { mode: 0o600 });
				utimesSync(file, i + 1, i + 1);
				return file;
			},
		);
		vi.useFakeTimers({ toFake: ["Date"] });
		vi.setSystemTime(new Date("2010-01-01T00:00:00Z"));
		await logOnce(env);
		expect(old.map(existsSync)).toEqual([false, true, true]);
		expect(
			readdirSync(directory).some((file) => file.startsWith("2010-")),
		).toBe(true);
	});

	it("protects another active writer, including one in the same process", async () => {
		const { env, directory } = sandbox();
		await withProcessEnv(env, async () => {
			const first = await import("./templates/pi-ext-debug.ts");
			first.dbg?.("active");
			const active = readdirSync(directory)[0]!;
			try {
				for (let i = 0; i < 5; i++) await logOnce(env);
				expect(existsSync(join(directory, active))).toBe(true);
				first.dbg?.("still.active");
				expect(readFileSync(join(directory, active), "utf8")).toContain(
					'"event":"still.active"',
				);
			} finally {
				first.closeDebug();
			}
		});
		expect(readdirSync(directory)).toHaveLength(3);
	});

	it.each(["ESRCH", "EPERM"])(
		"only reclaims an unmarked file when PID probing returns ESRCH (%s)",
		async (code) => {
			const { env, directory } = sandbox();
			mkdirSync(directory, { recursive: true, mode: 0o700 });
			const old = join(
				directory,
				"2020-01-01T00-00-00-000Z-2147483647-000000000000.jsonl",
			);
			writeFileSync(old, "old\n", { mode: 0o600 });
			vi.spyOn(process, "kill").mockImplementation(() => {
				throw Object.assign(new Error("probe"), { code });
			});
			for (let i = 0; i < 4; i++) await logOnce(env);
			expect(existsSync(old)).toBe(code !== "ESRCH");
		},
	);

	it.each(["close", "rename"])(
		"keeps failed %s segments unmarked and protects them from same-PID cleanup",
		async (operation) => {
			const { env, directory } = sandbox();
			await withProcessEnv(env, async () => {
				const logger = await import("./templates/pi-ext-debug.ts");
				logger.dbg?.("before.close");
				const old = join(directory, readdirSync(directory)[0]!);
				const actual =
					await vi.importActual<typeof import("node:fs")>("node:fs");
				let leakedFd: number | undefined;
				if (operation === "close")
					vi.mocked(closeSync).mockImplementationOnce((fd) => {
						leakedFd = fd;
						throw new Error("close failure");
					});
				else
					vi.mocked(renameSync).mockImplementationOnce(() => {
						throw new Error("rename failure");
					});
				try {
					expect(() => logger.closeDebug()).not.toThrow();
					for (let i = 0; i < 4; i++) await logOnce(env);
					expect(existsSync(old)).toBe(true);
					logger.dbg?.("after.close");
					expect(
						records(directory).some((row) => row.event === "after.close"),
					).toBe(true);
				} finally {
					logger.closeDebug();
					if (leakedFd !== undefined) actual.closeSync(leakedFd);
				}
			});
		},
	);

	it.each(["write", "rollover-open"])(
		"silently stops after %s failure, even after close",
		async (operation) => {
			const { env, directory } = sandbox();
			await withProcessEnv(env, async () => {
				const logger = await import("./templates/pi-ext-debug.ts");
				logger.dbg?.("before.failure");
				if (operation === "write")
					vi.mocked(writeSync).mockImplementationOnce(() => {
						throw new Error("write failure");
					});
				else
					vi.mocked(openSync).mockImplementation(() => {
						throw new Error("open failure");
					});
				expect(() => {
					for (let i = 0; i < 12000; i++)
						logger.dbg?.("sample", { modelId: "a".repeat(127) });
					logger.closeDebug();
					logger.dbg?.("after.failure");
				}).not.toThrow();
				expect(
					records(directory).some((row) => row.event === "after.failure"),
				).toBe(false);
				if (operation === "rollover-open")
					expect(
						records(directory).some((row) => row.event === "debug.roll"),
					).toBe(true);
			});
		},
	);

	it("leaves unrelated files and matching symlinks untouched", async () => {
		const { env, directory } = sandbox();
		mkdirSync(directory, { recursive: true, mode: 0o700 });
		const unrelated = join(directory, "notes.jsonl");
		writeFileSync(unrelated, "keep", { mode: 0o600 });
		const link = join(
			directory,
			"2099-01-01T00-00-00-000Z-1-000000000000.closed.jsonl",
		);
		for (let i = 1; i <= 3; i++)
			mkdirSync(
				join(
					directory,
					`2099-01-01T00-00-00-000Z-1-00000000000${i}.closed.jsonl`,
				),
			);
		if (posix) symlinkSync(unrelated, link);
		for (let i = 0; i < 4; i++) await logOnce(env);
		expect(readFileSync(unrelated, "utf8")).toBe("keep");
		if (posix) expect(lstatSync(link).isSymbolicLink()).toBe(true);
		expect(
			readdirSync(directory).filter(
				(name) =>
					lstatSync(join(directory, name)).isFile() && name !== "notes.jsonl",
			),
		).toHaveLength(3);
	});
});

describe("pi-ext-debug template directories", () => {
	it("creates missing private directories and a private file", async () => {
		const { env, directory } = sandbox();

		await logOnce(env);

		expect(records(directory).map((record) => record.event)).toEqual([
			"session.start",
			"request.start",
			"request.finish",
		]);
		if (posix) {
			for (const part of [
				join(directory, "..", ".."),
				join(directory, ".."),
				directory,
			])
				expect(lstatSync(part).mode & 0o777).toBe(0o700);
			const [file] = readdirSync(directory);
			expect(lstatSync(join(directory, file!)).mode & 0o777).toBe(0o600);
		}
	});

	it("reuses existing private directories for a new file", async () => {
		const { env, directory } = sandbox();

		await logOnce(env);
		await logOnce(env);

		expect(readdirSync(directory)).toHaveLength(2);
		expect(records(directory)).toHaveLength(6);
	});

	it.runIf(posix)("refuses a directory readable by others", async () => {
		const { env, state, directory } = sandbox();
		mkdirSync(join(state, "pi-ext"), { recursive: true, mode: 0o700 });
		chmodSync(join(state, "pi-ext"), 0o755);

		await logOnce(env);

		expect(existsSync(directory)).toBe(false);
	});

	it.runIf(posix)("refuses a symlinked extension directory", async () => {
		const { env, state, directory } = sandbox();
		const target = join(state, "elsewhere");
		mkdirSync(target, { recursive: true, mode: 0o700 });
		mkdirSync(join(directory, ".."), { recursive: true, mode: 0o700 });
		chmodSync(join(state, "pi-ext"), 0o700);
		symlinkSync(target, directory);

		await logOnce(env);

		expect(readdirSync(target)).toEqual([]);
	});
});