logixia 1.3.1 → 1.5.0

package/dist/index.mjs

@@ -1,7 +1,319 @@
-import { A as LogixiaContext, C as redactObject, D as DEFAULT_LOG_COLORS, E as serializeError, M as createFastifyContextHook, O as DEFAULT_LOG_LEVELS, S as applyRedaction, T as normalizeError, _ as traceStorage, b as registerForShutdown, c as LogixiaLogger, d as createTraceMiddleware, f as extractTraceId, g as setTraceId, h as runWithTraceId, i as WebSocketTraceInterceptor, j as createExpressContextMiddleware, k as LogLevel, l as createLogger$1, m as getCurrentTraceId, n as LOGIXIA_LOGGER_PREFIX, o as KafkaTraceInterceptor, p as generateTraceId, r as LogixiaLoggerModule, s as LogixiaLoggerService, t as LOGIXIA_LOGGER_CONFIG, u as DEFAULT_TRACE_HEADERS, v as deregisterFromShutdown, w as isError, x as resetShutdownHandlers, y as flushOnExit } from "./logitron-logger.module-2AzkadqZ.mjs";
-import "./transport.manager-5VVdqS3o.mjs";
+import { A as isError, B as createExpressContextMiddleware, C as resetShutdownHandlers, D as getActiveOtelContext, E as disableOtelBridge, F as LogLevel, I as PluginRegistry, L as globalPluginRegistry, M as serializeError, N as DEFAULT_LOG_COLORS, O as getOtelMetaFields, P as DEFAULT_LOG_LEVELS, R as usePlugin, S as registerForShutdown, T as redactObject, V as createFastifyContextHook, _ as runWithTraceId, b as deregisterFromShutdown, c as __decorate, d as createLogger$1, f as DEFAULT_TRACE_HEADERS, g as getCurrentTraceId, h as generateTraceId, i as WebSocketTraceInterceptor, j as normalizeError, k as initOtelBridge, l as __decorateMetadata, m as extractTraceId, n as LOGIXIA_LOGGER_PREFIX, o as KafkaTraceInterceptor, p as createTraceMiddleware, r as LogixiaLoggerModule, s as LogixiaLoggerService, t as LOGIXIA_LOGGER_CONFIG, u as LogixiaLogger, v as setTraceId, w as applyRedaction, x as flushOnExit, y as traceStorage, z as LogixiaContext } from "./logitron-logger.module-DdVy45xE.mjs";
+import { f as internalWarn } from "./transport.manager-DR7TLXQT.mjs";
 import "./search-1txemGPh.mjs";
+import { Catch, Inject, Optional } from "@nestjs/common";
+import { randomUUID } from "node:crypto";
 
