@lssm/lib.logger 0.0.0-canary-20251217062943 → 0.0.0-canary-20251217072406

package/dist/context.browser.mjs

@@ -1 +1,88 @@
-import"zone.js";const e=globalThis.Zone,t=`__lssm_log_context_data__`;function n(){if(e)return e.current.get(t)}var r=class r{static instance;static fallbackCounter=0;static getInstance(){return r.instance||=new r,r.instance}run(n,r){let i={context:{...n},trace:this.getCurrentTrace()};return e?e.current.fork({name:`log-context`,properties:{[t]:i}}).run(r):r()}extend(e,t){let n={...this.getContext(),...e};return this.run(n,t)}set(e,t){let r=n();r&&(r.context[e]=t)}get(e){return n()?.context?.[e]}getContext(){return n()?.context||{}}setTrace(e){let t=n();t&&(t.trace=e)}getCurrentTrace(){return n()?.trace}generateId(){return typeof crypto<`u`&&typeof crypto.randomUUID==`function`?crypto.randomUUID():(r.fallbackCounter+=1,`log-${r.fallbackCounter}`)}};export{r as LogContext};
+import "zone.js";
+
+//#region src/context.browser.ts
+const ZONE = globalThis.Zone;
+const STORE_KEY = "__lssm_log_context_data__";
+function getStore() {
+	if (!ZONE) return void 0;
+	return ZONE.current.get(STORE_KEY);
+}
+/**
+* Browser implementation of LogContext using Zone.js for async context
+* propagation (similar to AsyncLocalStorage in Node).
+*/
+var LogContext = class LogContext {
+	static instance;
+	static fallbackCounter = 0;
+	static getInstance() {
+		if (!LogContext.instance) LogContext.instance = new LogContext();
+		return LogContext.instance;
+	}
+	/**
+	* Run a function with a new context
+	*/
+	run(context, fn) {
+		const contextData = {
+			context: { ...context },
+			trace: this.getCurrentTrace()
+		};
+		if (!ZONE) return fn();
+		return ZONE.current.fork({
+			name: "log-context",
+			properties: { [STORE_KEY]: contextData }
+		}).run(fn);
+	}
+	/**
+	* Run a function with an extended context (merges with current)
+	*/
+	extend(additionalContext, fn) {
+		const mergedContext = {
+			...this.getContext(),
+			...additionalContext
+		};
+		return this.run(mergedContext, fn);
+	}
+	/**
+	* Set context data for the current execution context
+	*/
+	set(key, value) {
+		const current = getStore();
+		if (current) current.context[key] = value;
+	}
+	/**
+	* Get a specific context value
+	*/
+	get(key) {
+		return getStore()?.context?.[key];
+	}
+	/**
+	* Get all context data
+	*/
+	getContext() {
+		return getStore()?.context || {};
+	}
+	/**
+	* Set trace context
+	*/
+	setTrace(trace) {
+		const current = getStore();
+		if (current) current.trace = trace;
+	}
+	/**
+	* Get current trace context
+	*/
+	getCurrentTrace() {
+		return getStore()?.trace;
+	}
+	/**
+	* Generate a unique ID for requests/operations
+	*/
+	generateId() {
+		if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+		LogContext.fallbackCounter += 1;
+		return `log-${LogContext.fallbackCounter}`;
+	}
+};
+
+//#endregion
+export { LogContext };

package/dist/context.mjs

@@ -1 +1 @@
-export{};
+export {  };

package/dist/context.node.mjs

@@ -1 +1,78 @@
-import{AsyncLocalStorage as e}from"node:async_hooks";var t=class t{static instance;storage;constructor(){this.storage=new e}static getInstance(){return t.instance||=new t,t.instance}run(e,t){let n={context:{...e},trace:this.getCurrentTrace()};return this.storage.run(n,t)}extend(e,t){let n={...this.getContext(),...e};return this.run(n,t)}set(e,t){let n=this.storage.getStore();n&&(n.context[e]=t)}get(e){return this.storage.getStore()?.context?.[e]}getContext(){return this.storage.getStore()?.context||{}}setTrace(e){let t=this.storage.getStore();t&&(t.trace=e)}getCurrentTrace(){return this.storage.getStore()?.trace}generateId(){return crypto.randomUUID()}};export{t as LogContext};
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/context.node.ts
+/**
+* Node.js implementation of LogContext using AsyncLocalStorage.
+*/
+var LogContext = class LogContext {
+	static instance;
+	storage;
+	constructor() {
+		this.storage = new AsyncLocalStorage();
+	}
+	static getInstance() {
+		if (!LogContext.instance) LogContext.instance = new LogContext();
+		return LogContext.instance;
+	}
+	/**
+	* Run a function with a new context
+	*/
+	run(context, fn) {
+		const contextData = {
+			context: { ...context },
+			trace: this.getCurrentTrace()
+		};
+		return this.storage.run(contextData, fn);
+	}
+	/**
+	* Run a function with an extended context (merges with current)
+	*/
+	extend(additionalContext, fn) {
+		const mergedContext = {
+			...this.getContext(),
+			...additionalContext
+		};
+		return this.run(mergedContext, fn);
+	}
+	/**
+	* Set context data for the current execution context
+	*/
+	set(key, value) {
+		const current = this.storage.getStore();
+		if (current) current.context[key] = value;
+	}
+	/**
+	* Get a specific context value
+	*/
+	get(key) {
+		return this.storage.getStore()?.context?.[key];
+	}
+	/**
+	* Get all context data
+	*/
+	getContext() {
+		return this.storage.getStore()?.context || {};
+	}
+	/**
+	* Set trace context
+	*/
+	setTrace(trace) {
+		const current = this.storage.getStore();
+		if (current) current.trace = trace;
+	}
+	/**
+	* Get current trace context
+	*/
+	getCurrentTrace() {
+		return this.storage.getStore()?.trace;
+	}
+	/**
+	* Generate a unique ID for requests/operations
+	*/
+	generateId() {
+		return crypto.randomUUID();
+	}
+};
+
+//#endregion
+export { LogContext };

package/dist/elysia-plugin.mjs

