@jnpt/nest-logging 0.0.0-stage → 1.0.0

package/dist/fastify/fastify-logging.d.ts

@@ -0,0 +1,25 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { AppLogger } from '../logger/logger';
+import { type ConfigInput } from '../logger/types';
+import { type HeaderValue } from '../internal/http';
+export interface FastifyRequestLike {
+    raw: IncomingMessage;
+    url: string;
+    ip?: string;
+    params?: unknown;
+    body?: unknown;
+    rawBody?: Buffer | string;
+}
+export interface FastifyReplyLike {
+    raw: ServerResponse;
+    header(name: string, value: string): unknown;
+    getHeaders(): Record<string, HeaderValue>;
+}
+type HookDone = (err?: Error) => void;
+type Hook = (request: FastifyRequestLike, reply: FastifyReplyLike, done: HookDone) => void;
+export interface FastifyInstanceLike {
+    addHook(name: 'onRequest' | 'preHandler', hook: Hook): unknown;
+}
+export declare function registerFastifyLogging(fastify: FastifyInstanceLike, log: AppLogger, config?: ConfigInput | null): void;
+export declare function createFastifyLoggingPlugin(log: AppLogger, config?: ConfigInput | null): (fastify: FastifyInstanceLike, _opts: unknown, done: HookDone) => void;
+export {};

package/dist/fastify/fastify-logging.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFastifyLogging = registerFastifyLogging;
+exports.createFastifyLoggingPlugin = createFastifyLoggingPlugin;
+const context_1 = require("../logger/context");
+const logger_1 = require("../logger/logger");
+const types_1 = require("../logger/types");
+const http_1 = require("../internal/http");
+const incoming_1 = require("../internal/incoming");
+const correlationKey = Symbol('nestLoggingCorrelationId');
+// registerFastifyLogging adds hooks to a Fastify instance that log every incoming
+// request + response as a single "request" entry and set up the correlation ID.
+// If config is omitted, the global default config (configureDefaults) is used.
+function registerFastifyLogging(fastify, log, config) {
+    const ownConfig = config ? (0, types_1.buildConfig)(config) : undefined;
+    fastify.addHook('onRequest', (request, reply, done) => {
+        const cfg = ownConfig ?? (0, logger_1.getDefaultConfig)();
+        const url = request.raw.url ?? request.url;
+        // Skip excluded patterns
+        if ((0, http_1.shouldSkip)((0, incoming_1.splitUrl)(url).path, cfg)) {
+            done();
+            return;
+        }
+        // Setup correlation ID
+        const correlationId = (0, incoming_1.firstHeader)(request.raw.headers['x-correlation-id']) || (0, context_1.generateCorrelationId)();
+        request[correlationKey] = correlationId;
+        reply.header(context_1.CorrelationIDHeader, correlationId);
+        (0, incoming_1.trackIncoming)(log, cfg, correlationId, {
+            req: request.raw,
+            res: reply.raw,
+            url,
+            params: () => request.params,
+            body: () => ({
+                raw: typeof request.rawBody === 'string' ? Buffer.from(request.rawBody) : request.rawBody,
+                parsed: request.body,
+            }),
+            ip: () => request.ip,
+            responseHeaders: () => ({ ...reply.raw.getHeaders(), ...reply.getHeaders() }),
+        });
+        (0, context_1.withCorrelationId)(correlationId, () => done());
+    });
+    // Body parsing runs on stream events, which lose the async context;
+    // re-enter it right before the route handler.
+    fastify.addHook('preHandler', (request, _reply, done) => {
+        const correlationId = request[correlationKey];
+        if (correlationId)
+            (0, context_1.withCorrelationId)(correlationId, () => done());
+        else
+            done();
+    });
+}
+// createFastifyLoggingPlugin returns a Fastify plugin for fastify.register().
+// It is not encapsulated (same as wrapping with fastify-plugin), so it covers all routes.
+function createFastifyLoggingPlugin(log, config) {
+    const plugin = (fastify, _opts, done) => {
+        registerFastifyLogging(fastify, log, config);
+        done();
+    };
+    plugin[Symbol.for('skip-override')] = true;
+    plugin[Symbol.for('fastify.display-name')] = 'nest-logging';
+    return plugin;
+}

