@prosopo/logger 1.0.4 → 2.0.1

package/src/tests/logger.unit.test.ts

@@ -12,8 +12,24 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import { stringifyBigInts } from "@prosopo/util";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { getLogger, stringifyBigInts } from "../logger.js";
+import {
+	getLogger,
+	parseDirectives,
+	parseLogLevel,
+	resolveLevel,
+	setGlobalDirectives,
+} from "../logger.js";
+
+// print() re-resolves PROSOPO_LOG_LEVEL directives at print time, so a stray
+// env value (e.g. PROSOPO_LOG_LEVEL=fatal) would otherwise suppress output that
+// these tests expect. Reset directives before every test to keep the suite
+// deterministic regardless of the developer's environment.
+beforeEach(() => {
+	setGlobalDirectives("");
+});
+
 describe("unpackError", () => {
 	let captured: string[] = [];
 
@@ -79,7 +95,7 @@ describe("unpackError", () => {
 });
 
 describe("stringifyBigInts", () => {
-	it("should strigify big int", () => {
+	it("should stringify big int", () => {
 		const bigInt = BigInt(12345678901234567890n);
 
 		const stringified = stringifyBigInts(bigInt);
@@ -132,3 +148,253 @@ describe("stringifyBigInts", () => {
 		]);
 	});
 });
+
+describe("parseLogLevel", () => {
+	it("parses a bare level", () => {
+		expect(parseLogLevel("warn")).toBe("warn");
+	});
+
+	it("extracts the global level from a directive string", () => {
+		expect(parseLogLevel("warn,database=trace")).toBe("warn");
+	});
+
+	it("returns the fallback for a directives-only string", () => {
+		expect(parseLogLevel("database=trace", "info")).toBe("info");
+	});
+
+	it("returns the fallback for undefined", () => {
+		expect(parseLogLevel(undefined, "info")).toBe("info");
+	});
+});
+
+describe("parseDirectives", () => {
+	it("parses a bare level as the global default (empty-string key)", () => {
+		const directives = parseDirectives("debug");
+		expect(directives.get("")).toBe("debug");
+	});
+
+	it("parses scope=level pairs", () => {
+		const directives = parseDirectives("provider:db=debug,provider:api=trace");
+		expect(directives.get("provider:db")).toBe("debug");
+		expect(directives.get("provider:api")).toBe("trace");
+	});
+
+	it("ignores empty and invalid entries", () => {
+		const directives = parseDirectives(" , provider:db=debug , bogus=nope ");
+		expect(directives.get("provider:db")).toBe("debug");
+		expect(directives.has("bogus")).toBe(false);
+	});
+
+	it("ignores an empty-scope entry like '=debug' (only a bare level sets the global default)", () => {
+		const directives = parseDirectives("=debug");
+		expect(directives.has("")).toBe(false);
+	});
+
+	it("does not let an empty-scope entry override a real scope's level", () => {
+		const directives = parseDirectives("=debug,provider:db=warn");
+		expect(directives.has("")).toBe(false);
+		expect(directives.get("provider:db")).toBe("warn");
+	});
+
+	it("parses per-scope overrides", () => {
+		const d = parseDirectives("warn,database=trace");
+		expect(d.get("")).toBe("warn");
+		expect(d.get("database")).toBe("trace");
+	});
+
+	it("parses directives-only (no global default)", () => {
+		const d = parseDirectives("database=trace");
+		expect(d.has("")).toBe(false);
+		expect(d.get("database")).toBe("trace");
+	});
+});
+
+describe("resolveLevel", () => {
+	it("returns an exact scope match", () => {
+		const directives = parseDirectives("provider:db=debug");
+		expect(resolveLevel("provider:db", directives, "info")).toBe("debug");
+	});
+
+	it("returns the most specific matching prefix", () => {
+		const directives = parseDirectives("provider=warn,provider:db=debug");
+		expect(resolveLevel("provider:db:query", directives, "info")).toBe("debug");
+	});
+
+	it("falls back to the global default when no scope matches", () => {
+		const directives = parseDirectives("other=trace,error");
+		expect(resolveLevel("provider:db", directives, "info")).toBe("error");
+	});
+
+	it("falls back to the supplied fallback when nothing matches", () => {
+		const directives = parseDirectives("other=trace");
+		expect(resolveLevel("provider:db", directives, "info")).toBe("info");
+	});
+
+	it("matches the exact scope", () => {
+		const d = parseDirectives("warn,database:mongo=trace");
+		expect(resolveLevel("database:mongo", d, "info")).toBe("trace");
+	});
+
+	it("matches a prefix when exact scope has no entry", () => {
+		const d = parseDirectives("warn,database=debug");
+		expect(resolveLevel("database:mongo:queries", d, "info")).toBe("debug");
+	});
+
+	it("falls back to global default when no scope matches", () => {
+		const d = parseDirectives("warn,database=debug");
+		expect(resolveLevel("provider:request", d, "info")).toBe("warn");
+	});
+
+	it("returns fallback when directives are empty", () => {
+		const d = parseDirectives("");
+		expect(resolveLevel("any:scope", d, "info")).toBe("info");
+	});
+});
+
+describe("Logger.with subscope + directives", () => {
+	let captured: string[] = [];
+
+	beforeEach(() => {
+		captured = [];
+		const capture = (...args: unknown[]): void => {
+			captured.push(String(args[0]));
+		};
+		vi.spyOn(console, "debug").mockImplementation(capture);
+		vi.spyOn(console, "info").mockImplementation(capture);
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+		setGlobalDirectives("");
+	});
+
+	it("concatenates parent scope with subscope", () => {
+		setGlobalDirectives("parent:child=debug");
+		const child = getLogger("info", "parent").with({}, "child");
+		child.debug(() => ({ msg: "hello" }));
+		expect(captured.length).toBe(1);
+	});
+
+	it("uses the subscope directly when the parent scope is empty (no leading colon)", () => {
+		setGlobalDirectives("admin=debug");
+		const child = getLogger("info", "").with({}, "admin");
+		child.debug(() => ({ msg: "hello" }));
+		// If the scope were ":admin" the "admin" directive would not match and the
+		// debug line would be suppressed.
+		expect(captured.length).toBe(1);
+	});
+
+	it("re-resolves directives at print time rather than baking them in (no sticky level)", () => {
+		setGlobalDirectives("admin=debug");
+		const child = getLogger("info", "").with({}, "admin");
+		// Directive removed after the child was created.
+		setGlobalDirectives("");
+		child.debug(() => ({ msg: "should be suppressed" }));
+		expect(captured.length).toBe(0);
+		// The inherited info level still applies.
+		child.info(() => ({ msg: "visible" }));
+		expect(captured.length).toBe(1);
+	});
+});
+
+describe("setGlobalDirectives", () => {
+	// Restore the env-derived directives so a failing assertion can't leak state
+	// into later tests, without clobbering a non-empty PROSOPO_LOG_LEVEL.
+	afterEach(() => {
+		setGlobalDirectives(process.env.PROSOPO_LOG_LEVEL ?? "");
+	});
+
+	it("affects an existing logger's filtering at emit time", () => {
+		const logger = getLogger("info", "test-scope");
+		const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+		try {
+			// Globally warn: a debug message from a logger created at info is suppressed.
+			setGlobalDirectives("warn");
+			logger.debug(() => ({ msg: "hidden" }));
+			expect(debugSpy).not.toHaveBeenCalled();
+
+			// Raising test-scope to trace at runtime lets the same logger emit debug.
+			setGlobalDirectives("warn,test-scope=trace");
+			logger.debug(() => ({ msg: "shown" }));
+			expect(debugSpy).toHaveBeenCalledTimes(1);
+		} finally {
+			debugSpy.mockRestore();
+		}
+	});
+});
+
+describe("emitted record", () => {
+	afterEach(() => {
+		setGlobalDirectives(process.env.PROSOPO_LOG_LEVEL ?? "");
+	});
+
+	it("uses the message level rather than the logger's configured level", () => {
+		setGlobalDirectives("trace");
+		const logger = getLogger("info", "record-scope");
+		const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+		try {
+			logger.error(() => ({ msg: "boom" }));
+			expect(errorSpy).toHaveBeenCalledTimes(1);
+			const output = errorSpy.mock.calls[0]?.[0];
+			expect(typeof output).toBe("string");
+			const record: { level: string; scope: string; msg: string } = JSON.parse(
+				output as string,
+			);
+			expect(record.level).toBe("error");
+			expect(record.scope).toBe("record-scope");
+			expect(record.msg).toBe("boom");
+		} finally {
+			errorSpy.mockRestore();
+		}
+	});
+});
+
+describe("Logger.with subscope", () => {
+	it("appends subscope to parent scope", () => {
+		const parent = getLogger("info", "provider");
+		const child = parent.with({}, "request");
+		expect(child.getScope()).toBe("provider:request");
+	});
+
+	it("does not produce a leading colon when parent scope is empty", () => {
+		const parent = getLogger("info", "");
+		const child = parent.with({}, "request");
+		expect(child.getScope()).toBe("request");
+	});
+
+	it("trims surrounding whitespace from the subscope", () => {
+		const parent = getLogger("info", "provider");
+		const child = parent.with({}, "  request  ");
+		expect(child.getScope()).toBe("provider:request");
+	});
+
+	it("treats a whitespace-only subscope as absent", () => {
+		const parent = getLogger("info", "provider");
+		const child = parent.with({}, "   ");
+		expect(child.getScope()).toBe("provider");
+	});
+
+	it("merges parent and child default data into emitted records", () => {
+		setGlobalDirectives("trace");
+		const parent = getLogger("info", "test").with({ requestId: "abc" });
+		const child = parent.with({ extra: 1 });
+		const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+		try {
+			child.info(() => ({ data: { perCall: true } }));
+			expect(infoSpy).toHaveBeenCalledTimes(1);
+			const output = infoSpy.mock.calls[0]?.[0];
+			expect(typeof output).toBe("string");
+			const record: { scope: string; data: Record<string, unknown> } =
+				JSON.parse(output as string);
+			expect(record.scope).toBe("test");
+			expect(record.data).toMatchObject({
+				requestId: "abc",
+				extra: 1,
+				perCall: true,
+			});
+		} finally {
+			infoSpy.mockRestore();
+			setGlobalDirectives(process.env.PROSOPO_LOG_LEVEL ?? "");
+		}
+	});
+});