loggily 0.6.0 → 0.6.2

package/dist/worker.d.mts

@@ -1,173 +0,0 @@
-import { o as Logger } from "./core-7D7sstHl.mjs";
-
-//#region src/worker.d.ts
-/** Message sent from worker to main thread for console output */
-interface WorkerConsoleMessage {
-  type: "console";
-  level: "log" | "debug" | "info" | "warn" | "error" | "trace";
-  namespace?: string;
-  args: unknown[];
-  timestamp: number;
-}
-/** Message sent from worker to main thread for structured log output */
-interface WorkerLogMessage {
-  type: "log";
-  level: "trace" | "debug" | "info" | "warn" | "error";
-  namespace: string;
-  message: string;
-  data?: Record<string, unknown>;
-  timestamp: number;
-}
-/** Message sent from worker to main thread for span events */
-interface WorkerSpanMessage {
-  type: "span";
-  event: "start" | "end";
-  namespace: string;
-  spanId: string;
-  traceId: string;
-  parentId: string | null;
-  startTime: number;
-  endTime?: number;
-  duration?: number;
-  props: Record<string, unknown>;
-  spanData: Record<string, unknown>;
-  timestamp: number;
-}
-/** Union type for all worker messages */
-type WorkerMessage = WorkerConsoleMessage | WorkerLogMessage | WorkerSpanMessage;
-/** Type guard for WorkerConsoleMessage */
-declare function isWorkerConsoleMessage(msg: unknown): msg is WorkerConsoleMessage;
-/** Type guard for WorkerLogMessage */
-declare function isWorkerLogMessage(msg: unknown): msg is WorkerLogMessage;
-/** Type guard for WorkerSpanMessage */
-declare function isWorkerSpanMessage(msg: unknown): msg is WorkerSpanMessage;
-/** Type guard for any worker message */
-declare function isWorkerMessage(msg: unknown): msg is WorkerMessage;
-type PostMessageFn = (message: WorkerConsoleMessage) => void;
-/**
- * Forward console.* calls from worker to main thread.
- *
- * Monkey-patches console methods to send messages via postMessage.
- * Call this at the start of your worker script.
- *
- * @param postMessage - The worker's postMessage function
- * @param namespace - Optional namespace for log messages (e.g., "km:worker:parse")
- *
- * @example
- * ```typescript
- * // At top of worker file:
- * import { forwardConsole } from "loggily/worker"
- * forwardConsole(postMessage, "km:worker:parse")
- *
- * // Now all console.* calls are forwarded:
- * console.log("processing", { file: "test.md" })
- * console.error(new Error("failed"))
- * ```
- */
-declare function forwardConsole(postMessage: PostMessageFn, namespace?: string): void;
-/**
- * Restore original console methods.
- * Call this if you need to disable console forwarding.
- */
-declare function restoreConsole(): void;
-type PostMessageAnyFn = (message: WorkerMessage) => void;
-/** Reset worker ID counters (for testing) */
-declare function resetWorkerIds(): void;
-interface WorkerLoggerOptions {
-  /** Parent span ID for nested spans */
-  parentSpanId?: string | null;
-  /** Trace ID for distributed tracing */
-  traceId?: string | null;
-}
-/**
- * Create a logger instance for use in a worker thread.
- *
- * All log calls and span events are forwarded to the main thread via postMessage.
- * The main thread should use createWorkerLogHandler to process these messages.
- *
- * @param postMessage - The worker's postMessage function
- * @param namespace - Logger namespace (e.g., "km:worker:parse")
- * @param props - Optional initial props
- * @param options - Optional configuration
- *
- * @example
- * ```typescript
- * import { createWorkerLogger } from "loggily/worker"
- *
- * const log = createWorkerLogger(postMessage, "km:worker:parse")
- *
- * log.info("starting parse", { file: "test.md" })
- *
- * {
- *   using span = log.span("process")
- *   span.info("processing...")
- *   span.spanData.lineCount = 100
- * }
- * // Span end event automatically sent to main thread
- * ```
- */
-declare function createWorkerLogger(postMessage: PostMessageAnyFn, namespace: string, props?: Record<string, unknown>, options?: WorkerLoggerOptions): Logger;
-interface WorkerConsoleHandlerOptions {
-  /** Default namespace if message doesn't include one */
-  defaultNamespace?: string;
-  /** Custom logger to use (defaults to creating one with the namespace) */
-  logger?: Logger;
-}
-/**
- * Create a handler for worker console messages.
- *
- * Use this on the main thread to receive and output messages from workers.
- *
- * @param options - Handler options
- * @returns Handler function to call with worker messages
- *
- * @example
- * ```typescript
- * import { createWorkerConsoleHandler } from "loggily/worker"
- *
- * const handleConsole = createWorkerConsoleHandler({
- *   defaultNamespace: "km:worker:parse"
- * })
- *
- * worker.onmessage = (e) => {
- *   if (e.data.type === "console") {
- *     handleConsole(e.data)
- *   } else {
- *     // Handle other message types
- *   }
- * }
- * ```
- */
-declare function createWorkerConsoleHandler(options?: WorkerConsoleHandlerOptions): (message: WorkerConsoleMessage) => void;
-interface WorkerLogHandlerOptions {
-  /** Enable span output (default: uses spansAreEnabled()) */
-  enableSpans?: boolean;
-}
-/**
- * Create a handler for worker logger messages (logs and spans).
- *
- * Use this on the main thread to receive and output messages from workers
- * that use createWorkerLogger.
- *
- * @param options - Handler options
- * @returns Handler function to call with worker messages
- *
- * @example
- * ```typescript
- * import { createWorkerLogHandler, isWorkerMessage } from "loggily/worker"
- *
- * const handleLog = createWorkerLogHandler()
- *
- * worker.onmessage = (e) => {
- *   if (isWorkerMessage(e.data)) {
- *     handleLog(e.data)
- *   } else {
- *     // Handle other message types
- *   }
- * }
- * ```
- */
-declare function createWorkerLogHandler(options?: WorkerLogHandlerOptions): (message: WorkerMessage) => void;
-//#endregion
-export { WorkerConsoleHandlerOptions, WorkerConsoleMessage, WorkerLogHandlerOptions, WorkerLogMessage, WorkerMessage, WorkerSpanMessage, createWorkerConsoleHandler, createWorkerLogHandler, createWorkerLogger, forwardConsole, isWorkerConsoleMessage, isWorkerLogMessage, isWorkerMessage, isWorkerSpanMessage, resetWorkerIds, restoreConsole };
-//# sourceMappingURL=worker.d.mts.map

