@jnpt/nest-logging 0.0.0-stage → 1.1.0

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;

package/dist/logger/logger.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppLogger = void 0;
+exports.configureDefaults = configureDefaults;
+exports.getDefaultConfig = getDefaultConfig;
+exports.mergeExtras = mergeExtras;
+const node_worker_threads_1 = require("node:worker_threads");
+const context_1 = require("./context");
+const masking_1 = require("./masking");
+const types_1 = require("./types");
+let globalConfig = (0, types_1.defaultConfig)();
+// configureDefaults sets default configuration for all loggers.
+// Accepts a full or partial config (missing fields use defaultConfig()); undefined/null is ignored.
+function configureDefaults(config) {
+    if (config)
+        globalConfig = (0, types_1.buildConfig)(config);
+}
+// getDefaultConfig returns the default configuration
+function getDefaultConfig() {
+    return globalConfig;
+}
+const threadName = node_worker_threads_1.isMainThread ? 'main' : `worker-${node_worker_threads_1.threadId}`;
+// AppLogger is the main structured logger
+class AppLogger {
+    name;
+    ownConfig;
+    output = process.stdout;
+    maskingFor;
+    maskingUtil;
+    // new AppLogger(name) follows the global default config (configureDefaults);
+    // new AppLogger(name, config) uses its own config (partial allowed, merged onto defaultConfig()).
+    constructor(name, config) {
+        this.name = name;
+        if (config)
+            this.ownConfig = (0, types_1.buildConfig)(config);
+    }
+    get config() {
+        return this.ownConfig ?? getDefaultConfig();
+    }
+    get masking() {
+        const config = this.config;
+        if (this.maskingFor !== config) {
+            this.maskingUtil = new masking_1.MaskingUtil(config);
+            this.maskingFor = config;
+        }
+        return this.maskingUtil;
+    }
+    // maskUrl masks sensitive query parameters in a URL using this logger's maskedFields
+    maskUrl(url) {
+        return this.masking.maskUrl(url);
+    }
+    // setOutput sets the output writer (default: process.stdout)
+    setOutput(w) {
+        this.output = w;
+    }
+    // debug logs a debug message
+    debug(message, ...extra) {
+        this.logApplicationIfEnabled('DEBUG', message, undefined, extra);
+    }
+    // info logs an info message
+    info(message, ...extra) {
+        this.logApplicationIfEnabled('INFO', message, undefined, extra);
+    }
+    // warn logs a warning message
+    warn(message, ...extra) {
+        this.logApplicationIfEnabled('WARN', message, undefined, extra);
+    }
+    // warnError logs a warning message with error
+    warnError(message, err, ...extra) {
+        this.logApplicationIfEnabled('WARN', message, err, extra);
+    }
+    // error logs an error message
+    error(message, ...extra) {
+        this.logApplicationIfEnabled('ERROR', message, undefined, extra);
+    }
+    // errorWithErr logs an error message with error
+    errorWithErr(message, err, ...extra) {
+        this.logApplicationIfEnabled('ERROR', message, err, extra);
+    }
+    // logIncomingHttp logs incoming request and response as a single entry
+    logIncomingHttp(method, uri, statusCode, durationMs, request, response, remoteAddr = '', userAgent = '') {
+        if (!this.isRequestLoggingEnabled())
+            return;
+        this.logRequest(getStatusLevel(statusCode), 'Incoming request', method, uri, statusCode, durationMs, remoteAddr, userAgent, request, response);
+    }
+    // logOutgoingHttp logs outgoing request and response as a single entry
+    logOutgoingHttp(method, uri, statusCode, durationMs, request, response) {
+        if (!this.isRequestLoggingEnabled())
+            return;
+        this.logRequest(getStatusLevel(statusCode), 'Outgoing request', method, this.maskUrl(uri), statusCode, durationMs, '', '', request, response, { direction: 'outgoing' });
+    }
+    logApplicationIfEnabled(level, message, err, extra) {
+        if (!this.isApplicationLoggingEnabled() || !this.isLevelEnabled(level))
+            return;
+        const entry = this.baseEntry(level, message, types_1.LogTypeApplication);
+        entry.request_body = {};
+        entry.response_body = {};
+        if (err !== undefined && err !== null && this.config.applicationLogging.includeStackTrace) {
+            entry.error = this.buildErrorInfo(err);
+        }
+        entry.extra = mergeExtras(extra);
+        this.writeLog(entry);
+    }
+    logRequest(level, message, method, uri, statusCode, durationMs, remoteAddr, userAgent, request, response, extra) {
+        const entry = this.baseEntry(level, message, types_1.LogTypeRequest);
+        entry.method = method;
+        entry.uri = uri;
+        entry.status_code = statusCode;
+        entry.duration_ms = durationMs;
+        entry.remote_address = remoteAddr || undefined;
+        entry.user_agent = userAgent || undefined;
+        entry.request_body = request ? this.buildRequestBody(request) : {};
+        entry.response_body = response ? this.buildResponseBody(response) : {};
+        entry.extra = extra;
+        this.writeLog(entry);
+    }
+    baseEntry(level, message, type) {
+        // Property order here is the JSON field order.
+        return {
+            '@timestamp': (0, types_1.formatTimestamp)(new Date()),
+            '@version': '1',
+            application: this.config.applicationName,
+            message,
+            logger_name: this.name,
+            thread_name: threadName,
+            level,
+            level_value: types_1.LevelValue[level] ?? 0,
+            type,
+            correlation_id: (0, context_1.getCorrelationId)(),
+            method: '',
+            uri: '',
+            status_code: undefined,
+            duration_ms: undefined,
+            remote_address: undefined,
+            user_agent: undefined,
+            request_body: undefined,
+            response_body: undefined,
+            error: undefined,
+            extra: undefined,
+        };
+    }
+    buildRequestBody(req) {
+        const cfg = this.config.requestLogging;
+        const body = {};
+        if (cfg.logHeaders && req.headers)
+            body.headers = this.masking.maskHeaders(req.headers);
+        if (req.queryParams)
+            body.query_params = this.masking.maskBody(req.queryParams);
+        if (req.pathParams)
+            body.path_params = req.pathParams;
+        if (cfg.logBody && req.body !== undefined && req.body !== null)
+            body.body = this.masking.maskBody(req.body);
+        if (req.contentType)
+            body.content_type = req.contentType;
+        if (req.contentLength && req.contentLength > 0)
+            body.content_length = req.contentLength;
+        return body;
+    }
+    buildResponseBody(res) {
+        const cfg = this.config.requestLogging;
+        const body = {};
+        if (cfg.logHeaders && res.headers)
+            body.headers = this.masking.maskHeaders(res.headers);
+        if (cfg.logResponseBody && res.body !== undefined && res.body !== null)
+            body.body = this.masking.maskBody(res.body);
+        if (res.contentType)
+            body.content_type = res.contentType;
+        if (res.contentLength && res.contentLength > 0)
+            body.content_length = res.contentLength;
+        return body;
+    }
+    buildErrorInfo(err) {
+        const info = {
+            class: err instanceof Error ? err.constructor?.name || err.name : typeof err,
+            message: err instanceof Error ? err.message : String(err),
+        };
+        if (this.config.applicationLogging.includeStackTrace) {
+            const stack = err instanceof Error && err.stack ? err.stack : new Error().stack;
+            info.stack_trace = parseStack(stack, this.config.applicationLogging.maxStackTraceDepth);
+        }
+        return info;
+    }
+    writeLog(entry) {
+        let data;
+        try {
+            data = JSON.stringify(entry);
+        }
+        catch (err) {
+            this.output.write(`Failed to marshal log entry: ${err instanceof Error ? err.message : String(err)}\n`);
+            return;
+        }
+        this.output.write(data + '\n');
+    }
+    isApplicationLoggingEnabled() {
+        return this.config.enabled && this.config.applicationLogging.enabled;
+    }
+    isRequestLoggingEnabled() {
+        return this.config.enabled && this.config.requestLogging.enabled;
+    }
+    // isLevelEnabled checks if the given level should be logged based on minLevel
+    isLevelEnabled(level) {
+        const minLevelValue = types_1.LevelValue[this.config.minLevel] ?? types_1.LevelValue.DEBUG; // default to DEBUG if invalid
+        const levelValue = types_1.LevelValue[level];
+        if (levelValue === undefined)
+            return true; // log unknown levels
+        return levelValue >= minLevelValue;
+    }
+}
+exports.AppLogger = AppLogger;
+function getStatusLevel(statusCode) {
+    if (statusCode >= 500)
+        return 'ERROR';
+    if (statusCode >= 400)
+        return 'WARN';
+    return 'INFO';
+}
+// parseStack turns "    at fn (file:line:col)" lines into trimmed frames, up to maxDepth
+function parseStack(stack, maxDepth) {
+    if (!stack)
+        return undefined;
+    const frames = stack
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('at '))
+        .map((line) => line.slice(3))
+        .slice(0, Math.max(0, maxDepth));
+    return frames.length > 0 ? frames : undefined;
+}
+// mergeExtras converts any value (object or class instance) to a plain object and merges them.
+// Values that are not objects after JSON round-trip (arrays, primitives) are stored under "data".
+function mergeExtras(extras) {
+    if (extras.length === 0)
+        return undefined;
+    const result = {};
+    for (const extra of extras) {
+        if (extra === undefined || extra === null)
+            continue;
+        if ((0, masking_1.isPlainObject)(extra)) {
+            Object.assign(result, extra);
+            continue;
+        }
+        let parsed;
+        try {
+            const json = JSON.stringify(extra);
+            if (json === undefined)
+                continue;
+            parsed = JSON.parse(json);
+        }
+        catch {
+            continue;
+        }
+        if ((0, masking_1.isPlainObject)(parsed))
+            Object.assign(result, parsed);
+        else
+            result.data = extra;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}

package/dist/logger/masking.d.ts

@@ -0,0 +1,12 @@
+import type { Config } from './types';
+export declare class MaskingUtil {
+    private readonly maskedHeaders;
+    private readonly maskedFields;
+    private readonly maskValue;
+    constructor(config: Config);
+    maskHeaders(headers?: Record<string, string>): Record<string, string> | undefined;
+    maskUrl(url: string): string;
+    maskBody(body: unknown): unknown;
+    private maskValueRecursive;
+}
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;

package/dist/logger/masking.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaskingUtil = void 0;
+exports.isPlainObject = isPlainObject;
+// MaskingUtil provides utilities for masking sensitive data
+class MaskingUtil {
+    maskedHeaders;
+    maskedFields;
+    maskValue;
+    constructor(config) {
+        this.maskedHeaders = new Set(config.maskedHeaders.map((h) => h.toLowerCase()));
+        this.maskedFields = new Set(config.maskedFields.map((f) => f.toLowerCase()));
+        this.maskValue = config.maskValue;
+    }
+    // maskHeaders masks sensitive headers (case-insensitive)
+    maskHeaders(headers) {
+        if (!headers)
+            return undefined;
+        const masked = {};
+        for (const [key, value] of Object.entries(headers)) {
+            masked[key] = this.maskedHeaders.has(key.toLowerCase()) ? this.maskValue : value;
+        }
+        return masked;
+    }
+    // maskUrl masks query parameters whose name is a masked field (case-insensitive).
+    // Returns the URL unchanged when nothing matches or it cannot be parsed.
+    maskUrl(url) {
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            return url;
+        }
+        let changed = false;
+        for (const key of new Set(parsed.searchParams.keys())) {
+            if (this.maskedFields.has(key.toLowerCase())) {
+                parsed.searchParams.set(key, this.maskValue);
+                changed = true;
+            }
+        }
+        return changed ? parsed.toString() : url;
+    }
+    // maskBody masks sensitive fields in body, recursively through objects and arrays (case-insensitive)
+    maskBody(body) {
+        if (body === undefined || body === null)
+            return body;
+        return this.maskValueRecursive(body);
+    }
+    maskValueRecursive(value) {
+        if (Array.isArray(value))
+            return value.map((item) => this.maskValueRecursive(item));
+        if (isPlainObject(value)) {
+            const masked = {};
+            for (const [key, v] of Object.entries(value)) {
+                masked[key] = this.maskedFields.has(key.toLowerCase()) ? this.maskValue : this.maskValueRecursive(v);
+            }
+            return masked;
+        }
+        return value;
+    }
+}
+exports.MaskingUtil = MaskingUtil;
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}

