logixia 1.13.3 → 2.0.4

package/dist/index.mjs

@@ -1,16 +1,14 @@
-import { n as internalLog, r as internalWarn } from "./internal-log-Cm8SOWSV.mjs";
-import { i as stringifyForLog, n as retrocycle, r as safeStringify, t as decycleValue } from "./safe-stringify-DJ66tW5I.mjs";
-import { i as HttpError, n as DEFAULT_MAX_BUFFER_SIZE, r as DEFAULT_REQUEST_TIMEOUT_MS, t as BatchBuffer } from "./batch-buffer-PGvSgbmd.mjs";
-import "./entry-fields-BJkuPnIg.mjs";
-import { a as _setActiveContextKey, c as getCurrentTraceId, d as sanitizeIncomingId, f as setTraceId, i as TraceContext, l as getTraceContextKey, n as MAX_INCOMING_ID_LENGTH, o as createTraceMiddleware, p as traceStorage, r as TRACE_CONTEXT_KEY, s as extractTraceId, t as DEFAULT_TRACE_HEADERS, u as runWithTraceId } from "./trace.utils-CvXgaiQT.mjs";
-import { n as createExpressContextMiddleware, r as createFastifyContextHook, t as LogixiaContext } from "./async-context-BzJrbfQs.mjs";
-import { A as initOtelBridge, C as registerForShutdown, D as disableOtelBridge, E as redactObject, F as DEFAULT_LOG_LEVELS, I as LogLevel, L as PluginRegistry, M as normalizeError, N as serializeError, O as getActiveOtelContext, P as DEFAULT_LOG_COLORS, R as globalPluginRegistry, S as flushOnExit, T as applyRedaction, _ as LogixiaLoggerService, a as ErrorResponseBuilder, b as _shutdownRegistrySize, c as LogixiaException, d as LOGIXIA_LOGGER_PREFIX, f as LOGIXIA_TRACE_CONFIG, g as KafkaTraceInterceptor, i as LogixiaExceptionFilter, j as isError, k as getOtelMetaFields, l as isLogixiaException, m as WebSocketTraceInterceptor, n as LOGIXIA_EXCEPTION_FILTER_OPTIONS, o as generateRequestId, p as LogixiaLoggerModule, r as LogMethod, s as generateTraceId, t as InjectLogger, u as LOGIXIA_LOGGER_CONFIG, v as LogixiaLogger, w as resetShutdownHandlers, x as deregisterFromShutdown, y as createLogger$1, z as usePlugin } from "./nestjs-extras-ImbuDhs1.mjs";
-import { t as safeToString } from "./coerce.utils-Cu6IUTgX.mjs";
-import { u as stripControlChars } from "./transport.manager-CpdVHEGP.mjs";
-import { a as BasicSearchEngine, i as CorrelationEngine, n as PatternRecognitionEngine, o as BasicLogIndexer, r as NLPSearchEngine, t as SearchManager } from "./search-DjXSn6v5.mjs";
+import { C as globalPluginRegistry, D as DEFAULT_LOG_LEVELS, E as DEFAULT_LOG_COLORS, O as LogLevel, S as PluginRegistry, T as DEFAULT_CONFIG, _ as getOtelMetaFields, a as isLogixiaException, b as normalizeError, c as _shutdownRegistrySize, d as registerForShutdown, f as resetShutdownHandlers, g as getActiveOtelContext, h as disableOtelBridge, i as LogixiaException, l as deregisterFromShutdown, m as redactObject, n as generateRequestId, o as LogixiaLogger, p as applyRedaction, r as generateTraceId, s as createLogger$1, t as ErrorResponseBuilder, u as flushOnExit, v as initOtelBridge, w as usePlugin, x as serializeError, y as isError } from "./builder-D70z6kjj.mjs";
+import { a as TRACE_CONTEXT_KEY, c as createTraceMiddleware, d as getTraceContextKey, f as runWithTraceId, h as traceStorage, i as MAX_INCOMING_ID_LENGTH, l as extractTraceId, m as setTraceId, o as TraceContext, p as sanitizeIncomingId, r as DEFAULT_TRACE_HEADERS, s as _setActiveContextKey, u as getCurrentTraceId } from "./request-trace-C_fvIDv4.mjs";
+import { n as createExpressContextMiddleware, r as createFastifyContextHook, t as LogixiaContext } from "./async-context-B05ArHgM.mjs";
+import { n as internalLog, r as internalWarn } from "./internal-log-uCSd1PMc.mjs";
+import { t as safeToString } from "./coerce.utils-B_rEudCn.mjs";
+import { i as stringifyForLog, n as retrocycle, r as safeStringify, t as decycleValue } from "./safe-stringify-BMRl3EX3.mjs";
+import { d as stripControlChars } from "./transport.manager-eZ_EeC00.mjs";
+import { i as toOtelSeverity, n as DiscordTransport, r as OtlpLogTransport, t as SlackTransport } from "./slack.transport-Ce96JBDk.mjs";
+import { a as BasicSearchEngine, i as CorrelationEngine, n as PatternRecognitionEngine, o as BasicLogIndexer, r as NLPSearchEngine, t as SearchManager } from "./search-CWMVYC-R.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
-
-//#region src/formatters/json.formatter.ts
+// src/formatters/json.formatter.ts
 /**
 * Build a JSON.stringify replacer that replaces circular references with the
 * string '[Circular]' instead of throwing. A fresh replacer must be created per
@@ -74,9 +72,7 @@ var JsonFormatter = class {
 		return serialized;
 	}
 };
-
-//#endregion
-//#region src/formatters/text.formatter.ts
+// src/formatters/text.formatter.ts
 const stripControls = (value) => stripControlChars(safeToString(value));
 var TextFormatter = class TextFormatter {
 	constructor(options = {}) {
@@ -138,7 +134,6 @@ var TextFormatter = class TextFormatter {
 		switch (this.timestampFormat) {
 			case "iso": return date.toISOString();
 			case "short": return date.toLocaleTimeString();
-			case "locale":
 			default: return date.toLocaleString();
 		}
 	}
@@ -196,9 +191,7 @@ var TextFormatter = class TextFormatter {
 		});
 	}
 };
-
-//#endregion
-//#region src/utils/runtime-control.ts
+// src/utils/runtime-control.ts
 const DEFAULT_CYCLE = [
 	"error",
 	"warn",
@@ -215,13 +208,14 @@ const DEFAULT_CYCLE = [
 * memorizable command (`kill -USR2 <pid>`) is enough to ratchet verbosity up
 * while chasing a bug and back down again — no value to remember.
 */
