repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
scripts/codegen/pi-ext-debug.test.ts
Rawimport {
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([]);
});
});