@amkisko/json-logging 0.0.0-stage → 0.1.0

package/dist/http.js

@@ -0,0 +1,34 @@
+/**
+ * Shared HTTP helpers: ambient logger binding, request context, and completion lines.
+ * Framework adapters live on separate entrypoints (`./hono`, `./express`, ...).
+ *
+ * @example
+ * ```ts
+ * import { bindHttpLogger, httpLogger, withHttpContext } from "@amkisko/json-logging/http";
+ *
+ * bindHttpLogger(httpLogger({ loggerOptions: { base: { service: "api" } } }));
+ * await withHttpContext({ method: "GET", path: "/" }, () => {
+ *   httpLogger().info("inside request");
+ * });
+ * ```
+ *
+ * @module
+ */
+import { bindHttpLogger, getAmbientHttpLogger } from "./http-ambient.js";
+import { createLogger } from "./json-logging.js";
+export { bindHttpLogger, bindLoggerFromOptions, resetHttpLoggerForTests, } from "./http-ambient.js";
+export { allocateRequestId, defaultRandomId, fallbackRequestId, httpFieldsFrom, isValidRequestId, logRequestCompletion, pickAllowlistedHeaders, pickContextKeys, REQUEST_ID_PATTERN, requestPathFromUrl, withHttpContext, } from "./http-context.js";
+/** Resolve the ambient HTTP logger, or create and bind one from options. */
+export function httpLogger(options) {
+    if (options?.logger) {
+        return options.logger;
+    }
+    const ambient = getAmbientHttpLogger();
+    if (ambient) {
+        return ambient;
+    }
+    const created = createLogger(options?.loggerOptions);
+    bindHttpLogger(created);
+    return created;
+}
+//# sourceMappingURL=http.js.map

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Structured JSON logging with ActiveSupport-style `tagged` and `withContext`.
+ *
+ * @example
+ * ```ts
+ * import { createLogger, withContext } from "@amkisko/json-logging";
+ *
+ * const logger = createLogger({ base: { service: "api" } });
+ * await withContext({ requestId: "abc" }, async () => {
+ *   logger.info("handled request");
+ * });
+ * ```
+ *
+ * @module
+ */
+export type { ConsoleMethodName, ConsoleMethods } from "./console-state.js";
+export { captureConsoleMethods, getBridgeOriginals, isInBridge, } from "./console-state.js";
+export type { AlsConstructor, AlsInstance, ContextFields } from "./context.js";
+export { getBlockTags, getContext, isAsyncLocalStorageAvailable, peekLogStore, withContext, } from "./context.js";
+export { createLogger, JsonLogging } from "./json-logging.js";
+export { Logger } from "./logger.js";
+export type { CompiledRedactPath } from "./redact.js";
+export { applyCompiledRedactPaths, applyRedactPaths, compileRedactPaths, } from "./redact.js";
+export { isSensitiveKey, MAX_CONTEXT_SIZE, MAX_DEPTH, MAX_STRING_LENGTH, prepareTags, sanitizeError, sanitizeHash, sanitizeString, } from "./sanitize.js";
+export { buildFallbackRecord, buildRecord, currentTimestamp, formatTimestamp, parseMessage, SYSTEM_KEYS, toJsonLine, } from "./serialize.js";
+export { isEnabled, LEVEL_ORDER, SEVERITY_NAMES, severityName } from "./severity.js";
+export { consoleSink, consoleSinkFrom, streamSink } from "./sinks.js";
+export type { PerformanceLike } from "./timestamp.js";
+export { defaultPerformance } from "./timestamp.js";
+export type { ContextProvider, FieldSerializer, JsonPrimitive, JsonValue, Level, LoggerOptions, LogMessage, LogRecord, SeverityName, Sink, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,26 @@
+/**
+ * Structured JSON logging with ActiveSupport-style `tagged` and `withContext`.
+ *
+ * @example
+ * ```ts
+ * import { createLogger, withContext } from "@amkisko/json-logging";
+ *
+ * const logger = createLogger({ base: { service: "api" } });
+ * await withContext({ requestId: "abc" }, async () => {
+ *   logger.info("handled request");
+ * });
+ * ```
+ *
+ * @module
+ */
+export { captureConsoleMethods, getBridgeOriginals, isInBridge, } from "./console-state.js";
+export { getBlockTags, getContext, isAsyncLocalStorageAvailable, peekLogStore, withContext, } from "./context.js";
+export { createLogger, JsonLogging } from "./json-logging.js";
+export { Logger } from "./logger.js";
+export { applyCompiledRedactPaths, applyRedactPaths, compileRedactPaths, } from "./redact.js";
+export { isSensitiveKey, MAX_CONTEXT_SIZE, MAX_DEPTH, MAX_STRING_LENGTH, prepareTags, sanitizeError, sanitizeHash, sanitizeString, } from "./sanitize.js";
+export { buildFallbackRecord, buildRecord, currentTimestamp, formatTimestamp, parseMessage, SYSTEM_KEYS, toJsonLine, } from "./serialize.js";
+export { isEnabled, LEVEL_ORDER, SEVERITY_NAMES, severityName } from "./severity.js";
+export { consoleSink, consoleSinkFrom, streamSink } from "./sinks.js";
+export { defaultPerformance } from "./timestamp.js";
+//# sourceMappingURL=index.js.map

package/dist/json-logging.d.ts

@@ -0,0 +1,9 @@
+import { Logger } from "./logger.js";
+import type { LoggerOptions } from "./types.js";
+/** Create a {@link Logger} with optional level, sink, base fields, redact, and serializers. */
+export declare function createLogger(options?: LoggerOptions): Logger;
+/** ActiveSupport-style factory: `JsonLogging.new(options)` mirrors {@link createLogger}. */
+export declare const JsonLogging: {
+    new: (options?: LoggerOptions) => Logger;
+};
+//# sourceMappingURL=json-logging.d.ts.map

package/dist/json-logging.js

@@ -0,0 +1,12 @@
+import { Logger } from "./logger.js";
+/** Create a {@link Logger} with optional level, sink, base fields, redact, and serializers. */
+export function createLogger(options = {}) {
+    return new Logger(options);
+}
+/** ActiveSupport-style factory: `JsonLogging.new(options)` mirrors {@link createLogger}. */
+export const JsonLogging = {
+    new(options = {}) {
+        return createLogger(options);
+    },
+};
+//# sourceMappingURL=json-logging.js.map

package/dist/koa.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Koa middleware that attaches request context (and optional completion lines).
+ *
+ * @example
+ * ```ts
+ * import { withKoaLogging } from "@amkisko/json-logging/koa";
+ * app.use(withKoaLogging({ logCompletion: true }));
+ * ```
+ *
+ * @module
+ */
+import type { Logger } from "./logger.js";
+import type { LoggerOptions } from "./types.js";
+/** Minimal Koa context shape (no Koa runtime dependency). */
+export type KoaContextLike = {
+    method: string;
+    path?: string;
+    url?: string;
+    status?: number;
+    get: (name: string) => string;
+};
+/** Options for {@link withKoaLogging}. */
+export type WithKoaLoggingOptions = {
+    headerName?: string;
+    logger?: Logger;
+    loggerOptions?: LoggerOptions;
+    headersAllowlist?: readonly string[];
+    logCompletion?: boolean;
+};
+/** Koa-style middleware function. */
+export type KoaMiddleware = (ctx: KoaContextLike, next: () => Promise<void>) => Promise<void>;
+/** Build Koa middleware: `(ctx, next) => ...`. Bind loggers via `./http`. */
+export declare function withKoaLogging(options?: WithKoaLoggingOptions): KoaMiddleware;
+//# sourceMappingURL=koa.d.ts.map

package/dist/koa.js

@@ -0,0 +1,54 @@
+/**
+ * Koa middleware that attaches request context (and optional completion lines).
+ *
+ * @example
+ * ```ts
+ * import { withKoaLogging } from "@amkisko/json-logging/koa";
+ * app.use(withKoaLogging({ logCompletion: true }));
+ * ```
+ *
+ * @module
+ */
+import { bindLoggerFromOptions, getAmbientHttpLogger } from "./http-ambient.js";
+import { httpFieldsFrom, logRequestCompletion, withHttpContext, } from "./http-context.js";
+/** Build Koa middleware: `(ctx, next) => ...`. Bind loggers via `./http`. */
+export function withKoaLogging(options = {}) {
+    bindLoggerFromOptions(options);
+    const headerName = options.headerName ?? "x-request-id";
+    return async (ctx, next) => {
+        const existing = ctx.get(headerName);
+        const input = {
+            method: ctx.method,
+            path: ctx.path,
+            url: ctx.url,
+            requestId: existing.length > 0 ? existing : undefined,
+            headers: {
+                get: (name) => {
+                    const value = ctx.get(name);
+                    return value.length > 0 ? value : null;
+                },
+            },
+        };
+        const started = Date.now();
+        const fields = httpFieldsFrom(input, headerName);
+        await withHttpContext(input, async () => {
+            try {
+                await next();
+            }
+            finally {
+                if (options.logCompletion) {
+                    const logger = options.logger ?? getAmbientHttpLogger();
+                    if (logger) {
+                        logRequestCompletion(logger, {
+                            method: typeof fields.method === "string" ? fields.method : undefined,
+                            path: typeof fields.path === "string" ? fields.path : undefined,
+                            status: typeof ctx.status === "number" ? ctx.status : 0,
+                            elapsedMs: Date.now() - started,
+                        });
+                    }
+                }
+            }
+        }, options);
+    };
+}
+//# sourceMappingURL=koa.js.map

package/dist/logger.d.ts

@@ -0,0 +1,46 @@
+import type { ContextProvider, FieldSerializer, Level, LoggerOptions, LogMessage, Sink } from "./types.js";
+/** Structured logger: severity methods, sticky tags, child loggers, never-raise emit path. */
+export declare class Logger {
+    /** Minimum level that will be written. */
+    readonly level: Level;
+    /** Destination for JSON lines. */
+    readonly sink: Sink;
+    /** Sanitized root fields merged into every line. */
+    readonly base: Record<string, unknown>;
+    /** Optional clock override (tests). */
+    readonly clock?: () => Date;
+    /** Sticky tags from construction or {@link Logger.tagged}. */
+    readonly tags: readonly string[];
+    /** Configured redact paths (dot notation). */
+    readonly redact: readonly string[];
+    /** Root-field serializers. */
+    readonly serializers: Readonly<Record<string, FieldSerializer>>;
+    /** Optional ambient context provider. */
+    readonly contextProvider?: ContextProvider;
+    private readonly compiledRedact;
+    constructor(options?: LoggerOptions);
+    /** True when a message at `level` would be emitted. */
+    isLevelEnabled(level: Level): boolean;
+    /** Emit a debug line when enabled. */
+    debug(message: LogMessage): void;
+    /** Emit an info line when enabled. */
+    info(message: LogMessage): void;
+    /** Emit a warn line when enabled. */
+    warn(message: LogMessage): void;
+    /** Emit an error line when enabled. */
+    error(message: LogMessage): void;
+    /** Emit a fatal line when enabled. */
+    fatal(message: LogMessage): void;
+    /** Child logger with extra root bindings merged into `base`. */
+    child(bindings: Record<string, unknown>): Logger;
+    /**
+     * Block form runs `fn` with nested tags; sticky form returns a child logger.
+     * Pass tags then a callback, or only tags for a sticky child.
+     */
+    tagged(callback: () => unknown): unknown;
+    tagged(tag: string | number | boolean, callback: () => unknown): unknown;
+    tagged(tag: string | number | boolean, tag2: string | number | boolean, callback: () => unknown): unknown;
+    tagged(...tags: (string | number | boolean | null | undefined)[]): Logger;
+    private log;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.js

@@ -0,0 +1,130 @@
+import { withBlockTags } from "./context.js";
+import { compileRedactPaths } from "./redact.js";
+import { prepareTags, sanitizeHash } from "./sanitize.js";
+import { buildFallbackRecord, buildRecord, toJsonLine } from "./serialize.js";
+import { isEnabled } from "./severity.js";
+import { consoleSink } from "./sinks.js";
+function isCallback(value) {
+    return typeof value === "function";
+}
+/** Structured logger: severity methods, sticky tags, child loggers, never-raise emit path. */
+export class Logger {
+    /** Minimum level that will be written. */
+    level;
+    /** Destination for JSON lines. */
+    sink;
+    /** Sanitized root fields merged into every line. */
+    base;
+    /** Optional clock override (tests). */
+    clock;
+    /** Sticky tags from construction or {@link Logger.tagged}. */
+    tags;
+    /** Configured redact paths (dot notation). */
+    redact;
+    /** Root-field serializers. */
+    serializers;
+    /** Optional ambient context provider. */
+    contextProvider;
+    compiledRedact;
+    constructor(options = {}) {
+        this.level = options.level ?? "info";
+        this.sink = options.sink ?? consoleSink();
+        this.base = options.base ? sanitizeHash(options.base) : {};
+        this.clock = options.clock;
+        this.tags = options.tags ? prepareTags(options.tags) : [];
+        this.redact = options.redact ? [...options.redact] : [];
+        this.serializers = options.serializers ? { ...options.serializers } : {};
+        this.contextProvider = options.contextProvider;
+        this.compiledRedact = compileRedactPaths(this.redact);
+    }
+    /** True when a message at `level` would be emitted. */
+    isLevelEnabled(level) {
+        return isEnabled(this.level, level);
+    }
+    /** Emit a debug line when enabled. */
+    debug(message) {
+        this.log("debug", message);
+    }
+    /** Emit an info line when enabled. */
+    info(message) {
+        this.log("info", message);
+    }
+    /** Emit a warn line when enabled. */
+    warn(message) {
+        this.log("warn", message);
+    }
+    /** Emit an error line when enabled. */
+    error(message) {
+        this.log("error", message);
+    }
+    /** Emit a fatal line when enabled. */
+    fatal(message) {
+        this.log("fatal", message);
+    }
+    /** Child logger with extra root bindings merged into `base`. */
+    child(bindings) {
+        return new Logger({
+            level: this.level,
+            sink: this.sink,
+            clock: this.clock,
+            tags: this.tags,
+            redact: this.redact,
+            serializers: this.serializers,
+            contextProvider: this.contextProvider,
+            base: { ...this.base, ...sanitizeHash(bindings) },
+        });
+    }
+    tagged(...args) {
+        if (args.length === 0) {
+            return this;
+        }
+        const last = args[args.length - 1];
+        if (isCallback(last)) {
+            const tags = prepareTags(args.slice(0, -1));
+            return withBlockTags(tags, last);
+        }
+        const tags = prepareTags(args);
+        return new Logger({
+            level: this.level,
+            sink: this.sink,
+            clock: this.clock,
+            base: this.base,
+            redact: this.redact,
+            serializers: this.serializers,
+            contextProvider: this.contextProvider,
+            tags: [...this.tags, ...tags],
+        });
+    }
+    log(level, message) {
+        if (!this.isLevelEnabled(level)) {
+            return;
+        }
+        try {
+            const record = buildRecord({
+                message,
+                level,
+                stickyTags: this.tags,
+                base: this.base,
+                preparedBase: true,
+                preparedTags: true,
+                clock: this.clock,
+                compiledRedact: this.compiledRedact,
+                serializers: this.serializers,
+                contextProvider: this.contextProvider,
+            });
+            const line = toJsonLine(record);
+            void this.sink.write(line, record);
+        }
+        catch (error) {
+            try {
+                const fallback = buildFallbackRecord(level, message, error, this.clock);
+                const line = toJsonLine(fallback);
+                void this.sink.write(line, fallback);
+            }
+            catch {
+                // Last resort: never throw from the log path.
+            }
+        }
+    }
+}
+//# sourceMappingURL=logger.js.map

package/dist/next.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Next.js helpers: wrap middleware or route handlers with request-scoped log context.
+ *
+ * @example
+ * ```ts
+ * import { withRequestLogging } from "@amkisko/json-logging/next";
+ * import { httpLogger } from "@amkisko/json-logging/http";
+ *
+ * export default withRequestLogging(async (req) => {
+ *   httpLogger().info({ path: req.nextUrl?.pathname });
+ * });
+ * ```
+ *
+ * @module
+ */
+import { allocateRequestId, defaultRandomId, fallbackRequestId } from "./http-context.js";
+import type { Logger } from "./logger.js";
+import type { LoggerOptions } from "./types.js";
+/** Minimal Next request shape used by the wrapper (no Next runtime dependency). */
+export type RequestLike = {
+    headers: Headers;
+    method?: string;
+    url?: string;
+    nextUrl?: {
+        pathname?: string;
+    };
+};
+/** Options for {@link withRequestLogging}. */
+export type WithRequestLoggingOptions = {
+    headerName?: string;
+    logger?: Logger;
+    loggerOptions?: LoggerOptions;
+};
+export { allocateRequestId, defaultRandomId, fallbackRequestId };
+/**
+ * Wrap a Next.js middleware or route handler with request-scoped context.
+ * Bind loggers via `@amkisko/json-logging/http` (`bindHttpLogger` / `httpLogger`).
+ */
+export declare function withRequestLogging<TArgs extends unknown[], TResult>(handler: (request: RequestLike, ...rest: TArgs) => TResult | Promise<TResult>, options?: WithRequestLoggingOptions): (request: RequestLike, ...rest: TArgs) => Promise<TResult>;
+//# sourceMappingURL=next.d.ts.map

package/dist/next.js

@@ -0,0 +1,34 @@
+/**
+ * Next.js helpers: wrap middleware or route handlers with request-scoped log context.
+ *
+ * @example
+ * ```ts
+ * import { withRequestLogging } from "@amkisko/json-logging/next";
+ * import { httpLogger } from "@amkisko/json-logging/http";
+ *
+ * export default withRequestLogging(async (req) => {
+ *   httpLogger().info({ path: req.nextUrl?.pathname });
+ * });
+ * ```
+ *
+ * @module
+ */
+import { bindLoggerFromOptions } from "./http-ambient.js";
+import { allocateRequestId, defaultRandomId, fallbackRequestId, withHttpContext, } from "./http-context.js";
+export { allocateRequestId, defaultRandomId, fallbackRequestId };
+/**
+ * Wrap a Next.js middleware or route handler with request-scoped context.
+ * Bind loggers via `@amkisko/json-logging/http` (`bindHttpLogger` / `httpLogger`).
+ */
+export function withRequestLogging(handler, options = {}) {
+    bindLoggerFromOptions(options);
+    return async (request, ...rest) => {
+        return (await withHttpContext({
+            headers: request.headers,
+            method: request.method,
+            url: request.url,
+            path: request.nextUrl?.pathname,
+        }, () => handler(request, ...rest), options));
+    };
+}
+//# sourceMappingURL=next.js.map

package/dist/objects.d.ts

@@ -0,0 +1,12 @@
+export declare function isPlainObject(value: unknown): value is {
+    [key: string]: unknown;
+};
+export declare function plainObjectFrom(value: object): {
+    [key: string]: unknown;
+};
+export declare function readObjectField(record: {
+    [key: string]: unknown;
+}, key: string): {
+    [key: string]: unknown;
+};
+//# sourceMappingURL=objects.d.ts.map

package/dist/objects.js

@@ -0,0 +1,18 @@
+export function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function plainObjectFrom(value) {
+    const result = {};
+    for (const key of Object.keys(value)) {
+        result[key] = Reflect.get(value, key);
+    }
+    return result;
+}
+export function readObjectField(record, key) {
+    const value = record[key];
+    if (isPlainObject(value)) {
+        return value;
+    }
+    return {};
+}
+//# sourceMappingURL=objects.js.map

package/dist/redact.d.ts

@@ -0,0 +1,9 @@
+/** Dot-path segments after {@link compileRedactPaths} (config-time). */
+export type CompiledRedactPath = readonly string[];
+/** Compile redact paths once at logger construction. Config-time only. */
+export declare function compileRedactPaths(paths: readonly string[]): CompiledRedactPath[];
+/** Apply precompiled redact paths to a value tree. */
+export declare function applyCompiledRedactPaths(value: unknown, paths: readonly CompiledRedactPath[]): unknown;
+/** Apply string paths (compiles each call). Prefer compileRedactPaths on hot paths. */
+export declare function applyRedactPaths(value: unknown, paths: readonly string[]): unknown;
+//# sourceMappingURL=redact.d.ts.map

package/dist/redact.js

@@ -0,0 +1,77 @@
+import { plainObjectFrom } from "./objects.js";
+const FILTERED = "[FILTERED]";
+function splitPath(path) {
+    if (path.length === 0) {
+        return undefined;
+    }
+    const parts = path.split(".");
+    if (parts.some((part) => part.length === 0)) {
+        return undefined;
+    }
+    return parts;
+}
+/** Compile redact paths once at logger construction. Config-time only. */
+export function compileRedactPaths(paths) {
+    const compiled = [];
+    for (const path of paths) {
+        const parts = splitPath(path);
+        if (parts) {
+            compiled.push(parts);
+        }
+    }
+    return compiled;
+}
+function redactArray(value, parts, index, key) {
+    if (key === "*") {
+        return value.map((item) => redactAt(item, parts, index + 1));
+    }
+    const idx = Number(key);
+    if (!Number.isInteger(idx) || idx < 0 || idx >= value.length) {
+        return value;
+    }
+    const copy = value.slice();
+    copy[idx] = redactAt(copy[idx], parts, index + 1);
+    return copy;
+}
+function redactObject(value, parts, index, key) {
+    if (key === "*") {
+        const out = {};
+        for (const childKey of Object.keys(value)) {
+            out[childKey] = redactAt(value[childKey], parts, index + 1);
+        }
+        return out;
+    }
+    if (!(key in value)) {
+        return value;
+    }
+    return {
+        ...value,
+        [key]: redactAt(value[key], parts, index + 1),
+    };
+}
+function redactAt(value, parts, index) {
+    if (index >= parts.length) {
+        return FILTERED;
+    }
+    if (typeof value !== "object" || value === null) {
+        return value;
+    }
+    const key = String(parts[index]);
+    if (Array.isArray(value)) {
+        return redactArray(value, parts, index, key);
+    }
+    return redactObject(plainObjectFrom(value), parts, index, key);
+}
+/** Apply precompiled redact paths to a value tree. */
+export function applyCompiledRedactPaths(value, paths) {
+    let current = value;
+    for (const parts of paths) {
+        current = redactAt(current, parts, 0);
+    }
+    return current;
+}
+/** Apply string paths (compiles each call). Prefer compileRedactPaths on hot paths. */
+export function applyRedactPaths(value, paths) {
+    return applyCompiledRedactPaths(value, compileRedactPaths(paths));
+}
+//# sourceMappingURL=redact.js.map

package/dist/remix.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Remix helpers: run handleRequest / loader bodies with request-scoped log context.
+ *
+ * @example
+ * ```ts
+ * import { withRemixContext } from "@amkisko/json-logging/remix";
+ * import { httpLogger } from "@amkisko/json-logging/http";
+ *
+ * return withRemixContext({ request, context }, () => {
+ *   httpLogger().info("loading");
+ *   return handle(request);
+ * });
+ * ```
+ *
+ * @module
+ */
+import type { Logger } from "./logger.js";
+import type { LoggerOptions } from "./types.js";
+/** Minimal Remix request shape (no Remix runtime dependency). */
+export type RemixRequestLike = {
+    method?: string;
+    url?: string;
+    headers?: Headers;
+};
+/** Load / app context bag passed into Remix. */
+export type RemixContextBag = Record<string, unknown>;
+/** Options for {@link withRemixContext}. */
+export type WithRemixContextOptions = {
+    logger?: Logger;
+    loggerOptions?: LoggerOptions;
+    requestIdHeader?: string;
+    /** Allowlisted keys copied from load context into log context. Default: none. */
+    contextKeys?: readonly string[];
+};
+/**
+ * Run a Remix handleRequest / middleware / loader body with ALS context.
+ * Bind loggers via `@amkisko/json-logging/http` (`bindHttpLogger` / `httpLogger`).
+ */
+export declare function withRemixContext<T>(input: {
+    request?: RemixRequestLike;
+    context?: RemixContextBag;
+}, fn: () => T | Promise<T>, options?: WithRemixContextOptions): T | Promise<T>;
+//# sourceMappingURL=remix.d.ts.map

package/dist/remix.js

@@ -0,0 +1,38 @@
+/**
+ * Remix helpers: run handleRequest / loader bodies with request-scoped log context.
+ *
+ * @example
+ * ```ts
+ * import { withRemixContext } from "@amkisko/json-logging/remix";
+ * import { httpLogger } from "@amkisko/json-logging/http";
+ *
+ * return withRemixContext({ request, context }, () => {
+ *   httpLogger().info("loading");
+ *   return handle(request);
+ * });
+ * ```
+ *
+ * @module
+ */
+import { bindLoggerFromOptions } from "./http-ambient.js";
+import { pickContextKeys, withHttpContext } from "./http-context.js";
+/**
+ * Run a Remix handleRequest / middleware / loader body with ALS context.
+ * Bind loggers via `@amkisko/json-logging/http` (`bindHttpLogger` / `httpLogger`).
+ */
+export function withRemixContext(input, fn, options = {}) {
+    bindLoggerFromOptions(options);
+    const requestId = input.context?.requestId != null ? String(input.context.requestId) : undefined;
+    return withHttpContext({
+        headers: input.request?.headers,
+        method: input.request?.method,
+        url: input.request?.url,
+        requestId,
+    }, fn, {
+        headerName: options.requestIdHeader,
+        logger: options.logger,
+        loggerOptions: options.loggerOptions,
+        extra: pickContextKeys(input.context, options.contextKeys),
+    });
+}
+//# sourceMappingURL=remix.js.map