@chidchanun/bcp 0.1.21 → 0.1.23

package/packages/server/src/logger.ts

@@ -0,0 +1,474 @@
+import {
+    requestId,
+    requestMethod,
+    requestUrl,
+} from "./request-context.js";
+
+export type LogLevel =
+    | "debug"
+    | "info"
+    | "warn"
+    | "error"
+    | "silent";
+
+export type LogFormat =
+    | "pretty"
+    | "json";
+
+export type LogFields =
+    Record<string, unknown>;
+
+export interface LoggerOptions {
+    name?: string;
+    level?: LogLevel;
+    format?: LogFormat;
+    bindings?: LogFields;
+    write?: (
+        line: string,
+        level: Exclude<LogLevel, "silent">
+    ) => void;
+    now?: () => Date;
+}
+
+export interface Logger {
+    debug(
+        message: string,
+        fields?: LogFields
+    ): void;
+    info(
+        message: string,
+        fields?: LogFields
+    ): void;
+    warn(
+        message: string,
+        fields?: LogFields
+    ): void;
+    error(
+        message: string,
+        fields?: LogFields
+    ): void;
+    child(
+        bindings: LogFields
+    ): Logger;
+}
+
+interface ResolvedLoggerOptions {
+    name: string;
+    level?: LogLevel;
+    format?: LogFormat;
+    bindings: LogFields;
+    write?: LoggerOptions["write"];
+    now: () => Date;
+}
+
+const LOG_LEVEL_WEIGHT:
+Record<LogLevel, number> = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    silent: Number.POSITIVE_INFINITY,
+};
+
+export function createLogger(
+    options: LoggerOptions = {}
+): Logger {
+    const resolved:
+        ResolvedLoggerOptions = {
+        name:
+            normalizeLoggerName(
+                options.name
+            ) ??
+            "bcp",
+        level:
+            options.level,
+        format:
+            options.format,
+        bindings: {
+            ...options.bindings,
+        },
+        write:
+            options.write,
+        now:
+            options.now ??
+            (() => new Date()),
+    };
+
+    return createLoggerInstance(
+        resolved
+    );
+}
+
+export const logger =
+    createLogger();
+
+export async function requestLogger(
+    bindings: LogFields = {}
+): Promise<Logger> {
+    const [
+        id,
+        method,
+        url,
+    ] = await Promise.all([
+        requestId(),
+        requestMethod(),
+        requestUrl(),
+    ]);
+
+    return logger.child({
+        ...bindings,
+        requestId:
+            id,
+        method,
+        path:
+            `${url.pathname}${url.search}`,
+    });
+}
+
+export async function attachRequestId(
+    response: Response
+): Promise<Response> {
+    const id =
+        await requestId();
+    const responseHeaders =
+        new Headers(
+            response.headers
+        );
+
+    responseHeaders.set(
+        "x-request-id",
+        id
+    );
+
+    return new Response(
+        response.body,
+        {
+            status:
+                response.status,
+            statusText:
+                response.statusText,
+            headers:
+                responseHeaders,
+        }
+    );
+}
+
+function createLoggerInstance(
+    options: ResolvedLoggerOptions
+): Logger {
+    const write = (
+        level: Exclude<LogLevel, "silent">,
+        message: string,
+        fields: LogFields = {}
+    ): void => {
+        const configuredLevel =
+            options.level ??
+            resolveEnvironmentLogLevel();
+
+        if (
+            LOG_LEVEL_WEIGHT[level] <
+            LOG_LEVEL_WEIGHT[configuredLevel]
+        ) {
+            return;
+        }
+
+        const record = {
+            timestamp:
+                options.now()
+                    .toISOString(),
+            level,
+            logger:
+                options.name,
+            message,
+            ...options.bindings,
+            ...fields,
+        };
+
+        const format =
+            options.format ??
+            resolveEnvironmentLogFormat();
+        const line =
+            format === "json"
+                ? stringifyLogRecord(
+                    record
+                )
+                : formatPrettyLogRecord(
+                    record
+                );
+
+        if (options.write) {
+            options.write(
+                line,
+                level
+            );
+            return;
+        }
+
+        writeConsoleLine(
+            line,
+            level
+        );
+    };
+
+    return {
+        debug(
+            message,
+            fields
+        ) {
+            write(
+                "debug",
+                message,
+                fields
+            );
+        },
+        info(
+            message,
+            fields
+        ) {
+            write(
+                "info",
+                message,
+                fields
+            );
+        },
+        warn(
+            message,
+            fields
+        ) {
+            write(
+                "warn",
+                message,
+                fields
+            );
+        },
+        error(
+            message,
+            fields
+        ) {
+            write(
+                "error",
+                message,
+                fields
+            );
+        },
+        child(
+            bindings
+        ) {
+            return createLoggerInstance({
+                ...options,
+                bindings: {
+                    ...options.bindings,
+                    ...bindings,
+                },
+            });
+        },
+    };
+}
+
+export function resolveEnvironmentLogLevel():
+LogLevel {
+    return normalizeLogLevel(
+        process.env.BCP_LOG_LEVEL
+    ) ??
+    "info";
+}
+
+export function resolveEnvironmentLogFormat():
+LogFormat {
+    return normalizeLogFormat(
+        process.env.BCP_LOG_FORMAT
+    ) ??
+    "pretty";
+}
+
+function normalizeLogLevel(
+    value:
+        string | undefined
+): LogLevel | null {
+    if (!value) {
+        return null;
+    }
+
+    const normalized =
+        value
+            .trim()
+            .toLowerCase();
+
+    return (
+        normalized === "debug" ||
+        normalized === "info" ||
+        normalized === "warn" ||
+        normalized === "error" ||
+        normalized === "silent"
+    )
+        ? normalized
+        : null;
+}
+
+function normalizeLogFormat(
+    value:
+        string | undefined
+): LogFormat | null {
+    if (!value) {
+        return null;
+    }
+
+    const normalized =
+        value
+            .trim()
+            .toLowerCase();
+
+    return (
+        normalized === "pretty" ||
+        normalized === "json"
+    )
+        ? normalized
+        : null;
+}
+
+function normalizeLoggerName(
+    value:
+        string | undefined
+): string | null {
+    if (!value) {
+        return null;
+    }
+
+    const normalized =
+        value.trim();
+
+    return normalized.length > 0
+        ? normalized
+        : null;
+}
+
+function formatPrettyLogRecord(
+    record: Record<string, unknown>
+): string {
+    const {
+        timestamp,
+        level,
+        logger: loggerName,
+        message,
+        ...fields
+    } = record;
+    const suffix =
+        Object.keys(fields).length > 0
+            ? " " +
+                Object.entries(fields)
+                    .map(
+                        ([key, value]) =>
+                            `${key}=${formatPrettyValue(value)}`
+                    )
+                    .join(" ")
+            : "";
+
+    return (
+        `[${String(timestamp)}] ` +
+        `[${String(level).toUpperCase()}] ` +
+        `[${String(loggerName)}] ` +
+        `${String(message)}${suffix}`
+    );
+}
+
+function formatPrettyValue(
+    value: unknown
+): string {
+    if (
+        typeof value === "string"
+    ) {
+        return /\s/.test(value)
+            ? (
+                JSON.stringify(
+                    value
+                ) ??
+                "\"\""
+            )
+            : value;
+    }
+
+    if (
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        value === null ||
+        value === undefined
+    ) {
+        return String(value);
+    }
+
+    return stringifyLogRecord(
+        value
+    );
+}
+
+function stringifyLogRecord(
+    value: unknown
+): string {
+    const seen =
+        new WeakSet<object>();
+    const serialized =
+        JSON.stringify(
+            value,
+            (_key, item) => {
+                if (
+                    item instanceof Error
+                ) {
+                    return {
+                        name:
+                            item.name,
+                        message:
+                            item.message,
+                        stack:
+                            item.stack,
+                        cause:
+                            item.cause,
+                    };
+                }
+
+                if (
+                    typeof item === "bigint"
+                ) {
+                    return item.toString();
+                }
+
+                if (
+                    item !== null &&
+                    typeof item === "object"
+                ) {
+                    if (seen.has(item)) {
+                        return "[Circular]";
+                    }
+
+                    seen.add(item);
+                }
+
+                return item;
+            }
+        );
+
+    return serialized ??
+        "undefined";
+}
+
+function writeConsoleLine(
+    line: string,
+    level: Exclude<LogLevel, "silent">
+): void {
+    if (level === "error") {
+        console.error(
+            line
+        );
+        return;
+    }
+
+    if (level === "warn") {
+        console.warn(
+            line
+        );
+        return;
+    }
+
+    console.log(
+        line
+    );
+}