logixia 2.0.0 → 2.0.4

package/dist/index.js

@@ -1,19 +1,15 @@
-const require_chunk = require('./chunk-nOFOJqeH.js');
-const require_internal_log = require('./internal-log-BUJYMZbE.js');
-const require_safe_stringify = require('./safe-stringify-DWo3aZp_.js');
-const require_batch_buffer = require('./batch-buffer-BY-mRWIK.js');
-require('./entry-fields-BvOLFlJ4.js');
-const require_trace_utils = require('./trace.utils-DpBOLDtq.js');
-const require_async_context = require('./async-context-DyQQYq3I.js');
-const require_builder = require('./builder-D44QktIo.js');
-const require_coerce_utils = require('./coerce.utils-B-LilukN.js');
-const require_transport_manager = require('./transport.manager-CXbKKdVE.js');
-const require_slack_transport = require('./slack.transport-BfJRouB2.js');
-const require_search = require('./search-C4V0OMEn.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_builder = require("./builder-M7NoaugM.js");
+const require_request_trace = require("./request-trace-wTJdKp6-.js");
+const require_async_context = require("./async-context-DTQgi8f7.js");
+const require_internal_log = require("./internal-log-b0Vp4qrB.js");
+const require_coerce_utils = require("./coerce.utils-C1C5sIX0.js");
+const require_safe_stringify = require("./safe-stringify-DLz1Kz3o.js");
+const require_transport_manager = require("./transport.manager-DkcEOlqV.js");
+const require_slack_transport = require("./slack.transport-Dlx3xvb7.js");
+const require_search = require("./search-DUfWuzFP.js");
 let node_async_hooks = require("node:async_hooks");
-node_async_hooks = require_chunk.__toESM(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
@@ -77,9 +73,7 @@ var JsonFormatter = class {
 		return serialized;
 	}
 };
-
-//#endregion
-//#region src/formatters/text.formatter.ts
+// src/formatters/text.formatter.ts
 const stripControls = (value) => require_transport_manager.stripControlChars(require_coerce_utils.safeToString(value));
 var TextFormatter = class TextFormatter {
 	constructor(options = {}) {
@@ -141,7 +135,6 @@ var TextFormatter = class TextFormatter {
 		switch (this.timestampFormat) {
 			case "iso": return date.toISOString();
 			case "short": return date.toLocaleTimeString();
-			case "locale":
 			default: return date.toLocaleString();
 		}
 	}
@@ -199,9 +192,7 @@ var TextFormatter = class TextFormatter {
 		});
 	}
 };
-
-//#endregion
-//#region src/utils/runtime-control.ts
+// src/utils/runtime-control.ts
 const DEFAULT_CYCLE = [
 	"error",
 	"warn",
@@ -218,13 +209,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);
 		require_internal_log.internalLog(`runtime level changed via ${signal}: ${current} → ${next}`);
 	};
 	process.on(signal, handler);
@@ -233,7 +225,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"];
@@ -241,7 +233,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",
@@ -270,13 +262,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) => {
@@ -302,7 +294,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)) {
@@ -314,9 +306,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 require_internal_log.internalWarn("level control: logger does not support setNamespaceLevels — ignored");
 		}
 		send(res, 200, snapshot());
@@ -378,9 +370,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.
 *
@@ -391,7 +428,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];
@@ -418,7 +455,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);
@@ -427,25 +464,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) require_internal_log.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 node_async_hooks.AsyncLocalStorage();
 /**
 * Merge fields into the wide event for the current async scope. No-op (with no
@@ -466,7 +534,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,10 +545,10 @@ function emit(logger$1, state, options, extra) {
 	if (extra) Object.assign(payload, extra);
 	payload[durationField] = Date.now() - state.startMs;
 	if (includeTrace) {
-		const traceId = require_trace_utils.getCurrentTraceId();
+		const traceId = require_request_trace.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(() => {});
 }
 /**
@@ -489,7 +557,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(),
@@ -498,10 +566,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)
 			});
@@ -516,7 +584,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)) {
@@ -534,192 +602,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: require_safe_stringify.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 ?? require_batch_buffer.DEFAULT_REQUEST_TIMEOUT_MS;
-		this.level = config.level;
-		this.buffer = new require_batch_buffer.BatchBuffer({
-			name: "OtlpLogTransport",
-			batchSize: this.batchSize,
-			maxBufferSize: config.maxBufferSize ?? require_batch_buffer.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 require_safe_stringify.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") {
-			require_internal_log.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 require_batch_buffer.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,
@@ -861,9 +751,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++) {
@@ -881,8 +772,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`;
 	}
@@ -999,9 +892,20 @@ var MetricsPlugin = class {
 function createMetricsPlugin(map, options) {
 	return new MetricsPlugin(map, options);
 }
-
-//#endregion
-//#region src/index.ts
+// src/index.ts
+/**
+* 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
+*/
 /**
 * Create a new Logixia logger instance with TypeScript support for custom levels
 * @param config - Logger configuration
@@ -1015,15 +919,13 @@ const logger = new require_builder.LogixiaLogger(require_builder.DEFAULT_CONFIG)
 /**
 * Export default configuration for reference
 */
-
-//#endregion
 exports.BasicLogIndexer = require_search.BasicLogIndexer;
 exports.BasicSearchEngine = require_search.BasicSearchEngine;
 exports.CorrelationEngine = require_search.CorrelationEngine;
 exports.DEFAULT_CONFIG = require_builder.DEFAULT_CONFIG;
 exports.DEFAULT_LOG_COLORS = require_builder.DEFAULT_LOG_COLORS;
 exports.DEFAULT_LOG_LEVELS = require_builder.DEFAULT_LOG_LEVELS;