package/dist/logger/types.d.ts

@@ -0,0 +1,77 @@
+export type LogType = 'application' | 'request';
+export declare const LogTypeApplication: LogType;
+export declare const LogTypeRequest: LogType;
+export interface LogEntry {
+    '@timestamp': string;
+    '@version': string;
+    application: string;
+    message: string;
+    logger_name: string;
+    thread_name: string;
+    level: string;
+    level_value: number;
+    type: LogType;
+    correlation_id: string;
+    method: string;
+    uri: string;
+    status_code?: number;
+    duration_ms?: number;
+    remote_address?: string;
+    user_agent?: string;
+    request_body: unknown;
+    response_body: unknown;
+    error?: ErrorInfo;
+    extra?: Record<string, unknown>;
+}
+export interface ErrorInfo {
+    class: string;
+    message: string;
+    stack_trace?: string[];
+    root_cause?: string;
+}
+export interface RequestInfo {
+    headers?: Record<string, string>;
+    queryParams?: Record<string, string>;
+    pathParams?: Record<string, string>;
+    body?: unknown;
+    contentType?: string;
+    contentLength?: number;
+}
+export interface ResponseInfo {
+    headers?: Record<string, string>;
+    body?: unknown;
+    contentType?: string;
+    contentLength?: number;
+}
+export interface Config {
+    applicationName: string;
+    enabled: boolean;
+    minLevel: string;
+    requestLogging: RequestLoggingConfig;
+    applicationLogging: ApplicationLoggingConfig;
+    maskedHeaders: string[];
+    maskedFields: string[];
+    maskValue: string;
+}
+export interface RequestLoggingConfig {
+    enabled: boolean;
+    logHeaders: boolean;
+    logBody: boolean;
+    logResponseBody: boolean;
+    maxBodySize: number;
+    excludePatterns: string[];
+    includePatterns: string[];
+}
+export interface ApplicationLoggingConfig {
+    enabled: boolean;
+    includeStackTrace: boolean;
+    maxStackTraceDepth: number;
+}
+export type ConfigInput = Partial<Omit<Config, 'requestLogging' | 'applicationLogging'>> & {
+    requestLogging?: Partial<RequestLoggingConfig>;
+    applicationLogging?: Partial<ApplicationLoggingConfig>;
+};
+export declare function defaultConfig(): Config;
+export declare function buildConfig(input?: ConfigInput): Config;
+export declare const LevelValue: Readonly<Record<string, number>>;
+export declare function formatTimestamp(d: Date): string;