+//#region src/exceptions/exception.ts
+var LogixiaException = class extends Error {
+	constructor(options) {
+		super(options.message, { cause: options.cause });
+		this.name = "LogixiaException";
+		this.errorCode = options.code;
+		this.errorType = options.type;
+		this.httpStatus = options.httpStatus;
+		this.param = options.param;
+		this.details = options.details;
+		this.docUrl = options.docUrl;
+		this.metadata = options.metadata;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/**
+* Returns `true` when `value` is a `LogixiaException` instance.
+*
+* Useful in exception filters or middleware that need to distinguish a
+* `LogixiaException` from a plain `Error` or a framework `HttpException`.
+*
+* @example
+* ```ts
+* if (isLogixiaException(err)) {
+*   console.log(err.errorCode, err.httpStatus);
+* }
+* ```
+*/
+function isLogixiaException(value) {
+	return value instanceof LogixiaException;
+}
+
+//#endregion
+//#region src/exceptions/builder.ts
+/**
+* Generates a `req_` prefixed request ID using Node's built-in `crypto.randomUUID`.
+* No extra dependencies required.
+*
+* @example `'req_550e8400e29b41d4a716446655440000'`
+*/
+function generateRequestId() {
+	return `req_${randomUUID().replaceAll("-", "")}`;
+}
+/**
+* Maps an HTTP status code to a human-friendly error type string.
+* Used as a fallback when the exception is a generic `HttpException`.
+*/
+function httpStatusToType(status) {
+	if (status === 400) return "api_error";
+	if (status === 401) return "authentication_error";
+	if (status === 402) return "payment_error";
+	if (status === 403) return "authorization_error";
+	if (status === 404) return "not_found_error";
+	if (status === 408) return "timeout_error";
+	if (status === 409) return "conflict_error";
+	if (status === 422) return "validation_error";
+	if (status === 429) return "rate_limit_error";
+	if (status >= 500) return "server_error";
+	if (status >= 400) return "api_error";
+	return "server_error";
+}
+/**
+* Duck-type check for NestJS `HttpException`.
+* Avoids a hard import on `@nestjs/common` so the builder is usable outside NestJS.
+*/
+function isHttpException(value) {
+	return typeof value === "object" && value !== null && typeof value["getStatus"] === "function" && typeof value["getResponse"] === "function";
+}
+/**
+* Builds the optional `debug` block from an error.
+* Returns `undefined` when there is nothing useful to include.
+*/
+function buildDebug(error, service, durationMs) {
+	const stack = error instanceof Error ? error.stack : void 0;
+	const causeRaw = error instanceof Error ? error.cause : void 0;
+	let cause;
+	if (causeRaw instanceof Error) cause = causeRaw.message;
+	else if (causeRaw !== void 0 && causeRaw !== null) cause = String(causeRaw);
+	if (!stack && !cause && !service && durationMs === void 0) return void 0;
+	return {
+		...stack !== void 0 ? { stack } : {},
+		...cause !== void 0 ? { cause } : {},
+		...service !== void 0 ? { service } : {},
+		...durationMs !== void 0 ? { duration_ms: durationMs } : {}
+	};
+}
+var ErrorResponseBuilder = class {
+	/**
+	* Build a `LogixiaErrorResponse` from any thrown value.
+	*
+	* @param params - See `BuildParams`.
+	* @returns The unified error response and the HTTP status code to send.
+	*
+	* @example In a NestJS exception filter
+	* ```ts
+	* const { response, httpStatus } = ErrorResponseBuilder.build<AppCode, AppType>({
+	*   exception,
+	*   requestId: request.headers['x-trace-id'] as string | undefined,
+	*   path:      request.url,
+	*   service:   process.env.SERVICE_NAME,
+	*   startTime: request.startTime,
+	* });
+	*
+	* if (process.env.NODE_ENV === 'production') delete response.debug;
+	* response.setHeader('X-Trace-ID', response.meta.request_id);
+	* response.status(httpStatus).json(response);
+	* ```
+	*/
+	static build(params) {
+		const { exception, path, service, startTime, requestId: rawRequestId } = params;
+		const requestId = rawRequestId ?? generateRequestId();
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		const durationMs = startTime !== void 0 ? Date.now() - startTime : void 0;
+		if (isLogixiaException(exception)) {
+			const debug$1 = buildDebug(exception, service, durationMs);
+			const errorBlock = {
+				type: exception.errorType,
+				code: exception.errorCode,
+				message: exception.message
+			};
+			if (exception.param !== void 0) errorBlock.param = exception.param;
+			if (exception.details !== void 0 && exception.details.length > 0) errorBlock.details = exception.details;
+			if (exception.docUrl !== void 0) errorBlock.doc_url = exception.docUrl;
+			return {
+				response: {
+					success: false,
+					error: errorBlock,
+					meta: {
+						request_id: requestId,
+						timestamp,
+						path,
+						status: exception.httpStatus
+					},
+					...debug$1 !== void 0 ? { debug: debug$1 } : {}
+				},
+				httpStatus: exception.httpStatus
+			};
+		}
+		if (isHttpException(exception)) {
+			const status = exception.getStatus();
+			const exResponse = exception.getResponse();
+			let message;
+			if (typeof exResponse === "string") message = exResponse;
+			else if (typeof exResponse === "object" && exResponse !== null && "message" in exResponse) {
+				const raw = exResponse.message;
+				message = Array.isArray(raw) ? raw.join(", ") : String(raw);
+			} else message = exception.message;
+			const type = httpStatusToType(status);
+			const code = `HTTP_${status}`;
+			const debug$1 = buildDebug(exception, service, durationMs);
+			return {
+				response: {
+					success: false,
+					error: {
+						type,
+						code,
+						message
+					},
+					meta: {
+						request_id: requestId,
+						timestamp,
+						path,
+						status
+					},
+					...debug$1 !== void 0 ? { debug: debug$1 } : {}
+				},
+				httpStatus: status
+			};
+		}
+		const debug = buildDebug(exception instanceof Error ? exception : new Error(String(exception)), service, durationMs);
+		return {
+			response: {
+				success: false,
+				error: {
+					type: "server_error",
+					code: "INTERNAL_SERVER_ERROR",
+					message: "An unexpected error occurred."
+				},
+				meta: {
+					request_id: requestId,
+					timestamp,
+					path,
+					status: 500
+				},
+				...debug !== void 0 ? { debug } : {}
+			},
+			httpStatus: 500
+		};
+	}
+};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+
+//#endregion
+//#region src/core/nestjs-extras.ts
+/**
+* Inject the Logixia logger registered in the current NestJS DI container.
+*
+* Equivalent to `@Inject(LOGIXIA_LOGGER_TOKEN)` but without needing to import
+* the internal token constant yourself.
+*
+* @example
+* ```ts
+* constructor(@InjectLogger() private readonly logger: LogixiaLoggerService) {}
+* ```
+*/
+const InjectLogger = () => Inject(`${LOGIXIA_LOGGER_PREFIX}SERVICE`);
+/**
+* Method decorator that auto-logs entry, exit, duration, and errors.
+*
+* Works on both async and sync methods. Attaches to the logger found on the
+* class instance via a `logger` property (the conventional NestJS name).
+*
+* @example
+* ```ts
+* @LogMethod({ level: 'info', logArgs: true })
+* async processPayment(orderId: string): Promise<void> { … }
+* ```
+*/
+function LogMethod(options = {}) {
+	const { level = "debug", logArgs = true, logResult = false, logErrors = true } = options;
+	return function(target, propertyKey, descriptor) {
+		var _constructor;
+		const originalMethod = descriptor.value;
+		if (typeof originalMethod !== "function") return descriptor;
+		const methodName = String(propertyKey);
+		const className = ((_constructor = target.constructor) === null || _constructor === void 0 ? void 0 : _constructor.name) ?? "Unknown";
+		const label = options.label ?? `${className}.${methodName}`;
+		descriptor.value = async function(...args) {
+			const logger$1 = this.logger;
+			const start = Date.now();
+			const entry = { method: label };
+			if (logArgs && args.length > 0) entry["args"] = args;
+			if (logger$1) {
+				const logFn = logger$1[level] ?? logger$1.debug.bind(logger$1);
+				if (typeof logFn === "function") await logFn(`→ ${label}`, entry).catch(() => void 0);
+			}
+			try {
+				const result = await originalMethod.apply(this, args);
+				const exit = {
+					method: label,
+					durationMs: Date.now() - start
+				};
+				if (logResult) exit["result"] = result;
+				if (logger$1) {
+					const logFn = logger$1[level] ?? logger$1.debug.bind(logger$1);
+					if (typeof logFn === "function") await logFn(`← ${label}`, exit).catch(() => void 0);
+				}
+				return result;
+			} catch (error) {
+				if (logger$1 && logErrors) {
+					const err = error instanceof Error ? error : new Error(String(error));
+					logger$1.error(err, `${label} durationMs=${Date.now() - start}`);
+				}
+				throw error;
+			}
+		};
+		return descriptor;
+	};
+}
+let LogixiaExceptionFilter = class LogixiaExceptionFilter$1 {
+	constructor(logger$1) {
+		this.logger = logger$1;
+	}
+	catch(exception, host) {
+		var _request$headers;
+		const ctx = host.switchToHttp();
+		const request = ctx.getRequest();
+		const response = ctx.getResponse();
+		const requestId = ((_request$headers = request.headers) === null || _request$headers === void 0 ? void 0 : _request$headers["x-trace-id"]) ?? request.id ?? void 0;
+		const { response: errorResponse, httpStatus } = ErrorResponseBuilder.build({
+			exception,
+			requestId,
+			path: request.url ?? "/",
+			startTime: request.startTime
+		});
+		if (this.logger) {
+			const contextStr = [
+				`method=${String(request.method ?? "")}`,
+				`url=${String(request.url ?? "")}`,
+				`status=${httpStatus}`,
+				`request_id=${errorResponse.meta.request_id}`
+			].join(" ");
+			if (httpStatus >= 500) {
+				const err = exception instanceof Error ? exception : new Error(String(exception));
+				this.logger.error(err, void 0, contextStr);
+			} else if (isLogixiaException(exception)) this.logger.warn(`[${errorResponse.error.code}] ${errorResponse.error.message}`, contextStr);
+			else this.logger.warn(`[${httpStatus}] ${errorResponse.error.message}`, contextStr);
+		}
+		if (process.env["NODE_ENV"] === "production") delete errorResponse.debug;
+		response.setHeader("X-Trace-ID", errorResponse.meta.request_id);
+		response.setHeader("X-Request-ID", errorResponse.meta.request_id);
+		if (httpStatus === 429) response.setHeader("Retry-After", "60");
+		response.status(httpStatus).json(errorResponse);
+	}
+};
+LogixiaExceptionFilter = __decorate([
+	Catch(),
+	__decorateParam(0, Optional()),
+	__decorateParam(0, Inject(`${LOGIXIA_LOGGER_PREFIX}SERVICE`)),
+	__decorateMetadata("design:paramtypes", [Object])
+], LogixiaExceptionFilter);
+
+//#endregion
 //#region src/formatters/json.formatter.ts
 var JsonFormatter = class {
 	constructor(options = {}) {
@@ -165,6 +477,309 @@ var TextFormatter = class TextFormatter {
 	}
 };
 
+//#endregion
+//#region src/utils/typed-logger.ts
+/**
+* Define a typed schema for a category of log entries.
+*
+* Call this once at module initialisation and pass it to `createTypedLogger`.
+* In development, every log call is validated against the schema.
+*/
+function defineLogSchema(fields) {
+	return {
+		fields,
+		validate(payload) {
+			if (process.env["NODE_ENV"] === "production") return [];
+			const warnings = [];
+			for (const [key, def] of Object.entries(fields)) {
+				const value = payload[key];
+				if (def.required && (value === void 0 || value === null)) {
+					warnings.push(`Required field "${key}" is missing`);
+					continue;
+				}
+				if (value !== void 0 && value !== null) {
+					const actualType = Array.isArray(value) ? "array" : typeof value;
+					if (actualType !== def.type) warnings.push(`Field "${key}" expected type "${def.type}" but got "${actualType}"`);
+					if (def.validate) {
+						const msg = def.validate(value);
+						if (msg) warnings.push(`Field "${key}": ${msg}`);
+					}
+				}
+			}
+			return warnings;
+		}
+	};
+}
+/**
+* Wrap any logixia logger with a type-safe field interface.
+*
+* @param logger  Any object that implements `IBaseLogger` (e.g. the result of `createLogger()`)
+* @param schema  Optional schema for dev-time validation. Created with `defineLogSchema()`.
+*/
+function createTypedLogger(logger$1, schema) {
+	function withValidation(level, fn, message, data) {
+		if (schema && data) {
+			const warnings = schema.validate(data);
+			for (const w of warnings) internalWarn(`[logixia/schema] ${w} — level=${level} message="${message}"`);
+		}
+		return fn(message, data);
+	}
+	return {
+		raw: logger$1,
+		error(messageOrError, data) {
+			return logger$1.error(messageOrError, data);
+		},
+		warn: (m, d) => withValidation("warn", logger$1.warn.bind(logger$1), m, d),
+		info: (m, d) => withValidation("info", logger$1.info.bind(logger$1), m, d),
+		debug: (m, d) => withValidation("debug", logger$1.debug.bind(logger$1), m, d),
+		verbose: (m, d) => withValidation("verbose", (logger$1.verbose ?? logger$1.debug).bind(logger$1), m, d),
+		trace: (m, d) => withValidation("trace", (logger$1.trace ?? logger$1.debug).bind(logger$1), m, d)
+	};
+}
+
+//#endregion
+//#region src/metrics.ts
+const DEFAULT_BUCKETS = [
+	1,
+	5,
+	10,
+	25,
+	50,
+	100,
+	250,
+	500,
+	1e3,
+	2500,
+	5e3,
+	1e4
+];
+function buildLabelKey(config, entry) {
+	const labelNames = config.labels ?? [];
+	if (labelNames.length === 0) return "{}";
+	const pairs = {};
+	const payload = entry.payload ?? {};
+	for (const name of labelNames) {
+		const raw = name === "level" ? entry.level : payload[name];
+		pairs[name] = raw !== void 0 && raw !== null ? String(raw) : "";
+	}
+	return JSON.stringify(pairs);
+}
+function renderLabels(labelKey) {
+	if (labelKey === "{}") return "";
+	const obj = JSON.parse(labelKey);
+	return `{${Object.entries(obj).map(([k, v]) => `${k}="${escapeLabel(v)}"`).join(",")}}`;
+}
+function escapeLabel(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
+}
+/**
+* A logixia plugin that extracts Prometheus-compatible metrics from log entries.
+*
+* Implements `LogixiaPlugin` — pass directly to `logger.use()`:
+* ```ts
+* const metrics = new MetricsPlugin({ ... });
+* logger.use(metrics);
+* ```
+*
+* Or use the `createMetricsPlugin()` factory (preferred):
+* ```ts
+* const metrics = createMetricsPlugin({ ... });
+* logger.use(metrics);
+* ```
+*/
+var MetricsPlugin = class {
+	constructor(map) {
+		this.name = "logixia-metrics";
+		this.metricState = /* @__PURE__ */ new Map();
+		this.map = map;
+		this.initAllState();
+	}
+	onInit() {}
+	onLog(entry) {
+		const payload = entry.payload ?? {};
+		for (const [rawName, config] of Object.entries(this.map)) {
+			const state = this.metricState.get(rawName);
+			if (!state) continue;
+			const labelKey = buildLabelKey(config, entry);
+			if (config.type === "counter" && state.type === "counter") {
+				if (config.levelFilter && entry.level !== config.levelFilter) continue;
+				if (config.field !== void 0 && payload[config.field] !== config.value) continue;
+				state.values.set(labelKey, (state.values.get(labelKey) ?? 0) + 1);
+			} else if (config.type === "histogram" && state.type === "histogram") {
+				const raw = payload[config.field];
+				if (raw === void 0 || raw === null) continue;
+				const val = Number(raw);
+				if (Number.isNaN(val)) continue;
+				if (!state.counts.has(labelKey)) {
+					state.counts.set(labelKey, Array.from({ length: state.buckets.length + 1 }).fill(0));
+					state.sums.set(labelKey, 0);
+					state.observations.set(labelKey, 0);
+				}
+				const bucketArr = state.counts.get(labelKey);
+				for (let i = 0; i < state.buckets.length; i++) if (val <= state.buckets[i]) bucketArr[i]++;
+				bucketArr[state.buckets.length]++;
+				state.sums.set(labelKey, (state.sums.get(labelKey) ?? 0) + val);
+				state.observations.set(labelKey, (state.observations.get(labelKey) ?? 0) + 1);
+			} else if (config.type === "gauge" && state.type === "gauge") {
+				const raw = payload[config.field];
+				if (raw === void 0 || raw === null) continue;
+				const val = Number(raw);
+				if (Number.isNaN(val)) continue;
+				state.values.set(labelKey, val);
+			}
+		}
+		return entry;
+	}
+	/**
+	* Render all registered metrics in the Prometheus text exposition format
+	* (version 0.0.4).
+	*
+	* All metric names are prefixed with `logixia_`.
+	*
+	* @example
+	* ```
+	* # HELP logixia_error_count Total error log entries
+	* # TYPE logixia_error_count counter
+	* logixia_error_count{context="OrderService"} 7
+	* ```
+	*/
+	render() {
+		const lines = [];
+		for (const [rawName, config] of Object.entries(this.map)) {
+			const metricName = `logixia_${rawName}`;
+			const state = this.metricState.get(rawName);
+			if (!state) continue;
+			const helpText = config.help ?? rawName.replace(/_/g, " ");
+			lines.push(`# HELP ${metricName} ${helpText}`);
+			lines.push(`# TYPE ${metricName} ${config.type}`);
+			if (state.type === "counter") if (state.values.size === 0) lines.push(`${metricName} 0`);
+			else for (const [labelKey, count] of state.values) lines.push(`${metricName}${renderLabels(labelKey)} ${count}`);
+			else if (state.type === "histogram") for (const [labelKey, bucketCounts] of state.counts) {
+				const labelSuffix = renderLabels(labelKey);
+				const baseObj = labelKey === "{}" ? {} : JSON.parse(labelKey);
+				for (let i = 0; i < state.buckets.length; i++) {
+					const leKey = JSON.stringify({
+						...baseObj,
+						le: String(state.buckets[i])
+					});
+					lines.push(`${metricName}_bucket${renderLabels(leKey)} ${bucketCounts[i] ?? 0}`);
+				}
+				const infKey = JSON.stringify({
+					...baseObj,
+					le: "+Inf"
+				});
+				lines.push(`${metricName}_bucket${renderLabels(infKey)} ${bucketCounts[state.buckets.length] ?? 0}`);
+				lines.push(`${metricName}_sum${labelSuffix} ${state.sums.get(labelKey) ?? 0}`);
+				lines.push(`${metricName}_count${labelSuffix} ${state.observations.get(labelKey) ?? 0}`);
+			}
+			else if (state.type === "gauge") if (state.values.size === 0) lines.push(`${metricName} 0`);
+			else for (const [labelKey, val] of state.values) lines.push(`${metricName}${renderLabels(labelKey)} ${val}`);
+		}
+		return `${lines.join("\n")}\n`;
+	}
+	/**
+	* Reset all metric counters and observations back to zero.
+	* Useful between test runs or on a scheduled reset interval.
+	*/
+	reset() {
+		this.metricState.clear();
+		this.initAllState();
+	}
+	/**
+	* Express route handler — call `app.get('/metrics', metrics.expressHandler())`.
+	*
+	* @example
+	* ```ts
+	* import express from 'express';
+	* const app = express();
+	* app.get('/metrics', metrics.expressHandler());
+	* ```
+	*/
+	expressHandler() {
+		return (_req, res) => {
+			res.set("Content-Type", "text/plain; version=0.0.4; charset=utf-8");
+			res.end(this.render());
+		};
+	}
+	/**
+	* Raw Node.js `http` server handler.
+	* Responds to `GET /metrics` with the Prometheus text payload.
+	*
+	* @example Start a dedicated metrics server on the standard port:
+	* ```ts
+	* import http from 'node:http';
+	* const server = http.createServer(metrics.httpHandler());
+	* server.listen(9464); // Prometheus default port for custom exporters
+	* ```
+	*/
+	httpHandler() {
+		return (req, res) => {
+			if (!(req.url === "/metrics" || req.url === "/metrics/")) {
+				res.writeHead(404).end("Not found");
+				return;
+			}
+			const body = this.render();
+			res.writeHead(200, {
+				"Content-Type": "text/plain; version=0.0.4; charset=utf-8",
+				"Content-Length": Buffer.byteLength(body)
+			});
+			res.end(body);
+		};
+	}
+	initAllState() {
+		for (const [rawName, config] of Object.entries(this.map)) this.initSingleState(rawName, config);
+	}
+	initSingleState(rawName, config) {
+		if (config.type === "counter") this.metricState.set(rawName, {
+			type: "counter",
+			values: /* @__PURE__ */ new Map()
+		});
+		else if (config.type === "histogram") {
+			const buckets = [...config.buckets ?? DEFAULT_BUCKETS].sort((a, b) => a - b);
+			this.metricState.set(rawName, {
+				type: "histogram",
+				buckets,
+				counts: /* @__PURE__ */ new Map(),
+				sums: /* @__PURE__ */ new Map(),
+				observations: /* @__PURE__ */ new Map()
+			});
+		} else this.metricState.set(rawName, {
+			type: "gauge",
+			values: /* @__PURE__ */ new Map()
+		});
+	}
+};
+/**
+* Create a `MetricsPlugin` from a metrics map and return it ready for
+* `logger.use()`.
+*
+* @example
+* ```ts
+* import { createMetricsPlugin } from 'logixia';
+*
+* const metrics = createMetricsPlugin({
+*   http_request_duration: {
+*     type: 'histogram',
+*     field: 'duration',
+*     labels: ['method', 'statusCode'],
+*     help: 'HTTP request duration in milliseconds',
+*   },
+*   error_count: {
+*     type: 'counter',
+*     levelFilter: 'error',
+*     labels: ['context'],
+*     help: 'Total error log entries',
+*   },
+* });
+*
+* logger.use(metrics);
+* app.get('/metrics', metrics.expressHandler());
+* ```
+*/
+function createMetricsPlugin(map) {
+	return new MetricsPlugin(map);
+}
+
 //#endregion
 //#region src/index.ts
 /**
@@ -236,5 +851,5 @@ const logger = new LogixiaLogger(DEFAULT_CONFIG);
 */
 
 //#endregion
-export { DEFAULT_CONFIG, DEFAULT_LOG_COLORS, DEFAULT_LOG_LEVELS, DEFAULT_TRACE_HEADERS, JsonFormatter, KafkaTraceInterceptor, LOGIXIA_LOGGER_CONFIG, LOGIXIA_LOGGER_PREFIX, LogLevel, LogixiaContext, LogixiaLogger, LogixiaLoggerModule, LogixiaLoggerService, TextFormatter, WebSocketTraceInterceptor, applyRedaction, createExpressContextMiddleware, createFastifyContextHook, createLogger, createLoggerService, createTraceMiddleware, deregisterFromShutdown, extractTraceId, flushOnExit, generateTraceId, getCurrentTraceId, isError, logger, normalizeError, redactObject, registerForShutdown, resetShutdownHandlers, runWithTraceId, serializeError, setTraceId, traceStorage };
+export { DEFAULT_CONFIG, DEFAULT_LOG_COLORS, DEFAULT_LOG_LEVELS, DEFAULT_TRACE_HEADERS, ErrorResponseBuilder, InjectLogger, JsonFormatter, KafkaTraceInterceptor, LOGIXIA_LOGGER_CONFIG, LOGIXIA_LOGGER_PREFIX, LogLevel, LogMethod, LogixiaContext, LogixiaException, LogixiaExceptionFilter, LogixiaLogger, LogixiaLoggerModule, LogixiaLoggerService, MetricsPlugin, PluginRegistry, TextFormatter, WebSocketTraceInterceptor, applyRedaction, createExpressContextMiddleware, createFastifyContextHook, createLogger, createLoggerService, createMetricsPlugin, createTraceMiddleware, createTypedLogger, defineLogSchema, deregisterFromShutdown, disableOtelBridge, extractTraceId, flushOnExit, generateRequestId, generateTraceId, getActiveOtelContext, getCurrentTraceId, getOtelMetaFields, globalPluginRegistry, initOtelBridge, isError, isLogixiaException, logger, normalizeError, redactObject, registerForShutdown, resetShutdownHandlers, runWithTraceId, serializeError, setTraceId, traceStorage, usePlugin };
 //# sourceMappingURL=index.mjs.map