package/dist/worker.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker.d.mts","names":[],"sources":["../src/worker.ts"],"mappings":";;;;UAyDiB,oBAAA;EACf,IAAA;EACA,KAAA;EACA,SAAA;EACA,IAAA;EACA,SAAA;AAAA;;UAIe,gBAAA;EACf,IAAA;EACA,KAAA;EACA,SAAA;EACA,OAAA;EACA,IAAA,GAAO,MAAA;EACP,SAAA;AAAA;;UAIe,iBAAA;EACf,IAAA;EACA,KAAA;EACA,SAAA;EACA,MAAA;EACA,OAAA;EACA,QAAA;EACA,SAAA;EACA,OAAA;EACA,QAAA;EACA,KAAA,EAAO,MAAA;EACP,QAAA,EAAU,MAAA;EACV,SAAA;AAAA;;KAIU,aAAA,GAAgB,oBAAA,GAAuB,gBAAA,GAAmB,iBAAA;;iBAGtD,sBAAA,CAAuB,GAAA,YAAe,GAAA,IAAO,oBAAA;AAoB7D;AAAA,iBAVgB,kBAAA,CAAmB,GAAA,YAAe,GAAA,IAAO,gBAAA;;iBAUzC,mBAAA,CAAoB,GAAA,YAAe,GAAA,IAAO,iBAAA;;iBAS1C,eAAA,CAAgB,GAAA,YAAe,GAAA,IAAO,aAAA;AAAA,KAMjD,aAAA,IAAiB,OAAA,EAAS,oBAAA;;;AAN/B;;;;;;;;;AAEC;;;;;AA+ED;;;;iBAAgB,cAAA,CAAe,WAAA,EAAa,aAAA,EAAe,SAAA;;;;;iBAiC3C,cAAA,CAAA;AAAA,KASX,gBAAA,IAAoB,OAAA,EAAS,aAAA;;iBAclB,cAAA,CAAA;AAAA,UAKN,mBAAA;EAnBL;EAqBH,YAAA;;EAEA,OAAA;AAAA;AATF;;;;;AAGC;;;;;AAoCD;;;;;;;;;;;;;;;;;AAvCA,iBAuCgB,kBAAA,CACd,WAAA,EAAa,gBAAA,EACb,SAAA,UACA,KAAA,GAAO,MAAA,mBACP,OAAA,GAAS,mBAAA,GACR,MAAA;AAAA,UA2Lc,2BAAA;EAAA;EAEf,gBAAA;;EAEA,MAAA,GAAS,MAAA;AAAA;;;;;AAkFX;;;;;;;;;;AAyBA;;;;;AA6BA;;;;;;iBAtDgB,0BAAA,CACd,OAAA,GAAS,2BAAA,IACP,OAAA,EAAS,oBAAA;AAAA,UAuBI,uBAAA;EA6BqF;EA3BpG,WAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Bc,sBAAA,CAAuB,OAAA,GAAS,uBAAA,IAAgC,OAAA,EAAS,aAAA"}