package/dist/logger/types.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LevelValue = exports.LogTypeRequest = exports.LogTypeApplication = void 0;
+exports.defaultConfig = defaultConfig;
+exports.buildConfig = buildConfig;
+exports.formatTimestamp = formatTimestamp;
+exports.LogTypeApplication = 'application';
+exports.LogTypeRequest = 'request';
+// defaultConfig returns default configuration
+function defaultConfig() {
+    return {
+        applicationName: 'application',
+        enabled: true,
+        minLevel: 'DEBUG',
+        requestLogging: {
+            enabled: true,
+            logHeaders: true,
+            logBody: true,
+            logResponseBody: true,
+            maxBodySize: 10240,
+            excludePatterns: ['/health', '/metrics', '/favicon.ico'],
+            includePatterns: [],
+        },
+        applicationLogging: {
+            enabled: true,
+            includeStackTrace: true,
+            maxStackTraceDepth: 50,
+        },
+        maskedHeaders: ['Authorization', 'X-Api-Key', 'Cookie', 'Set-Cookie'],
+        maskedFields: ['password', 'secret', 'token', 'creditCard', 'ssn'],
+        maskValue: '***MASKED***',
+    };
+}
+// buildConfig merges a partial config onto defaultConfig()
+function buildConfig(input) {
+    const base = defaultConfig();
+    if (!input)
+        return base;
+    return {
+        ...base,
+        ...input,
+        requestLogging: { ...base.requestLogging, ...input.requestLogging },
+        applicationLogging: { ...base.applicationLogging, ...input.applicationLogging },
+    };
+}
+// LevelValue maps log level to numeric value
+exports.LevelValue = {
+    TRACE: 5000,
+    DEBUG: 10000,
+    INFO: 20000,
+    WARN: 30000,
+    ERROR: 40000,
+};
+// formatTimestamp formats time to ISO 8601 with local timezone, e.g. 2006-01-02T15:04:05.000+07:00
+function formatTimestamp(d) {
+    const pad = (n, w = 2) => String(Math.abs(n)).padStart(w, '0');
+    const offset = -d.getTimezoneOffset();
+    const sign = offset >= 0 ? '+' : '-';
+    return (`${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` +
+        `T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}` +
+        `${sign}${pad(Math.trunc(offset / 60))}:${pad(offset % 60)}`);
+}

