logger/test/logger.test.ts

import { describe, expect, it, vi } from "vitest";
import { createLogger, isLogCallOptions, parseLoggingOverride } from "../src/index";
import type { LogEvent, LogSink } from "../src/index";
import { createSentrySink } from "../src/sentry";

function sink(): { sink: LogSink; events: LogEvent[] } {
    const events: LogEvent[] = [];
    return { events, sink: { emit: (event) => events.push(event) } };
}

describe("parseLoggingOverride", () => {
    it("accepts a global level and a namespace-filtered level", () => {
        expect(parseLoggingOverride("debug")).toEqual({ level: "debug", namespaces: [] });
        expect(parseLoggingOverride("debug:WIDGET, API")).toEqual({
            level: "debug",
            namespaces: ["WIDGET", "API"],
        });
        expect(parseLoggingOverride("verbose")).toBeUndefined();
    });
});

describe("isLogCallOptions", () => {
    it("accepts only known option keys", () => {
        expect(isLogCallOptions({ sentry: true })).toBe(true);
        expect(isLogCallOptions({ suppressSentry: true })).toBe(true);
        expect(isLogCallOptions({ sentry: true, suppressSentry: false })).toBe(true);
        expect(isLogCallOptions({ requestId: "req_1" })).toBe(false);
        expect(isLogCallOptions({ sentry: true, requestId: "req_1" })).toBe(false);
        expect(isLogCallOptions({})).toBe(false);
    });
});