-exports.DEFAULT_TRACE_HEADERS = require_trace_utils.DEFAULT_TRACE_HEADERS;
+exports.DEFAULT_TRACE_HEADERS = require_request_trace.DEFAULT_TRACE_HEADERS;
 exports.DiscordTransport = require_slack_transport.DiscordTransport;
 exports.ErrorResponseBuilder = require_builder.ErrorResponseBuilder;
 exports.JsonFormatter = JsonFormatter;
@@ -1031,19 +933,19 @@ exports.LogLevel = require_builder.LogLevel;
 exports.LogixiaContext = require_async_context.LogixiaContext;
 exports.LogixiaException = require_builder.LogixiaException;
 exports.LogixiaLogger = require_builder.LogixiaLogger;
-exports.MAX_INCOMING_ID_LENGTH = require_trace_utils.MAX_INCOMING_ID_LENGTH;
+exports.MAX_INCOMING_ID_LENGTH = require_request_trace.MAX_INCOMING_ID_LENGTH;
 exports.MetricsPlugin = MetricsPlugin;
 exports.NLPSearchEngine = require_search.NLPSearchEngine;
 exports.OVERFLOW_LABEL_VALUE = OVERFLOW_LABEL_VALUE;
-exports.OtlpLogTransport = OtlpLogTransport;
+exports.OtlpLogTransport = require_slack_transport.OtlpLogTransport;
 exports.PatternRecognitionEngine = require_search.PatternRecognitionEngine;
 exports.PluginRegistry = require_builder.PluginRegistry;
 exports.SearchManager = require_search.SearchManager;
 exports.SlackTransport = require_slack_transport.SlackTransport;
-exports.TRACE_CONTEXT_KEY = require_trace_utils.TRACE_CONTEXT_KEY;
+exports.TRACE_CONTEXT_KEY = require_request_trace.TRACE_CONTEXT_KEY;
 exports.TextFormatter = TextFormatter;
-exports.TraceContext = require_trace_utils.TraceContext;
-exports._setActiveContextKey = require_trace_utils._setActiveContextKey;
+exports.TraceContext = require_request_trace.TraceContext;
+exports._setActiveContextKey = require_request_trace._setActiveContextKey;
 exports._shutdownRegistrySize = require_builder._shutdownRegistrySize;
 exports.addEventFields = addEventFields;
 exports.applyRedaction = require_builder.applyRedaction;
@@ -1052,21 +954,21 @@ exports.createFastifyContextHook = require_async_context.createFastifyContextHoo
 exports.createLevelControlHandler = createLevelControlHandler;
 exports.createLogger = createLogger;
 exports.createMetricsPlugin = createMetricsPlugin;
-exports.createTraceMiddleware = require_trace_utils.createTraceMiddleware;
+exports.createTraceMiddleware = require_request_trace.createTraceMiddleware;
 exports.createTypedLogger = createTypedLogger;
 exports.decycleValue = require_safe_stringify.decycleValue;
 exports.defineLogSchema = defineLogSchema;
 exports.deregisterFromShutdown = require_builder.deregisterFromShutdown;
 exports.disableOtelBridge = require_builder.disableOtelBridge;
-exports.extractTraceId = require_trace_utils.extractTraceId;
+exports.extractTraceId = require_request_trace.extractTraceId;
 exports.flushOnExit = require_builder.flushOnExit;
 exports.generateRequestId = require_builder.generateRequestId;
 exports.generateTraceId = require_builder.generateTraceId;
 exports.getActiveOtelContext = require_builder.getActiveOtelContext;
-exports.getCurrentTraceId = require_trace_utils.getCurrentTraceId;
+exports.getCurrentTraceId = require_request_trace.getCurrentTraceId;
 exports.getEventFields = getEventFields;
 exports.getOtelMetaFields = require_builder.getOtelMetaFields;
-exports.getTraceContextKey = require_trace_utils.getTraceContextKey;
+exports.getTraceContextKey = require_request_trace.getTraceContextKey;
 exports.globalPluginRegistry = require_builder.globalPluginRegistry;
 exports.initOtelBridge = require_builder.initOtelBridge;
 exports.isError = require_builder.isError;
@@ -1078,16 +980,17 @@ exports.registerForShutdown = require_builder.registerForShutdown;
 exports.registerLevelSignal = registerLevelSignal;
 exports.resetShutdownHandlers = require_builder.resetShutdownHandlers;
 exports.retrocycle = require_safe_stringify.retrocycle;
-exports.runWithTraceId = require_trace_utils.runWithTraceId;
+exports.runWithTraceId = require_request_trace.runWithTraceId;
 exports.safeStringify = require_safe_stringify.safeStringify;
-exports.sanitizeIncomingId = require_trace_utils.sanitizeIncomingId;
+exports.sanitizeIncomingId = require_request_trace.sanitizeIncomingId;
 exports.serializeError = require_builder.serializeError;
 exports.setEventField = setEventField;
-exports.setTraceId = require_trace_utils.setTraceId;
+exports.setTraceId = require_request_trace.setTraceId;
 exports.stringifyForLog = require_safe_stringify.stringifyForLog;
-exports.toOtelSeverity = toOtelSeverity;
-exports.traceStorage = require_trace_utils.traceStorage;
+exports.toOtelSeverity = require_slack_transport.toOtelSeverity;
+exports.traceStorage = require_request_trace.traceStorage;
 exports.usePlugin = require_builder.usePlugin;
 exports.wideEventMiddleware = wideEventMiddleware;
 exports.withWideEvent = withWideEvent;
+
 //# sourceMappingURL=index.js.map