package/dist/logging.module.d.ts

@@ -0,0 +1,15 @@
+import type { DynamicModule, MiddlewareConsumer, NestModule } from '@nestjs/common';
+import type { ConfigInput } from './logger/types';
+interface HttpAdapterHostLike {
+    httpAdapter?: {
+        getType?(): string;
+        getInstance?(): unknown;
+    };
+}
+export declare class LoggingModule implements NestModule {
+    private readonly adapterHost?;
+    constructor(adapterHost?: HttpAdapterHostLike | undefined);
+    static forRoot(config?: ConfigInput | null): DynamicModule;
+    configure(consumer: MiddlewareConsumer): void;
+}
+export {};

package/dist/logging.module.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingModule = void 0;
+const fastify_logging_1 = require("./fastify/fastify-logging");
+const logger_1 = require("./logger/logger");
+const logging_middleware_1 = require("./middleware/logging.middleware");
+// LoggingModule.forRoot(config?) sets the global default config and logs every incoming request:
+// Express apps get LoggingMiddleware on all routes, Fastify apps (FastifyAdapter) get Fastify hooks.
+// @nestjs/core is only loaded lazily (no static runtime import), so it works with both
+// CommonJS (Nest <= 11) and ESM (Nest 12+) applications.
+class LoggingModule {
+    adapterHost;
+    constructor(adapterHost) {
+        this.adapterHost = adapterHost;
+    }
+    static forRoot(config) {
+        (0, logger_1.configureDefaults)(config);
+        injectHttpAdapterHost();
+        return { module: LoggingModule };
+    }
+    configure(consumer) {
+        const adapter = this.adapterHost?.httpAdapter;
+        if (adapter?.getType?.() === 'fastify') {
+            (0, fastify_logging_1.registerFastifyLogging)(adapter.getInstance(), new logger_1.AppLogger('LoggingMiddleware'));
+            return;
+        }
+        consumer.apply(logging_middleware_1.LoggingMiddleware).forRoutes('*');
+    }
+}
+exports.LoggingModule = LoggingModule;
+let injected = false;
+// Declares the constructor dependency (what @Inject(HttpAdapterHost) would emit).
+function injectHttpAdapterHost() {
+    if (injected)
+        return;
+    injected = true;
+    const reflect = Reflect;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { HttpAdapterHost } = require('@nestjs/core');
+        reflect.defineMetadata?.('design:paramtypes', [HttpAdapterHost], LoggingModule);
+    }
+    catch {
+        // @nestjs/core not resolvable: fall back to the Express middleware only
+    }
+}