describe("createLogger", () => {
    it("uses environment defaults and never evaluates suppressed lazy data", () => {
        const destination = sink();
        const expensive = vi.fn(() => ({ huge: "snapshot" }));
        const logger = createLogger({ environment: "production", sinks: [destination.sink] });
        logger.debug("ignored", expensive);
        logger.error("kept", expensive);
        expect(expensive).toHaveBeenCalledTimes(1);
        expect(destination.events).toHaveLength(1);
        expect(destination.events[0]?.arguments).toEqual(["kept", { huge: "snapshot" }]);
        expect(destination.events[0]?.async).toBeUndefined();
    });

    it("never starts suppressed async lazy factories", () => {
        const destination = sink();
        const expensive = vi.fn(async () => ({ huge: "snapshot" }));
        const logger = createLogger({ environment: "production", sinks: [destination.sink] });
        logger.debug("ignored", expensive);
        expect(expensive).not.toHaveBeenCalled();
        expect(destination.events).toHaveLength(0);
    });

    it("settles async lazy factories before emitting and sets async", async () => {
        const destination = sink();
        const factory = vi.fn(async () => ({ data: 1 }));
        const logger = createLogger({ environment: "development", sinks: [destination.sink] });
        logger.debug("response", factory);
        expect(factory).toHaveBeenCalledTimes(1);
        expect(destination.events).toHaveLength(0);
        await vi.waitFor(() => expect(destination.events).toHaveLength(1));
        expect(destination.events[0]).toMatchObject({
            arguments: ["response", { data: 1 }],
            async: true,
        });
    });

    it("unwraps direct Promise arguments and keeps rejection reasons", async () => {
        const destination = sink();
        const reason = new Error("boom");
        const logger = createLogger({ environment: "development", sinks: [destination.sink] });
        logger.error("failed", { id: 1 }, Promise.reject(reason));
        expect(destination.events).toHaveLength(0);
        await vi.waitFor(() => expect(destination.events).toHaveLength(1));
        expect(destination.events[0]).toMatchObject({
            arguments: ["failed", { id: 1 }, reason],
            async: true,
        });
    });

    it("applies session namespace filtering to namespace descendants", () => {
        const destination = sink();
        const storage = { getItem: () => "debug:WIDGET" };
        createLogger({
            environment: "production",
            namespace: "WIDGET:Button",
            sessionStorage: storage,
            sinks: [destination.sink],
        }).debug("shown");
        createLogger({
            environment: "production",
            namespace: "API",
            sessionStorage: storage,
            sinks: [destination.sink],
        }).debug("hidden");
        expect(destination.events.map((event) => event.arguments[0])).toEqual(["shown"]);
    });

    it("builds immutable child namespaces and reports failed assertions as errors", () => {
        const destination = sink();
        const root = createLogger({
            environment: "development",
            namespace: "WIDGET",
            sinks: [destination.sink],
        });
        root.child("Button").assert(false, "missing label");
        expect(root.namespace).toBe("WIDGET");
        expect(destination.events[0]).toMatchObject({
            level: "error",
            namespace: "WIDGET:Button",
            arguments: ["Assertion failed", "missing label"],
        });
    });

    it("sends production browser errors to Sentry without writing to the console", () => {
        const destination = sink();
        const consoleError = vi.spyOn(console, "error").mockImplementation(() => undefined);
        const logger = createLogger({
            environment: "production",
            runtime: "browser",
            sentry: destination.sink,
        });
        logger.error("captured");
        expect(destination.events).toHaveLength(1);
        expect(destination.events[0]).toMatchObject({
            sendToSentryIssue: true,
            sendToSentryLogs: false,
            sendToConsole: true,
        });
        expect(consoleError).not.toHaveBeenCalled();
        consoleError.mockRestore();
    });

    it("forces selected events to Sentry Logs without writing them to the console", () => {
        const destination = sink();
        const consoleInfo = vi.spyOn(console, "info").mockImplementation(() => undefined);
        const logger = createLogger({
            environment: "production",
            runtime: "browser",
            sentry: destination.sink,
        });
        logger.info("Cache warmed", { sentry: true });
        expect(destination.events).toHaveLength(1);
        expect(destination.events[0]).toMatchObject({
            level: "info",
            arguments: ["Cache warmed"],
            sendToSentryLogs: true,
            sendToSentryIssue: false,
            sendToConsole: false,
        });
        expect(consoleInfo).not.toHaveBeenCalled();
        consoleInfo.mockRestore();
    });

    it("strips trailing call options from event arguments and supports data plus options", () => {
        const destination = sink();
        const logger = createLogger({
            environment: "production",
            runtime: "browser",
            sentry: destination.sink,
        });
        logger.warn("slow", { ms: 1200 }, { sentry: true });
        expect(destination.events[0]).toMatchObject({
            level: "warn",
            arguments: ["slow", { ms: 1200 }],
            sendToSentryLogs: true,
            sendToConsole: false,
        });
    });

    it("suppresses Sentry Issues when suppressSentry is set", () => {
        const destination = sink();
        const logger = createLogger({
            environment: "production",
            runtime: "browser",
            sentry: destination.sink,
        });
        logger.error("expected", new Error("nope"), { suppressSentry: true });
        expect(destination.events).toHaveLength(1);
        expect(destination.events[0]).toMatchObject({
            sendToSentryIssue: false,
            sendToSentryLogs: false,
            arguments: ["expected", expect.any(Error)],
        });
    });

    it("never marks events for Sentry in development", () => {
        const destination = sink();
        const logger = createLogger({
            environment: "development",
            sinks: [
                destination.sink,
                createSentrySink(
                    {
                        withScope: (callback) =>
                            callback({
                                setLevel: () => undefined,
                                setTag: () => undefined,
                                setExtras: () => undefined,
                            }),
                        captureException: vi.fn(),
                        captureMessage: vi.fn(),
                        logger: {
                            trace: vi.fn(),
                            debug: vi.fn(),
                            info: vi.fn(),
                            warn: vi.fn(),
                            error: vi.fn(),
                        },
                    },
                    { logs: true },
                ),
            ],
        });
        logger.error("local only");
        logger.info("probe", { sentry: true });
        expect(destination.events).toHaveLength(2);
        expect(
            destination.events.every(
                (event) => !event.sendToSentryIssue && !event.sendToSentryLogs,
            ),
        ).toBe(true);
    });

    it("keeps production Node errors on stderr as well as sending them to Sentry", () => {
        const destination = sink();
        const consoleError = vi.spyOn(console, "error").mockImplementation(() => undefined);
        const logger = createLogger({
            environment: "production",
            runtime: "node",
            sentry: destination.sink,
        });
        logger.error("captured");
        expect(destination.events).toHaveLength(1);
        expect(consoleError).toHaveBeenCalledTimes(1);
        consoleError.mockRestore();
    });

    it("mirrors warn to Sentry Logs in production when logs are enabled on the sink", () => {
        const destination = sink();
        const logger = createLogger({
            environment: "production",
            runtime: "browser",
            sinks: [
                destination.sink,
                createSentrySink(
                    {
                        withScope: () => undefined,
                        captureException: vi.fn(),
                        captureMessage: vi.fn(),
                        logger: {
                            trace: vi.fn(),
                            debug: vi.fn(),
                            info: vi.fn(),
                            warn: vi.fn(),
                            error: vi.fn(),
                        },
                    },
                    { logs: true },
                ),
            ],
        });
        logger.warn("noisy");
        logger.info("below default production logs threshold");
        expect(destination.events).toHaveLength(1);
        expect(destination.events[0]).toMatchObject({
            level: "warn",
            sendToSentryLogs: true,
            sendToConsole: false,
        });
    });

    it("mirrors info to Sentry Logs in staging when logs are enabled", () => {
        const destination = sink();
        const logger = createLogger({
            environment: "staging",
            runtime: "browser",
            sinks: [
                destination.sink,
                createSentrySink(
                    {
                        withScope: () => undefined,
                        captureException: vi.fn(),
                        captureMessage: vi.fn(),
                        logger: {
                            trace: vi.fn(),
                            debug: vi.fn(),
                            info: vi.fn(),
                            warn: vi.fn(),
                            error: vi.fn(),
                        },
                    },
                    { logs: true },
                ),
            ],
        });
        logger.info("visible in staging logs");
        logger.debug("still below staging logs threshold");
        expect(destination.events.map((event) => event.arguments[0])).toEqual([
            "visible in staging logs",
        ]);
        expect(destination.events[0]).toMatchObject({
            sendToSentryLogs: true,
            sendToConsole: false,
        });
    });
});