@mks2508/better-logger 0.18.2-alpha.1 → 0.18.3

package/dist/chunks/transports-COPWmlF1.cjs

@@ -1,756 +0,0 @@
-const require_core = require("./core-Dzz7agGa.cjs");
-//#region src/types/transports.ts
-/**
-* Map a `LogLevel` to the OpenTelemetry numeric severity (1-24) used by
-* SigNoz / any OTLP/HTTP backend. Spec-compliant banded values:
-*   TRACE=1-4, DEBUG=5-8, INFO=9-12, WARN=13-16, ERROR=17-20, FATAL=21-24
-* We use the canonical mid-band value per level.
-*
-* @see https://opentelemetry.io/docs/specs/otel/logs/data-model/#severity-fields
-*/
-const LOG_LEVEL_TO_SEVERITY_NUMBER = {
-	trace: 1,
-	debug: 5,
-	info: 9,
-	warn: 13,
-	error: 17,
-	critical: 21
-};
-/**
-* Map a `LogLevel` to its OpenTelemetry severity name (uppercase, OTel spec).
-*/
-const LOG_LEVEL_TO_SEVERITY_TEXT = {
-	trace: "TRACE",
-	debug: "DEBUG",
-	info: "INFO",
-	warn: "WARN",
-	error: "ERROR",
-	critical: "FATAL"
-};
-//#endregion
-//#region src/transports/ConsoleTransport.ts
-var ConsoleTransport = class {
-	options;
-	name = "console";
-	constructor(options) {
-		this.options = options;
-	}
-	write(record) {
-		const method = this.getConsoleMethod(record.level);
-		const prefix = record.prefix ? `[${record.prefix}] ` : "";
-		const location = record.location ? ` (${record.location.file}:${record.location.line})` : "";
-		console[method](`[${record.level.toUpperCase()}]${prefix} ${record.msg}${location}`);
-	}
-	getConsoleMethod(level) {
-		switch (level) {
-			case "debug": return "log";
-			case "info": return "info";
-			case "warn": return "warn";
-			case "error":
-			case "critical": return "error";
-			default: return "log";
-		}
-	}
-};
-//#endregion
-//#region src/transports/FileTransport.ts
-const MAX_BUFFER_DEFAULT = 1e4;
-const BATCH_SIZE_DEFAULT = 100;
-const FS_PROMISES_LOAD_TIMEOUT_MS = 50;
-const LOCAL_STORAGE_KEY_PREFIX = "better-logger:";
-/**
-* File-based transport.
-*
-* - In Node, writes batches via `fs.promises.appendFile` (non-blocking).
-* - In the browser, writes batches into `localStorage` (fallback no-op if
-*   `localStorage` is unavailable — e.g. private mode, sandboxed iframes).
-*
-* Fixed in 5.1.0:
-*   - BUG-N3: uses async `fs.promises.appendFile` instead of sync `appendFileSync`.
-*   - BUG-N4: destination is sanitised to reject path traversal (`..`, `~`, abs paths).
-*   - BUG-N5: dynamic `import('node:fs/promises')` instead of CJS `require('fs')`.
-*   - BUG-N6: browser case uses `localStorage` with try/catch (was silent no-op).
-*
-*/
-var FileTransport = class {
-	name = "file";
-	buffer = [];
-	flushTimer;
-	options;
-	closed = false;
-	constructor(options) {
-		this.options = {
-			batchSize: BATCH_SIZE_DEFAULT,
-			maxBufferSize: MAX_BUFFER_DEFAULT,
-			...options ?? {}
-		};
-		if (this.options.flushInterval) this.flushTimer = setInterval(() => {
-			this.flush();
-		}, this.options.flushInterval);
-	}
-	get bufferSize() {
-		return this.buffer.length;
-	}
-	get maxBufferSize() {
-		return this.options.maxBufferSize ?? MAX_BUFFER_DEFAULT;
-	}
-	isReady() {
-		return !this.closed;
-	}
-	write(record) {
-		if (this.closed) return;
-		if (this.buffer.length >= this.maxBufferSize) {
-			const dropped = this.buffer.shift();
-			if (dropped && this.options.onError) {
-				const entry = {
-					level: "warn",
-					message: "FileTransport buffer overflow: oldest record dropped",
-					args: [],
-					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-					hookEvent: "onError",
-					error: /* @__PURE__ */ new Error("FileTransport buffer overflow"),
-					extra: { droppedRecord: dropped }
-				};
-				this.options.onError(entry);
-			}
-		}
-		this.buffer.push(JSON.stringify(record) + "\n");
-		const batchSize = this.options.batchSize ?? BATCH_SIZE_DEFAULT;
-		if (this.buffer.length >= batchSize) this.flush();
-	}
-	async flush() {
-		if (this.closed || this.buffer.length === 0) return;
-		const payload = this.buffer.join("");
-		this.buffer = [];
-		if (isNodeLike()) await this.flushNode(payload);
-		else await this.flushBrowser(payload);
-	}
-	async flushNode(payload) {
-		const destination = this.resolveNodeDestination();
-		try {
-			await (await loadNodeFsPromises()).appendFile(destination, payload, "utf8");
-		} catch (error) {
-			this.emitError("FileTransport failed to write to disk", error);
-		}
-	}
-	async flushBrowser(payload) {
-		if (typeof localStorage === "undefined") {
-			this.emitError("FileTransport: localStorage is not available in this environment", null);
-			return;
-		}
-		try {
-			const key = LOCAL_STORAGE_KEY_PREFIX + this.resolveBrowserKey();
-			const existing = localStorage.getItem(key) ?? "";
-			localStorage.setItem(key, existing + payload);
-		} catch (error) {
-			this.emitError("FileTransport: localStorage write failed (quota? private mode?)", error);
-		}
-	}
-	async close() {
-		this.closed = true;
-		if (this.flushTimer) {
-			clearInterval(this.flushTimer);
-			this.flushTimer = void 0;
-		}
-		await this.flush();
-	}
-	resolveNodeDestination() {
-		const requested = this.options.destination ?? "app.log";
-		const sanitised = sanitiseNodePath(requested);
-		if (sanitised === null) {
-			this.emitError(`FileTransport: refusing destination with traversal segment: ${requested}`, null);
-			return "app.log";
-		}
-		return sanitised;
-	}
-	resolveBrowserKey() {
-		return sanitiseBrowserKey(this.options.destination ?? "default");
-	}
-	emitError(message, cause) {
-		if (!this.options.onError) return;
-		const entry = {
-			level: "error",
-			message,
-			args: [],
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			hookEvent: "onError",
-			error: cause instanceof Error ? cause : new Error(String(cause))
-		};
-		this.options.onError(entry);
-	}
-};
-function isNodeLike() {
-	return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-}
-/**
-* Reject paths that escape the working directory. Allows relative paths
-* under `cwd/`. Absolute paths are rejected by default — if a caller needs
-* an absolute location, pass it through a documented escape hatch (not
-* exposed here on purpose).
-*/
-function sanitiseNodePath(input) {
-	if (!input) return null;
-	const normalised = input.replace(/\\/g, "/").trim();
-	if (normalised.length === 0) return null;
-	if (normalised.startsWith("/") || /^[a-zA-Z]:\//.test(normalised)) return null;
-	const segments = normalised.split("/").filter((s) => s.length > 0 && s !== ".");
-	if (segments.some((s) => s === ".." || s === "~")) return null;
-	return segments.join("/");
-}
-function sanitiseBrowserKey(input) {
-	return input.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || "default";
-}
-/**
-* Cached dynamic import of `node:fs/promises`. The cache is intentionally
-* module-scoped so subsequent flushes don't pay the import cost.
-*/
-let _fsPromisesPromise = null;
-async function loadNodeFsPromises() {
-	if (_fsPromisesPromise) return _fsPromisesPromise;
-	const importPromise = import("node:fs/promises");
-	const timeoutPromise = new Promise((_, reject) => {
-		setTimeout(() => reject(/* @__PURE__ */ new Error(`fs/promises import timed out after ${FS_PROMISES_LOAD_TIMEOUT_MS}ms`)), FS_PROMISES_LOAD_TIMEOUT_MS);
-	});
-	_fsPromisesPromise = Promise.race([importPromise, timeoutPromise]).catch((err) => {
-		_fsPromisesPromise = null;
-		throw err;
-	});
-	return _fsPromisesPromise;
-}
-//#endregion
-//#region src/transports/HttpTransport.ts
-const DEFAULT_MAX_BUFFER = 1e4;
-const DEFAULT_BATCH_SIZE = 50;
-const DEFAULT_MAX_RETRIES = 3;
-const DEFAULT_INITIAL_BACKOFF = 250;
-const DEFAULT_MAX_BACKOFF = 5e3;
-const DEFAULT_FETCH_TIMEOUT = 1e4;
-/**
-* HTTP-based transport. Buffers records, batches them on size or interval,
-* POSTs the batch as JSON, and surfaces failures via retry, bounded buffer,
-* and an `onError` hook — never a silent `.catch(() => {})`.
-*
-* Extending this class is the recommended way to ship a new transport:
-* see {@link OtlpTransport}.
-*
-*/
-var HttpTransport = class {
-	name = "http";
-	buffer = [];
-	flushTimer;
-	closed = false;
-	/** Options bag — `protected` so subclasses (e.g. {@link OtlpTransport}) can read or extend it. */
-	options;
-	constructor(options) {
-		this.options = {
-			batchSize: DEFAULT_BATCH_SIZE,
-			maxBufferSize: DEFAULT_MAX_BUFFER,
-			maxRetries: DEFAULT_MAX_RETRIES,
-			initialBackoffMs: DEFAULT_INITIAL_BACKOFF,
-			maxBackoffMs: DEFAULT_MAX_BACKOFF,
-			fetchTimeoutMs: DEFAULT_FETCH_TIMEOUT,
-			...options ?? {}
-		};
-		if (this.options.flushInterval) this.flushTimer = setInterval(() => {
-			this.flush();
-		}, this.options.flushInterval);
-	}
-	get bufferSize() {
-		return this.buffer.length;
-	}
-	get maxBufferSize() {
-		return this.options.maxBufferSize ?? DEFAULT_MAX_BUFFER;
-	}
-	isReady() {
-		return !this.closed && Boolean(this.options.url);
-	}
-	write(record) {
-		if (this.closed) return;
-		if (this.buffer.length >= this.maxBufferSize) this.applyOverflowPolicy();
-		this.buffer.push(record);
-		const batchSize = this.options.batchSize ?? DEFAULT_BATCH_SIZE;
-		if (this.buffer.length >= batchSize) this.flush();
-	}
-	/**
-	* Serialises a batch into the request body. Subclasses override to
-	* switch encodings (e.g. {@link OtlpTransport} produces OTLP/HTTP JSON
-	* instead of the default `{ logs: [...] }` envelope).
-	*
-	*/
-	serializeBody(records) {
-		return JSON.stringify({ logs: records });
-	}
-	/**
-	* Builds the request headers. Subclasses may prepend transport-specific
-	* headers (e.g. `signoz-ingestion-key`).
-	*
-	*/
-	buildHeaders() {
-		return {
-			"Content-Type": "application/json",
-			...this.options.headers ?? {}
-		};
-	}
-	applyOverflowPolicy() {
-		const dropped = this.buffer.shift();
-		if (dropped && this.options.onError) {
-			const entry = {
-				level: "warn",
-				message: "HttpTransport buffer overflow: oldest record dropped",
-				args: [dropped],
-				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-				hookEvent: "onError",
-				error: /* @__PURE__ */ new Error("HttpTransport buffer overflow"),
-				extra: { droppedRecord: dropped }
-			};
-			this.options.onError(entry);
-		}
-	}
-	async flush() {
-		if (this.closed || this.buffer.length === 0 || !this.options.url) return;
-		const records = [...this.buffer];
-		this.buffer = [];
-		if (!await this.sendWithRetry(records)) {
-			const combined = records.concat(this.buffer);
-			if (combined.length > this.maxBufferSize) {
-				const trimmed = combined.slice(combined.length - this.maxBufferSize);
-				const droppedCount = combined.length - trimmed.length;
-				if (droppedCount > 0 && this.options.onError) {
-					const entry = {
-						level: "error",
-						message: `HttpTransport dropped ${droppedCount} records after retry exhaustion`,
-						args: [],
-						timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-						hookEvent: "onError",
-						error: /* @__PURE__ */ new Error("HttpTransport retry exhaustion"),
-						extra: { droppedCount }
-					};
-					this.options.onError(entry);
-				}
-				this.buffer = trimmed;
-			} else this.buffer = combined;
-		}
-	}
-	async sendWithRetry(records) {
-		const url = this.options.url;
-		if (!url) return false;
-		const maxRetries = this.options.maxRetries ?? DEFAULT_MAX_RETRIES;
-		const initialBackoff = this.options.initialBackoffMs ?? DEFAULT_INITIAL_BACKOFF;
-		const maxBackoff = this.options.maxBackoffMs ?? DEFAULT_MAX_BACKOFF;
-		const fetchTimeout = this.options.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT;
-		const body = this.serializeBody(records);
-		const headers = this.buildHeaders();
-		let attempt = 0;
-		let backoff = initialBackoff;
-		while (attempt <= maxRetries) {
-			try {
-				const controller = new AbortController();
-				const timeoutId = setTimeout(() => controller.abort(), fetchTimeout);
-				const response = await fetch(url, {
-					method: "POST",
-					headers,
-					body,
-					signal: controller.signal
-				});
-				clearTimeout(timeoutId);
-				if (response.ok) return true;
-				if (response.status >= 400 && response.status < 500) {
-					if (this.options.onError) {
-						const entry = {
-							level: "error",
-							message: `HttpTransport ${response.status} ${response.statusText} (not retried)`,
-							args: [],
-							timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-							hookEvent: "onError",
-							error: /* @__PURE__ */ new Error(`HTTP ${response.status}`),
-							extra: { responseStatus: response.status }
-						};
-						this.options.onError(entry);
-					}
-					return false;
-				}
-				if (attempt === maxRetries) break;
-				await sleep(backoff);
-				backoff = Math.min(backoff * 2, maxBackoff);
-			} catch (error) {
-				if (attempt === maxRetries) {
-					if (this.options.onError) {
-						const entry = {
-							level: "error",
-							message: `HttpTransport fetch failed after ${maxRetries + 1} attempts`,
-							args: [],
-							timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-							hookEvent: "onError",
-							error: error instanceof Error ? error : new Error(String(error))
-						};
-						this.options.onError(entry);
-					}
-					return false;
-				}
-				await sleep(backoff);
-				backoff = Math.min(backoff * 2, maxBackoff);
-			}
-			attempt++;
-		}
-		return false;
-	}
-	async close() {
-		this.closed = true;
-		if (this.flushTimer) {
-			clearInterval(this.flushTimer);
-			this.flushTimer = void 0;
-		}
-		await this.flush();
-	}
-};
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-//#endregion
-//#region src/transports/OtlpTransport.ts
-/**
-* OTLP/HTTP transport for SigNoz (or any OTLP-compliant backend).
-*
-* Extends {@link HttpTransport} — inherits retry, bounded buffer, status
-* check, async close, and the on-error hook. Overrides only the payload
-* shape and the request headers.
-*
-* ```ts
-* logger.addTransport({
-*   target: new OtlpTransport({
-*     endpoint: 'https://otelcollector.example.com:4318',
-*     serviceName: 'my-app',
-*     serviceVersion: '1.2.3',
-*     environment: 'production',
-*     ingestKeyEnvVar: 'SIGNOZ_KEY'
-*   })
-* });
-* ```
-*
-*/
-var OtlpTransport = class extends HttpTransport {
-	name = "otlp";
-	resource;
-	/** Resolved at construction. Never logged, never written to source. */
-	ingestKeyValue;
-	constructor(options) {
-		if (!options.endpoint) throw new Error("OtlpTransport: `endpoint` is required");
-		if (!options.serviceName) throw new Error("OtlpTransport: `serviceName` is required");
-		const ingestKey = readIngestKey(options.ingestKeyEnvVar);
-		const httpOptions = {
-			url: `${stripTrailingSlash(options.endpoint)}/v1/logs`,
-			headers: {
-				...ingestKey ? { "signoz-ingestion-key": ingestKey } : {},
-				...options.headers ?? {}
-			},
-			batchSize: options.batchSize,
-			flushInterval: options.flushInterval,
-			maxBufferSize: options.maxBufferSize,
-			maxRetries: options.maxRetries,
-			initialBackoffMs: options.initialBackoffMs,
-			maxBackoffMs: options.maxBackoffMs,
-			fetchTimeoutMs: options.fetchTimeoutMs,
-			onError: options.onError
-		};
-		super(httpOptions);
-		this.resource = {
-			"service.name": options.serviceName,
-			...options.serviceVersion ? { "service.version": options.serviceVersion } : {},
-			...options.environment ? { "deployment.environment": options.environment } : {},
-			...options.resourceAttributes ?? {}
-		};
-		this.ingestKeyValue = ingestKey;
-	}
-	/**
-	* Builds the OTLP/HTTP JSON payload from the currently buffered records.
-	* One `resourceLogs` block per batch (matches OTel collector batching
-	* guidance). Exposed for tests + custom transport subclasses.
-	*
-	*/
-	buildPayload(records) {
-		return { resourceLogs: [{
-			resource: { attributes: Object.entries(this.resource).filter((entry) => typeof entry[1] === "string").map(([key, value]) => ({
-				key,
-				value: { stringValue: value }
-			})) },
-			scopeLogs: [{
-				scope: {
-					name: "better-logger",
-					version: "5.1.0"
-				},
-				logRecords: records.map((r) => this.toLogRecord(r))
-			}]
-		}] };
-	}
-	/**
-	* Serialises a batch into the OTLP/HTTP JSON request body. Overrides
-	* {@link HttpTransport.serializeBody}.
-	*
-	*/
-	serializeBody(records) {
-		return JSON.stringify(this.buildPayload(records));
-	}
-	/**
-	* Builds request headers. Adds `signoz-ingestion-key` from the value
-	* resolved at construction time (never logged, never written to source).
-	*
-	*/
-	buildHeaders() {
-		return {
-			"Content-Type": "application/json",
-			...this.ingestKeyValue ? { "signoz-ingestion-key": this.ingestKeyValue } : {},
-			...this.options.headers ?? {}
-		};
-	}
-	toLogRecord(record) {
-		const timeUnixNano = String(BigInt(record.time) * 1000000n);
-		const base = {
-			timeUnixNano,
-			observedTimeUnixNano: timeUnixNano,
-			severityNumber: LOG_LEVEL_TO_SEVERITY_NUMBER[record.level],
-			severityText: record.severityText,
-			body: { stringValue: record.msg }
-		};
-		const attributes = collectAttributes(record);
-		if (attributes.length > 0) base.attributes = attributes;
-		if (record.traceId) base.traceId = record.traceId;
-		if (record.spanId) base.spanId = record.spanId;
-		return base;
-	}
-};
-function stripTrailingSlash(value) {
-	return value.endsWith("/") ? value.slice(0, -1) : value;
-}
-/**
-* Reads the ingest API key from `process.env[name]`. Returns undefined
-* silently if `process` is unavailable (strict browser bundles) or the
-* variable is unset. Never throws, never logs the value.
-*/
-function readIngestKey(envVarName) {
-	if (!envVarName) return void 0;
-	if (typeof process === "undefined") return void 0;
-	const value = process.env?.[envVarName];
-	if (!value) return void 0;
-	return value;
-}
-function collectAttributes(record) {
-	const out = [];
-	if (record.prefix) out.push({
-		key: "logger.prefix",
-		value: { stringValue: record.prefix }
-	});
-	if (record.tag) out.push({
-		key: "logger.tag",
-		value: { stringValue: record.tag }
-	});
-	if (record.location) {
-		out.push({
-			key: "code.filepath",
-			value: { stringValue: record.location.file }
-		});
-		out.push({
-			key: "code.lineno",
-			value: { intValue: record.location.line }
-		});
-		if (record.location.function) out.push({
-			key: "code.function",
-			value: { stringValue: record.location.function }
-		});
-	}
-	if (record.attributes) for (const [key, value] of Object.entries(record.attributes)) {
-		const mapped = toOtlpAttribute(value);
-		if (mapped) out.push({
-			key,
-			value: mapped
-		});
-	}
-	return out;
-}
-function toOtlpAttribute(value) {
-	if (value === null || value === void 0) return null;
-	if (typeof value === "string") return { stringValue: value };
-	if (typeof value === "number") {
-		if (Number.isInteger(value)) return { intValue: value };
-		return { doubleValue: value };
-	}
-	if (typeof value === "boolean") return { boolValue: value };
-	if (Array.isArray(value)) return { arrayValue: { values: value.map((v) => toOtlpAttribute(v)).filter((v) => v !== null) } };
-	return { stringValue: JSON.stringify(value) };
-}
-//#endregion
-//#region src/transports/TransportManager.ts
-function generateTransportId() {
-	return `transport-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-/**
-* Built-in registry of named transports. Users can call
-* {@link TransportManager.register} to add their own (e.g. a custom
-* Datadog or Loki transport) and then instantiate it via
-* `addTransport({ target: 'datadog', options })`.
-*
-* The four built-ins are registered automatically:
-*   - `'console'` → {@link ConsoleTransport}
-*   - `'file'`    → {@link FileTransport}
-*   - `'http'`    → {@link HttpTransport}
-*   - `'otlp'`    → {@link OtlpTransport}
-*/
-const BUILTIN_REGISTRY = /* @__PURE__ */ new Map([
-	["console", ConsoleTransport],
-	["file", FileTransport],
-	["http", HttpTransport],
-	["otlp", OtlpTransport]
-]);
-var TransportManager = class {
-	transports = /* @__PURE__ */ new Map();
-	defaultLevel = "info";
-	registry = new Map(BUILTIN_REGISTRY);
-	constructor(defaultLevel) {
-		if (defaultLevel) this.defaultLevel = defaultLevel;
-	}
-	/**
-	* Registers a custom transport under a string name. Once registered,
-	* `addTransport({ target: 'name', options })` instantiates it.
-	*
-	* @example
-	* transportManager.register('datadog', DatadogTransport);
-	* transportManager.add({ target: 'datadog', options: { apiKey: env('DD_KEY') } });
-	*
-	*/
-	register(name, ctor) {
-		if (BUILTIN_REGISTRY.has(name)) throw new Error(`TransportManager.register: '${name}' is a built-in and cannot be overridden`);
-		this.registry.set(name, ctor);
-	}
-	/**
-	* Lists all registered transport names (built-ins + custom).
-	*
-	*/
-	listRegistered() {
-		return [...this.registry.keys()];
-	}
-	add(target) {
-		const id = generateTransportId();
-		const level = target.level || this.defaultLevel;
-		let transport;
-		if (typeof target.target === "string") {
-			const ctor = this.registry.get(target.target);
-			if (!ctor) throw new Error(`TransportManager.add: unknown transport name '${target.target}'. Registered: ${this.listRegistered().join(", ")}`);
-			transport = new ctor(target.options ?? {});
-		} else transport = target.target;
-		const entry = {
-			id,
-			transport,
-			options: target.options || {},
-			level,
-			levelValue: require_core.LOG_LEVELS[level]
-		};
-		this.transports.set(id, entry);
-		return id;
-	}
-	remove(id) {
-		const entry = this.transports.get(id);
-		if (entry) {
-			const closeResult = entry.transport.close?.();
-			if (closeResult instanceof Promise) closeResult.catch(() => {});
-			return this.transports.delete(id);
-		}
-		return false;
-	}
-	async write(record) {
-		const promises = [];
-		for (const entry of this.transports.values()) {
-			if (record.levelValue < entry.levelValue) continue;
-			let transformedRecord = record;
-			if (entry.options.transform) {
-				const result = entry.options.transform(record);
-				if (result === null) continue;
-				transformedRecord = result;
-			}
-			try {
-				const result = entry.transport.write(transformedRecord);
-				if (result instanceof Promise) promises.push(result.catch((err) => {
-					console.error("TransportManager.write: transport failed:", err);
-				}));
-			} catch (error) {
-				console.error("TransportManager.write: transport threw synchronously:", error);
-			}
-		}
-		await Promise.all(promises);
-	}
-	async flush() {
-		const promises = [];
-		for (const entry of this.transports.values()) if (entry.transport.flush) try {
-			const result = entry.transport.flush();
-			if (result instanceof Promise) promises.push(result.catch((err) => {
-				console.error("TransportManager.flush: transport failed:", err);
-			}));
-		} catch (error) {
-			console.error("TransportManager.flush: transport threw synchronously:", error);
-		}
-		await Promise.all(promises);
-	}
-	async close() {
-		await this.flush();
-		const promises = [];
-		for (const entry of this.transports.values()) if (entry.transport.close) try {
-			const result = entry.transport.close();
-			if (result instanceof Promise) promises.push(result.catch((err) => {
-				console.error("TransportManager.close: transport failed:", err);
-			}));
-		} catch (error) {
-			console.error("TransportManager.close: transport threw synchronously:", error);
-		}
-		await Promise.all(promises);
-		this.transports.clear();
-	}
-	get count() {
-		return this.transports.size;
-	}
-	list() {
-		return Array.from(this.transports.keys());
-	}
-};
-//#endregion
-Object.defineProperty(exports, "ConsoleTransport", {
-	enumerable: true,
-	get: function() {
-		return ConsoleTransport;
-	}
-});
-Object.defineProperty(exports, "FileTransport", {
-	enumerable: true,
-	get: function() {
-		return FileTransport;
-	}
-});
-Object.defineProperty(exports, "HttpTransport", {
-	enumerable: true,
-	get: function() {
-		return HttpTransport;
-	}
-});
-Object.defineProperty(exports, "LOG_LEVEL_TO_SEVERITY_NUMBER", {
-	enumerable: true,
-	get: function() {
-		return LOG_LEVEL_TO_SEVERITY_NUMBER;
-	}
-});
-Object.defineProperty(exports, "LOG_LEVEL_TO_SEVERITY_TEXT", {
-	enumerable: true,
-	get: function() {
-		return LOG_LEVEL_TO_SEVERITY_TEXT;
-	}
-});
-Object.defineProperty(exports, "OtlpTransport", {
-	enumerable: true,
-	get: function() {
-		return OtlpTransport;
-	}
-});
-Object.defineProperty(exports, "TransportManager", {
-	enumerable: true,
-	get: function() {
-		return TransportManager;
-	}
-});
-
-//# sourceMappingURL=transports-COPWmlF1.cjs.map