@@ -1 +1,84 @@
-import{LogContext as e}from"./context.node.mjs";import{Logger as t}from"./logger.node.mjs";import{Elysia as n}from"elysia";function r(n={}){let{logger:r=new t,logRequests:i=!0,logResponses:a=!0,excludePaths:o=[`/health`,`/metrics`]}=n,s=e.getInstance();return function(e){return e.derive(e=>{let{request:t,path:n}=e;if(o.some(e=>n.startsWith(e)))return{logger:r};let a=new URL(t.url),c={requestId:s.generateId(),method:t.method,url:t.url,path:a.pathname,userAgent:t.headers.get(`user-agent`)||void 0,timestamp:new Date().toISOString()},l=performance.now();return s.run(c,()=>{i&&r.info(`→ ${t.method} ${n}`,{method:t.method,path:n,userAgent:c.userAgent,requestId:c.requestId})}),{logger:r,requestContext:c,startTime:l}}).onAfterHandle(e=>{let{request:t,startTime:n,requestContext:r,logger:i}=e;if(!n||!r)return;let o=performance.now()-n,s=new URL(t.url).pathname;a&&i.info(`← 200 ${t.method} ${s}`,{method:t.method,path:s,duration:`${o.toFixed(2)}ms`,requestId:r.requestId})}).onError(e=>{let{request:t,error:n,code:r,startTime:i,requestContext:a,logger:o}=e;if(!i||!a)return;let s=performance.now()-i,c=new URL(t.url).pathname;o?.error(`✖ ${r} ${t.method} ${c}`,{method:t.method,path:c,error:n?.toString?.()||`Unknown error`,code:r,duration:`${s.toFixed(2)}ms`,requestId:a.requestId})}).derive(()=>({logInfo:(e,t)=>{r.info(e,t)},logError:(e,t,n)=>{r.error(e,n,t)},traceOperation:async(e,t)=>r.trace({operationType:`custom`,operationName:e,autoTiming:!0},t)}))}}const i=r;export{i as createElysiaLogger,r as elysiaLogger};
+import { LogContext } from "./context.node.mjs";
+import { Logger } from "./logger.node.mjs";
+import { Elysia } from "elysia";
+
+//#region src/elysia-plugin.ts
+/**
+* Simple ElysiaJS Logger Plugin
+* Provides automatic request logging and tracing
+*/
+function elysiaLogger(config = {}) {
+	const { logger = new Logger(), logRequests = true, logResponses = true, excludePaths = ["/health", "/metrics"] } = config;
+	const context = LogContext.getInstance();
+	return function(app) {
+		return app.derive((ctx) => {
+			const { request, path } = ctx;
+			if (excludePaths.some((excludePath) => path.startsWith(excludePath))) return { logger };
+			const url = new URL(request.url);
+			const requestContext = {
+				requestId: context.generateId(),
+				method: request.method,
+				url: request.url,
+				path: url.pathname,
+				userAgent: request.headers.get("user-agent") || void 0,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			const startTime = performance.now();
+			context.run(requestContext, () => {
+				if (logRequests) logger.info(`→ ${request.method} ${path}`, {
+					method: request.method,
+					path,
+					userAgent: requestContext.userAgent,
+					requestId: requestContext.requestId
+				});
+			});
+			return {
+				logger,
+				requestContext,
+				startTime
+			};
+		}).onAfterHandle((ctx) => {
+			const { request, startTime, requestContext, logger: logger$1 } = ctx;
+			if (!startTime || !requestContext) return;
+			const duration = performance.now() - startTime;
+			const path = new URL(request.url).pathname;
+			if (logResponses) logger$1.info(`← 200 ${request.method} ${path}`, {
+				method: request.method,
+				path,
+				duration: `${duration.toFixed(2)}ms`,
+				requestId: requestContext.requestId
+			});
+		}).onError((ctx) => {
+			const { request, error, code, startTime, requestContext, logger: logger$1 } = ctx;
+			if (!startTime || !requestContext) return;
+			const duration = performance.now() - startTime;
+			const path = new URL(request.url).pathname;
+			logger$1?.error(`✖ ${code} ${request.method} ${path}`, {
+				method: request.method,
+				path,
+				error: error?.toString?.() || "Unknown error",
+				code,
+				duration: `${duration.toFixed(2)}ms`,
+				requestId: requestContext.requestId
+			});
+		}).derive(() => ({
+			logInfo: (message, metadata) => {
+				logger.info(message, metadata);
+			},
+			logError: (message, error, metadata) => {
+				logger.error(message, metadata, error);
+			},
+			traceOperation: async (operationName, operation) => {
+				return logger.trace({
+					operationType: "custom",
+					operationName,
+					autoTiming: true
+				}, operation);
+			}
+		}));
+	};
+}
+const createElysiaLogger = elysiaLogger;
+
+//#endregion
+export { createElysiaLogger, elysiaLogger };

package/dist/formatters.mjs

@@ -1,9 +1,179 @@
-import{LogLevel as e}from"./types.mjs";const t={reset:`\x1B[0m`,bright:`\x1B[1m`,dim:`\x1B[2m`,red:`\x1B[31m`,green:`\x1B[32m`,yellow:`\x1B[33m`,blue:`\x1B[34m`,magenta:`\x1B[35m`,cyan:`\x1B[36m`,white:`\x1B[37m`,gray:`\x1B[90m`,bgRed:`\x1B[41m`,bgYellow:`\x1B[43m`},n={[e.TRACE]:{color:t.gray,symbol:`○`,name:`TRACE`},[e.DEBUG]:{color:t.blue,symbol:`●`,name:`DEBUG`},[e.INFO]:{color:t.green,symbol:`●`,name:`INFO `},[e.WARN]:{color:t.yellow,symbol:`▲`,name:`WARN `},[e.ERROR]:{color:t.red,symbol:`✖`,name:`ERROR`},[e.FATAL]:{color:t.bgRed+t.white,symbol:`💀`,name:`FATAL`}};var r=class{enableColors;constructor(e=!0){this.enableColors=e}format(e){let r=[],i=n[e.level],a=this.formatTimestamp(e.timestamp);r.push(this.colorize(a,t.gray));let o=`${i.symbol} ${i.name}`;if(r.push(this.colorize(o,i.color)),e.traceId){let n=this.formatTraceInfo(e);r.push(this.colorize(n,t.cyan))}if(r.push(this.colorize(e.message,t.white)),e.duration!==void 0){let n=`(${this.formatDuration(e.duration)})`;r.push(this.colorize(n,t.magenta))}let s=r.join(` `);if(e.context&&Object.keys(e.context).length>0&&(s+=`
-`+this.formatContext(e.context)),e.metadata&&Object.keys(e.metadata).length>0&&(s+=`
-`+this.formatMetadata(e.metadata)),e.error&&(s+=`
-`+this.formatError(e.error)),e.tags&&e.tags.length>0){let n=e.tags.map(e=>`#${e}`).join(` `);s+=`
-`+this.colorize(`Tags: ${n}`,t.blue)}return s}formatTimestamp(e){return e.toISOString().substring(11,23)}formatTraceInfo(e){let t=[`trace:${e.traceId?.substring(0,8)||`unknown`}`];return e.spanId&&e.spanId.length>=8&&t.push(`span:${e.spanId.substring(0,8)}`),e.parentId&&e.parentId.length>=8&&t.push(`parent:${e.parentId.substring(0,8)}`),`[${t.join(`|`)}]`}formatDuration(e){return e<1?`${(e*1e3).toFixed(0)}μs`:e<1e3?`${e.toFixed(2)}ms`:`${(e/1e3).toFixed(2)}s`}formatContext(e){let n=this.formatObject(e,2);return this.colorize(`Context: ${n}`,t.cyan)}formatMetadata(e){let n=this.formatObject(e,2);return this.colorize(`Metadata: ${n}`,t.blue)}formatError(e){let n=this.colorize(`Error: ${e.name}: ${e.message}`,t.red);if(e.stack){let r=e.stack.split(`
-`).slice(1,6).map(e=>`  ${e}`).join(`
-`);n+=`
-`+this.colorize(r,t.gray)}return n}formatObject(e,t=0){let n=` `.repeat(t),r=Object.entries(e);return r.length===0?`{}`:r[0]&&typeof r[0][1]!=`object`?`{ ${r[0][0]}: ${this.formatValue(r[0][1])} }`:`{\n${r.map(([e,r])=>`${n}  ${e}: ${this.formatValue(r,t+2)}`).join(`
-`)}\n${n}}`}formatValue(e,t=0){return e===null?`null`:e===void 0?`undefined`:typeof e==`string`?`"${e}"`:typeof e==`boolean`||typeof e==`number`?String(e):e instanceof Date?e.toISOString():Array.isArray(e)?e.length===0?`[]`:`[${e.map(e=>this.formatValue(e)).join(`, `)}]`:typeof e==`object`?this.formatObject(e,t):String(e)}colorize(e,n){return this.enableColors?`${n}${e}${t.reset}`:e}},i=class{format(e){let t={timestamp:e.timestamp,level:e.level,message:e.message};return e.traceId&&(t.traceId=e.traceId),e.spanId&&(t.spanId=e.spanId),e.parentId&&(t.parentId=e.parentId),e.duration!==void 0&&(t.duration=e.duration),e.context&&Object.keys(e.context).length>0&&(t.context=e.context),e.metadata&&Object.keys(e.metadata).length>0&&(t.metadata=e.metadata),e.error&&(t.error={name:e.error.name,message:e.error.message,stack:e.error.stack}),e.tags&&e.tags.length>0&&(t.tags=e.tags),JSON.stringify(t)}},a=class{template;dateFormat;constructor(e=`{timestamp} [{level}] {message}`,t){this.template=e,this.dateFormat=t||(e=>e.toISOString())}format(t){let n=e[t.level],r=this.dateFormat(t.timestamp),i=this.template.replace(`{timestamp}`,r).replace(`{level}`,n).replace(`{message}`,t.message).replace(`{traceId}`,t.traceId||``).replace(`{spanId}`,t.spanId||``).replace(`{duration}`,t.duration?.toString()||``);return t.context&&(i=i.replace(`{context}`,JSON.stringify(t.context))),t.metadata&&(i=i.replace(`{metadata}`,JSON.stringify(t.metadata))),i}};export{a as CustomFormatter,r as DevFormatter,i as ProductionFormatter};
+import { LogLevel } from "./types.mjs";
+
+//#region src/formatters.ts
+const colors = {
+	reset: "\x1B[0m",
+	bright: "\x1B[1m",
+	dim: "\x1B[2m",
+	red: "\x1B[31m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	blue: "\x1B[34m",
+	magenta: "\x1B[35m",
+	cyan: "\x1B[36m",
+	white: "\x1B[37m",
+	gray: "\x1B[90m",
+	bgRed: "\x1B[41m",
+	bgYellow: "\x1B[43m"
+};
+const levelConfig = {
+	[LogLevel.TRACE]: {
+		color: colors.gray,
+		symbol: "○",
+		name: "TRACE"
+	},
+	[LogLevel.DEBUG]: {
+		color: colors.blue,
+		symbol: "●",
+		name: "DEBUG"
+	},
+	[LogLevel.INFO]: {
+		color: colors.green,
+		symbol: "●",
+		name: "INFO "
+	},
+	[LogLevel.WARN]: {
+		color: colors.yellow,
+		symbol: "▲",
+		name: "WARN "
+	},
+	[LogLevel.ERROR]: {
+		color: colors.red,
+		symbol: "✖",
+		name: "ERROR"
+	},
+	[LogLevel.FATAL]: {
+		color: colors.bgRed + colors.white,
+		symbol: "💀",
+		name: "FATAL"
+	}
+};
+var DevFormatter = class {
+	enableColors;
+	constructor(enableColors = true) {
+		this.enableColors = enableColors;
+	}
+	format(entry) {
+		const parts = [];
+		const config = levelConfig[entry.level];
+		const timestamp = this.formatTimestamp(entry.timestamp);
+		parts.push(this.colorize(timestamp, colors.gray));
+		const levelText = `${config.symbol} ${config.name}`;
+		parts.push(this.colorize(levelText, config.color));
+		if (entry.traceId) {
+			const traceInfo = this.formatTraceInfo(entry);
+			parts.push(this.colorize(traceInfo, colors.cyan));
+		}
+		parts.push(this.colorize(entry.message, colors.white));
+		if (entry.duration !== void 0) {
+			const durationText = `(${this.formatDuration(entry.duration)})`;
+			parts.push(this.colorize(durationText, colors.magenta));
+		}
+		let output = parts.join(" ");
+		if (entry.context && Object.keys(entry.context).length > 0) output += "\n" + this.formatContext(entry.context);
+		if (entry.metadata && Object.keys(entry.metadata).length > 0) output += "\n" + this.formatMetadata(entry.metadata);
+		if (entry.error) output += "\n" + this.formatError(entry.error);
+		if (entry.tags && entry.tags.length > 0) {
+			const tagsText = entry.tags.map((tag) => `#${tag}`).join(" ");
+			output += "\n" + this.colorize(`Tags: ${tagsText}`, colors.blue);
+		}
+		return output;
+	}
+	formatTimestamp(timestamp) {
+		return timestamp.toISOString().substring(11, 23);
+	}
+	formatTraceInfo(entry) {
+		const parts = [`trace:${entry.traceId?.substring(0, 8) || "unknown"}`];
+		if (entry.spanId && entry.spanId.length >= 8) parts.push(`span:${entry.spanId.substring(0, 8)}`);
+		if (entry.parentId && entry.parentId.length >= 8) parts.push(`parent:${entry.parentId.substring(0, 8)}`);
+		return `[${parts.join("|")}]`;
+	}
+	formatDuration(duration) {
+		if (duration < 1) return `${(duration * 1e3).toFixed(0)}μs`;
+		else if (duration < 1e3) return `${duration.toFixed(2)}ms`;
+		else return `${(duration / 1e3).toFixed(2)}s`;
+	}
+	formatContext(context) {
+		const formatted = this.formatObject(context, 2);
+		return this.colorize(`Context: ${formatted}`, colors.cyan);
+	}
+	formatMetadata(metadata) {
+		const formatted = this.formatObject(metadata, 2);
+		return this.colorize(`Metadata: ${formatted}`, colors.blue);
+	}
+	formatError(error) {
+		let output = this.colorize(`Error: ${error.name}: ${error.message}`, colors.red);
+		if (error.stack) {
+			const indentedStack = error.stack.split("\n").slice(1, 6).map((line) => `  ${line}`).join("\n");
+			output += "\n" + this.colorize(indentedStack, colors.gray);
+		}
+		return output;
+	}
+	formatObject(obj, indent = 0) {
+		const spaces = " ".repeat(indent);
+		const entries = Object.entries(obj);
+		if (entries.length === 0) return "{}";
+		if (entries[0] && typeof entries[0][1] !== "object") return `{ ${entries[0][0]}: ${this.formatValue(entries[0][1])} }`;
+		return `{\n${entries.map(([key, value]) => {
+			return `${spaces}  ${key}: ${this.formatValue(value, indent + 2)}`;
+		}).join("\n")}\n${spaces}}`;
+	}
+	formatValue(value, indent = 0) {
+		if (value === null) return "null";
+		if (value === void 0) return "undefined";
+		if (typeof value === "string") return `"${value}"`;
+		if (typeof value === "boolean" || typeof value === "number") return String(value);
+		if (value instanceof Date) return value.toISOString();
+		if (Array.isArray(value)) {
+			if (value.length === 0) return "[]";
+			return `[${value.map((v) => this.formatValue(v)).join(", ")}]`;
+		}
+		if (typeof value === "object") return this.formatObject(value, indent);
+		return String(value);
+	}
+	colorize(text, color) {
+		if (!this.enableColors) return text;
+		return `${color}${text}${colors.reset}`;
+	}
+};
+var ProductionFormatter = class {
+	format(entry) {
+		const logObject = {
+			timestamp: entry.timestamp,
+			level: entry.level,
+			message: entry.message
+		};
+		if (entry.traceId) logObject.traceId = entry.traceId;
+		if (entry.spanId) logObject.spanId = entry.spanId;
+		if (entry.parentId) logObject.parentId = entry.parentId;
+		if (entry.duration !== void 0) logObject.duration = entry.duration;
+		if (entry.context && Object.keys(entry.context).length > 0) logObject.context = entry.context;
+		if (entry.metadata && Object.keys(entry.metadata).length > 0) logObject.metadata = entry.metadata;
+		if (entry.error) logObject.error = {
+			name: entry.error.name,
+			message: entry.error.message,
+			stack: entry.error.stack
+		};
+		if (entry.tags && entry.tags.length > 0) logObject.tags = entry.tags;
+		return JSON.stringify(logObject);
+	}
+};
+var CustomFormatter = class {
+	template;
+	dateFormat;
+	constructor(template = "{timestamp} [{level}] {message}", dateFormat) {
+		this.template = template;
+		this.dateFormat = dateFormat || ((date) => date.toISOString());
+	}
+	format(entry) {
+		const levelName = LogLevel[entry.level];
+		const timestamp = this.dateFormat(entry.timestamp);
+		let formatted = this.template.replace("{timestamp}", timestamp).replace("{level}", levelName).replace("{message}", entry.message).replace("{traceId}", entry.traceId || "").replace("{spanId}", entry.spanId || "").replace("{duration}", entry.duration?.toString() || "");
+		if (entry.context) formatted = formatted.replace("{context}", JSON.stringify(entry.context));
+		if (entry.metadata) formatted = formatted.replace("{metadata}", JSON.stringify(entry.metadata));
+		return formatted;
+	}
+};
+
+//#endregion
+export { CustomFormatter, DevFormatter, ProductionFormatter };

package/dist/index.browser.mjs

@@ -1 +1,8 @@
-import{LogContext as e}from"./context.browser.mjs";import{LogLevel as t}from"./types.mjs";import{Timer as n}from"./timer.mjs";import{DevFormatter as r,ProductionFormatter as i}from"./formatters.mjs";import{Tracer as a}from"./tracer.browser.mjs";import{Logger as o}from"./logger.browser.mjs";export{r as DevFormatter,e as LogContext,t as LogLevel,o as Logger,i as ProductionFormatter,n as Timer,a as Tracer};
+import { LogContext } from "./context.browser.mjs";
+import { LogLevel } from "./types.mjs";
+import { Timer } from "./timer.mjs";
+import { DevFormatter, ProductionFormatter } from "./formatters.mjs";
+import { Tracer } from "./tracer.browser.mjs";
+import { Logger } from "./logger.browser.mjs";
+
+export { DevFormatter, LogContext, LogLevel, Logger, ProductionFormatter, Timer, Tracer };

package/dist/index.mjs

@@ -1 +1,9 @@
-import{LogContext as e}from"./context.node.mjs";import{LogLevel as t}from"./types.mjs";import{Timer as n}from"./timer.mjs";import{Tracer as r}from"./tracer.node.mjs";import{DevFormatter as i,ProductionFormatter as a}from"./formatters.mjs";import{Logger as o}from"./logger.node.mjs";import{createElysiaLogger as s,elysiaLogger as c}from"./elysia-plugin.mjs";export{i as DevFormatter,e as LogContext,t as LogLevel,o as Logger,a as ProductionFormatter,n as Timer,r as Tracer,s as createElysiaLogger,c as elysiaLogger};
+import { LogContext } from "./context.node.mjs";
+import { LogLevel } from "./types.mjs";
+import { Timer } from "./timer.mjs";
+import { Tracer } from "./tracer.node.mjs";
+import { DevFormatter, ProductionFormatter } from "./formatters.mjs";
+import { Logger } from "./logger.node.mjs";
+import { createElysiaLogger, elysiaLogger } from "./elysia-plugin.mjs";
+
+export { DevFormatter, LogContext, LogLevel, Logger, ProductionFormatter, Timer, Tracer, createElysiaLogger, elysiaLogger };

package/dist/logger.browser.mjs

@@ -1 +1,189 @@
-import{LogContext as e}from"./context.browser.mjs";import{LogLevel as t}from"./types.mjs";import{TimerManager as n}from"./timer.mjs";import{DevFormatter as r,ProductionFormatter as i}from"./formatters.mjs";import{Tracer as a}from"./tracer.browser.mjs";var o=class o{config;formatter;context;tracer;timerManager;constructor(o){this.config={level:t.INFO,environment:process.env.NODE_ENV||`development`,enableTracing:!0,enableTiming:!0,enableContext:!0,enableColors:!0,maxContextDepth:10,timestampFormat:`iso`,...o},this.context=e.getInstance(),this.tracer=new a,this.timerManager=new n,this.formatter=this.config.environment===`production`?new i:new r(this.config.enableColors)}traceLog(e,n){this.log(t.TRACE,e,n)}debug(e,n){this.log(t.DEBUG,e,n)}info(e,n){this.log(t.INFO,e,n)}warn(e,n){this.log(t.WARN,e,n)}error(e,n,r){this.log(t.ERROR,e,n,r)}fatal(e,n,r){this.log(t.FATAL,e,n,r)}withContext(e,t){return this.context.run(e,t)}extendContext(e,t){return this.context.extend(e,t)}setContext(e,t){this.context.set(e,t)}getContext(){return this.context.getContext()}trace=async(e,t)=>this.config.enableTracing?this.tracer.trace(e,t):await t();getTraceId(){return this.tracer.getCurrentTrace()?.traceId}startSpan(e){return this.config.enableTracing?this.tracer.startSpan(e):null}finishSpan(e){if(this.config.enableTracing)return this.tracer.finishSpan(e)}addTraceMetadata(e,t){this.config.enableTracing&&this.tracer.addMetadata(e,t)}addTraceTags(...e){this.config.enableTracing&&this.tracer.addTags(...e)}startTimer(e){return this.config.enableTiming?this.timerManager.start(e):null}stopTimer(e){if(this.config.enableTiming)return this.timerManager.stop(e)}getTimer(e){return this.timerManager.get(e)}child(e){let t=new o(this.config);return Object.entries(e).forEach(([e,n])=>{t.setContext(e,n)}),t}setLevel(e){this.config.level=e}setFormatter(e){this.formatter=e}async profile(e,n,r){let i=this.startTimer(`profile-${e}`),a=performance.now();try{let o=await this.tracer.trace({operationType:`custom`,operationName:`profile:${e}`,autoTiming:!0},n),s=performance.now()-a;return i?.stop(),r?.logLevel||t.DEBUG,this.log(t.DEBUG,`Profile: ${e} completed`,{operation:e,duration:`${s.toFixed(2)}ms`,result:r?.logResult?o:`[result hidden]`}),o}catch(t){let n=performance.now()-a;throw i?.stop(),this.error(`Profile: ${e} failed`,{operation:e,duration:`${n.toFixed(2)}ms`,error:t.message},t),t}}logRequest(e,t,n,r){let i=this.getHttpLogLevel(n),a=`${e.toUpperCase()} ${t}${n?` ${n}`:``}`;this.log(i,a,{method:e,url:t,statusCode:n,duration:r?`${r.toFixed(2)}ms`:void 0,type:`http_request`})}async flush(){this.timerManager.clear()}getStats(){return{activeTimers:this.timerManager.getActive().length,activeSpans:this.tracer.getActiveSpans().length,config:{...this.config}}}output(e,n){n>=t.ERROR?console.error(e):console.log(e)}log(e,t,n,r){if(e<this.config.level)return;let i=this.config.enableTracing?this.tracer.getCurrentTrace():void 0,a=this.config.enableContext?this.context.getContext():void 0,o={level:e,message:t,timestamp:new Date,traceId:i?.traceId,parentId:i?.parentId,spanId:i?.spanId,context:a,metadata:n,error:r,tags:i?.tags};i?.metadata?.duration&&(o.duration=i.metadata.duration);let s=this.formatter.format(o);this.output(s,e)}getHttpLogLevel(e){return e?e>=500?t.ERROR:e>=400?t.WARN:t.INFO:t.INFO}};export{o as Logger};
+import { LogContext } from "./context.browser.mjs";
+import { LogLevel } from "./types.mjs";
+import { TimerManager } from "./timer.mjs";
+import { DevFormatter, ProductionFormatter } from "./formatters.mjs";
+import { Tracer } from "./tracer.browser.mjs";
+
+//#region src/logger.browser.ts
+var Logger = class Logger {
+	config;
+	formatter;
+	context;
+	tracer;
+	timerManager;
+	constructor(config) {
+		this.config = {
+			level: LogLevel.INFO,
+			environment: process.env.NODE_ENV || "development",
+			enableTracing: true,
+			enableTiming: true,
+			enableContext: true,
+			enableColors: true,
+			maxContextDepth: 10,
+			timestampFormat: "iso",
+			...config
+		};
+		this.context = LogContext.getInstance();
+		this.tracer = new Tracer();
+		this.timerManager = new TimerManager();
+		this.formatter = this.config.environment === "production" ? new ProductionFormatter() : new DevFormatter(this.config.enableColors);
+	}
+	traceLog(message, metadata) {
+		this.log(LogLevel.TRACE, message, metadata);
+	}
+	debug(message, metadata) {
+		this.log(LogLevel.DEBUG, message, metadata);
+	}
+	info(message, metadata) {
+		this.log(LogLevel.INFO, message, metadata);
+	}
+	warn(message, metadata) {
+		this.log(LogLevel.WARN, message, metadata);
+	}
+	error(message, metadata, error) {
+		this.log(LogLevel.ERROR, message, metadata, error);
+	}
+	fatal(message, metadata, error) {
+		this.log(LogLevel.FATAL, message, metadata, error);
+	}
+	withContext(context, fn) {
+		return this.context.run(context, fn);
+	}
+	extendContext(additionalContext, fn) {
+		return this.context.extend(additionalContext, fn);
+	}
+	setContext(key, value) {
+		this.context.set(key, value);
+	}
+	getContext() {
+		return this.context.getContext();
+	}
+	trace = async (options, fn) => {
+		if (!this.config.enableTracing) return await fn();
+		return this.tracer.trace(options, fn);
+	};
+	getTraceId() {
+		return this.tracer.getCurrentTrace()?.traceId;
+	}
+	startSpan(options) {
+		if (!this.config.enableTracing) return null;
+		return this.tracer.startSpan(options);
+	}
+	finishSpan(spanId) {
+		if (!this.config.enableTracing) return;
+		return this.tracer.finishSpan(spanId);
+	}
+	addTraceMetadata(key, value) {
+		if (this.config.enableTracing) this.tracer.addMetadata(key, value);
+	}
+	addTraceTags(...tags) {
+		if (this.config.enableTracing) this.tracer.addTags(...tags);
+	}
+	startTimer(id) {
+		if (!this.config.enableTiming) return null;
+		return this.timerManager.start(id);
+	}
+	stopTimer(id) {
+		if (!this.config.enableTiming) return;
+		return this.timerManager.stop(id);
+	}
+	getTimer(id) {
+		return this.timerManager.get(id);
+	}
+	child(context) {
+		const childLogger = new Logger(this.config);
+		Object.entries(context).forEach(([key, value]) => {
+			childLogger.setContext(key, value);
+		});
+		return childLogger;
+	}
+	setLevel(level) {
+		this.config.level = level;
+	}
+	setFormatter(formatter) {
+		this.formatter = formatter;
+	}
+	async profile(operationName, fn, options) {
+		const timer = this.startTimer(`profile-${operationName}`);
+		const startTime = performance.now();
+		try {
+			const result = await this.tracer.trace({
+				operationType: "custom",
+				operationName: `profile:${operationName}`,
+				autoTiming: true
+			}, fn);
+			const duration = performance.now() - startTime;
+			timer?.stop();
+			options?.logLevel || LogLevel.DEBUG;
+			this.log(LogLevel.DEBUG, `Profile: ${operationName} completed`, {
+				operation: operationName,
+				duration: `${duration.toFixed(2)}ms`,
+				result: options?.logResult ? result : "[result hidden]"
+			});
+			return result;
+		} catch (error) {
+			const duration = performance.now() - startTime;
+			timer?.stop();
+			this.error(`Profile: ${operationName} failed`, {
+				operation: operationName,
+				duration: `${duration.toFixed(2)}ms`,
+				error: error.message
+			}, error);
+			throw error;
+		}
+	}
+	logRequest(method, url, statusCode, duration) {
+		const level = this.getHttpLogLevel(statusCode);
+		const message = `${method.toUpperCase()} ${url}${statusCode ? ` ${statusCode}` : ""}`;
+		this.log(level, message, {
+			method,
+			url,
+			statusCode,
+			duration: duration ? `${duration.toFixed(2)}ms` : void 0,
+			type: "http_request"
+		});
+	}
+	async flush() {
+		this.timerManager.clear();
+	}
+	getStats() {
+		return {
+			activeTimers: this.timerManager.getActive().length,
+			activeSpans: this.tracer.getActiveSpans().length,
+			config: { ...this.config }
+		};
+	}
+	output(message, level) {
+		if (level >= LogLevel.ERROR) console.error(message);
+		else console.log(message);
+	}
+	log(level, message, metadata, error) {
+		if (level < this.config.level) return;
+		const currentTrace = this.config.enableTracing ? this.tracer.getCurrentTrace() : void 0;
+		const contextData = this.config.enableContext ? this.context.getContext() : void 0;
+		const entry = {
+			level,
+			message,
+			timestamp: /* @__PURE__ */ new Date(),
+			traceId: currentTrace?.traceId,
+			parentId: currentTrace?.parentId,
+			spanId: currentTrace?.spanId,
+			context: contextData,
+			metadata,
+			error,
+			tags: currentTrace?.tags
+		};
+		if (currentTrace?.metadata?.duration) entry.duration = currentTrace.metadata.duration;
+		const formatted = this.formatter.format(entry);
+		this.output(formatted, level);
+	}
+	getHttpLogLevel(statusCode) {
+		if (!statusCode) return LogLevel.INFO;
+		if (statusCode >= 500) return LogLevel.ERROR;
+		if (statusCode >= 400) return LogLevel.WARN;
+		return LogLevel.INFO;
+	}
+};
+
+//#endregion
+export { Logger };

package/dist/logger.mjs

@@ -1 +1,3 @@
-import{Logger as e}from"./logger.node.mjs";export{e as Logger};
+import { Logger } from "./logger.node.mjs";
+
+export { Logger };

package/dist/logger.node.mjs

@@ -1 +1,189 @@
-import{LogContext as e}from"./context.node.mjs";import{LogLevel as t}from"./types.mjs";import{TimerManager as n}from"./timer.mjs";import{Tracer as r}from"./tracer.node.mjs";import{DevFormatter as i,ProductionFormatter as a}from"./formatters.mjs";var o=class o{config;formatter;context;tracer;timerManager;constructor(o){this.config={level:t.INFO,environment:process.env.NODE_ENV||`development`,enableTracing:!0,enableTiming:!0,enableContext:!0,enableColors:!0,maxContextDepth:10,timestampFormat:`iso`,...o},this.context=e.getInstance(),this.tracer=new r,this.timerManager=new n,this.formatter=this.config.environment===`production`?new a:new i(this.config.enableColors)}traceLog(e,n){this.log(t.TRACE,e,n)}debug(e,n){this.log(t.DEBUG,e,n)}info(e,n){this.log(t.INFO,e,n)}warn(e,n){this.log(t.WARN,e,n)}error(e,n,r){this.log(t.ERROR,e,n,r)}fatal(e,n,r){this.log(t.FATAL,e,n,r)}withContext(e,t){return this.context.run(e,t)}extendContext(e,t){return this.context.extend(e,t)}setContext(e,t){this.context.set(e,t)}getContext(){return this.context.getContext()}trace=async(e,t)=>this.config.enableTracing?this.tracer.trace(e,t):await t();getTraceId(){return this.tracer.getCurrentTrace()?.traceId}startSpan(e){return this.config.enableTracing?this.tracer.startSpan(e):null}finishSpan(e){if(this.config.enableTracing)return this.tracer.finishSpan(e)}addTraceMetadata(e,t){this.config.enableTracing&&this.tracer.addMetadata(e,t)}addTraceTags(...e){this.config.enableTracing&&this.tracer.addTags(...e)}startTimer(e){return this.config.enableTiming?this.timerManager.start(e):null}stopTimer(e){if(this.config.enableTiming)return this.timerManager.stop(e)}getTimer(e){return this.timerManager.get(e)}child(e){let t=new o(this.config);return Object.entries(e).forEach(([e,n])=>{t.setContext(e,n)}),t}setLevel(e){this.config.level=e}setFormatter(e){this.formatter=e}async profile(e,n,r){let i=this.startTimer(`profile-${e}`),a=performance.now();try{let o=await this.tracer.trace({operationType:`custom`,operationName:`profile:${e}`,autoTiming:!0},n),s=performance.now()-a;i?.stop();let c=r?.logLevel||t.DEBUG;return this.log(c,`Profile: ${e} completed`,{operation:e,duration:`${s.toFixed(2)}ms`,result:r?.logResult?o:`[result hidden]`}),o}catch(t){let n=performance.now()-a;throw i?.stop(),this.error(`Profile: ${e} failed`,{operation:e,duration:`${n.toFixed(2)}ms`,error:t.message},t),t}}logRequest(e,t,n,r){let i=this.getHttpLogLevel(n),a=`${e.toUpperCase()} ${t}${n?` ${n}`:``}`;this.log(i,a,{method:e,url:t,statusCode:n,duration:r?`${r.toFixed(2)}ms`:void 0,type:`http_request`})}async flush(){this.timerManager.clear()}getStats(){return{activeTimers:this.timerManager.getActive().length,activeSpans:this.tracer.getActiveSpans().length,config:{...this.config}}}output(e,n){n>=t.ERROR?console.error(e):console.log(e)}log(e,t,n,r){if(e<this.config.level)return;let i=this.config.enableTracing?this.tracer.getCurrentTrace():void 0,a=this.config.enableContext?this.context.getContext():void 0,o={level:e,message:t,timestamp:new Date,traceId:i?.traceId,parentId:i?.parentId,spanId:i?.spanId,context:a,metadata:n,error:r,tags:i?.tags};i?.metadata?.duration&&(o.duration=i.metadata.duration);let s=this.formatter.format(o);this.output(s,e)}getHttpLogLevel(e){return e?e>=500?t.ERROR:e>=400?t.WARN:t.INFO:t.INFO}};export{o as Logger};
+import { LogContext } from "./context.node.mjs";
+import { LogLevel } from "./types.mjs";
+import { TimerManager } from "./timer.mjs";
+import { Tracer } from "./tracer.node.mjs";
+import { DevFormatter, ProductionFormatter } from "./formatters.mjs";
+
+//#region src/logger.node.ts
+var Logger = class Logger {
+	config;
+	formatter;
+	context;
+	tracer;
+	timerManager;
+	constructor(config) {
+		this.config = {
+			level: LogLevel.INFO,
+			environment: process.env.NODE_ENV || "development",
+			enableTracing: true,
+			enableTiming: true,
+			enableContext: true,
+			enableColors: true,
+			maxContextDepth: 10,
+			timestampFormat: "iso",
+			...config
+		};
+		this.context = LogContext.getInstance();
+		this.tracer = new Tracer();
+		this.timerManager = new TimerManager();
+		this.formatter = this.config.environment === "production" ? new ProductionFormatter() : new DevFormatter(this.config.enableColors);
+	}
+	traceLog(message, metadata) {
+		this.log(LogLevel.TRACE, message, metadata);
+	}
+	debug(message, metadata) {
+		this.log(LogLevel.DEBUG, message, metadata);
+	}
+	info(message, metadata) {
+		this.log(LogLevel.INFO, message, metadata);
+	}
+	warn(message, metadata) {
+		this.log(LogLevel.WARN, message, metadata);
+	}
+	error(message, metadata, error) {
+		this.log(LogLevel.ERROR, message, metadata, error);
+	}
+	fatal(message, metadata, error) {
+		this.log(LogLevel.FATAL, message, metadata, error);
+	}
+	withContext(context, fn) {
+		return this.context.run(context, fn);
+	}
+	extendContext(additionalContext, fn) {
+		return this.context.extend(additionalContext, fn);
+	}
+	setContext(key, value) {
+		this.context.set(key, value);
+	}
+	getContext() {
+		return this.context.getContext();
+	}
+	trace = async (options, fn) => {
+		if (!this.config.enableTracing) return await fn();
+		return this.tracer.trace(options, fn);
+	};
+	getTraceId() {
+		return this.tracer.getCurrentTrace()?.traceId;
+	}
+	startSpan(options) {
+		if (!this.config.enableTracing) return null;
+		return this.tracer.startSpan(options);
+	}
+	finishSpan(spanId) {
+		if (!this.config.enableTracing) return;
+		return this.tracer.finishSpan(spanId);
+	}
+	addTraceMetadata(key, value) {
+		if (this.config.enableTracing) this.tracer.addMetadata(key, value);
+	}
+	addTraceTags(...tags) {
+		if (this.config.enableTracing) this.tracer.addTags(...tags);
+	}
+	startTimer(id) {
+		if (!this.config.enableTiming) return null;
+		return this.timerManager.start(id);
+	}
+	stopTimer(id) {
+		if (!this.config.enableTiming) return;
+		return this.timerManager.stop(id);
+	}
+	getTimer(id) {
+		return this.timerManager.get(id);
+	}
+	child(context) {
+		const childLogger = new Logger(this.config);
+		Object.entries(context).forEach(([key, value]) => {
+			childLogger.setContext(key, value);
+		});
+		return childLogger;
+	}
+	setLevel(level) {
+		this.config.level = level;
+	}
+	setFormatter(formatter) {
+		this.formatter = formatter;
+	}
+	async profile(operationName, fn, options) {
+		const timer = this.startTimer(`profile-${operationName}`);
+		const startTime = performance.now();
+		try {
+			const result = await this.tracer.trace({
+				operationType: "custom",
+				operationName: `profile:${operationName}`,
+				autoTiming: true
+			}, fn);
+			const duration = performance.now() - startTime;
+			timer?.stop();
+			const logLevel = options?.logLevel || LogLevel.DEBUG;
+			this.log(logLevel, `Profile: ${operationName} completed`, {
+				operation: operationName,
+				duration: `${duration.toFixed(2)}ms`,
+				result: options?.logResult ? result : "[result hidden]"
+			});
+			return result;
+		} catch (error) {
+			const duration = performance.now() - startTime;
+			timer?.stop();
+			this.error(`Profile: ${operationName} failed`, {
+				operation: operationName,
+				duration: `${duration.toFixed(2)}ms`,
+				error: error.message
+			}, error);
+			throw error;
+		}
+	}
+	logRequest(method, url, statusCode, duration) {
+		const level = this.getHttpLogLevel(statusCode);
+		const message = `${method.toUpperCase()} ${url}${statusCode ? ` ${statusCode}` : ""}`;
+		this.log(level, message, {
+			method,
+			url,
+			statusCode,
+			duration: duration ? `${duration.toFixed(2)}ms` : void 0,
+			type: "http_request"
+		});
+	}
+	async flush() {
+		this.timerManager.clear();
+	}
+	getStats() {
+		return {
+			activeTimers: this.timerManager.getActive().length,
+			activeSpans: this.tracer.getActiveSpans().length,
+			config: { ...this.config }
+		};
+	}
+	output(message, level) {
+		if (level >= LogLevel.ERROR) console.error(message);
+		else console.log(message);
+	}
+	log(level, message, metadata, error) {
+		if (level < this.config.level) return;
+		const currentTrace = this.config.enableTracing ? this.tracer.getCurrentTrace() : void 0;
+		const contextData = this.config.enableContext ? this.context.getContext() : void 0;
+		const entry = {
+			level,
+			message,
+			timestamp: /* @__PURE__ */ new Date(),
+			traceId: currentTrace?.traceId,
+			parentId: currentTrace?.parentId,
+			spanId: currentTrace?.spanId,
+			context: contextData,
+			metadata,
+			error,
+			tags: currentTrace?.tags
+		};
+		if (currentTrace?.metadata?.duration) entry.duration = currentTrace.metadata.duration;
+		const formatted = this.formatter.format(entry);
+		this.output(formatted, level);
+	}
+	getHttpLogLevel(statusCode) {
+		if (!statusCode) return LogLevel.INFO;
+		if (statusCode >= 500) return LogLevel.ERROR;
+		if (statusCode >= 400) return LogLevel.WARN;
+		return LogLevel.INFO;
+	}
+};
+
+//#endregion
+export { Logger };

package/dist/timer.mjs

@@ -1 +1,164 @@
-var e=class{id;startTime;laps=[];stopped=!1;stopTime;constructor(e){this.id=e||crypto.randomUUID(),this.startTime=performance.now()}stop(){if(this.stopped)return this.getElapsed();this.stopTime=performance.now(),this.stopped=!0;let e=this.stopTime-this.startTime;return this.laps.push({label:`stop`,time:this.stopTime,elapsed:e}),e}lap(e){if(this.stopped)return this.getElapsed();let t=performance.now(),n=t-this.startTime;return this.laps.push({label:e||`lap-${this.laps.length+1}`,time:t,elapsed:n}),n}getElapsed(){return this.stopped&&this.stopTime?this.stopTime-this.startTime:performance.now()-this.startTime}getLaps(){return[...this.laps]}getSummary(){return{id:this.id,totalTime:this.getElapsed(),isRunning:!this.stopped,laps:this.getLaps()}}reset(){this.startTime=performance.now(),this.laps=[],this.stopped=!1,this.stopTime=void 0}},t=class{timers=new Map;start(t){let n=new e(t);return this.timers.set(n.id,n),n}get(e){return this.timers.get(e)}stop(e){let t=this.timers.get(e);if(t){let n=t.stop();return this.timers.delete(e),n}}getActive(){return Array.from(this.timers.values()).filter(e=>!!e.getSummary().isRunning)}clear(){this.timers.clear()}getSummary(){return Array.from(this.timers.values()).map(e=>e.getSummary())}};async function n(t,n){let r=new e(n?.id);try{let e=await t(),i=r.stop();return n?.onComplete?.(i),{result:e,elapsed:i,timer:r}}catch(e){throw r.stop(),e}}function r(t,n){let r=new e(n?.id);try{let e=t(),i=r.stop();return n?.onComplete?.(i),{result:e,elapsed:i,timer:r}}catch(e){throw r.stop(),e}}export{e as Timer,t as TimerManager,n as timed,r as timedSync};
+//#region src/timer.ts
+var Timer = class {
+	id;
+	startTime;
+	laps = [];
+	stopped = false;
+	stopTime;
+	constructor(id) {
+		this.id = id || crypto.randomUUID();
+		this.startTime = performance.now();
+	}
+	/**
+	* Stop the timer and return elapsed time in milliseconds
+	*/
+	stop() {
+		if (this.stopped) return this.getElapsed();
+		this.stopTime = performance.now();
+		this.stopped = true;
+		const elapsed = this.stopTime - this.startTime;
+		this.laps.push({
+			label: "stop",
+			time: this.stopTime,
+			elapsed
+		});
+		return elapsed;
+	}
+	/**
+	* Record a lap time and return elapsed time since start
+	*/
+	lap(label) {
+		if (this.stopped) return this.getElapsed();
+		const now = performance.now();
+		const elapsed = now - this.startTime;
+		this.laps.push({
+			label: label || `lap-${this.laps.length + 1}`,
+			time: now,
+			elapsed
+		});
+		return elapsed;
+	}
+	/**
+	* Get elapsed time without stopping the timer
+	*/
+	getElapsed() {
+		if (this.stopped && this.stopTime) return this.stopTime - this.startTime;
+		return performance.now() - this.startTime;
+	}
+	/**
+	* Get all recorded laps
+	*/
+	getLaps() {
+		return [...this.laps];
+	}
+	/**
+	* Get timer summary with total time and laps
+	*/
+	getSummary() {
+		return {
+			id: this.id,
+			totalTime: this.getElapsed(),
+			isRunning: !this.stopped,
+			laps: this.getLaps()
+		};
+	}
+	/**
+	* Reset the timer (starts a new timing session)
+	*/
+	reset() {
+		this.startTime = performance.now();
+		this.laps = [];
+		this.stopped = false;
+		this.stopTime = void 0;
+	}
+};
+/**
+* Utility class for managing multiple timers
+*/
+var TimerManager = class {
+	timers = /* @__PURE__ */ new Map();
+	/**
+	* Start a new timer
+	*/
+	start(id) {
+		const timer = new Timer(id);
+		this.timers.set(timer.id, timer);
+		return timer;
+	}
+	/**
+	* Get an existing timer
+	*/
+	get(id) {
+		return this.timers.get(id);
+	}
+	/**
+	* Stop and remove a timer
+	*/
+	stop(id) {
+		const timer = this.timers.get(id);
+		if (timer) {
+			const elapsed = timer.stop();
+			this.timers.delete(id);
+			return elapsed;
+		}
+	}
+	/**
+	* Get all active timers
+	*/
+	getActive() {
+		return Array.from(this.timers.values()).filter((timer) => !timer.getSummary().isRunning === false);
+	}
+	/**
+	* Clear all timers
+	*/
+	clear() {
+		this.timers.clear();
+	}
+	/**
+	* Get summary of all timers
+	*/
+	getSummary() {
+		return Array.from(this.timers.values()).map((timer) => timer.getSummary());
+	}
+};
+/**
+* Decorator/wrapper function to time async operations
+*/
+async function timed(operation, options) {
+	const timer = new Timer(options?.id);
+	try {
+		const result = await operation();
+		const elapsed = timer.stop();
+		options?.onComplete?.(elapsed);
+		return {
+			result,
+			elapsed,
+			timer
+		};
+	} catch (error) {
+		timer.stop();
+		throw error;
+	}
+}
+/**
+* Decorator/wrapper function to time synchronous operations
+*/
+function timedSync(operation, options) {
+	const timer = new Timer(options?.id);
+	try {
+		const result = operation();
+		const elapsed = timer.stop();
+		options?.onComplete?.(elapsed);
+		return {
+			result,
+			elapsed,
+			timer
+		};
+	} catch (error) {
+		timer.stop();
+		throw error;
+	}
+}
+
+//#endregion
+export { Timer, TimerManager, timed, timedSync };

package/dist/tracer.browser.mjs

@@ -1 +1,115 @@
-import{LogContext as e}from"./context.browser.mjs";import{Timer as t}from"./timer.mjs";var n=class{context;activeSpans=new Map;constructor(){this.context=e.getInstance()}startSpan(e){let t=this.context.getCurrentTrace(),n={traceId:t?.traceId||this.generateTraceId(),parentId:t?.spanId,spanId:this.generateSpanId(),operationType:e.operationType,operationName:e.operationName,startTime:performance.now(),metadata:{...e.metadata},tags:[...e.tags||[]]};return this.activeSpans.set(n.spanId,n),this.context.setTrace(n),n}finishSpan(e){let t=this.activeSpans.get(e);if(!t)return;let n=performance.now()-t.startTime;if(this.activeSpans.delete(e),this.context.getCurrentTrace()?.spanId===e&&t.parentId){let e=this.findSpanById(t.parentId);e&&this.context.setTrace(e)}return n}async trace(e,n){let r=this.startSpan(e),i=e.autoTiming===!1?void 0:new t(`trace-${r.spanId}`);try{let e=await n(),t=this.finishSpan(r.spanId);return i&&i.stop(),t!==void 0&&(r.metadata.duration=t),e}catch(e){r.metadata.error={name:e.name||`Unknown`,message:e.message||`Unknown error`,stack:e.stack};let t=this.finishSpan(r.spanId);throw r.metadata.duration=t,i&&i.stop(),e}}addMetadata(e,t){let n=this.context.getCurrentTrace();n&&(n.metadata[e]=t)}addTags(...e){let t=this.context.getCurrentTrace();t&&t.tags.push(...e)}getCurrentTrace(){return this.context.getCurrentTrace()}getActiveSpans(){return Array.from(this.activeSpans.values())}findSpanById(e){return this.activeSpans.get(e)}generateTraceId(){return crypto.randomUUID().replace(/-/g,``)}generateSpanId(){return crypto.randomUUID().replace(/-/g,``).substring(0,16)}};export{n as Tracer};
+import { LogContext } from "./context.browser.mjs";
+import { Timer } from "./timer.mjs";
+
+//#region src/tracer.browser.ts
+var Tracer = class {
+	context;
+	activeSpans = /* @__PURE__ */ new Map();
+	constructor() {
+		this.context = LogContext.getInstance();
+	}
+	/**
+	* Start a new trace span
+	*/
+	startSpan(options) {
+		const parentTrace = this.context.getCurrentTrace();
+		const span = {
+			traceId: parentTrace?.traceId || this.generateTraceId(),
+			parentId: parentTrace?.spanId,
+			spanId: this.generateSpanId(),
+			operationType: options.operationType,
+			operationName: options.operationName,
+			startTime: performance.now(),
+			metadata: { ...options.metadata },
+			tags: [...options.tags || []]
+		};
+		this.activeSpans.set(span.spanId, span);
+		this.context.setTrace(span);
+		return span;
+	}
+	/**
+	* Finish a trace span
+	*/
+	finishSpan(spanId) {
+		const span = this.activeSpans.get(spanId);
+		if (!span) return;
+		const duration = performance.now() - span.startTime;
+		this.activeSpans.delete(spanId);
+		if (this.context.getCurrentTrace()?.spanId === spanId && span.parentId) {
+			const parentSpan = this.findSpanById(span.parentId);
+			if (parentSpan) this.context.setTrace(parentSpan);
+		}
+		return duration;
+	}
+	/**
+	* Execute a function within a trace span
+	*/
+	async trace(options, fn) {
+		const span = this.startSpan(options);
+		const timer = options.autoTiming !== false ? new Timer(`trace-${span.spanId}`) : void 0;
+		try {
+			const result = await fn();
+			const duration = this.finishSpan(span.spanId);
+			if (timer) timer.stop();
+			if (duration !== void 0) span.metadata.duration = duration;
+			return result;
+		} catch (error) {
+			span.metadata.error = {
+				name: error.name || "Unknown",
+				message: error.message || "Unknown error",
+				stack: error.stack
+			};
+			const duration = this.finishSpan(span.spanId);
+			span.metadata.duration = duration;
+			if (timer) timer.stop();
+			throw error;
+		}
+	}
+	/**
+	* Add metadata to current span
+	*/
+	addMetadata(key, value) {
+		const currentTrace = this.context.getCurrentTrace();
+		if (currentTrace) currentTrace.metadata[key] = value;
+	}
+	/**
+	* Add tags to current span
+	*/
+	addTags(...tags) {
+		const currentTrace = this.context.getCurrentTrace();
+		if (currentTrace) currentTrace.tags.push(...tags);
+	}
+	/**
+	* Get current trace context
+	*/
+	getCurrentTrace() {
+		return this.context.getCurrentTrace();
+	}
+	/**
+	* Get all active spans
+	*/
+	getActiveSpans() {
+		return Array.from(this.activeSpans.values());
+	}
+	/**
+	* Find a span by ID
+	*/
+	findSpanById(spanId) {
+		return this.activeSpans.get(spanId);
+	}
+	/**
+	* Generate a unique trace ID
+	*/
+	generateTraceId() {
+		return crypto.randomUUID().replace(/-/g, "");
+	}
+	/**
+	* Generate a unique span ID
+	*/
+	generateSpanId() {
+		return crypto.randomUUID().replace(/-/g, "").substring(0, 16);
+	}
+};
+
+//#endregion
+export { Tracer };

package/dist/tracer.mjs

@@ -1 +1,3 @@
-import{Tracer as e}from"./tracer.node.mjs";export{e as Tracer};
+import { Tracer } from "./tracer.node.mjs";
+
+export { Tracer };

package/dist/tracer.node.mjs

@@ -1 +1,115 @@
-import{LogContext as e}from"./context.node.mjs";import{Timer as t}from"./timer.mjs";var n=class{context;activeSpans=new Map;constructor(){this.context=e.getInstance()}startSpan(e){let t=this.context.getCurrentTrace(),n={traceId:t?.traceId||this.generateTraceId(),parentId:t?.spanId,spanId:this.generateSpanId(),operationType:e.operationType,operationName:e.operationName,startTime:performance.now(),metadata:{...e.metadata},tags:[...e.tags||[]]};return this.activeSpans.set(n.spanId,n),this.context.setTrace(n),n}finishSpan(e){let t=this.activeSpans.get(e);if(!t)return;let n=performance.now()-t.startTime;if(this.activeSpans.delete(e),this.context.getCurrentTrace()?.spanId===e&&t.parentId){let e=this.findSpanById(t.parentId);e&&this.context.setTrace(e)}return n}async trace(e,n){let r=this.startSpan(e),i=e.autoTiming===!1?void 0:new t(`trace-${r.spanId}`);try{let e=await n(),t=this.finishSpan(r.spanId);return i&&i.stop(),t!==void 0&&(r.metadata.duration=t),e}catch(e){r.metadata.error={name:e.name||`Unknown`,message:e.message||`Unknown error`,stack:e.stack};let t=this.finishSpan(r.spanId);throw r.metadata.duration=t,i&&i.stop(),e}}addMetadata(e,t){let n=this.context.getCurrentTrace();n&&(n.metadata[e]=t)}addTags(...e){let t=this.context.getCurrentTrace();t&&t.tags.push(...e)}getCurrentTrace(){return this.context.getCurrentTrace()}getActiveSpans(){return Array.from(this.activeSpans.values())}findSpanById(e){return this.activeSpans.get(e)}generateTraceId(){return crypto.randomUUID().replace(/-/g,``)}generateSpanId(){return crypto.randomUUID().replace(/-/g,``).substring(0,16)}};export{n as Tracer};
+import { LogContext } from "./context.node.mjs";
+import { Timer } from "./timer.mjs";
+
+//#region src/tracer.node.ts
+var Tracer = class {
+	context;
+	activeSpans = /* @__PURE__ */ new Map();
+	constructor() {
+		this.context = LogContext.getInstance();
+	}
+	/**
+	* Start a new trace span
+	*/
+	startSpan(options) {
+		const parentTrace = this.context.getCurrentTrace();
+		const span = {
+			traceId: parentTrace?.traceId || this.generateTraceId(),
+			parentId: parentTrace?.spanId,
+			spanId: this.generateSpanId(),
+			operationType: options.operationType,
+			operationName: options.operationName,
+			startTime: performance.now(),
+			metadata: { ...options.metadata },
+			tags: [...options.tags || []]
+		};
+		this.activeSpans.set(span.spanId, span);
+		this.context.setTrace(span);
+		return span;
+	}
+	/**
+	* Finish a trace span
+	*/
+	finishSpan(spanId) {
+		const span = this.activeSpans.get(spanId);
+		if (!span) return;
+		const duration = performance.now() - span.startTime;
+		this.activeSpans.delete(spanId);
+		if (this.context.getCurrentTrace()?.spanId === spanId && span.parentId) {
+			const parentSpan = this.findSpanById(span.parentId);
+			if (parentSpan) this.context.setTrace(parentSpan);
+		}
+		return duration;
+	}
+	/**
+	* Execute a function within a trace span
+	*/
+	async trace(options, fn) {
+		const span = this.startSpan(options);
+		const timer = options.autoTiming !== false ? new Timer(`trace-${span.spanId}`) : void 0;
+		try {
+			const result = await fn();
+			const duration = this.finishSpan(span.spanId);
+			if (timer) timer.stop();
+			if (duration !== void 0) span.metadata.duration = duration;
+			return result;
+		} catch (error) {
+			span.metadata.error = {
+				name: error.name || "Unknown",
+				message: error.message || "Unknown error",
+				stack: error.stack
+			};
+			const duration = this.finishSpan(span.spanId);
+			span.metadata.duration = duration;
+			if (timer) timer.stop();
+			throw error;
+		}
+	}
+	/**
+	* Add metadata to current span
+	*/
+	addMetadata(key, value) {
+		const currentTrace = this.context.getCurrentTrace();
+		if (currentTrace) currentTrace.metadata[key] = value;
+	}
+	/**
+	* Add tags to current span
+	*/
+	addTags(...tags) {
+		const currentTrace = this.context.getCurrentTrace();
+		if (currentTrace) currentTrace.tags.push(...tags);
+	}
+	/**
+	* Get current trace context
+	*/
+	getCurrentTrace() {
+		return this.context.getCurrentTrace();
+	}
+	/**
+	* Get all active spans
+	*/
+	getActiveSpans() {
+		return Array.from(this.activeSpans.values());
+	}
+	/**
+	* Find a span by ID
+	*/
+	findSpanById(spanId) {
+		return this.activeSpans.get(spanId);
+	}
+	/**
+	* Generate a unique trace ID
+	*/
+	generateTraceId() {
+		return crypto.randomUUID().replace(/-/g, "");
+	}
+	/**
+	* Generate a unique span ID
+	*/
+	generateSpanId() {
+		return crypto.randomUUID().replace(/-/g, "").substring(0, 16);
+	}
+};
+
+//#endregion
+export { Tracer };

package/dist/types.mjs

@@ -1 +1,13 @@
-let e=function(e){return e[e.TRACE=0]=`TRACE`,e[e.DEBUG=1]=`DEBUG`,e[e.INFO=2]=`INFO`,e[e.WARN=3]=`WARN`,e[e.ERROR=4]=`ERROR`,e[e.FATAL=5]=`FATAL`,e}({});export{e as LogLevel};
+//#region src/types.ts
+let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+	LogLevel$1[LogLevel$1["TRACE"] = 0] = "TRACE";
+	LogLevel$1[LogLevel$1["DEBUG"] = 1] = "DEBUG";
+	LogLevel$1[LogLevel$1["INFO"] = 2] = "INFO";
+	LogLevel$1[LogLevel$1["WARN"] = 3] = "WARN";
+	LogLevel$1[LogLevel$1["ERROR"] = 4] = "ERROR";
+	LogLevel$1[LogLevel$1["FATAL"] = 5] = "FATAL";
+	return LogLevel$1;
+}({});
+
+//#endregion
+export { LogLevel };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lssm/lib.logger",
-  "version": "0.0.0-canary-20251217062943",
+  "version": "0.0.0-canary-20251217072406",
   "description": "Comprehensive logging library optimized for Bun with ElysiaJS integration",
   "keywords": [
     "logging",
@@ -23,8 +23,8 @@
     "dev": "bun build:bundle --watch"
   },
   "devDependencies": {
-    "@lssm/tool.typescript": "0.0.0-canary-20251217062943",
-    "@lssm/tool.tsdown": "0.0.0-canary-20251217062943",
+    "@lssm/tool.typescript": "0.0.0-canary-20251217072406",
+    "@lssm/tool.tsdown": "0.0.0-canary-20251217072406",
     "tsdown": "^0.17.4",
     "typescript": "^5.9.3"
   },