package/dist/worker.mjs

@@ -1,468 +0,0 @@
-import { D as writeSpan, c as createSpanDataProxy, s as createLogger, u as enableSpans } from "./core-BDFU50FQ.mjs";
-import "./index.mjs";
-//#region src/worker.ts
-/**
-* Worker Thread Logger/Console Forwarding
-*
-* Provides utilities to forward loggily and console.* output from worker threads
-* to the main thread, ensuring proper integration with DEBUG_LOG and log files.
-*
-* ## Full Logger Forwarding (Recommended)
-*
-* @example Worker side:
-* ```typescript
-* import { createWorkerLogger } from "loggily/worker"
-* const log = createWorkerLogger(postMessage, "km:worker:parse")
-*
-* log.info("processing", { file: "test.md" })
-* {
-*   using span = log.span("parse")
-*   // ... work ...
-*   span.spanData.lines = 100
-* }
-* ```
-*
-* @example Main thread side:
-* ```typescript
-* import { createWorkerLogHandler } from "loggily/worker"
-*
-* const handleLog = createWorkerLogHandler()
-* worker.onmessage = (e) => {
-*   if (e.data.type === "log" || e.data.type === "span") handleLog(e.data)
-* }
-* ```
-*
-* ## Console Forwarding (Simple)
-*
-* @example Worker side:
-* ```typescript
-* import { forwardConsole } from "loggily/worker"
-* forwardConsole(postMessage)
-*
-* console.log("message")  // Forwarded to main thread
-* ```
-*/
-/** Type guard for WorkerConsoleMessage */
-function isWorkerConsoleMessage(msg) {
-	return typeof msg === "object" && msg?.type === "console" && typeof msg.level === "string" && Array.isArray(msg.args);
-}
-/** Type guard for WorkerLogMessage */
-function isWorkerLogMessage(msg) {
-	return typeof msg === "object" && msg?.type === "log" && typeof msg.level === "string" && typeof msg.namespace === "string";
-}
-/** Type guard for WorkerSpanMessage */
-function isWorkerSpanMessage(msg) {
-	return typeof msg === "object" && msg?.type === "span" && typeof msg.event === "string";
-}
-/** Type guard for any worker message */
-function isWorkerMessage(msg) {
-	return isWorkerConsoleMessage(msg) || isWorkerLogMessage(msg) || isWorkerSpanMessage(msg);
-}
-/** Store original console methods for restoration */
-let originalConsole = null;
-/**
-* Serialize a value for transmission via postMessage.
-* Handles non-serializable values like functions and circular references.
-*/
-function serializeArg(arg, depth = 0) {
-	if (depth > 5) return "[max depth]";
-	if (arg === null || arg === void 0) return arg;
-	if (typeof arg === "function") return `[Function: ${arg.name || "anonymous"}]`;
-	if (typeof arg === "symbol") return arg.toString();
-	if (typeof arg === "bigint") return arg.toString() + "n";
-	if (arg instanceof Error) return {
-		name: arg.name,
-		message: arg.message,
-		stack: arg.stack
-	};
-	if (Array.isArray(arg)) return arg.map((v) => serializeArg(v, depth + 1));
-	if (typeof arg === "object") try {
-		structuredClone(arg);
-		return arg;
-	} catch {
-		const result = {};
-		const seen = /* @__PURE__ */ new Set();
-		seen.add(arg);
-		for (const [key, value] of Object.entries(arg)) if (typeof value === "object" && value !== null && seen.has(value)) result[key] = "[Circular]";
-		else result[key] = serializeArg(value, depth + 1);
-		return result;
-	}
-	return arg;
-}
-/**
-* Forward console.* calls from worker to main thread.
-*
-* Monkey-patches console methods to send messages via postMessage.
-* Call this at the start of your worker script.
-*
-* @param postMessage - The worker's postMessage function
-* @param namespace - Optional namespace for log messages (e.g., "km:worker:parse")
-*
-* @example
-* ```typescript
-* // At top of worker file:
-* import { forwardConsole } from "loggily/worker"
-* forwardConsole(postMessage, "km:worker:parse")
-*
-* // Now all console.* calls are forwarded:
-* console.log("processing", { file: "test.md" })
-* console.error(new Error("failed"))
-* ```
-*/
-function forwardConsole(postMessage, namespace) {
-	if (!originalConsole) originalConsole = { ...console };
-	for (const level of [
-		"log",
-		"debug",
-		"info",
-		"warn",
-		"error",
-		"trace"
-	]) console[level] = (...args) => {
-		const serializedArgs = args.map((arg) => serializeArg(arg));
-		try {
-			postMessage({
-				type: "console",
-				level,
-				namespace,
-				args: serializedArgs,
-				timestamp: Date.now()
-			});
-		} catch {
-			originalConsole?.[level](...args);
-		}
-	};
-}
-/**
-* Restore original console methods.
-* Call this if you need to disable console forwarding.
-*/
-function restoreConsole() {
-	if (originalConsole) {
-		Object.assign(console, originalConsole);
-		originalConsole = null;
-	}
-}
-let workerSpanIdCounter = 0;
-let workerTraceIdCounter = 0;
-function generateWorkerSpanId() {
-	return `wsp_${(++workerSpanIdCounter).toString(36)}`;
-}
-function generateWorkerTraceId() {
-	return `wtr_${(++workerTraceIdCounter).toString(36)}`;
-}
-/** Reset worker ID counters (for testing) */
-function resetWorkerIds() {
-	workerSpanIdCounter = 0;
-	workerTraceIdCounter = 0;
-}
-/**
-* Create a logger instance for use in a worker thread.
-*
-* All log calls and span events are forwarded to the main thread via postMessage.
-* The main thread should use createWorkerLogHandler to process these messages.
-*
-* @param postMessage - The worker's postMessage function
-* @param namespace - Logger namespace (e.g., "km:worker:parse")
-* @param props - Optional initial props
-* @param options - Optional configuration
-*
-* @example
-* ```typescript
-* import { createWorkerLogger } from "loggily/worker"
-*
-* const log = createWorkerLogger(postMessage, "km:worker:parse")
-*
-* log.info("starting parse", { file: "test.md" })
-*
-* {
-*   using span = log.span("process")
-*   span.info("processing...")
-*   span.spanData.lineCount = 100
-* }
-* // Span end event automatically sent to main thread
-* ```
-*/
-function createWorkerLogger(postMessage, namespace, props = {}, options = {}) {
-	const { parentSpanId = null, traceId = null } = options;
-	function log(level, message, data) {
-		const resolved = typeof message === "function" ? message() : message;
-		try {
-			postMessage({
-				type: "log",
-				level,
-				namespace,
-				message: resolved,
-				data: data ? {
-					...props,
-					...data
-				} : Object.keys(props).length > 0 ? props : void 0,
-				timestamp: Date.now()
-			});
-		} catch (err) {
-			try {
-				postMessage({
-					type: "log",
-					level: "error",
-					namespace,
-					message: `postMessage failed for ${level} "${resolved}": ${err instanceof Error ? err.message : String(err)}`,
-					timestamp: Date.now()
-				});
-			} catch {}
-		}
-	}
-	function createSpan(spanNamespace, spanProps) {
-		const fullNamespace = spanNamespace ? `${namespace}:${spanNamespace}` : namespace;
-		const mergedProps = {
-			...props,
-			...spanProps
-		};
-		const spanId = generateWorkerSpanId();
-		const spanTraceId = traceId || generateWorkerTraceId();
-		const startTime = Date.now();
-		const customSpanData = {};
-		try {
-			postMessage({
-				type: "span",
-				event: "start",
-				namespace: fullNamespace,
-				spanId,
-				traceId: spanTraceId,
-				parentId: parentSpanId,
-				startTime,
-				props: mergedProps,
-				spanData: {},
-				timestamp: Date.now()
-			});
-		} catch (err) {
-			try {
-				postMessage({
-					type: "log",
-					level: "error",
-					namespace: fullNamespace,
-					message: `postMessage failed for span start "${fullNamespace}": ${err instanceof Error ? err.message : String(err)}`,
-					timestamp: Date.now()
-				});
-			} catch {}
-		}
-		let ended = false;
-		const spanData = createSpanDataProxy(() => ({
-			id: spanId,
-			traceId: spanTraceId,
-			parentId: parentSpanId,
-			startTime,
-			endTime: ended ? Date.now() : null,
-			duration: Date.now() - startTime
-		}), customSpanData);
-		function endSpan() {
-			if (ended) return;
-			ended = true;
-			const endTime = Date.now();
-			const duration = endTime - startTime;
-			try {
-				postMessage({
-					type: "span",
-					event: "end",
-					namespace: fullNamespace,
-					spanId,
-					traceId: spanTraceId,
-					parentId: parentSpanId,
-					startTime,
-					endTime,
-					duration,
-					props: mergedProps,
-					spanData: customSpanData,
-					timestamp: Date.now()
-				});
-			} catch (err) {
-				try {
-					postMessage({
-						type: "log",
-						level: "error",
-						namespace: fullNamespace,
-						message: `postMessage failed for span end "${fullNamespace}" (${duration}ms): ${err instanceof Error ? err.message : String(err)}`,
-						timestamp: Date.now()
-					});
-				} catch {}
-			}
-		}
-		return {
-			...createWorkerLogger(postMessage, fullNamespace, mergedProps, {
-				parentSpanId: spanId,
-				traceId: spanTraceId
-			}),
-			spanData,
-			end: endSpan,
-			[Symbol.dispose]: endSpan
-		};
-	}
-	return {
-		name: namespace,
-		props: Object.freeze({ ...props }),
-		spanData: null,
-		trace: (msg, data) => log("trace", msg, data),
-		debug: (msg, data) => log("debug", msg, data),
-		info: (msg, data) => log("info", msg, data),
-		warn: (msg, data) => log("warn", msg, data),
-		error: (msgOrError, data) => {
-			if (msgOrError instanceof Error) log("error", msgOrError.message, {
-				...data,
-				error_type: msgOrError.name,
-				error_stack: msgOrError.stack,
-				error_code: msgOrError.code
-			});
-			else log("error", msgOrError, data);
-		},
-		logger(childNamespace, childProps) {
-			return createWorkerLogger(postMessage, childNamespace ? `${namespace}:${childNamespace}` : namespace, {
-				...props,
-				...childProps
-			}, options);
-		},
-		span: createSpan,
-		child(context) {
-			if (typeof context === "string") return this.logger(context);
-			return createWorkerLogger(postMessage, namespace, {
-				...props,
-				...context
-			}, options);
-		},
-		end() {}
-	};
-}
-/** Safely stringify a value, handling circular refs and BigInt */
-function safeStringify(value) {
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return String(value);
-	}
-}
-/** Format console args into a message string and optional data object */
-function formatConsoleArgs(args) {
-	const message = args.length === 0 ? "" : args.length === 1 && typeof args[0] === "string" ? args[0] : args.map((a) => typeof a === "string" ? a : safeStringify(a)).join(" ");
-	const lastArg = args[args.length - 1];
-	return {
-		message,
-		data: args.length > 1 && typeof lastArg === "object" && lastArg !== null && !Array.isArray(lastArg) ? lastArg : void 0
-	};
-}
-/** Dispatch a message to a logger at the given console level */
-function dispatchToLogger(logger, level, message, data) {
-	switch (level) {
-		case "trace":
-			logger.trace?.(message, data);
-			break;
-		case "debug":
-			logger.debug?.(message, data);
-			break;
-		case "info":
-		case "log":
-			logger.info?.(message, data);
-			break;
-		case "warn":
-			logger.warn?.(message, data);
-			break;
-		case "error":
-			logger.error?.(message, data);
-			break;
-	}
-}
-/**
-* Create a handler for worker console messages.
-*
-* Use this on the main thread to receive and output messages from workers.
-*
-* @param options - Handler options
-* @returns Handler function to call with worker messages
-*
-* @example
-* ```typescript
-* import { createWorkerConsoleHandler } from "loggily/worker"
-*
-* const handleConsole = createWorkerConsoleHandler({
-*   defaultNamespace: "km:worker:parse"
-* })
-*
-* worker.onmessage = (e) => {
-*   if (e.data.type === "console") {
-*     handleConsole(e.data)
-*   } else {
-*     // Handle other message types
-*   }
-* }
-* ```
-*/
-function createWorkerConsoleHandler(options = {}) {
-	const loggers = /* @__PURE__ */ new Map();
-	function getLogger(namespace) {
-		const ns = namespace || options.defaultNamespace || "worker";
-		let logger = loggers.get(ns);
-		if (!logger) {
-			logger = options.logger ? options.logger : createLogger(ns);
-			loggers.set(ns, logger);
-		}
-		return logger;
-	}
-	return (message) => {
-		const logger = getLogger(message.namespace);
-		const { message: msg, data } = formatConsoleArgs(message.args);
-		dispatchToLogger(logger, message.level, msg, data);
-	};
-}
-/**
-* Create a handler for worker logger messages (logs and spans).
-*
-* Use this on the main thread to receive and output messages from workers
-* that use createWorkerLogger.
-*
-* @param options - Handler options
-* @returns Handler function to call with worker messages
-*
-* @example
-* ```typescript
-* import { createWorkerLogHandler, isWorkerMessage } from "loggily/worker"
-*
-* const handleLog = createWorkerLogHandler()
-*
-* worker.onmessage = (e) => {
-*   if (isWorkerMessage(e.data)) {
-*     handleLog(e.data)
-*   } else {
-*     // Handle other message types
-*   }
-* }
-* ```
-*/
-function createWorkerLogHandler(options = {}) {
-	const loggers = /* @__PURE__ */ new Map();
-	if (options.enableSpans) enableSpans();
-	function getLogger(namespace) {
-		let logger = loggers.get(namespace);
-		if (!logger) {
-			logger = createLogger(namespace);
-			loggers.set(namespace, logger);
-		}
-		return logger;
-	}
-	return (message) => {
-		if (isWorkerConsoleMessage(message)) {
-			const logger = getLogger(message.namespace || "worker");
-			const { message: msg, data } = formatConsoleArgs(message.args);
-			dispatchToLogger(logger, message.level, msg, data);
-		} else if (isWorkerLogMessage(message)) dispatchToLogger(getLogger(message.namespace), message.level, message.message, message.data);
-		else if (isWorkerSpanMessage(message)) {
-			if (message.event === "end") writeSpan(message.namespace, message.duration ?? 0, {
-				span_id: message.spanId,
-				trace_id: message.traceId,
-				parent_id: message.parentId,
-				...message.props,
-				...message.spanData
-			});
-		}
-	};
-}
-//#endregion
-export { createWorkerConsoleHandler, createWorkerLogHandler, createWorkerLogger, forwardConsole, isWorkerConsoleMessage, isWorkerLogMessage, isWorkerMessage, isWorkerSpanMessage, resetWorkerIds, restoreConsole };
-
-//# sourceMappingURL=worker.mjs.map