-function registerLevelSignal(logger$1, options = {}) {
+function registerLevelSignal(logger, options = {}) {
 	const signal = options.signal ?? "SIGUSR2";
 	const cycle = options.cycle && options.cycle.length > 0 ? options.cycle : [...DEFAULT_CYCLE];
 	const handler = () => {
-		const current = logger$1.getLevel();
-		const next = cycle[(cycle.indexOf(current) + 1) % cycle.length];
-		logger$1.setLevel(next);
+		const current = logger.getLevel();
+		const idx = cycle.indexOf(current);
+		const next = cycle[(idx + 1) % cycle.length];
+		logger.setLevel(next);
 		internalLog(`runtime level changed via ${signal}: ${current} → ${next}`);
 	};
 	process.on(signal, handler);
@@ -230,7 +224,7 @@ function registerLevelSignal(logger$1, options = {}) {
 	};
 }
 /** Maximum accepted request body size for the level control handler. */
-const MAX_BODY_BYTES = 16 * 1024;
+const MAX_BODY_BYTES = 16384;
 function isJsonContentType(req) {
 	var _req$headers;
 	const raw = (_req$headers = req.headers) === null || _req$headers === void 0 ? void 0 : _req$headers["content-type"];
@@ -238,7 +232,7 @@ function isJsonContentType(req) {
 	if (typeof value !== "string") return false;
 	return value.split(";")[0].trim().toLowerCase() === "application/json";
 }
-const VALID_LEVELS = new Set([
+const VALID_LEVELS = /* @__PURE__ */ new Set([
 	"error",
 	"warn",
 	"info",
@@ -267,13 +261,13 @@ const VALID_LEVELS = new Set([
 * which also keeps cross-site form posts out) and a body of at most 16 KB
 * (otherwise 413).
 */
-function createLevelControlHandler(logger$1, options = {}) {
+function createLevelControlHandler(logger, options = {}) {
 	const allowed = options.allowedLevels && options.allowedLevels.length > 0 ? new Set(options.allowedLevels.map((l) => l.toLowerCase())) : VALID_LEVELS;
 	const snapshot = () => {
 		var _logger$getNamespaceL;
 		return {
-			level: logger$1.getLevel(),
-			namespaceLevels: ((_logger$getNamespaceL = logger$1.getNamespaceLevels) === null || _logger$getNamespaceL === void 0 ? void 0 : _logger$getNamespaceL.call(logger$1)) ?? {}
+			level: logger.getLevel(),
+			namespaceLevels: ((_logger$getNamespaceL = logger.getNamespaceLevels) === null || _logger$getNamespaceL === void 0 ? void 0 : _logger$getNamespaceL.call(logger)) ?? {}
 		};
 	};
 	const send = (res, status, body) => {
@@ -299,7 +293,7 @@ function createLevelControlHandler(logger$1, options = {}) {
 				});
 				return;
 			}
-			logger$1.setLevel(lvl);
+			logger.setLevel(lvl);
 		}
 		if (parsed.namespaceLevels !== void 0) {
 			if (typeof parsed.namespaceLevels !== "object" || parsed.namespaceLevels === null || Array.isArray(parsed.namespaceLevels)) {
@@ -311,9 +305,9 @@ function createLevelControlHandler(logger$1, options = {}) {
 				send(res, 400, { error: `unknown level "${String(lvl)}" for namespace "${pat}"` });
 				return;
 			}
-			if (logger$1.setNamespaceLevels) {
+			if (logger.setNamespaceLevels) {
 				const coerced = Object.fromEntries(Object.entries(nl).map(([pat, lvl]) => [pat, String(lvl).toLowerCase()]));
-				logger$1.setNamespaceLevels(coerced);
+				logger.setNamespaceLevels(coerced);
 			} else internalWarn("level control: logger does not support setNamespaceLevels — ignored");
 		}
 		send(res, 200, snapshot());
@@ -375,9 +369,54 @@ function createLevelControlHandler(logger$1, options = {}) {
 		send(res, 405, { error: `method ${method} not allowed` });
 	};
 }
-
-//#endregion
-//#region src/utils/typed-logger.ts
+// src/utils/typed-logger.ts
+/**
+* logixia — TypeScript typed log fields
+*
+* Solves the type-safety gap: standard `Record<string, unknown>` metadata gives
+* zero IDE autocomplete and lets typos slip silently into production logs.
+*
+* Two complementary utilities:
+*
+* 1. `createTypedLogger<TFields>()` — wraps any IBaseLogger so that the second
+*    argument of every log method is constrained to `TFields` (a typed object).
+*    Compile-time safety, zero runtime overhead.
+*
+* 2. `defineLogSchema<TFields>(schema)` — declares expected fields with optional
+*    validators. In development (NODE_ENV !== 'production') every log call is
+*    validated against the schema and a warning is emitted for missing required
+*    fields or type mismatches.
+*
+* @example
+* ```ts
+* import { createTypedLogger, defineLogSchema } from 'logixia';
+*
+* interface OrderFields {
+*   orderId: string;
+*   userId: string;
+*   amount?: number;
+*   currency?: string;
+* }
+*
+* const schema = defineLogSchema<OrderFields>({
+*   orderId: { type: 'string', required: true },
+*   userId:  { type: 'string', required: true },
+*   amount:  { type: 'number' },
+*   currency: { type: 'string' },
+* });
+*
+* const orderLogger = createTypedLogger<OrderFields>(baseLogger, schema);
+* await orderLogger.info('Order created', { orderId: 'ord_123', userId: 'usr_456', amount: 99.99 });
+* //                                       ^^^^ fully typed autocomplete ^^^^
+* ```
+*/
+function isProduction() {
+	try {
+		return process.env.NODE_ENV === "production";
+	} catch {
+		return false;
+	}
+}
 /**
 * Define a typed schema for a category of log entries.
 *
@@ -388,7 +427,7 @@ function defineLogSchema(fields) {
 	return {
 		fields,
 		validate(payload) {
-			if (process.env["NODE_ENV"] === "production") return [];
+			if (isProduction()) return [];
 			const warnings = [];
 			for (const [key, def] of Object.entries(fields)) {
 				const value = payload[key];
@@ -415,7 +454,7 @@ function defineLogSchema(fields) {
 * @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 createTypedLogger(logger, schema) {
 	function withValidation(level, fn, message, data) {
 		if (schema && data) {
 			const warnings = schema.validate(data);
@@ -424,25 +463,56 @@ function createTypedLogger(logger$1, schema) {
 		return fn(message, data);
 	}
 	return {
-		raw: logger$1,
+		raw: logger,
 		error(messageOrError, data) {
 			if (schema && data) {
 				const warnings = schema.validate(data);
 				const display = messageOrError instanceof Error ? messageOrError.message : messageOrError;
 				for (const w of warnings) internalWarn(`[logixia/schema] ${w} — level=error message="${display}"`);
 			}
-			return logger$1.error(messageOrError, data);
+			return logger.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)
+		warn: (m, d) => withValidation("warn", logger.warn.bind(logger), m, d),
+		info: (m, d) => withValidation("info", logger.info.bind(logger), m, d),
+		debug: (m, d) => withValidation("debug", logger.debug.bind(logger), m, d),
+		verbose: (m, d) => withValidation("verbose", (logger.verbose ?? logger.debug).bind(logger), m, d),
+		trace: (m, d) => withValidation("trace", (logger.trace ?? logger.debug).bind(logger), m, d)
 	};
 }
-
-//#endregion
-//#region src/wide-events.ts
+// src/wide-events.ts
+/**
+* logixia — Canonical Log Lines / Wide Events.
+*
+* Emit ONE dense, structured event per unit of work (usually a request) instead
+* of scattering details across many narrow log lines. Fields are accumulated as
+* the request flows through middleware and business logic, then the whole event
+* is emitted ONCE — in a `finally`/teardown path so it fires even on errors.
+*
+* This is the "canonical log line" pattern (Stripe) / "wide events" /
+* "Observability 2.0" (Honeycomb): one pre-joined, queryable record per request,
+* so operators never JOIN across log lines during an incident. It composes with
+* logixia's existing trace correlation — when a trace is active, the event
+* carries `traceId`/`spanId`, making it OTel-friendly.
+*
+* @example Manual scope
+* ```ts
+* import { withWideEvent, addEventFields } from 'logixia';
+*
+* await withWideEvent(logger, { route: '/checkout' }, async () => {
+*   addEventFields({ userId, planTier });        // from anywhere in the call tree
+*   addEventFields({ dbQueries: 4, cacheHit });
+*   // ...one wide event is emitted automatically when this callback settles,
+*   //    even if it throws.
+* });
+* ```
+*
+* @example Express middleware (auto-emit on response finish/close)
+* ```ts
+* import { wideEventMiddleware } from 'logixia';
+* app.use(wideEventMiddleware(logger));
+* app.get('/x', (req, res) => { addEventFields({ handled: 'x' }); res.json({}); });
+* ```
+*/
 const _storage = new AsyncLocalStorage();
 /**
 * Merge fields into the wide event for the current async scope. No-op (with no
@@ -463,7 +533,7 @@ function getEventFields() {
 	const state = _storage.getStore();
 	return state ? { ...state.fields } : void 0;
 }
-function emit(logger$1, state, options, extra) {
+function emit(logger, state, options, extra) {
 	if (state.emitted) return;
 	state.emitted = true;
 	const level = options.level ?? "info";
@@ -477,7 +547,7 @@ function emit(logger$1, state, options, extra) {
 		const traceId = getCurrentTraceId();
 		if (traceId !== void 0 && payload["traceId"] === void 0) payload["traceId"] = traceId;
 	}
-	const p = logger$1.logLevel(level, message, payload);
+	const p = logger.logLevel(level, message, payload);
 	if (p && typeof p.catch === "function") p.catch(() => {});
 }
 /**
@@ -486,7 +556,7 @@ function emit(logger$1, state, options, extra) {
 * when the callback settles — on success OR error (the canonical "emit in
 * finally" guarantee). On error, `error` + `errorMessage` fields are added.
 */
-async function withWideEvent(logger$1, initialFields, callback, options = {}) {
+async function withWideEvent(logger, initialFields, callback, options = {}) {
 	const state = {
 		fields: { ...initialFields },
 		startMs: Date.now(),
@@ -495,10 +565,10 @@ async function withWideEvent(logger$1, initialFields, callback, options = {}) {
 	return _storage.run(state, async () => {
 		try {
 			const result = await callback();
-			emit(logger$1, state, options);
+			emit(logger, state, options);
 			return result;
 		} catch (error) {
-			emit(logger$1, state, options, {
+			emit(logger, state, options, {
 				error: true,
 				errorMessage: error instanceof Error ? error.message : String(error)
 			});
@@ -513,7 +583,7 @@ async function withWideEvent(logger$1, initialFields, callback, options = {}) {
 * more via `addEventFields`. The completion event includes `statusCode` and the
 * request duration.
 */
-function wideEventMiddleware(logger$1, options = {}) {
+function wideEventMiddleware(logger, options = {}) {
 	return function logixiaWideEventMiddleware(req, res, next) {
 		var _options$skip, _req$socket, _res$once, _res$once2;
 		if ((_options$skip = options.skip) === null || _options$skip === void 0 ? void 0 : _options$skip.call(options, req)) {
@@ -531,192 +601,14 @@ function wideEventMiddleware(logger$1, options = {}) {
 			emitted: false
 		};
 		const finalize = () => {
-			emit(logger$1, state, options, { statusCode: res.statusCode ?? 0 });
+			emit(logger, state, options, { statusCode: res.statusCode ?? 0 });
 		};
 		(_res$once = res.once) === null || _res$once === void 0 || _res$once.call(res, "finish", finalize);
 		(_res$once2 = res.once) === null || _res$once2 === void 0 || _res$once2.call(res, "close", finalize);
 		_storage.run(state, () => next());
 	};
 }
-
-//#endregion
-//#region src/transports/otlp.transport.ts
-const HEX_32 = /^[0-9a-f]{32}$/;
-/**
-* OTLP JSON wants a 32-char lowercase hex trace id. Dashed UUIDs are
-* normalised; anything else (or all zeros) returns undefined.
-*/
-function toOtlpTraceId(id) {
-	const hex = id.replace(/-/g, "").toLowerCase();
-	return HEX_32.test(hex) && hex !== "0".repeat(32) ? hex : void 0;
-}
-/**
-* Map a logixia level name to an OTel SeverityNumber (1–24) and text.
-* Per the OTel logs SDK spec: TRACE=1, DEBUG=5, INFO=9, WARN=13, ERROR=17,
-* FATAL=21. Custom/unknown levels fall back to INFO (9).
-*/
-function toOtelSeverity(level) {
-	switch (level.toLowerCase()) {
-		case "trace": return {
-			number: 1,
-			text: "TRACE"
-		};
-		case "verbose": return {
-			number: 5,
-			text: "DEBUG"
-		};
-		case "debug": return {
-			number: 5,
-			text: "DEBUG"
-		};
-		case "info": return {
-			number: 9,
-			text: "INFO"
-		};
-		case "warn":
-		case "warning": return {
-			number: 13,
-			text: "WARN"
-		};
-		case "error": return {
-			number: 17,
-			text: "ERROR"
-		};
-		case "fatal": return {
-			number: 21,
-			text: "FATAL"
-		};
-		default: return {
-			number: 9,
-			text: "INFO"
-		};
-	}
-}
-/** Coerce a JS value into an OTLP AnyValue. */
-function toAnyValue(value) {
-	if (typeof value === "string") return { stringValue: value };
-	if (typeof value === "boolean") return { boolValue: value };
-	if (typeof value === "number") return Number.isInteger(value) ? { intValue: value } : { doubleValue: value };
-	if (typeof value === "bigint") return { stringValue: value.toString() };
-	if (value === null || value === void 0) return { stringValue: "" };
-	try {
-		return { stringValue: stringifyForLog(value) };
-	} catch {
-		return { stringValue: String(value) };
-	}
-}
-/** Build the OTLP KeyValue attribute list from a flat record. */
-function toAttributes(rec) {
-	return Object.entries(rec).map(([key, value]) => ({
-		key,
-		value: toAnyValue(value)
-	}));
-}
-var OtlpLogTransport = class {
-	constructor(config) {
-		this.name = "otlp";
-		this.flushTimer = null;
-		this.url = config.url;
-		this.headers = config.headers ?? {};
-		this.batchSize = config.batchSize ?? 100;
-		this.flushIntervalMs = config.flushIntervalMs ?? 5e3;
-		this.requestTimeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-		this.level = config.level;
-		this.buffer = new BatchBuffer({
-			name: "OtlpLogTransport",
-			batchSize: this.batchSize,
-			maxBufferSize: config.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE,
-			send: (entries) => this.send(entries)
-		});
-		this.resourceAttrs = toAttributes({
-			"service.name": config.serviceName ?? "logixia",
-			...config.serviceVersion ? { "service.version": config.serviceVersion } : {},
-			...config.environment ? { "deployment.environment": config.environment } : {},
-			...config.resourceAttributes ?? {}
-		});
-		this.flushTimer = setInterval(() => {
-			this.flush().catch(() => {});
-		}, this.flushIntervalMs);
-		if (this.flushTimer.unref) this.flushTimer.unref();
-	}
-	write(entry) {
-		this.buffer.push(entry);
-		this.buffer.flushIfFull();
-	}
-	/** Convert one entry into an OTLP LogRecord. */
-	toLogRecord(entry) {
-		const sev = toOtelSeverity(entry.level);
-		const tsNanos = String(entry.timestamp.getTime() * 1e6);
-		const attrs = { ...entry.data ?? {} };
-		if (entry.context !== void 0) attrs["context"] = entry.context;
-		if (entry.appName !== void 0) attrs["app.name"] = entry.appName;
-		if (entry.environment !== void 0) attrs["deployment.environment"] = entry.environment;
-		const record = {
-			timeUnixNano: tsNanos,
-			observedTimeUnixNano: tsNanos,
-			severityNumber: sev.number,
-			severityText: sev.text,
-			body: { stringValue: entry.message },
-			attributes: toAttributes(attrs)
-		};
-		if (entry.traceId) {
-			const traceId = toOtlpTraceId(entry.traceId);
-			if (traceId) record["traceId"] = traceId;
-			else record["attributes"].push({
-				key: "trace_id",
-				value: { stringValue: entry.traceId }
-			});
-		}
-		return record;
-	}
-	buildPayload(entries) {
-		return stringifyForLog({ resourceLogs: [{
-			resource: { attributes: this.resourceAttrs },
-			scopeLogs: [{
-				scope: { name: "logixia" },
-				logRecords: entries.map((e) => this.toLogRecord(e))
-			}]
-		}] });
-	}
-	flush() {
-		return this.buffer.flush();
-	}
-	async send(entries) {
-		if (typeof fetch !== "function") {
-			internalWarn("OtlpLogTransport: global fetch unavailable — cannot export logs");
-			return;
-		}
-		const controller = new AbortController();
-		const timer = setTimeout(() => controller.abort(), this.requestTimeoutMs);
-		try {
-			const res = await fetch(this.url, {
-				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-					...this.headers
-				},
-				body: this.buildPayload(entries),
-				signal: controller.signal
-			});
-			if (!res.ok) throw new HttpError(res.status, "", "OTLP export");
-		} catch (err) {
-			if (controller.signal.aborted) throw new Error(`OTLP export timed out after ${this.requestTimeoutMs}ms`, { cause: err });
-			throw err;
-		} finally {
-			clearTimeout(timer);
-		}
-	}
-	async close() {
-		if (this.flushTimer) {
-			clearInterval(this.flushTimer);
-			this.flushTimer = null;
-		}
-		await this.buffer.close();
-	}
-};
-
-//#endregion
-//#region src/metrics.ts
+// src/metrics.ts
 const DEFAULT_BUCKETS = [
 	1,
 	5,
@@ -858,9 +750,10 @@ var MetricsPlugin = class {
 			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) {
+			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++) {
@@ -878,8 +771,10 @@ var MetricsPlugin = class {
 				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}`);
+			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`;
 	}
@@ -996,52 +891,20 @@ var MetricsPlugin = class {
 function createMetricsPlugin(map, options) {
 	return new MetricsPlugin(map, options);
 }
-
-//#endregion
-//#region src/index.ts
+// src/index.ts
 /**
-* Default configuration for Logixia logger
+* Logixia - Advanced TypeScript Logger
+*
+* A comprehensive logging library with support for:
+* - Multiple output formats (console, file, JSON)
+* - Trace ID tracking
+* - Performance monitoring
+* - NestJS integration
+* - Customizable log levels and colors
+* - Intelligent log search and aggregation
+* - Natural language query processing
+* - Pattern recognition and anomaly detection
 */
-const DEFAULT_CONFIG = {
-	appName: "App",
-	environment: "development",
-	traceId: true,
-	format: {
-		timestamp: true,
-		colorize: true,
-		json: false
-	},
-	silent: false,
-	levelOptions: {
-		level: LogLevel.INFO,
-		levels: {
-			[LogLevel.ERROR]: 0,
-			[LogLevel.WARN]: 1,
-			[LogLevel.INFO]: 2,
-			[LogLevel.DEBUG]: 3,
-			[LogLevel.TRACE]: 4,
-			[LogLevel.VERBOSE]: 5
-		},
-		colors: {
-			[LogLevel.ERROR]: "red",
-			[LogLevel.WARN]: "yellow",
-			[LogLevel.INFO]: "blue",
-			[LogLevel.DEBUG]: "green",
-			[LogLevel.TRACE]: "gray",
-			[LogLevel.VERBOSE]: "cyan"
-		}
-	},
-	fields: {
-		timestamp: true,
-		level: true,
-		appName: true,
-		traceId: true,
-		message: true,
-		payload: true,
-		timeTaken: true
-	},
-	outputs: ["console"]
-};
 /**
 * Create a new Logixia logger instance with TypeScript support for custom levels
 * @param config - Logger configuration
@@ -1049,24 +912,12 @@ const DEFAULT_CONFIG = {
 */
 const createLogger = createLogger$1;
 /**
-* Create a new Logixia logger service for NestJS
-* @param config - Logger configuration
-* @returns LogixiaLoggerService instance
-*/
-function createLoggerService(config) {
-	return new LogixiaLoggerService({
-		...DEFAULT_CONFIG,
-		...config
-	});
-}
-/**
 * Default logger instance
 */
 const logger = new LogixiaLogger(DEFAULT_CONFIG);
 /**
 * Export default configuration for reference
 */
+export { BasicLogIndexer, BasicSearchEngine, CorrelationEngine, DEFAULT_CONFIG, DEFAULT_LOG_COLORS, DEFAULT_LOG_LEVELS, DEFAULT_TRACE_HEADERS, DiscordTransport, ErrorResponseBuilder, JsonFormatter, LogLevel, LogixiaContext, LogixiaException, LogixiaLogger, MAX_INCOMING_ID_LENGTH, MetricsPlugin, NLPSearchEngine, OVERFLOW_LABEL_VALUE, OtlpLogTransport, PatternRecognitionEngine, PluginRegistry, SearchManager, SlackTransport, TRACE_CONTEXT_KEY, TextFormatter, TraceContext, _setActiveContextKey, _shutdownRegistrySize, addEventFields, applyRedaction, createExpressContextMiddleware, createFastifyContextHook, createLevelControlHandler, createLogger, createMetricsPlugin, createTraceMiddleware, createTypedLogger, decycleValue, defineLogSchema, deregisterFromShutdown, disableOtelBridge, extractTraceId, flushOnExit, generateRequestId, generateTraceId, getActiveOtelContext, getCurrentTraceId, getEventFields, getOtelMetaFields, getTraceContextKey, globalPluginRegistry, initOtelBridge, isError, isLogixiaException, logger, normalizeError, redactObject, registerForShutdown, registerLevelSignal, resetShutdownHandlers, retrocycle, runWithTraceId, safeStringify, sanitizeIncomingId, serializeError, setEventField, setTraceId, stringifyForLog, toOtelSeverity, traceStorage, usePlugin, wideEventMiddleware, withWideEvent };
 
-//#endregion
-export { BasicLogIndexer, BasicSearchEngine, CorrelationEngine, DEFAULT_CONFIG, DEFAULT_LOG_COLORS, DEFAULT_LOG_LEVELS, DEFAULT_TRACE_HEADERS, ErrorResponseBuilder, InjectLogger, JsonFormatter, KafkaTraceInterceptor, LOGIXIA_EXCEPTION_FILTER_OPTIONS, LOGIXIA_LOGGER_CONFIG, LOGIXIA_LOGGER_PREFIX, LOGIXIA_TRACE_CONFIG, LogLevel, LogMethod, LogixiaContext, LogixiaException, LogixiaExceptionFilter, LogixiaLogger, LogixiaLoggerModule, LogixiaLoggerService, MAX_INCOMING_ID_LENGTH, MetricsPlugin, NLPSearchEngine, OVERFLOW_LABEL_VALUE, OtlpLogTransport, PatternRecognitionEngine, PluginRegistry, SearchManager, TRACE_CONTEXT_KEY, TextFormatter, TraceContext, WebSocketTraceInterceptor, _setActiveContextKey, _shutdownRegistrySize, addEventFields, applyRedaction, createExpressContextMiddleware, createFastifyContextHook, createLevelControlHandler, createLogger, createLoggerService, createMetricsPlugin, createTraceMiddleware, createTypedLogger, decycleValue, defineLogSchema, deregisterFromShutdown, disableOtelBridge, extractTraceId, flushOnExit, generateRequestId, generateTraceId, getActiveOtelContext, getCurrentTraceId, getEventFields, getOtelMetaFields, getTraceContextKey, globalPluginRegistry, initOtelBridge, isError, isLogixiaException, logger, normalizeError, redactObject, registerForShutdown, registerLevelSignal, resetShutdownHandlers, retrocycle, runWithTraceId, safeStringify, sanitizeIncomingId, serializeError, setEventField, setTraceId, stringifyForLog, toOtelSeverity, traceStorage, usePlugin, wideEventMiddleware, withWideEvent };
 //# sourceMappingURL=index.mjs.map