pi-harness-runtime 1.1.440 → 1.1.441

package/packages/logging/test/fanout.test.ts

@@ -1,186 +0,0 @@
-/**
- * The delivery semantics of the shipper.
- *
- * Two modes:
- *   - `fallback` (the default): the transports form a chain, the first one
- *     that accepts the batch wins and the later ones are not called.
- *   - `fanout` (explicit opt-in): every transport receives the batch, each
- *     one tracks its own success, and the batch is only spooled when EVERY
- *     transport failed.
- */
-
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { LogShipper } from "../src/shipper.js";
-import { LogSpool } from "../src/spool.js";
-import type { LogBatch, LogTransport } from "../src/types.js";
-
-const created: string[] = [];
-
-function tempDir(): string {
-	const dir = mkdtempSync(join(tmpdir(), "log-fanout-"));
-	created.push(dir);
-	return dir;
-}
-
-afterEach(() => {
-	while (created.length > 0) {
-		rmSync(created.pop() as string, { recursive: true, force: true });
-	}
-});
-
-interface RecordingTransport extends LogTransport {
-	batches: LogBatch[];
-}
-
-function transport(name: string, fail = false): RecordingTransport {
-	const batches: LogBatch[] = [];
-	return {
-		name,
-		batches,
-		async send(batch: LogBatch): Promise<void> {
-			if (fail) throw new Error(`${name} is down`);
-			batches.push(batch);
-		},
-	};
-}
-
-/** A shipper that delivers one record per flush. */
-function buildShipper(options: {
-	transports: LogTransport[];
-	delivery?: "fallback" | "fanout";
-	spoolDir?: string;
-}): LogShipper {
-	return new LogShipper({
-		app: "pi-harness",
-		installationId: "install-1",
-		transports: options.transports,
-		delivery: options.delivery,
-		spool: options.spoolDir ? new LogSpool({ dir: options.spoolDir }) : undefined,
-		buffer: { maxSize: 10, maxBatchSize: 1 },
-		flushIntervalMs: 0,
-	});
-}
-
-describe("the fallback delivery", () => {
-	test("the first transport that accepts the batch wins", async () => {
-		const first = transport("r2");
-		const second = transport("webhook");
-		const shipper = buildShipper({ transports: [first, second] });
-
-		shipper.info("unit", "service.started", "boom");
-		await shipper.flush();
-
-		expect(first.batches).toHaveLength(1);
-		expect(second.batches).toHaveLength(0);
-	});
-
-	test("a failing transport hands over to the next one", async () => {
-		const first = transport("r2", true);
-		const second = transport("webhook");
-		const shipper = buildShipper({ transports: [first, second] });
-
-		shipper.info("unit", "service.started", "boom");
-		await shipper.flush();
-
-		expect(first.batches).toHaveLength(0);
-		expect(second.batches).toHaveLength(1);
-	});
-
-	test("the batch is spooled when every transport failed", async () => {
-		const dir = tempDir();
-		const spool = new LogSpool({ dir });
-		const shipper = buildShipper({
-			transports: [transport("r2", true), transport("webhook", true)],
-			spoolDir: dir,
-		});
-
-		shipper.info("unit", "service.started", "boom");
-		await shipper.flush();
-
-		expect(spool.list().length).toBe(1);
-	});
-});
-
-describe("the fanout delivery", () => {
-	test("every transport receives the batch", async () => {
-		const first = transport("r2");
-		const second = transport("webhook");
-		const shipper = buildShipper({ transports: [first, second], delivery: "fanout" });
-
-		shipper.info("unit", "service.started", "boom");
-		await shipper.flush();
-
-		expect(first.batches).toHaveLength(1);
-		expect(second.batches).toHaveLength(1);
-	});
-
-	test("a failing transport does not stop the others", async () => {
-		const first = transport("r2", true);
-		const second = transport("webhook");
-		const shipper = buildShipper({ transports: [first, second], delivery: "fanout" });
-
-		shipper.info("unit", "service.started", "boom");
-		await shipper.flush();
-
-		expect(first.batches).toHaveLength(0);
-		expect(second.batches).toHaveLength(1);
-	});
-
-	test("the batch is not spooled when one transport accepted it", async () => {
-		const dir = tempDir();
-		const spool = new LogSpool({ dir });
-		const shipper = buildShipper({
-			transports: [transport("r2", true), transport("webhook")],
-			delivery: "fanout",
-			spoolDir: dir,
-		});
-
-		shipper.info("unit", "service.started", "boom");
-		await shipper.flush();
-
-		expect(spool.list()).toHaveLength(0);
-	});
-
-	test("the batch is spooled when every transport failed", async () => {
-		const dir = tempDir();
-		const spool = new LogSpool({ dir });
-		const shipper = buildShipper({
-			transports: [transport("r2", true), transport("webhook", true)],
-			delivery: "fanout",
-			spoolDir: dir,
-		});
-
-		shipper.info("unit", "service.started", "boom");
-		await shipper.flush();
-
-		expect(spool.list()).toHaveLength(1);
-	});
-
-	test("every transport tracks its own delivery state", async () => {
-		const first = transport("r2", true);
-		const second = transport("webhook");
-		const shipper = buildShipper({ transports: [first, second], delivery: "fanout" });
-
-		shipper.info("unit", "service.started", "boom");
-		await shipper.flush();
-
-		const status = shipper.getTransportStatus();
-		expect(status).toHaveLength(2);
-		const r2 = status.find((entry) => entry.name === "r2");
-		const webhook = status.find((entry) => entry.name === "webhook");
-		expect(r2?.failed).toBe(1);
-		expect(r2?.delivered).toBe(0);
-		expect(r2?.lastError).toContain("r2 is down");
-		expect(webhook?.delivered).toBe(1);
-		expect(webhook?.failed).toBe(0);
-		expect(webhook?.lastSuccessAt).toBeDefined();
-	});
-
-	test("the fallback is the default", () => {
-		const shipper = buildShipper({ transports: [transport("r2")] });
-		expect(shipper.deliveryMode).toBe("fallback");
-	});
-});

