@veryfront/ext-content-mdx 0.1.985

package/esm/src/utils/logger/logger.d.ts

@@ -0,0 +1,166 @@
+import { type LogLevelName, type SerializedError } from "./core.js";
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+export type LogFormat = "text" | "json";
+/**
+ * Structured log entry for JSON output.
+ * Fields are designed for easy Grafana/Loki filtering.
+ */
+export interface LogEntry {
+    timestamp: string;
+    level: LogLevelName;
+    service: string;
+    veryfrontVersion: string;
+    message: string;
+    component?: string;
+    context?: Record<string, unknown>;
+    error?: SerializedError;
+    /** @deprecated Use `request_id` instead. Kept for Grafana dashboard transition. Planned removal after Grafana dashboard migration is complete. */
+    requestId?: string;
+    /** @deprecated Use `trace_id` instead. Kept for Grafana dashboard transition. Planned removal after Grafana dashboard migration is complete. */
+    traceId?: string;
+    /** @deprecated Use `span_id` instead. Kept for Grafana dashboard transition. Planned removal after Grafana dashboard migration is complete. */
+    spanId?: string;
+    /** @deprecated Use `project_slug` instead. Kept for Grafana dashboard transition. Planned removal after Grafana dashboard migration is complete. */
+    projectSlug?: string;
+    request_id?: string;
+    trace_id?: string;
+    span_id?: string;
+    project_slug?: string;
+    request_url?: string;
+    domain?: string;
+    project_id?: string;
+    release_id?: string;
+    branch_id?: string;
+    branch_name?: string;
+    run_execution_id?: string;
+    batch_id?: string;
+    run_target?: string;
+    task?: string;
+    event_kind?: string;
+    user_visible?: string;
+    user_id?: string;
+    conversation_id?: string;
+    /** @deprecated Use `user_id` instead. Kept for Grafana dashboard transition. */
+    userId?: string;
+    /** @deprecated Use `conversation_id` instead. Kept for Grafana dashboard transition. */
+    conversationId?: string;
+    /** @deprecated Use `duration_ms` instead. Kept for Grafana dashboard transition. Planned removal after Grafana dashboard migration is complete. */
+    durationMs?: number;
+    duration_ms?: number;
+}
+/** Public API contract for logger. */
+export interface Logger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    time<T>(label: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Create a child logger with additional context bound to all log entries.
+     */
+    child(context: Record<string, unknown>): Logger;
+    /**
+     * Create a component-scoped logger. The component name is included as a
+     * structured `component` field in JSON output and rendered as `[component]`
+     * in text output.
+     */
+    component(name: string): Logger;
+}
+type ConsoleLoggerOptions = {
+    injectTraceContext?: boolean;
+};
+/**
+ * Determine the log level based on environment variables.
+ * Exported for testing purposes.
+ * @internal
+ */
+export declare function getDefaultLevel(envLevel?: string | undefined, debugFlag?: string | undefined): LogLevel;
+/**
+ * Re-read logger configuration from environment variables.
+ * Call after loading .env files so the logger picks up any overrides.
+ */
+export declare function refreshLoggerConfig(): void;
+/** @internal Alias kept for tests. */
+export declare const __resetLoggerConfigForTests: typeof refreshLoggerConfig;
+declare class ConsoleLogger implements Logger {
+    private prefix;
+    private readonly options;
+    private boundContext;
+    private componentName?;
+    constructor(prefix: string, boundContext?: Record<string, unknown>, componentName?: string, options?: ConsoleLoggerOptions);
+    child(context: Record<string, unknown>): Logger;
+    component(name: string): Logger;
+    private formatJson;
+    private formatTextLine;
+    private log;
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    time<T>(label: string, fn: () => Promise<T>): Promise<T>;
+}
+/**
+ * Register the request context getter.
+ * Called by request-context.ts during module initialization.
+ * @internal
+ */
+export declare function __registerRequestContextGetter(getter: () => {
+    logger: Logger;
+} | undefined): void;
+/**
+ * Register the trace context getter.
+ * Called by trace-bridge.ts after OTLP initialization.
+ * @internal
+ */
+export declare function __registerTraceContextGetter(getter: () => {
+    traceId?: string;
+    spanId?: string;
+}): void;
+/**
+ * Reset the trace context getter.
+ * Only intended for testing purposes.
+ * @internal
+ */
+export declare function __resetTraceContextGetterForTests(): void;
+export declare const cliLogger: Logger;
+/** Shared server logger value. */
+export declare const serverLogger: Logger;
+/** Shared renderer logger value. */
+export declare const rendererLogger: Logger;
+/** Shared bundler logger value. */
+export declare const bundlerLogger: Logger;
+/** Shared agent logger value. */
+export declare const agentLogger: Logger;
+export declare const proxyLogger: Logger;
+/** Shared logger value. */
+export declare const logger: Logger;
+/**
+ * Get the base logger without request context awareness.
+ * Use this when you need to create a request-scoped logger in middleware.
+ */
+export declare function getBaseLogger(prefix: string, options?: ConsoleLoggerOptions): ConsoleLogger;
+/**
+ * Create a logger for a specific request context.
+ * Useful for binding request-specific metadata to all logs.
+ */
+export declare function createRequestLogger(baseLogger: Logger, requestContext: {
+    requestId?: string;
+    traceId?: string;
+    projectSlug?: string;
+}): Logger;
+/** Create run user logger. */
+export declare function createRunUserLogger(baseLogger: Logger, runContext: {
+    projectId: string;
+    runExecutionId: string;
+    task: string;
+    batchId?: string | null;
+    runTarget?: string | null;
+    eventKind?: string;
+}): Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/esm/src/utils/logger/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../src/src/utils/logger/logger.ts"],"names":[],"mappings":"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"}