package/dist/httpclient/logging-fetch.d.ts

@@ -0,0 +1,4 @@
+import { AppLogger } from '../logger/logger';
+import { type ConfigInput } from '../logger/types';
+export type FetchFn = typeof globalThis.fetch;
+export declare function createLoggingFetch(log: AppLogger, config?: ConfigInput | null, baseFetch?: FetchFn): FetchFn;

package/dist/httpclient/logging-fetch.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLoggingFetch = createLoggingFetch;
+const context_1 = require("../logger/context");
+const logger_1 = require("../logger/logger");
+const types_1 = require("../logger/types");
+const http_1 = require("../internal/http");
+// createLoggingFetch returns a fetch() that propagates X-Correlation-ID and logs every call
+// (request + response) as a single "request" entry with extra.direction = "outgoing".
+// If config is omitted, the global default config (configureDefaults) is used.
+// baseFetch defaults to the global fetch (Node >= 18).
+function createLoggingFetch(log, config, baseFetch = globalThis.fetch) {
+    const ownConfig = config ? (0, types_1.buildConfig)(config) : undefined;
+    return async function loggingFetch(input, init) {
+        const cfg = ownConfig ?? (0, logger_1.getDefaultConfig)();
+        const inputRequest = input instanceof Request ? input : undefined;
+        const url = inputRequest ? inputRequest.url : String(input);
+        const method = (init?.method ?? inputRequest?.method ?? 'GET').toUpperCase();
+        // Ensure correlation ID
+        const correlationId = (0, context_1.ensureCorrelationId)();
+        const headers = new Headers(init?.headers ?? inputRequest?.headers);
+        headers.set(context_1.CorrelationIDHeader, correlationId);
+        // Capture request body
+        const bodyBytes = await readRequestBody(init, inputRequest);
+        const requestInfo = {
+            headers: (0, http_1.extractHeaders)(headers, cfg),
+            body: cfg.requestLogging.logBody && bodyBytes ? (0, http_1.parseBody)(bodyBytes, cfg.requestLogging.maxBodySize) : undefined,
+            contentType: headers.get('content-type') ?? undefined,
+            contentLength: bodyBytes && bodyBytes.length > 0 ? bodyBytes.length : undefined,
+        };
+        // Execute request
+        const startTime = performance.now();
+        let response;
+        try {
+            response = await baseFetch(input, { ...init, headers });
+        }
+        catch (err) {
+            const duration = Math.floor(performance.now() - startTime);
+            (0, context_1.withCorrelationId)(correlationId, () => log.errorWithErr('Outgoing request failed', err, { method, url: log.maskUrl(url), duration_ms: duration }));
+            throw err;
+        }
+        const duration = Math.floor(performance.now() - startTime);
+        // Capture response body (from a clone, so the caller can still read the original)
+        let responseBody;
+        if (cfg.requestLogging.logResponseBody && response.body) {
+            try {
+                const buf = Buffer.from(await response.clone().arrayBuffer());
+                responseBody = (0, http_1.parseBody)(buf, cfg.requestLogging.maxBodySize);
+            }
+            catch {
+                responseBody = undefined;
+            }
+        }
+        const responseInfo = {
+            headers: (0, http_1.extractHeaders)(response.headers, cfg),
+            body: responseBody,
+            contentType: response.headers.get('content-type') ?? undefined,
+            contentLength: (0, http_1.parseContentLength)(response.headers.get('content-length')),
+        };
+        // Log request + response as single entry
+        (0, context_1.withCorrelationId)(correlationId, () => log.logOutgoingHttp(method, url, response.status, duration, requestInfo, responseInfo));
+        return response;
+    };
+}
+async function readRequestBody(init, inputRequest) {
+    const body = init?.body;
+    if (body === undefined || body === null) {
+        if (inputRequest?.body)
+            return Buffer.from(await inputRequest.clone().arrayBuffer());
+        return undefined;
+    }
+    if (typeof body === 'string')
+        return Buffer.from(body);
+    if (body instanceof URLSearchParams)
+        return Buffer.from(body.toString());
+    if (body instanceof ArrayBuffer)
+        return Buffer.from(body);
+    if (ArrayBuffer.isView(body))
+        return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    if (body instanceof Blob)
+        return Buffer.from(await body.arrayBuffer());
+    return undefined; // streams / FormData are sent untouched and not logged
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './logger/types';
+export * from './logger/context';
+export { MaskingUtil } from './logger/masking';
+export { AppLogger, configureDefaults, getDefaultConfig, mergeExtras, type Writer } from './logger/logger';
+export { matchPattern, shouldSkip } from './internal/http';
+export { createLoggingMiddleware, LoggingMiddleware, type HttpRequest, type HttpResponse, type NextFunction, } from './middleware/logging.middleware';
+export { createFastifyLoggingPlugin, registerFastifyLogging, type FastifyInstanceLike, type FastifyReplyLike, type FastifyRequestLike, } from './fastify/fastify-logging';
+export { createLoggingFetch, type FetchFn } from './httpclient/logging-fetch';
+export { LoggingModule } from './logging.module';

package/dist/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingModule = exports.createLoggingFetch = exports.registerFastifyLogging = exports.createFastifyLoggingPlugin = exports.LoggingMiddleware = exports.createLoggingMiddleware = exports.shouldSkip = exports.matchPattern = exports.mergeExtras = exports.getDefaultConfig = exports.configureDefaults = exports.AppLogger = exports.MaskingUtil = void 0;
+__exportStar(require("./logger/types"), exports);
+__exportStar(require("./logger/context"), exports);
+var masking_1 = require("./logger/masking");
+Object.defineProperty(exports, "MaskingUtil", { enumerable: true, get: function () { return masking_1.MaskingUtil; } });
+var logger_1 = require("./logger/logger");
+Object.defineProperty(exports, "AppLogger", { enumerable: true, get: function () { return logger_1.AppLogger; } });
+Object.defineProperty(exports, "configureDefaults", { enumerable: true, get: function () { return logger_1.configureDefaults; } });
+Object.defineProperty(exports, "getDefaultConfig", { enumerable: true, get: function () { return logger_1.getDefaultConfig; } });
+Object.defineProperty(exports, "mergeExtras", { enumerable: true, get: function () { return logger_1.mergeExtras; } });
+var http_1 = require("./internal/http");
+Object.defineProperty(exports, "matchPattern", { enumerable: true, get: function () { return http_1.matchPattern; } });
+Object.defineProperty(exports, "shouldSkip", { enumerable: true, get: function () { return http_1.shouldSkip; } });
+var logging_middleware_1 = require("./middleware/logging.middleware");
+Object.defineProperty(exports, "createLoggingMiddleware", { enumerable: true, get: function () { return logging_middleware_1.createLoggingMiddleware; } });
+Object.defineProperty(exports, "LoggingMiddleware", { enumerable: true, get: function () { return logging_middleware_1.LoggingMiddleware; } });
+var fastify_logging_1 = require("./fastify/fastify-logging");
+Object.defineProperty(exports, "createFastifyLoggingPlugin", { enumerable: true, get: function () { return fastify_logging_1.createFastifyLoggingPlugin; } });
+Object.defineProperty(exports, "registerFastifyLogging", { enumerable: true, get: function () { return fastify_logging_1.registerFastifyLogging; } });
+var logging_fetch_1 = require("./httpclient/logging-fetch");
+Object.defineProperty(exports, "createLoggingFetch", { enumerable: true, get: function () { return logging_fetch_1.createLoggingFetch; } });
+var logging_module_1 = require("./logging.module");
+Object.defineProperty(exports, "LoggingModule", { enumerable: true, get: function () { return logging_module_1.LoggingModule; } });

package/dist/internal/http.d.ts

@@ -0,0 +1,9 @@
+import type { Config } from '../logger/types';
+export declare function shouldSkip(path: string, config: Config): boolean;
+export declare function matchPattern(pattern: string, path: string): boolean;
+export declare function canonicalHeaderKey(key: string): string;
+export type HeaderValue = string | number | string[] | undefined;
+export declare function extractHeaders(headers: Record<string, HeaderValue> | Iterable<[string, string]>, config: Config): Record<string, string> | undefined;
+export declare function parseBody(raw: Buffer | string, maxBodySize: number): unknown;
+export declare function truncateBody(buf: Buffer, maxSize: number): string;
+export declare function parseContentLength(value: string | null | undefined): number | undefined;

package/dist/internal/http.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldSkip = shouldSkip;
+exports.matchPattern = matchPattern;
+exports.canonicalHeaderKey = canonicalHeaderKey;
+exports.extractHeaders = extractHeaders;
+exports.parseBody = parseBody;
+exports.truncateBody = truncateBody;
+exports.parseContentLength = parseContentLength;
+// shouldSkip applies excludePatterns first, then includePatterns (if any are set)
+function shouldSkip(path, config) {
+    const { excludePatterns, includePatterns } = config.requestLogging;
+    if (excludePatterns.some((p) => matchPattern(p, path)))
+        return true;
+    if (includePatterns.length > 0)
+        return !includePatterns.some((p) => matchPattern(p, path));
+    return false;
+}
+// matchPattern supports exact match, "/prefix/*" and "/prefix/**" (both are prefix matches)
+function matchPattern(pattern, path) {
+    if (pattern.endsWith('/**'))
+        return path.startsWith(pattern.slice(0, -3));
+    if (pattern.endsWith('/*'))
+        return path.startsWith(pattern.slice(0, -2));
+    return pattern === path;
+}
+// canonicalHeaderKey mirrors Go's http.CanonicalHeaderKey: "x-correlation-id" -> "X-Correlation-Id"
+function canonicalHeaderKey(key) {
+    return key.toLowerCase().replace(/(^|-)([a-z])/g, (_, sep, c) => sep + c.toUpperCase());
+}
+// extractHeaders flattens headers to "key: v1, v2" with canonical keys; undefined when logHeaders is off
+function extractHeaders(headers, config) {
+    if (!config.requestLogging.logHeaders)
+        return undefined;
+    const result = {};
+    const entries = Symbol.iterator in headers ? headers : Object.entries(headers);
+    for (const [key, value] of entries) {
+        if (value === undefined)
+            continue;
+        const k = canonicalHeaderKey(key);
+        const v = Array.isArray(value) ? value.join(', ') : String(value);
+        result[k] = k in result ? `${result[k]}, ${v}` : v;
+    }
+    return result;
+}
+// parseBody returns parsed JSON, or the raw text truncated to maxBodySize bytes; undefined when empty
+function parseBody(raw, maxBodySize) {
+    const buf = typeof raw === 'string' ? Buffer.from(raw) : raw;
+    if (buf.length === 0)
+        return undefined;
+    const text = buf.toString('utf8');
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return truncateBody(buf, maxBodySize);
+    }
+}
+function truncateBody(buf, maxSize) {
+    if (buf.length > maxSize)
+        return buf.subarray(0, maxSize).toString('utf8') + '... [TRUNCATED]';
+    return buf.toString('utf8');
+}
+function parseContentLength(value) {
+    if (!value)
+        return undefined;
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+}