package/packages/logging/test/identity-transport.test.ts

@@ -1,197 +0,0 @@
-/**
- * Client side identity and transport semantics.
- *
- * The transports form a FALLBACK chain, not a broadcast: the first transport
- * that accepts a batch wins and the later ones are never called. This file
- * documents that behaviour explicitly, because a silent "broadcast" would
- * duplicate every batch.
- */
-
-import { afterEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { LogShipper } from "../src/shipper.js";
-import { resolveInstallationId } from "../src/installation.js";
-import { resolveLogSinkConfig } from "../src/config.js";
-import { LOG_SCHEMA_VERSION, type LogBatch, type LogTransport } from "../src/types.js";
-
-const created: string[] = [];
-
-function tempDir(): string {
-	const dir = mkdtempSync(join(tmpdir(), "log-identity-"));
-	created.push(dir);
-	return dir;
-}
-
-afterEach(() => {
-	while (created.length > 0) {
-		rmSync(created.pop() as string, { recursive: true, force: true });
-	}
-});
-
-function recorder(name: string): { transport: LogTransport; batches: LogBatch[] } {
-	const batches: LogBatch[] = [];
-	return {
-		batches,
-		transport: {
-			name,
-			async send(batch: LogBatch): Promise<void> {
-				batches.push(batch);
-			},
-		},
-	};
-}
-
-describe("transport semantics", () => {
-	test("stops at the first successful transport - the chain is not a broadcast", async () => {
-		const first = recorder("first");
-		const second = recorder("second");
-		const shipper = new LogShipper({
-			transports: [first.transport, second.transport],
-			flushIntervalMs: 0,
-		});
-
-		shipper.info("unit", "service.started");
-		await shipper.flush();
-
-		expect(first.batches).toHaveLength(1);
-		expect(second.batches).toHaveLength(0);
-	});
-
-	test("uses the next transport only when the first one fails", async () => {
-		const failing = recorder("first");
-		failing.transport = {
-			name: "first",
-			async send(): Promise<void> {
-				throw new Error("transport down");
-			},
-		};
-		const second = recorder("second");
-		const shipper = new LogShipper({
-			transports: [failing.transport, second.transport],
-			flushIntervalMs: 0,
-		});
-
-		shipper.info("unit", "service.started");
-		await shipper.flush();
-
-		expect(second.batches).toHaveLength(1);
-	});
-});
-
-describe("batch schema v2", () => {
-	test("carries the schema version, the installation id and the app version", async () => {
-		const transport = recorder("only");
-		const shipper = new LogShipper({
-			app: "pi-harness",
-			appVersion: "9.9.9",
-			installationId: "11111111-2222-3333-4444-555555555555",
-			hostLabel: "laptop",
-			transports: [transport.transport],
-			flushIntervalMs: 0,
-		});
-
-		shipper.info("unit", "service.started");
-		await shipper.flush();
-
-		const batch = transport.batches[0];
-		expect(batch.schemaVersion).toBe(LOG_SCHEMA_VERSION);
-		expect(batch.installationId).toBe("11111111-2222-3333-4444-555555555555");
-		expect(batch.appVersion).toBe("9.9.9");
-		expect(batch.hostLabel).toBe("laptop");
-		expect(batch.batchId.length).toBeGreaterThan(0);
-	});
-
-	test("does not send the hostname as an identity", async () => {
-		const transport = recorder("only");
-		const shipper = new LogShipper({
-			installationId: "11111111-2222-3333-4444-555555555555",
-			transports: [transport.transport],
-			flushIntervalMs: 0,
-		});
-
-		shipper.info("unit", "service.started");
-		await shipper.flush();
-
-		const batch = transport.batches[0];
-		// The hostname may travel as a display label, but the identity is the
-		// installation id.
-		expect(batch.installationId).not.toBe(batch.hostLabel);
-	});
-});
-
-describe("installation identity", () => {
-	test("creates the id once and reuses it", () => {
-		const dir = tempDir();
-		const path = join(dir, "installation-id.txt");
-
-		const first = resolveInstallationId({ path });
-		const second = resolveInstallationId({ path });
-
-		expect(first).toBe(second);
-		expect(existsSync(path)).toBe(true);
-		expect(readFileSync(path, "utf8").trim()).toBe(first);
-	});
-
-	test("replaces an invalid id file", () => {
-		const dir = tempDir();
-		const path = join(dir, "installation-id.txt");
-		writeFileSync(path, "not-a-uuid\n");
-
-		const id = resolveInstallationId({ path });
-
-		expect(id).not.toBe("not-a-uuid");
-		expect(readFileSync(path, "utf8").trim()).toBe(id);
-	});
-});
-
-describe("transport selection", () => {
-	const env = {
-		PI_LOG_R2_BUCKET: "bucket",
-		PI_LOG_R2_ACCESS_KEY_ID: "ak",
-		PI_LOG_R2_SECRET_ACCESS_KEY: "sk",
-		PI_LOG_R2_ENDPOINT: "https://example.invalid",
-	};
-
-	test("auto prefers the webhook ingress so only the server writes to R2", () => {
-		const config = resolveLogSinkConfig({
-			env: { ...env, PI_LOG_WEBHOOK_URL: "https://logs.example.invalid/api/logs" },
-			keysDir: join(tempDir(), "keys"),
-			installationId: "install",
-		});
-
-		expect(config.transports.map((transport) => transport.name)).toEqual(["webhook"]);
-		expect(config.notes.join(" ")).toContain("client ingress point");
-	});
-
-	test("auto falls back to R2 when no webhook is configured", () => {
-		const config = resolveLogSinkConfig({
-			env,
-			keysDir: join(tempDir(), "keys"),
-			installationId: "install",
-		});
-
-		expect(config.transports.map((transport) => transport.name)).toEqual(["r2"]);
-	});
-
-	test("r2+webhook keeps the explicit order (R2 first, webhook as fallback)", () => {
-		const config = resolveLogSinkConfig({
-			env: { ...env, PI_LOG_SINK: "r2+webhook", PI_LOG_WEBHOOK_URL: "https://logs.example.invalid/api/logs" },
-			keysDir: join(tempDir(), "keys"),
-			installationId: "install",
-		});
-
-		expect(config.transports.map((transport) => transport.name)).toEqual(["r2", "webhook"]);
-	});
-
-	test("the installation id reaches the resolved config", () => {
-		const config = resolveLogSinkConfig({
-			env: { PI_LOG_SINK: "off" },
-			keysDir: join(tempDir(), "keys"),
-			installationId: "install",
-		});
-
-		expect(config.installationId).toBe("install");
-	});
-});