package/esm/src/utils/logger/logger.js

@@ -0,0 +1,445 @@
+import { getEnv, isStdoutTTY } from "../../platform/compat/process.js";
+import { RUNTIME_VERSION } from "../version.js";
+import { ANSI, colorize, formatContextText, formatTimestamp, LEVEL_COLORS, LEVEL_GLYPHS, padTag, serializeError, } from "./core.js";
+import { redactSensitive, sanitizeSerializedError, sanitizeUrlCredentials } from "./redact.js";
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+// ---- Config helpers (must be declared before the eager init below) ----
+const LOG_LEVEL_MAP = {
+    DEBUG: LogLevel.DEBUG,
+    INFO: LogLevel.INFO,
+    WARN: LogLevel.WARN,
+    ERROR: LogLevel.ERROR,
+};
+function parseLogLevel(levelString) {
+    if (!levelString)
+        return undefined;
+    return LOG_LEVEL_MAP[levelString.toUpperCase()];
+}
+/**
+ * Determine the log level based on environment variables.
+ * Exported for testing purposes.
+ * @internal
+ */
+export function getDefaultLevel(envLevel = getEnv("LOG_LEVEL"), debugFlag = getEnv("VERYFRONT_DEBUG")) {
+    const parsedLevel = parseLogLevel(envLevel);
+    if (parsedLevel !== undefined)
+        return parsedLevel;
+    if (debugFlag === "1" || debugFlag === "true")
+        return LogLevel.DEBUG;
+    return LogLevel.INFO;
+}
+/**
+ * Determine log format from environment.
+ * Defaults to JSON in production for Grafana compatibility.
+ */
+function getDefaultFormat(envFormat = getEnv("LOG_FORMAT"), envMode = getEnv("NODE_ENV")) {
+    if (envFormat === "json" || envFormat === "text")
+        return envFormat;
+    return envMode === "production" ? "json" : "text";
+}
+// ---- Eager config resolution ----
+/**
+ * Eagerly resolved at module load time so the config is captured from
+ * host process env vars BEFORE any per-request project env overlay is
+ * active. The project overlay blocks access to host env (for security),
+ * which would cause the logger to fall back to "text" format during SSR.
+ */
+let loggerConfig = {
+    level: getDefaultLevel(),
+    format: getDefaultFormat(),
+};
+/**
+ * Re-read logger configuration from environment variables.
+ * Call after loading .env files so the logger picks up any overrides.
+ */
+export function refreshLoggerConfig() {
+    loggerConfig = {
+        level: getDefaultLevel(),
+        format: getDefaultFormat(),
+    };
+}
+/** @internal Alias kept for tests. */
+export const __resetLoggerConfigForTests = refreshLoggerConfig;
+function resolveLoggerConfig() {
+    return loggerConfig;
+}
+/**
+ * Extract context from variadic args.
+ * First object argument becomes context, errors are handled specially.
+ */
+function extractContext(args) {
+    let context;
+    let error;
+    for (const arg of args) {
+        if (arg instanceof Error) {
+            error = serializeError(arg);
+            continue;
+        }
+        if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
+            const contextArg = arg;
+            if (contextArg.error instanceof Error) {
+                const { error: contextError, ...rest } = contextArg;
+                error = serializeError(contextError);
+                if (Object.keys(rest).length > 0) {
+                    context = { ...context, ...rest };
+                }
+                continue;
+            }
+            context = { ...context, ...contextArg };
+        }
+    }
+    return { context, error };
+}
+const TAG_COLORS = {
+    CLI: ANSI.green,
+    SERVER: ANSI.blue,
+    RENDERER: ANSI.magenta,
+    BUNDLER: ANSI.yellow,
+    AGENT: ANSI.cyan,
+    PROXY: ANSI.cyan,
+    VERYFRONT: ANSI.cyan,
+};
+function isTty() {
+    try {
+        return isStdoutTTY();
+    }
+    catch (_) {
+        /* expected: TTY detection may fail in restricted environments */
+        return false;
+    }
+}
+function shouldUseColor() {
+    const noColor = getEnv("NO_COLOR");
+    const forceColor = getEnv("FORCE_COLOR");
+    const logColor = getEnv("LOG_COLOR");
+    if (forceColor === "0" || logColor === "0")
+        return false;
+    if (noColor !== undefined)
+        return false;
+    if (getEnv("CI") !== undefined)
+        return false;
+    if (forceColor || logColor === "1" || logColor === "true")
+        return true;
+    return isTty();
+}
+function extractToEntryField(entry, context, key, coerce) {
+    if (!(key in context))
+        return;
+    entry[key] = coerce(context[key]);
+    delete context[key];
+}
+class ConsoleLogger {
+    prefix;
+    options;
+    boundContext;
+    componentName;
+    constructor(prefix, boundContext, componentName, options = {}) {
+        this.prefix = prefix;
+        this.options = options;
+        this.boundContext = boundContext ?? {};
+        this.componentName = componentName;
+    }
+    child(context) {
+        return new ConsoleLogger(this.prefix, { ...this.boundContext, ...context }, this.componentName, this.options);
+    }
+    component(name) {
+        return new ConsoleLogger(this.prefix, { ...this.boundContext }, name, this.options);
+    }
+    formatJson(level, message, args) {
+        const { context, error } = extractContext(args);
+        const mergedContext = { ...this.boundContext, ...context };
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            service: this.prefix.toLowerCase(),
+            veryfrontVersion: RUNTIME_VERSION,
+            message,
+        };
+        if (this.componentName)
+            entry.component = this.componentName;
+        // Extract known fields to top level for easier Grafana filtering
+        extractToEntryField(entry, mergedContext, "requestId", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "traceId", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "spanId", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "projectSlug", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "durationMs", (v) => Number(v));
+        // Auto-inject trace context from OTel when not already set
+        if ((this.options.injectTraceContext ?? true) && traceContextGetter && !entry.traceId) {
+            const traceCtx = traceContextGetter();
+            if (traceCtx.traceId) {
+                entry.traceId = traceCtx.traceId;
+                entry.spanId = traceCtx.spanId;
+            }
+        }
+        // Extract standard snake_case fields for Loki filtering
+        extractToEntryField(entry, mergedContext, "request_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "trace_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "span_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "project_slug", (v) => String(v));
+        // request_url / domain are URL-shaped and lifted out of mergedContext
+        // *before* redactSensitive runs, so they bypass the key-based redactor.
+        // Scrub embedded credentials (userinfo, ?access_token=, …) here (#1989).
+        extractToEntryField(entry, mergedContext, "request_url", (v) => sanitizeUrlCredentials(String(v)));
+        extractToEntryField(entry, mergedContext, "domain", (v) => sanitizeUrlCredentials(String(v)));
+        extractToEntryField(entry, mergedContext, "project_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "release_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "branch_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "branch_name", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "run_execution_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "batch_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "run_target", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "task", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "event_kind", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "user_visible", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "duration_ms", (v) => Number(v));
+        extractToEntryField(entry, mergedContext, "user_id", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "conversation_id", (v) => String(v));
+        // Also extract camelCase variants so callers can use either convention
+        extractToEntryField(entry, mergedContext, "userId", (v) => String(v));
+        extractToEntryField(entry, mergedContext, "conversationId", (v) => String(v));
+        // Emit snake_case aliases for camelCase fields (transition period)
+        if (entry.requestId && !entry.request_id)
+            entry.request_id = entry.requestId;
+        if (entry.traceId && !entry.trace_id)
+            entry.trace_id = entry.traceId;
+        if (entry.spanId && !entry.span_id)
+            entry.span_id = entry.spanId;
+        if (entry.projectSlug && !entry.project_slug)
+            entry.project_slug = entry.projectSlug;
+        if (entry.durationMs != null && entry.duration_ms == null)
+            entry.duration_ms = entry.durationMs;
+        if (entry.userId && !entry.user_id)
+            entry.user_id = entry.userId;
+        if (entry.conversationId && !entry.conversation_id) {
+            entry.conversation_id = entry.conversationId;
+        }
+        // Redact credential-like keys from the free-form context bag before
+        // serialization (the deliberate top-level fields above are already
+        // extracted out of mergedContext, so they are unaffected).
+        if (Object.keys(mergedContext).length > 0)
+            entry.context = redactSensitive(mergedContext);
+        // The serialized error (name/message/stack) bypasses the key-based
+        // redactor; scrub credentials embedded in its message/stack (DSNs, Mongo
+        // URIs, ?access_token= URLs, userinfo) before emission (#1989).
+        if (error)
+            entry.error = sanitizeSerializedError(error);
+        return JSON.stringify(entry);
+    }
+    formatTextLine(level, message, args) {
+        const { context, error } = extractContext(args);
+        const mergedContext = { ...this.boundContext, ...context };
+        const enableColor = shouldUseColor();
+        const timestamp = colorize(formatTimestamp(), ANSI.dim, enableColor);
+        const tag = colorize(padTag(this.prefix), TAG_COLORS[this.prefix] ?? ANSI.cyan, enableColor);
+        const glyph = colorize(LEVEL_GLYPHS[level], LEVEL_COLORS[level], enableColor);
+        const componentTag = this.componentName
+            ? ` ${colorize(`[${this.componentName}]`, ANSI.dim, enableColor)}`
+            : "";
+        const contextText = formatContextText(redactSensitive(mergedContext), sanitizeSerializedError(error), enableColor);
+        return `${timestamp}  ${tag} ${glyph}${componentTag} ${message}${contextText}`;
+    }
+    log(level, logLevel, consoleFn, message, args) {
+        const { level: resolvedLevel, format: resolvedFormat } = resolveLoggerConfig();
+        if (resolvedLevel > logLevel)
+            return;
+        const line = resolvedFormat === "json"
+            ? this.formatJson(level, message, args)
+            : this.formatTextLine(level, message, args);
+        consoleFn(line);
+    }
+    debug(message, ...args) {
+        this.log("debug", LogLevel.DEBUG, console.debug, message, args);
+    }
+    info(message, ...args) {
+        this.log("info", LogLevel.INFO, console.log, message, args);
+    }
+    warn(message, ...args) {
+        this.log("warn", LogLevel.WARN, console.warn, message, args);
+    }
+    error(message, ...args) {
+        this.log("error", LogLevel.ERROR, console.error, message, args);
+    }
+    async time(label, fn) {
+        const start = performance.now();
+        try {
+            const result = await fn();
+            const durationMs = performance.now() - start;
+            this.debug(`${label} completed`, { durationMs: Math.round(durationMs) });
+            return result;
+        }
+        catch (error) {
+            const durationMs = performance.now() - start;
+            this.error(`${label} failed`, { durationMs: Math.round(durationMs) }, error);
+            throw error;
+        }
+    }
+}
+function createLogger(prefix, options) {
+    return new ConsoleLogger(prefix, undefined, undefined, options);
+}
+// Base loggers without request context
+const baseCliLogger = createLogger("CLI");
+const baseServerLogger = createLogger("SERVER");
+const baseRendererLogger = createLogger("RENDERER");
+const baseBundlerLogger = createLogger("BUNDLER");
+const baseAgentLogger = createLogger("AGENT");
+const baseProxyLogger = createLogger("PROXY");
+const baseLogger = createLogger("VERYFRONT");
+const BASE_LOGGER_MAP = {
+    CLI: baseCliLogger,
+    SERVER: baseServerLogger,
+    RENDERER: baseRendererLogger,
+    BUNDLER: baseBundlerLogger,
+    AGENT: baseAgentLogger,
+    PROXY: baseProxyLogger,
+};
+/**
+ * Request context getter - set by request-context.ts to avoid circular imports.
+ * This pattern allows the logger module to be imported first without
+ * depending on request-context.ts.
+ */
+let requestContextGetter = null;
+/**
+ * Register the request context getter.
+ * Called by request-context.ts during module initialization.
+ * @internal
+ */
+export function __registerRequestContextGetter(getter) {
+    requestContextGetter = getter;
+}
+/**
+ * Trace context getter - set by trace-bridge.ts to avoid importing OTel
+ * directly in the logger module. Returns the active span's traceId/spanId
+ * when OTel is initialized.
+ */
+let traceContextGetter = null;
+/**
+ * Register the trace context getter.
+ * Called by trace-bridge.ts after OTLP initialization.
+ * @internal
+ */
+export function __registerTraceContextGetter(getter) {
+    traceContextGetter = getter;
+}
+/**
+ * Reset the trace context getter.
+ * Only intended for testing purposes.
+ * @internal
+ */
+export function __resetTraceContextGetterForTests() {
+    traceContextGetter = null;
+}
+function withRequestLogger(base) {
+    const ctx = requestContextGetter?.();
+    return ctx?.logger ?? base;
+}
+/**
+ * Create a context-aware logger proxy that automatically uses
+ * request-scoped context from AsyncLocalStorage when available.
+ */
+function createContextAwareLogger(base) {
+    return {
+        debug(message, ...args) {
+            withRequestLogger(base).debug(message, ...args);
+        },
+        info(message, ...args) {
+            withRequestLogger(base).info(message, ...args);
+        },
+        warn(message, ...args) {
+            withRequestLogger(base).warn(message, ...args);
+        },
+        error(message, ...args) {
+            withRequestLogger(base).error(message, ...args);
+        },
+        time(label, fn) {
+            return withRequestLogger(base).time(label, fn);
+        },
+        child(context) {
+            return withRequestLogger(base).child(context);
+        },
+        component(name) {
+            return createComponentAwareLogger(base, name);
+        },
+    };
+}
+/**
+ * Create a component-scoped logger that still defers request-context
+ * resolution to call time. This avoids eagerly binding to whatever
+ * context exists at module load — critical because component loggers
+ * are typically created as top-level constants.
+ */
+function createComponentAwareLogger(base, componentName) {
+    return {
+        debug(message, ...args) {
+            withRequestLogger(base).component(componentName).debug(message, ...args);
+        },
+        info(message, ...args) {
+            withRequestLogger(base).component(componentName).info(message, ...args);
+        },
+        warn(message, ...args) {
+            withRequestLogger(base).component(componentName).warn(message, ...args);
+        },
+        error(message, ...args) {
+            withRequestLogger(base).component(componentName).error(message, ...args);
+        },
+        time(label, fn) {
+            return withRequestLogger(base).component(componentName).time(label, fn);
+        },
+        child(context) {
+            return withRequestLogger(base).component(componentName).child(context);
+        },
+        component(name) {
+            return createComponentAwareLogger(base, name);
+        },
+    };
+}
+// Context-aware loggers that automatically include request context
+export const cliLogger = createContextAwareLogger(baseCliLogger);
+/** Shared server logger value. */
+export const serverLogger = createContextAwareLogger(baseServerLogger);
+/** Shared renderer logger value. */
+export const rendererLogger = createContextAwareLogger(baseRendererLogger);
+/** Shared bundler logger value. */
+export const bundlerLogger = createContextAwareLogger(baseBundlerLogger);
+/** Shared agent logger value. */
+export const agentLogger = createContextAwareLogger(baseAgentLogger);
+export const proxyLogger = createContextAwareLogger(baseProxyLogger);
+/** Shared logger value. */
+export const logger = createContextAwareLogger(baseLogger);
+/**
+ * Get the base logger without request context awareness.
+ * Use this when you need to create a request-scoped logger in middleware.
+ */
+export function getBaseLogger(prefix, options) {
+    const resolvedPrefix = prefix.toUpperCase();
+    const validPrefix = resolvedPrefix in BASE_LOGGER_MAP ? resolvedPrefix : "VERYFRONT";
+    if (options?.injectTraceContext === false) {
+        return createLogger(validPrefix, options);
+    }
+    return BASE_LOGGER_MAP[resolvedPrefix] ?? baseLogger;
+}
+/**
+ * Create a logger for a specific request context.
+ * Useful for binding request-specific metadata to all logs.
+ */
+export function createRequestLogger(baseLogger, requestContext) {
+    return baseLogger.child(requestContext);
+}
+/** Create run user logger. */
+export function createRunUserLogger(baseLogger, runContext) {
+    return baseLogger.child({
+        project_id: runContext.projectId,
+        run_execution_id: runContext.runExecutionId,
+        ...(runContext.batchId ? { batch_id: runContext.batchId } : {}),
+        ...(runContext.runTarget ? { run_target: runContext.runTarget } : {}),
+        task: runContext.task,
+        event_kind: runContext.eventKind ?? "run_user_log",
+        user_visible: "true",
+    });
+}