package/dist/internal/incoming.d.ts

@@ -0,0 +1,22 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { AppLogger } from '../logger/logger';
+import type { Config } from '../logger/types';
+import { type HeaderValue } from './http';
+export interface IncomingSource {
+    req: IncomingMessage;
+    res: ServerResponse;
+    url: string;
+    params(): Record<string, unknown> | undefined;
+    body(): {
+        raw?: Buffer;
+        parsed?: unknown;
+    };
+    ip(): string | undefined;
+    responseHeaders(): Record<string, HeaderValue>;
+}
+export declare function splitUrl(url: string): {
+    path: string;
+    query: string;
+};
+export declare function trackIncoming(log: AppLogger, cfg: Config, correlationId: string, src: IncomingSource): void;
+export declare function firstHeader(value: HeaderValue): string | undefined;

package/dist/internal/incoming.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitUrl = splitUrl;
+exports.trackIncoming = trackIncoming;
+exports.firstHeader = firstHeader;
+const context_1 = require("../logger/context");
+const masking_1 = require("../logger/masking");
+const http_1 = require("./http");
+function splitUrl(url) {
+    const i = url.indexOf('?');
+    return i >= 0 ? { path: url.slice(0, i), query: url.slice(i + 1) } : { path: url, query: '' };
+}
+// trackIncoming captures the response body and writes one "Incoming request" entry
+// when the response finishes (or the connection closes).
+function trackIncoming(log, cfg, correlationId, src) {
+    const { req, res } = src;
+    const { path, query } = splitUrl(src.url);
+    // Capture response body (bytes are always counted; content kept only if it will be logged)
+    const chunks = [];
+    let responseSize = 0;
+    const capture = (chunk, encoding) => {
+        if (chunk === undefined || chunk === null || typeof chunk === 'function')
+            return;
+        const buf = Buffer.isBuffer(chunk)
+            ? chunk
+            : chunk instanceof Uint8Array
+                ? Buffer.from(chunk)
+                : Buffer.from(String(chunk), typeof encoding === 'string' ? encoding : 'utf8');
+        responseSize += buf.length;
+        if (cfg.requestLogging.logResponseBody)
+            chunks.push(buf);
+    };
+    const originalWrite = res.write;
+    const originalEnd = res.end;
+    res.write = function (chunk, ...args) {
+        capture(chunk, args[0]);
+        return originalWrite.apply(this, [chunk, ...args]);
+    };
+    res.end = function (chunk, ...args) {
+        capture(chunk, args[0]);
+        return originalEnd.apply(this, [chunk, ...args]);
+    };
+    const startTime = performance.now();
+    let logged = false;
+    const done = () => {
+        if (logged)
+            return;
+        logged = true;
+        const duration = Math.floor(performance.now() - startTime);
+        const requestInfo = {
+            headers: (0, http_1.extractHeaders)(req.headers, cfg),
+            queryParams: extractQueryParams(query),
+            pathParams: extractPathParams(src.params()),
+            body: cfg.requestLogging.logBody ? extractRequestBody(src, cfg) : undefined,
+            contentType: contentTypeWithoutParams(firstHeader(req.headers['content-type'])),
+            contentLength: (0, http_1.parseContentLength)(firstHeader(req.headers['content-length'])),
+        };
+        const responseHeaders = src.responseHeaders();
+        const responseInfo = {
+            headers: (0, http_1.extractHeaders)(responseHeaders, cfg),
+            body: cfg.requestLogging.logResponseBody && responseSize > 0
+                ? (0, http_1.parseBody)(Buffer.concat(chunks), cfg.requestLogging.maxBodySize)
+                : undefined,
+            contentType: firstHeader(findHeader(responseHeaders, 'content-type')),
+            contentLength: responseSize,
+        };
+        const ip = src.ip() ?? req.socket?.remoteAddress ?? '';
+        // Log request + response as single entry (inside the request's correlation context)
+        (0, context_1.withCorrelationId)(correlationId, () => log.logIncomingHttp(req.method ?? '', path, res.statusCode, duration, requestInfo, responseInfo, ip.startsWith('::ffff:') ? ip.slice(7) : ip, firstHeader(req.headers['user-agent'])));
+    };
+    res.once('finish', done);
+    res.once('close', done);
+}
+function extractRequestBody(src, cfg) {
+    const max = cfg.requestLogging.maxBodySize;
+    const { raw, parsed } = src.body();
+    // Raw bytes (NestFactory.create(..., { rawBody: true })) give exact parity with the Go version.
+    if (Buffer.isBuffer(raw))
+        return (0, http_1.parseBody)(raw, max);
+    if (Buffer.isBuffer(parsed) || typeof parsed === 'string')
+        return (0, http_1.parseBody)(parsed, max);
+    if (parsed === undefined || parsed === null)
+        return undefined;
+    // Parsed by body-parser: Express sets {} even when no body was sent.
+    if ((0, masking_1.isPlainObject)(parsed) && Object.keys(parsed).length === 0 && !hasRequestBody(src.req))
+        return undefined;
+    return parsed;
+}
+function hasRequestBody(req) {
+    return ((0, http_1.parseContentLength)(firstHeader(req.headers['content-length'])) ?? 0) > 0
+        || req.headers['transfer-encoding'] !== undefined;
+}
+function extractQueryParams(query) {
+    if (!query)
+        return undefined;
+    const result = {};
+    for (const [key, value] of new URLSearchParams(query)) {
+        result[key] = key in result ? `${result[key]}, ${value}` : value;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+function extractPathParams(params) {
+    if (!params || typeof params !== 'object')
+        return undefined;
+    const entries = Object.entries(params).filter(([, v]) => v !== undefined);
+    if (entries.length === 0)
+        return undefined;
+    return Object.fromEntries(entries.map(([k, v]) => [k, Array.isArray(v) ? v.join('/') : String(v)]));
+}
+function findHeader(headers, name) {
+    for (const [k, v] of Object.entries(headers))
+        if (k.toLowerCase() === name)
+            return v;
+    return undefined;
+}
+function contentTypeWithoutParams(value) {
+    return value?.split(';')[0].trim() || undefined;
+}
+function firstHeader(value) {
+    if (value === undefined)
+        return undefined;
+    return Array.isArray(value) ? value[0] : String(value);
+}

package/dist/logger/context.d.ts

@@ -0,0 +1,5 @@
+export declare const CorrelationIDHeader = "X-Correlation-ID";
+export declare function withCorrelationId<T>(correlationId: string, fn: () => T): T;
+export declare function getCorrelationId(): string;
+export declare function generateCorrelationId(): string;
+export declare function ensureCorrelationId(): string;

package/dist/logger/context.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorrelationIDHeader = void 0;
+exports.withCorrelationId = withCorrelationId;
+exports.getCorrelationId = getCorrelationId;
+exports.generateCorrelationId = generateCorrelationId;
+exports.ensureCorrelationId = ensureCorrelationId;
+const node_async_hooks_1 = require("node:async_hooks");
+const node_crypto_1 = require("node:crypto");
+// Node equivalent of Go's context.Context value: the correlation ID follows the
+// async call chain (AsyncLocalStorage), so it does not need to be passed by hand.
+const storage = new node_async_hooks_1.AsyncLocalStorage();
+// CorrelationIDHeader is the HTTP header name for correlation ID
+exports.CorrelationIDHeader = 'X-Correlation-ID';
+// withCorrelationId runs fn with the given correlation ID in the async context
+function withCorrelationId(correlationId, fn) {
+    return storage.run({ correlationId }, fn);
+}
+// getCorrelationId retrieves correlation ID from the async context ('' if none)
+function getCorrelationId() {
+    return storage.getStore()?.correlationId ?? '';
+}
+// generateCorrelationId generates a new correlation ID (UUID v4)
+function generateCorrelationId() {
+    return (0, node_crypto_1.randomUUID)();
+}
+// ensureCorrelationId returns the existing correlation ID or generates a new one
+function ensureCorrelationId() {
+    return getCorrelationId() || generateCorrelationId();
+}

package/dist/logger/logger.d.ts

@@ -0,0 +1,37 @@
+import { type Config, type ConfigInput, type RequestInfo, type ResponseInfo } from './types';
+export interface Writer {
+    write(chunk: string): unknown;
+}
+export declare function configureDefaults(config?: ConfigInput | null): void;
+export declare function getDefaultConfig(): Config;
+export declare class AppLogger {
+    private readonly name;
+    private readonly ownConfig?;
+    private output;
+    private maskingFor?;
+    private maskingUtil?;
+    constructor(name: string, config?: ConfigInput | null);
+    get config(): Config;
+    private get masking();
+    maskUrl(url: string): string;
+    setOutput(w: Writer): void;
+    debug(message: string, ...extra: unknown[]): void;
+    info(message: string, ...extra: unknown[]): void;
+    warn(message: string, ...extra: unknown[]): void;
+    warnError(message: string, err: unknown, ...extra: unknown[]): void;
+    error(message: string, ...extra: unknown[]): void;
+    errorWithErr(message: string, err: unknown, ...extra: unknown[]): void;
+    logIncomingHttp(method: string, uri: string, statusCode: number, durationMs: number, request?: RequestInfo, response?: ResponseInfo, remoteAddr?: string, userAgent?: string): void;
+    logOutgoingHttp(method: string, uri: string, statusCode: number, durationMs: number, request?: RequestInfo, response?: ResponseInfo): void;
+    private logApplicationIfEnabled;
+    private logRequest;
+    private baseEntry;
+    private buildRequestBody;
+    private buildResponseBody;
+    private buildErrorInfo;
+    private writeLog;
+    private isApplicationLoggingEnabled;
+    private isRequestLoggingEnabled;
+    private isLevelEnabled;
+}
+export declare function mergeExtras(extras: unknown[]): Record<string, unknown> | undefined;