package/dist/middleware/logging.middleware.d.ts

@@ -0,0 +1,18 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { NestMiddleware } from '@nestjs/common';
+import { AppLogger } from '../logger/logger';
+import { type ConfigInput } from '../logger/types';
+export interface HttpRequest extends IncomingMessage {
+    originalUrl?: string;
+    ip?: string;
+    params?: Record<string, unknown>;
+    body?: unknown;
+    rawBody?: Buffer;
+}
+export type HttpResponse = ServerResponse;
+export type NextFunction = (err?: unknown) => void;
+export declare function createLoggingMiddleware(log: AppLogger, config?: ConfigInput | null): (req: HttpRequest, res: HttpResponse, next: NextFunction) => void;
+export declare class LoggingMiddleware implements NestMiddleware {
+    private readonly handler;
+    use(req: HttpRequest, res: HttpResponse, next: NextFunction): void;
+}

package/dist/middleware/logging.middleware.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingMiddleware = void 0;
+exports.createLoggingMiddleware = createLoggingMiddleware;
+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");
+// createLoggingMiddleware returns an Express middleware that logs every incoming
+// request + response as a single "request" entry and sets up the correlation ID.
+// If config is omitted, the global default config (configureDefaults) is used.
+// For Fastify use createFastifyLoggingPlugin (LoggingModule picks the right one automatically).
+function createLoggingMiddleware(log, config) {
+    const ownConfig = config ? (0, types_1.buildConfig)(config) : undefined;
+    return function loggingMiddleware(req, res, next) {
+        const cfg = ownConfig ?? (0, logger_1.getDefaultConfig)();
+        const url = req.originalUrl ?? req.url ?? '/';
+        // Skip excluded patterns
+        if ((0, http_1.shouldSkip)((0, incoming_1.splitUrl)(url).path, cfg)) {
+            next();
+            return;
+        }
+        // Setup correlation ID
+        const correlationId = (0, incoming_1.firstHeader)(req.headers['x-correlation-id']) || (0, context_1.generateCorrelationId)();
+        res.setHeader(context_1.CorrelationIDHeader, correlationId);
+        (0, incoming_1.trackIncoming)(log, cfg, correlationId, {
+            req,
+            res,
+            url,
+            params: () => req.params,
+            body: () => ({ raw: req.rawBody, parsed: req.body }),
+            ip: () => req.ip,
+            responseHeaders: () => res.getHeaders(),
+        });
+        // Process request with the correlation ID available to everything downstream
+        (0, context_1.withCorrelationId)(correlationId, () => next());
+    };
+}
+// LoggingMiddleware is the NestJS (Express) class form; it logs with logger name "LoggingMiddleware"
+// and the global default config. LoggingModule registers it for all routes automatically.
+class LoggingMiddleware {
+    handler = createLoggingMiddleware(new logger_1.AppLogger('LoggingMiddleware'));
+    use(req, res, next) {
+        this.handler(req, res, next);
+    }
+}
+exports.LoggingMiddleware = LoggingMiddleware;