logixia 1.1.4 → 1.2.0

package/dist/transport.manager-C3Xr7Tvi.js

@@ -0,0 +1,1925 @@
+const require_chunk = require('./chunk-BTgCAUrQ.js');
+let node_events = require("node:events");
+node_events = require_chunk.__toESM(node_events);
+let node_readline = require("node:readline");
+node_readline = require_chunk.__toESM(node_readline);
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_util = require("node:util");
+node_util = require_chunk.__toESM(node_util);
+
+//#region src/utils/internal-log.ts
+/**
+* Internal logging helpers for use within the logixia library itself.
+*
+* These functions write directly to stderr/stdout without going through
+* LogixiaLogger — this avoids circular dependencies and ensures internal
+* diagnostics still surface even when the logger is misconfigured.
+*
+* Library code must NEVER call console.log/warn/error directly. Use these
+* helpers instead so that internal output can be silenced in tests by setting
+* the LOGIXIA_SILENT_INTERNAL=1 environment variable.
+*/
+const silent = process.env.LOGIXIA_SILENT_INTERNAL === "1";
+/**
+* Emit an internal debug/info message to stderr.
+* Use for field-enable/disable notifications that a developer might want to see
+* during development but should not appear in production log streams.
+*/
+function internalLog(message) {
+	if (!silent) process.stderr.write(`[logixia] ${message}\n`);
+}
+/**
+* Emit an internal warning to stderr.
+* Use when something is misconfigured but logixia can continue operating.
+*/
+function internalWarn(message) {
+	if (!silent) process.stderr.write(`[logixia:warn] ${message}\n`);
+}
+/**
+* Emit an internal error to stderr.
+* Use when a transport write fails or a serious internal error occurs.
+*/
+function internalError(message, error) {
+	if (!silent) {
+		let errStr = "";
+		if (error instanceof Error) errStr = ` — ${error.message}`;
+		else if (error != null) errStr = ` — ${String(error)}`;
+		process.stderr.write(`[logixia:error] ${message}${errStr}\n`);
+	}
+}
+
+//#endregion
+//#region src/transports/console.transport.ts
+var ConsoleTransport = class ConsoleTransport {
+	static #_ = this.COLORS = new Map([
+		["red", "\x1B[31m"],
+		["green", "\x1B[32m"],
+		["yellow", "\x1B[33m"],
+		["blue", "\x1B[34m"],
+		["magenta", "\x1B[35m"],
+		["cyan", "\x1B[36m"],
+		["white", "\x1B[37m"],
+		["gray", "\x1B[90m"],
+		["reset", "\x1B[0m"]
+	]);
+	constructor(config = {}) {
+		this.config = config;
+		this.name = "console";
+	}
+	write(entry) {
+		const formatted = this.formatEntry(entry) + "\n";
+		(entry.level.toLowerCase() === "error" ? process.stderr : process.stdout).write(formatted);
+		return Promise.resolve();
+	}
+	formatEntry(entry) {
+		if (this.config.format === "json") return JSON.stringify({
+			timestamp: this.config.timestamp !== false ? entry.timestamp.toISOString() : void 0,
+			level: entry.level,
+			message: entry.message,
+			...entry.data || {},
+			context: entry.context,
+			traceId: entry.traceId,
+			appName: entry.appName,
+			environment: entry.environment
+		}, null, 2);
+		const parts = [];
+		if (this.config.timestamp !== false) {
+			const timestamp = entry.timestamp.toISOString();
+			parts.push(this.colorize(timestamp, "gray"));
+		}
+		const level = entry.level.toUpperCase().padEnd(5);
+		const coloredLevel = this.colorize(level, this.getLevelColor(entry.level));
+		parts.push(coloredLevel);
+		if (entry.context) {
+			const context = `[${entry.context}]`;
+			parts.push(this.colorize(context, "cyan"));
+		}
+		if (entry.traceId) {
+			const traceId = `(${entry.traceId})`;
+			parts.push(this.colorize(traceId, "magenta"));
+		}
+		parts.push(entry.message);
+		if (entry.data && Object.keys(entry.data).length > 0) {
+			const data = JSON.stringify(entry.data);
+			parts.push(this.colorize(data, "blue"));
+		}
+		return parts.join(" ");
+	}
+	getLevelColor(level) {
+		return {
+			error: "red",
+			warn: "yellow",
+			warning: "yellow",
+			info: "green",
+			debug: "blue",
+			trace: "magenta",
+			verbose: "cyan"
+		}[level.toLowerCase()] || "white";
+	}
+	colorize(text, color) {
+		if (this.config.colorize === false) return text;
+		const reset = ConsoleTransport.COLORS.get("reset");
+		return `${ConsoleTransport.COLORS.get(color) ?? ConsoleTransport.COLORS.get("white")}${text}${reset}`;
+	}
+	close() {
+		return Promise.resolve();
+	}
+};
+
+//#endregion
+//#region src/transports/database.transport.ts
+var DatabaseTransport = class {
+	constructor(config) {
+		this.config = config;
+		this.name = "database";
+		this.batch = [];
+		this.isConnected = false;
+		this.batchSize = config.batchSize || 100;
+		this.flushInterval = config.flushInterval || 5e3;
+		this.setupFlushTimer();
+	}
+	async write(entry) {
+		if (!this.isConnected) await this.connect();
+		this.addToBatch(entry);
+		if (this.batch.length >= this.batchSize) await this.flush();
+	}
+	addToBatch(entry) {
+		this.batch.push(entry);
+	}
+	async flush() {
+		if (this.batch.length === 0) return;
+		const entriesToFlush = [...this.batch];
+		this.batch = [];
+		try {
+			switch (this.config.type) {
+				case "mongodb":
+					await this.flushToMongoDB(entriesToFlush);
+					break;
+				case "postgresql":
+					await this.flushToPostgreSQL(entriesToFlush);
+					break;
+				case "mysql":
+					await this.flushToMySQL(entriesToFlush);
+					break;
+				case "sqlite":
+					await this.flushToSQLite(entriesToFlush);
+					break;
+				default: throw new Error(`Unsupported database type: ${this.config.type}`);
+			}
+		} catch (error) {
+			internalError("Database flush error", error);
+			this.batch.unshift(...entriesToFlush);
+			throw error;
+		}
+	}
+	async isReady() {
+		try {
+			if (!this.isConnected) await this.connect();
+			return this.isConnected;
+		} catch {
+			return false;
+		}
+	}
+	async connect() {
+		if (this.connectionPromise) return this.connectionPromise;
+		this.connectionPromise = this.establishConnection();
+		return this.connectionPromise;
+	}
+	async establishConnection() {
+		try {
+			switch (this.config.type) {
+				case "mongodb":
+					await this.connectMongoDB();
+					break;
+				case "postgresql":
+					await this.connectPostgreSQL();
+					break;
+				case "mysql":
+					await this.connectMySQL();
+					break;
+				case "sqlite":
+					await this.connectSQLite();
+					break;
+			}
+			this.isConnected = true;
+		} catch (error) {
+			this.isConnected = false;
+			throw new Error(`Database connection failed: ${error}`, { cause: error });
+		}
+	}
+	async connectMongoDB() {
+		try {
+			const { MongoClient } = await Promise.resolve().then(() => require_chunk.__toDynamicImportESM()(require("./lib-BNEYXXTQ.js"))).catch(() => {
+				throw new Error("MongoDB driver not installed. Run: npm install mongodb");
+			});
+			this.connection = new MongoClient(this.config.connectionString || `mongodb://${this.config.host}:${this.config.port}/${this.config.database}`);
+			await this.connection.connect();
+			await this.connection.db(this.config.database).admin().ping();
+		} catch (error) {
+			throw new Error(`MongoDB connection failed: ${error}`, { cause: error });
+		}
+	}
+	async connectPostgreSQL() {
+		try {
+			const { Client } = await Promise.resolve().then(() => require("./esm-FNhqFIqG.js")).catch(() => {
+				throw new Error("PostgreSQL driver not installed. Run: npm install pg @types/pg");
+			});
+			const config = {
+				connectionString: this.config.connectionString,
+				host: this.config.host,
+				port: this.config.port,
+				database: this.config.database
+			};
+			if (this.config.username) config.user = this.config.username;
+			if (this.config.password) config.password = this.config.password;
+			if (this.config.ssl) config.ssl = typeof this.config.ssl === "boolean" ? {} : this.config.ssl;
+			this.connection = new Client(config);
+			await this.connection.connect();
+			await this.createPostgreSQLTable();
+		} catch (error) {
+			throw new Error(`PostgreSQL connection failed: ${error}`, { cause: error });
+		}
+	}
+	async connectMySQL() {
+		try {
+			const mysql = await Promise.resolve().then(() => require_chunk.__toDynamicImportESM()(require("./promise-DaiZ2BaH.js"))).catch(() => {
+				throw new Error("MySQL driver not installed. Run: npm install mysql2");
+			});
+			const config = {
+				host: this.config.host,
+				port: this.config.port,
+				database: this.config.database
+			};
+			if (this.config.username) config.user = this.config.username;
+			if (this.config.password) config.password = this.config.password;
+			if (this.config.ssl) config.ssl = typeof this.config.ssl === "boolean" ? {} : this.config.ssl;
+			this.connection = await mysql.createConnection(config);
+			await this.createMySQLTable();
+		} catch (error) {
+			throw new Error(`MySQL connection failed: ${error}`, { cause: error });
+		}
+	}
+	async connectSQLite() {
+		try {
+			const sqlite3 = await Promise.resolve().then(() => require_chunk.__toDynamicImportESM()(require("./sqlite3-CSkpjC90.js"))).catch(() => {
+				throw new Error("SQLite driver not installed. Run: npm install sqlite3 sqlite");
+			});
+			const { open } = await Promise.resolve().then(() => require("./build-DOx-YxF1.js")).catch(() => {
+				throw new Error("SQLite driver not installed. Run: npm install sqlite3 sqlite");
+			});
+			this.connection = await open({
+				filename: this.config.database,
+				driver: sqlite3.Database
+			});
+			await this.createSQLiteTable();
+		} catch (error) {
+			throw new Error(`SQLite connection failed: ${error}`, { cause: error });
+		}
+	}
+	async flushToMongoDB(entries) {
+		const collection = this.connection.db(this.config.database).collection(this.config.collection || "logs");
+		const documents = entries.map((entry) => ({
+			timestamp: entry.timestamp,
+			level: entry.level,
+			message: entry.message,
+			payload: entry.data,
+			context: entry.context,
+			traceId: entry.traceId,
+			appName: entry.appName,
+			environment: entry.environment
+		}));
+		await collection.insertMany(documents);
+	}
+	async flushToPostgreSQL(entries) {
+		const tableName = this.config.table || "logs";
+		const values = entries.map((entry) => [
+			entry.timestamp,
+			entry.level,
+			entry.message,
+			JSON.stringify(entry.data || {}),
+			entry.context,
+			entry.traceId,
+			entry.appName,
+			entry.environment
+		]);
+		const query = `
+      INSERT INTO ${tableName} 
+      (timestamp, level, message, payload, context, trace_id, app_name, environment)
+      VALUES ${values.map((_, i) => `($${i * 9 + 1}, $${i * 9 + 2}, $${i * 9 + 3}, $${i * 9 + 4}, $${i * 9 + 5}, $${i * 9 + 6}, $${i * 9 + 7}, $${i * 9 + 8}, $${i * 9 + 9})`).join(", ")}
+    `;
+		await this.connection.query(query, values.flat());
+	}
+	async flushToMySQL(entries) {
+		const tableName = this.config.table || "logs";
+		const values = entries.map((entry) => [
+			entry.timestamp,
+			entry.level,
+			entry.message,
+			JSON.stringify(entry.data || {}),
+			entry.context,
+			entry.traceId,
+			entry.appName,
+			entry.environment
+		]);
+		const query = `
+      INSERT INTO ${tableName} 
+      (timestamp, level, message, payload, context, trace_id, app_name, environment)
+      VALUES ?
+    `;
+		await this.connection.query(query, [values]);
+	}
+	async flushToSQLite(entries) {
+		const tableName = this.config.table || "logs";
+		const stmt = await this.connection.prepare(`
+      INSERT INTO ${tableName} 
+      (timestamp, level, message, payload, context, trace_id, app_name, environment)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+		for (const entry of entries) await stmt.run(entry.timestamp instanceof Date ? entry.timestamp.toISOString() : entry.timestamp, entry.level, entry.message, JSON.stringify(entry.data || {}), entry.context, entry.traceId, entry.appName, entry.environment);
+		await stmt.finalize();
+	}
+	async createPostgreSQLTable() {
+		const tableName = this.config.table || "logs";
+		const query = `
+      CREATE TABLE IF NOT EXISTS ${tableName} (
+        id SERIAL PRIMARY KEY,
+        timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        level VARCHAR(20) NOT NULL,
+        message TEXT NOT NULL,
+        payload JSONB,
+        context VARCHAR(255),
+        trace_id VARCHAR(255),
+        app_name VARCHAR(255),
+        environment VARCHAR(50),
+        time_taken INTEGER,
+        created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+		await this.connection.query(query);
+		await this.connection.query(`CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName} (timestamp)`);
+		await this.connection.query(`CREATE INDEX IF NOT EXISTS idx_${tableName}_level ON ${tableName} (level)`);
+		await this.connection.query(`CREATE INDEX IF NOT EXISTS idx_${tableName}_trace_id ON ${tableName} (trace_id)`);
+	}
+	async createMySQLTable() {
+		const query = `
+      CREATE TABLE IF NOT EXISTS ${this.config.table || "logs"} (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        timestamp DATETIME NOT NULL,
+        level VARCHAR(20) NOT NULL,
+        message TEXT NOT NULL,
+        payload JSON,
+        context VARCHAR(255),
+        trace_id VARCHAR(255),
+        app_name VARCHAR(255),
+        environment VARCHAR(50),
+        time_taken INT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        INDEX idx_timestamp (timestamp),
+        INDEX idx_level (level),
+        INDEX idx_trace_id (trace_id)
+      )
+    `;
+		await this.connection.execute(query);
+	}
+	async createSQLiteTable() {
+		const tableName = this.config.table || "logs";
+		const query = `
+      CREATE TABLE IF NOT EXISTS ${tableName} (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp TEXT NOT NULL,
+        level TEXT NOT NULL,
+        message TEXT NOT NULL,
+        payload TEXT,
+        context TEXT,
+        trace_id TEXT,
+        app_name TEXT,
+        environment TEXT,
+        time_taken INTEGER,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+		await this.connection.exec(query);
+		await this.connection.exec(`CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName} (timestamp)`);
+		await this.connection.exec(`CREATE INDEX IF NOT EXISTS idx_${tableName}_level ON ${tableName} (level)`);
+		await this.connection.exec(`CREATE INDEX IF NOT EXISTS idx_${tableName}_trace_id ON ${tableName} (trace_id)`);
+	}
+	setupFlushTimer() {
+		this.flushTimer = setInterval(() => {
+			this.flush().catch((error) => {
+				internalError("Scheduled database flush error", error);
+			});
+		}, this.flushInterval);
+	}
+	async close() {
+		if (this.flushTimer) clearInterval(this.flushTimer);
+		await this.flush();
+		if (this.connection) switch (this.config.type) {
+			case "mongodb":
+				await this.connection.close();
+				break;
+			case "postgresql":
+				await this.connection.end();
+				break;
+			case "mysql":
+				await this.connection.end();
+				break;
+			case "sqlite":
+				await this.connection.close();
+				break;
+		}
+		this.isConnected = false;
+	}
+	getBatchInfo() {
+		return {
+			batchSize: this.batchSize,
+			currentBatchLength: this.batch.length,
+			flushInterval: this.flushInterval,
+			isConnected: this.isConnected
+		};
+	}
+	async getLogCount() {
+		if (!this.isConnected) return 0;
+		try {
+			switch (this.config.type) {
+				case "mongodb": return await this.connection.db(this.config.database).collection(this.config.collection || "logs").countDocuments();
+				case "postgresql":
+				case "mysql":
+				case "sqlite": {
+					var _result$rows, _result$;
+					const tableName = this.config.table || "logs";
+					const result = await this.connection.query(`SELECT COUNT(*) as count FROM ${tableName}`);
+					return ((_result$rows = result.rows) === null || _result$rows === void 0 || (_result$rows = _result$rows[0]) === null || _result$rows === void 0 ? void 0 : _result$rows.count) || ((_result$ = result[0]) === null || _result$ === void 0 ? void 0 : _result$.count) || 0;
+				}
+				default: return 0;
+			}
+		} catch {
+			return 0;
+		}
+	}
+};
+
+//#endregion
+//#region src/transports/analytics.transport.ts
+var AnalyticsTransport = class {
+	constructor(name, config) {
+		this.batch = [];
+		this.isReady = false;
+		this.name = name;
+		this.config = {
+			batchSize: 50,
+			flushInterval: 1e4,
+			enableUserTracking: true,
+			enableEventTracking: true,
+			...config
+		};
+		this.level = config.level;
+		this.batchSize = this.config.batchSize || 50;
+		this.flushInterval = this.config.flushInterval || 1e4;
+		this.initialize();
+	}
+	async write(entry) {
+		if (!this.isReady) await this.waitForReady();
+		if (this.shouldSkipEntry(entry)) return;
+		if (this.config.batchSize && this.config.batchSize > 1) this.addToBatch(entry);
+		else await this.sendEntry(entry);
+	}
+	addToBatch(entry) {
+		this.batch.push(entry);
+		if (this.batch.length >= (this.config.batchSize || 50)) this.flush().catch((err) => internalError(`${this.name} batch flush failed`, err));
+		else if (!this.batchTimer && this.config.flushInterval) this.batchTimer = setTimeout(() => {
+			this.flush().catch((err) => internalError(`${this.name} interval flush failed`, err));
+		}, this.config.flushInterval);
+	}
+	async flush() {
+		if (this.batch.length === 0) return;
+		const entriesToSend = [...this.batch];
+		this.batch = [];
+		if (this.batchTimer) {
+			clearTimeout(this.batchTimer);
+			delete this.batchTimer;
+		}
+		try {
+			await this.sendBatch(entriesToSend);
+		} catch (error) {
+			internalError(`Analytics transport ${this.name} flush failed`, error);
+			this.batch.unshift(...entriesToSend);
+		}
+	}
+	async close() {
+		await this.flush();
+		if (this.batchTimer) clearTimeout(this.batchTimer);
+		await this.cleanup();
+	}
+	shouldSkipEntry(entry) {
+		return ["debug", "trace"].includes(entry.level.toLowerCase());
+	}
+	transformEntry(entry) {
+		const transformed = {
+			timestamp: entry.timestamp.toISOString(),
+			level: entry.level,
+			message: entry.message,
+			...entry.data
+		};
+		if (entry.context) transformed.context = entry.context;
+		if (entry.traceId) transformed.traceId = entry.traceId;
+		if (entry.appName) transformed.appName = entry.appName;
+		if (entry.environment) transformed.environment = entry.environment;
+		if (this.config.customProperties) Object.assign(transformed, this.config.customProperties);
+		return transformed;
+	}
+	async waitForReady(timeout = 5e3) {
+		const startTime = Date.now();
+		while (!this.isReady && Date.now() - startTime < timeout) await new Promise((resolve) => setTimeout(resolve, 100));
+		if (!this.isReady) throw new Error(`Analytics transport ${this.name} failed to initialize within ${timeout}ms`);
+	}
+};
+
+//#endregion
+//#region src/transports/datadog.transport.ts
+var DataDogTransport = class extends AnalyticsTransport {
+	constructor(config) {
+		super("datadog", config);
+		this.datadogConfig = config;
+		const site = config.site || "datadoghq.com";
+		this.baseUrl = `https://api.${site}`;
+		this.logsUrl = `https://http-intake.logs.${site}`;
+		this.metricsUrl = `https://api.${site}`;
+	}
+	async initialize() {
+		try {
+			if (!this.datadogConfig.apiKey) throw new Error("DataDog API key is required");
+			await this.testConnection();
+			this.isReady = true;
+		} catch (error) {
+			internalError("DataDog transport initialization failed", error);
+			throw error;
+		}
+	}
+	async sendEntry(entry) {
+		const promises = [];
+		if (this.datadogConfig.enableLogs !== false) promises.push(this.sendLog(entry));
+		if (this.datadogConfig.enableMetrics) promises.push(this.sendMetric(entry));
+		if (this.datadogConfig.enableTraces && entry.traceId) promises.push(this.sendTrace(entry));
+		await Promise.all(promises);
+	}
+	async sendBatch(entries) {
+		const promises = [];
+		if (this.datadogConfig.enableLogs !== false) promises.push(this.sendLogBatch(entries));
+		if (this.datadogConfig.enableMetrics) promises.push(this.sendMetricBatch(entries));
+		if (this.datadogConfig.enableTraces) {
+			const entriesWithTraces = entries.filter((e) => e.traceId);
+			if (entriesWithTraces.length > 0) promises.push(this.sendTraceBatch(entriesWithTraces));
+		}
+		await Promise.all(promises);
+	}
+	async cleanup() {}
+	async sendLog(entry) {
+		await this.sendLogBatch([entry]);
+	}
+	async sendLogBatch(entries) {
+		const payload = { logs: entries.map((entry) => this.transformToDataDogLog(entry)) };
+		await this.makeLogsRequest("/v1/input/" + this.datadogConfig.apiKey, payload);
+	}
+	async sendMetric(entry) {
+		await this.sendMetricBatch([entry]);
+	}
+	async sendMetricBatch(entries) {
+		const payload = { series: entries.map((entry) => this.transformToDataDogMetric(entry)) };
+		await this.makeMetricsRequest("/api/v1/series", payload);
+	}
+	async sendTrace(entry) {
+		await this.sendLog(entry);
+	}
+	async sendTraceBatch(entries) {
+		await this.sendLogBatch(entries);
+	}
+	transformToDataDogLog(entry) {
+		const transformed = this.transformEntry(entry);
+		return {
+			timestamp: entry.timestamp.toISOString(),
+			level: this.mapLogLevel(entry.level),
+			message: entry.message,
+			service: this.datadogConfig.service || "logitron",
+			version: this.datadogConfig.version,
+			env: this.datadogConfig.env || "production",
+			logger: {
+				name: "logitron",
+				thread_name: "main"
+			},
+			...transformed,
+			"dd.trace_id": entry.traceId,
+			"dd.span_id": this.generateSpanId(),
+			host: this.getHostname(),
+			source: "nodejs"
+		};
+	}
+	transformToDataDogMetric(entry) {
+		return {
+			metric: `logitron.logs.${entry.level}`,
+			points: [[Math.floor(entry.timestamp.getTime() / 1e3), 1]],
+			type: "count",
+			host: this.getHostname(),
+			tags: [
+				`level:${entry.level}`,
+				`service:${this.datadogConfig.service || "logitron"}`,
+				`env:${this.datadogConfig.env || "production"}`,
+				...entry.context ? [`context:${entry.context}`] : [],
+				...entry.appName ? [`app:${entry.appName}`] : []
+			]
+		};
+	}
+	transformToDataDogTrace(entry) {
+		return {
+			trace_id: entry.traceId,
+			span_id: this.generateSpanId(),
+			parent_id: null,
+			name: "log.entry",
+			service: this.datadogConfig.service || "logitron",
+			resource: entry.message,
+			type: "log",
+			start: entry.timestamp.getTime() * 1e6,
+			duration: 1e6,
+			meta: {
+				"log.level": entry.level,
+				"log.message": entry.message,
+				...entry.context && { "log.context": entry.context },
+				...entry.data && Object.keys(entry.data).reduce((acc, key) => {
+					acc[`log.${key}`] = String(entry.data[key]);
+					return acc;
+				}, {})
+			},
+			metrics: { _sampling_priority_v1: 1 }
+		};
+	}
+	mapLogLevel(level) {
+		return {
+			error: "error",
+			warn: "warn",
+			warning: "warn",
+			info: "info",
+			debug: "debug",
+			trace: "trace",
+			verbose: "debug"
+		}[level.toLowerCase()] || "info";
+	}
+	async makeLogsRequest(endpoint, data) {
+		const url = `${this.logsUrl}${endpoint}`;
+		try {
+			const response = await fetch(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"DD-API-KEY": this.datadogConfig.apiKey
+				},
+				body: JSON.stringify(data)
+			});
+			if (!response.ok) throw new Error(`DataDog Logs API error: ${response.status} ${response.statusText}`);
+		} catch (error) {
+			throw new Error(`Failed to send logs to DataDog: ${error.message}`, { cause: error });
+		}
+	}
+	async makeMetricsRequest(endpoint, data) {
+		const url = `${this.metricsUrl}${endpoint}`;
+		try {
+			const response = await fetch(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"DD-API-KEY": this.datadogConfig.apiKey
+				},
+				body: JSON.stringify(data)
+			});
+			if (!response.ok) throw new Error(`DataDog Metrics API error: ${response.status} ${response.statusText}`);
+		} catch (error) {
+			throw new Error(`Failed to send metrics to DataDog: ${error.message}`, { cause: error });
+		}
+	}
+	async testConnection() {
+		const testMetric = { series: [{
+			metric: "logitron.test",
+			points: [[Math.floor(Date.now() / 1e3), 1]],
+			type: "count",
+			host: this.getHostname(),
+			tags: ["test:true"]
+		}] };
+		await this.makeMetricsRequest("/api/v1/series", testMetric);
+	}
+	generateSpanId() {
+		return Math.floor(Math.random() * 0xffffffffffff).toString(16);
+	}
+	getHostname() {
+		try {
+			return require("node:os").hostname();
+		} catch {
+			return "unknown";
+		}
+	}
+	async sendCustomMetric(metric) {
+		const payload = { series: [{
+			metric: metric.name,
+			points: [[Math.floor((metric.timestamp || /* @__PURE__ */ new Date()).getTime() / 1e3), metric.value]],
+			type: "gauge",
+			host: this.getHostname(),
+			tags: Object.entries(metric.tags || {}).map(([key, value]) => `${key}:${value}`)
+		}] };
+		await this.makeMetricsRequest("/api/v1/series", payload);
+	}
+	async sendEvent(title, text, tags = []) {
+		const payload = {
+			title,
+			text,
+			date_happened: Math.floor(Date.now() / 1e3),
+			priority: "normal",
+			tags: [
+				`service:${this.datadogConfig.service || "logitron"}`,
+				`env:${this.datadogConfig.env || "production"}`,
+				...tags
+			],
+			source_type_name: "logitron"
+		};
+		const url = `${this.baseUrl}/api/v1/events`;
+		try {
+			const response = await fetch(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"DD-API-KEY": this.datadogConfig.apiKey
+				},
+				body: JSON.stringify(payload)
+			});
+			if (!response.ok) throw new Error(`DataDog Events API error: ${response.status} ${response.statusText}`);
+		} catch (error) {
+			throw new Error(`Failed to send event to DataDog: ${error.message}`, { cause: error });
+		}
+	}
+};
+
+//#endregion
+//#region src/transports/file.transport.ts
+const writeFile = (0, node_util.promisify)(node_fs.writeFile);
+const mkdir = (0, node_util.promisify)(node_fs.mkdir);
+const unlink = (0, node_util.promisify)(node_fs.unlink);
+const readdir = (0, node_util.promisify)(node_fs.readdir);
+const stat = (0, node_util.promisify)(node_fs.stat);
+var FileTransport = class {
+	constructor(config) {
+		this.name = "file";
+		this.batch = [];
+		this.lastRotation = /* @__PURE__ */ new Date();
+		this.config = {
+			format: "json",
+			batchSize: 100,
+			flushInterval: 5e3,
+			...config
+		};
+		this.level = config.level;
+		this.batchSize = this.config.batchSize || 100;
+		this.flushInterval = this.config.flushInterval || 5e3;
+		this.currentFilePath = this.generateFilePath();
+		this.ensureDirectoryExists();
+	}
+	async write(entry) {
+		try {
+			if (this.shouldRotateNow()) await this.rotate();
+			if (this.config.batchSize && this.config.batchSize > 1) this.addToBatch(entry);
+			else await this.writeBatch([entry]);
+		} catch (error) {
+			throw new Error(`File transport write failed: ${error.message}`, { cause: error });
+		}
+	}
+	async flush() {
+		if (this.batch.length > 0) {
+			await this.writeBatch([...this.batch]);
+			this.batch = [];
+		}
+		if (this.batchTimer) {
+			clearTimeout(this.batchTimer);
+			this.batchTimer = void 0;
+		}
+	}
+	formatEntry(entry) {
+		switch (this.config.format) {
+			case "json": return JSON.stringify({
+				timestamp: entry.timestamp.toISOString(),
+				level: entry.level,
+				message: entry.message,
+				...entry.data || {}
+			});
+			case "csv": return [
+				entry.timestamp.toISOString(),
+				entry.level,
+				`"${entry.message.replace(/"/g, "\"\"")}"`,
+				entry.context || "",
+				entry.traceId || "",
+				JSON.stringify(entry.data || {})
+			].join(",");
+			case "text":
+			default: return `${entry.timestamp.toISOString()} [${entry.level.toUpperCase()}] ${entry.message}${entry.data ? " " + JSON.stringify(entry.data) : ""}`;
+		}
+	}
+	addToBatch(entry) {
+		this.batch.push(entry);
+		if (this.batch.length >= (this.config.batchSize || 100)) this.flush().catch((err) => internalError("FileTransport batch flush failed", err));
+		else if (!this.batchTimer && this.config.flushInterval) this.batchTimer = setTimeout(() => {
+			this.flush().catch((err) => internalError("FileTransport interval flush failed", err));
+		}, this.config.flushInterval);
+	}
+	async writeBatch(entries) {
+		if (entries.length === 0) return;
+		const content = entries.map((entry) => this.formatEntry(entry)).join("\n") + "\n";
+		if (this.writeStream) return new Promise((resolve, reject) => {
+			this.writeStream.write(content, (error) => {
+				if (error) reject(error);
+				else resolve();
+			});
+		});
+		else await writeFile(this.currentFilePath, content, { flag: "a" });
+	}
+	shouldRotateNow() {
+		if (!this.config.rotation) return false;
+		return (/* @__PURE__ */ new Date()).getTime() - this.lastRotation.getTime() >= this.parseInterval(this.config.rotation.interval);
+	}
+	parseInterval(interval) {
+		const match = interval.match(/(\d+)([hdwmy])/i);
+		if (!match) return 1440 * 60 * 1e3;
+		const value = Number.parseInt(match[1] || "1", 10);
+		switch ((match[2] || "h").toLowerCase()) {
+			case "h": return value * 60 * 60 * 1e3;
+			case "d": return value * 24 * 60 * 60 * 1e3;
+			case "w": return value * 7 * 24 * 60 * 60 * 1e3;
+			case "m": return value * 30 * 24 * 60 * 60 * 1e3;
+			case "y": return value * 365 * 24 * 60 * 60 * 1e3;
+			default: return value * 60 * 60 * 1e3;
+		}
+	}
+	async rotate() {
+		var _this$config$rotation, _this$config$rotation2;
+		await this.flush();
+		if (this.writeStream) {
+			await new Promise((resolve) => {
+				this.writeStream.end(() => resolve());
+			});
+			this.writeStream = void 0;
+		}
+		const oldPath = this.currentFilePath;
+		this.currentFilePath = this.generateFilePath();
+		this.lastRotation = /* @__PURE__ */ new Date();
+		if ((_this$config$rotation = this.config.rotation) === null || _this$config$rotation === void 0 ? void 0 : _this$config$rotation.compress) await this.compressFile(oldPath);
+		if ((_this$config$rotation2 = this.config.rotation) === null || _this$config$rotation2 === void 0 ? void 0 : _this$config$rotation2.maxFiles) await this.cleanupOldFiles();
+	}
+	generateFilePath() {
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+		const dir = node_path.dirname(this.config.filename);
+		const ext = node_path.extname(this.config.filename);
+		const base = node_path.basename(this.config.filename, ext);
+		if (this.config.rotation) return node_path.join(dir, `${base}-${timestamp}${ext}`);
+		return this.config.filename;
+	}
+	async ensureDirectoryExists() {
+		const dir = node_path.dirname(this.currentFilePath);
+		try {
+			await mkdir(dir, { recursive: true });
+		} catch {}
+	}
+	async compressFile(_filePath) {}
+	async cleanupOldFiles() {
+		var _this$config$rotation3;
+		if (!((_this$config$rotation3 = this.config.rotation) === null || _this$config$rotation3 === void 0 ? void 0 : _this$config$rotation3.maxFiles)) return;
+		try {
+			const dir = node_path.dirname(this.config.filename);
+			const files = await readdir(dir);
+			const base = node_path.basename(this.config.filename, node_path.extname(this.config.filename));
+			const logFiles = files.filter((file) => file.startsWith(base)).map(async (file) => {
+				const filePath = node_path.join(dir, file);
+				return {
+					path: filePath,
+					mtime: (await stat(filePath)).mtime
+				};
+			});
+			const filesToDelete = (await Promise.all(logFiles)).sort((a, b) => b.mtime.getTime() - a.mtime.getTime()).slice(this.config.rotation.maxFiles);
+			for (const file of filesToDelete) await unlink(file.path);
+		} catch (error) {
+			internalError("Failed to cleanup old log files", error);
+		}
+	}
+	async close() {
+		await this.flush();
+		if (this.writeStream) return new Promise((resolve) => {
+			this.writeStream.end(() => resolve());
+		});
+	}
+};
+
+//#endregion
+//#region src/transports/google-analytics.transport.ts
+var GoogleAnalyticsTransport = class extends AnalyticsTransport {
+	constructor(config) {
+		super("google-analytics", config);
+		this.baseUrl = "https://www.google-analytics.com/mp/collect";
+		this.debugUrl = "https://www.google-analytics.com/debug/mp/collect";
+		this.gaConfig = config;
+	}
+	async initialize() {
+		try {
+			if (!this.gaConfig.measurementId) throw new Error("Google Analytics Measurement ID is required");
+			if (!this.gaConfig.apiSecret) throw new Error("Google Analytics API Secret is required");
+			await this.testConnection();
+			this.isReady = true;
+		} catch (error) {
+			internalError("Google Analytics transport initialization failed", error);
+			throw error;
+		}
+	}
+	async sendEntry(entry) {
+		const event = this.transformToGAEvent(entry);
+		await this.sendEvent(event);
+	}
+	async sendBatch(entries) {
+		const events = entries.map((entry) => this.transformToGAEvent(entry));
+		await this.sendEvents(events);
+	}
+	async cleanup() {}
+	transformToGAEvent(entry) {
+		const transformed = this.transformEntry(entry);
+		return {
+			name: "log_event",
+			params: {
+				event_category: this.mapLogLevelToCategory(entry.level),
+				event_label: entry.message,
+				log_level: entry.level,
+				log_message: entry.message,
+				timestamp: entry.timestamp.toISOString(),
+				...entry.context && { context: entry.context },
+				...entry.traceId && { trace_id: entry.traceId },
+				...entry.appName && { app_name: entry.appName },
+				...entry.environment && { environment: entry.environment },
+				...this.flattenData(transformed),
+				custom_dimension_1: entry.level,
+				custom_dimension_2: entry.context || "default",
+				custom_dimension_3: entry.environment || "production"
+			}
+		};
+	}
+	mapLogLevelToCategory(level) {
+		return {
+			error: "Error",
+			warn: "Warning",
+			warning: "Warning",
+			info: "Information",
+			debug: "Debug",
+			trace: "Trace",
+			verbose: "Verbose"
+		}[level.toLowerCase()] || "Information";
+	}
+	flattenData(data, prefix = "") {
+		const flattened = {};
+		for (const [key, value] of Object.entries(data)) {
+			const newKey = prefix ? `${prefix}_${key}` : key;
+			if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) Object.assign(flattened, this.flattenData(value, newKey));
+			else {
+				const stringValue = String(value);
+				flattened[newKey] = stringValue.length > 100 ? stringValue.slice(0, 100) : stringValue;
+			}
+		}
+		return flattened;
+	}
+	async sendEvent(event) {
+		const payload = {
+			client_id: this.gaConfig.clientId || this.generateClientId(),
+			events: [event]
+		};
+		await this.makeRequest(payload);
+	}
+	async sendEvents(events) {
+		const chunks = this.chunkArray(events, 25);
+		for (const chunk of chunks) {
+			const payload = {
+				client_id: this.gaConfig.clientId || this.generateClientId(),
+				events: chunk
+			};
+			await this.makeRequest(payload);
+		}
+	}
+	async makeRequest(payload, debug = false) {
+		const url = debug ? this.debugUrl : this.baseUrl;
+		const params = new URLSearchParams({
+			measurement_id: this.gaConfig.measurementId,
+			api_secret: this.gaConfig.apiSecret
+		});
+		try {
+			const response = await fetch(`${url}?${params}`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(payload)
+			});
+			if (!response.ok) {
+				const errorText = await response.text();
+				throw new Error(`Google Analytics API error: ${response.status} ${response.statusText} - ${errorText}`);
+			}
+			if (debug) {
+				const result = await response.json();
+				internalLog(`GA4 Debug Response: ${JSON.stringify(result)}`);
+			}
+		} catch (error) {
+			throw new Error(`Failed to send data to Google Analytics: ${error.message}`, { cause: error });
+		}
+	}
+	async testConnection() {
+		const testEvent = {
+			name: "logitron_test",
+			params: {
+				event_category: "Test",
+				event_label: "Connection Test",
+				test: true,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		};
+		const payload = {
+			client_id: this.gaConfig.clientId || this.generateClientId(),
+			events: [testEvent]
+		};
+		await this.makeRequest(payload, true);
+	}
+	generateClientId() {
+		return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+			const r = Math.random() * 16 | 0;
+			return (c === "x" ? r : r & 3 | 8).toString(16);
+		});
+	}
+	chunkArray(array, size) {
+		const chunks = [];
+		for (let i = 0; i < array.length; i += size) chunks.push(array.slice(i, i + size));
+		return chunks;
+	}
+	async trackPageView(pagePath, pageTitle) {
+		const event = {
+			name: "page_view",
+			params: {
+				page_location: pagePath,
+				page_title: pageTitle || pagePath,
+				engagement_time_msec: 1
+			}
+		};
+		await this.sendEvent(event);
+	}
+	async trackCustomEvent(eventName, parameters = {}) {
+		const event = {
+			name: eventName.toLowerCase().replace(/[^a-z0-9_]/g, "_"),
+			params: {
+				...this.flattenData(parameters),
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		};
+		await this.sendEvent(event);
+	}
+	async trackConversion(conversionName, value, currency) {
+		const event = {
+			name: conversionName,
+			params: {
+				...value !== void 0 && { value },
+				...currency && { currency },
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		};
+		await this.sendEvent(event);
+	}
+	async trackError(errorMessage, errorCode, fatal = false) {
+		const event = {
+			name: "exception",
+			params: {
+				description: errorMessage,
+				fatal,
+				...errorCode && { error_code: errorCode },
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		};
+		await this.sendEvent(event);
+	}
+	async setUserProperties(properties) {
+		const event = {
+			name: "user_properties_update",
+			params: {
+				...this.flattenData(properties),
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		};
+		await this.sendEvent(event);
+	}
+	async trackFileDownload(fileName, fileExtension) {
+		if (!this.gaConfig.enableEnhancedMeasurement) return;
+		const event = {
+			name: "file_download",
+			params: {
+				file_name: fileName,
+				file_extension: fileExtension,
+				link_url: fileName,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		};
+		await this.sendEvent(event);
+	}
+	async trackVideoEngagement(videoTitle, videoUrl, progress) {
+		if (!this.gaConfig.enableEnhancedMeasurement) return;
+		const event = {
+			name: "video_progress",
+			params: {
+				video_title: videoTitle,
+				video_url: videoUrl,
+				video_progress: progress,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		};
+		await this.sendEvent(event);
+	}
+};
+
+//#endregion
+//#region src/transports/mixpanel.transport.ts
+var MixpanelTransport = class extends AnalyticsTransport {
+	constructor(config) {
+		super("mixpanel", config);
+		this.baseUrl = "https://api.mixpanel.com";
+		this.mixpanelConfig = config;
+	}
+	async initialize() {
+		try {
+			if (!this.mixpanelConfig.token) throw new Error("Mixpanel token is required");
+			await this.testConnection();
+			this.isReady = true;
+		} catch (error) {
+			internalError("Mixpanel transport initialization failed", error);
+			throw error;
+		}
+	}
+	async sendEntry(entry) {
+		const event = this.transformToMixpanelEvent(entry);
+		await this.trackEvent(event);
+	}
+	async sendBatch(entries) {
+		const events = entries.map((entry) => this.transformToMixpanelEvent(entry));
+		await this.trackEvents(events);
+	}
+	async cleanup() {}
+	transformToMixpanelEvent(entry) {
+		const transformed = this.transformEntry(entry);
+		return {
+			name: `log_${entry.level}`,
+			properties: {
+				...transformed,
+				distinct_id: this.mixpanelConfig.distinct_id || "anonymous",
+				time: entry.timestamp.getTime(),
+				$insert_id: this.generateInsertId(entry),
+				...this.mixpanelConfig.enableSuperProperties ? this.mixpanelConfig.superProperties : {}
+			},
+			timestamp: entry.timestamp
+		};
+	}
+	async trackEvent(event) {
+		const payload = {
+			event: event.name,
+			properties: {
+				token: this.mixpanelConfig.token,
+				...event.properties
+			}
+		};
+		await this.makeRequest("/track", [payload]);
+	}
+	async trackEvents(events) {
+		const payload = events.map((event) => ({
+			event: event.name,
+			properties: {
+				token: this.mixpanelConfig.token,
+				...event.properties
+			}
+		}));
+		await this.makeRequest("/track", payload);
+	}
+	async makeRequest(endpoint, data) {
+		const url = `${this.mixpanelConfig.endpoint || this.baseUrl}${endpoint}`;
+		try {
+			const response = await fetch(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Accept: "text/plain"
+				},
+				body: JSON.stringify(data)
+			});
+			if (!response.ok) throw new Error(`Mixpanel API error: ${response.status} ${response.statusText}`);
+			const result = await response.text();
+			if (result !== "1") throw new Error(`Mixpanel API returned error: ${result}`);
+		} catch (error) {
+			throw new Error(`Failed to send data to Mixpanel: ${error.message}`, { cause: error });
+		}
+	}
+	async testConnection() {
+		const testEvent = {
+			event: "logitron_test",
+			properties: {
+				token: this.mixpanelConfig.token,
+				distinct_id: "test_user",
+				test: true,
+				time: Date.now()
+			}
+		};
+		await this.makeRequest("/track", [testEvent]);
+	}
+	generateInsertId(entry) {
+		return `${entry.timestamp.getTime()}_${this.simpleHash(entry.message + (entry.traceId || ""))}`;
+	}
+	simpleHash(str) {
+		let hash = 0;
+		for (let i = 0; i < str.length; i++) {
+			const char = str.charCodeAt(i);
+			hash = (hash << 5) - hash + char;
+			hash = hash & hash;
+		}
+		return Math.abs(hash).toString(36);
+	}
+	async identifyUser(user) {
+		if (!this.mixpanelConfig.enableUserTracking) return;
+		const payload = {
+			$token: this.mixpanelConfig.token,
+			$distinct_id: user.id,
+			$set: user.properties || {}
+		};
+		await this.makeRequest("/engage", [payload]);
+	}
+	async setUserProperties(userId, properties) {
+		if (!this.mixpanelConfig.enableUserTracking) return;
+		const payload = {
+			$token: this.mixpanelConfig.token,
+			$distinct_id: userId,
+			$set: properties
+		};
+		await this.makeRequest("/engage", [payload]);
+	}
+	async trackCustomEvent(eventName, properties = {}) {
+		if (!this.mixpanelConfig.enableEventTracking) return;
+		const payload = {
+			event: eventName,
+			properties: {
+				token: this.mixpanelConfig.token,
+				distinct_id: this.mixpanelConfig.distinct_id || "anonymous",
+				time: Date.now(),
+				...properties,
+				...this.mixpanelConfig.enableSuperProperties ? this.mixpanelConfig.superProperties : {}
+			}
+		};
+		await this.makeRequest("/track", [payload]);
+	}
+};
+
+//#endregion
+//#region src/transports/segment.transport.ts
+var SegmentTransport = class extends AnalyticsTransport {
+	constructor(config) {
+		super("segment", config);
+		this.segmentConfig = {
+			enableBatching: true,
+			maxBatchSize: 100,
+			flushAt: 20,
+			flushInterval: 1e4,
+			...config
+		};
+		this.baseUrl = config.dataPlaneUrl || "https://api.segment.io";
+	}
+	async initialize() {
+		try {
+			if (!this.segmentConfig.writeKey) throw new Error("Segment Write Key is required");
+			await this.testConnection();
+			this.isReady = true;
+		} catch (error) {
+			internalError("Segment transport initialization failed", error);
+			throw error;
+		}
+	}
+	async sendEntry(entry) {
+		const segmentEvent = this.transformToSegmentEvent(entry);
+		await this.track(segmentEvent);
+	}
+	async sendBatch(entries) {
+		if (!this.segmentConfig.enableBatching) {
+			for (const entry of entries) await this.sendEntry(entry);
+			return;
+		}
+		const segmentEvents = entries.map((entry) => this.transformToSegmentEvent(entry));
+		await this.batchTrack(segmentEvents);
+	}
+	async cleanup() {}
+	transformToSegmentEvent(entry) {
+		const transformed = this.transformEntry(entry);
+		return {
+			type: "track",
+			event: `Log ${entry.level.charAt(0).toUpperCase() + entry.level.slice(1)}`,
+			userId: this.extractUserId(entry),
+			anonymousId: this.generateAnonymousId(),
+			timestamp: entry.timestamp.toISOString(),
+			properties: {
+				level: entry.level,
+				message: entry.message,
+				logger: "logixia",
+				...transformed,
+				...entry.context && { context: entry.context },
+				...entry.traceId && { traceId: entry.traceId },
+				...entry.appName && { appName: entry.appName },
+				...entry.environment && { environment: entry.environment }
+			},
+			context: {
+				library: {
+					name: "logixia",
+					version: "1.0.0"
+				},
+				app: {
+					name: entry.appName || "unknown",
+					version: "1.0.0",
+					environment: entry.environment || "production"
+				},
+				...entry.traceId && { trace: { trace_id: entry.traceId } }
+			},
+			integrations: {
+				All: false,
+				"Segment.io": true
+			}
+		};
+	}
+	async track(event) {
+		await this.makeRequest("/v1/track", event);
+	}
+	async batchTrack(events) {
+		const chunks = this.chunkArray(events, this.segmentConfig.maxBatchSize || 100);
+		for (const chunk of chunks) {
+			const payload = { batch: chunk };
+			await this.makeRequest("/v1/batch", payload);
+		}
+	}
+	async makeRequest(endpoint, data) {
+		const url = `${this.baseUrl}${endpoint}`;
+		const auth = Buffer.from(`${this.segmentConfig.writeKey}:`).toString("base64");
+		try {
+			const response = await fetch(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Basic ${auth}`,
+					"User-Agent": "logixia/1.0.0"
+				},
+				body: JSON.stringify(data)
+			});
+			if (!response.ok) {
+				const errorText = await response.text();
+				throw new Error(`Segment API error: ${response.status} ${response.statusText} - ${errorText}`);
+			}
+		} catch (error) {
+			throw new Error(`Failed to send data to Segment: ${error.message}`, { cause: error });
+		}
+	}
+	async testConnection() {
+		const testEvent = {
+			type: "track",
+			event: "Logixia Test",
+			userId: "test-user",
+			anonymousId: this.generateAnonymousId(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			properties: {
+				test: true,
+				source: "logixia"
+			},
+			context: { library: {
+				name: "logixia",
+				version: "1.0.0"
+			} }
+		};
+		await this.makeRequest("/v1/track", testEvent);
+	}
+	extractUserId(entry) {
+		if (entry.data) {
+			const d = entry.data;
+			const id = d["userId"] ?? d["user_id"] ?? d["id"];
+			return typeof id === "string" ? id : void 0;
+		}
+	}
+	generateAnonymousId() {
+		return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+			const r = Math.random() * 16 | 0;
+			return (c === "x" ? r : r & 3 | 8).toString(16);
+		});
+	}
+	chunkArray(array, size) {
+		const chunks = [];
+		for (let i = 0; i < array.length; i += size) chunks.push(array.slice(i, i + size));
+		return chunks;
+	}
+	async identify(user) {
+		const payload = {
+			type: "identify",
+			userId: user.id,
+			anonymousId: this.generateAnonymousId(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			traits: {
+				...user.properties,
+				...user.traits
+			},
+			context: { library: {
+				name: "logitron",
+				version: "1.0.0"
+			} }
+		};
+		await this.makeRequest("/v1/identify", payload);
+	}
+	async page(name, properties = {}) {
+		const payload = {
+			type: "page",
+			name,
+			anonymousId: this.generateAnonymousId(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			properties: {
+				...properties,
+				url: properties.url || `/${name.toLowerCase().replace(/\s+/g, "-")}`,
+				title: properties.title || name
+			},
+			context: {
+				library: {
+					name: "logitron",
+					version: "1.0.0"
+				},
+				page: {
+					url: properties.url || `/${name.toLowerCase().replace(/\s+/g, "-")}`,
+					title: properties.title || name
+				}
+			}
+		};
+		await this.makeRequest("/v1/page", payload);
+	}
+	async screen(name, properties = {}) {
+		const payload = {
+			type: "screen",
+			name,
+			anonymousId: this.generateAnonymousId(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			properties: { ...properties },
+			context: {
+				library: {
+					name: "logitron",
+					version: "1.0.0"
+				},
+				screen: { name }
+			}
+		};
+		await this.makeRequest("/v1/screen", payload);
+	}
+	async group(groupId, traits = {}, userId) {
+		const payload = {
+			type: "group",
+			groupId,
+			userId,
+			anonymousId: this.generateAnonymousId(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			traits,
+			context: { library: {
+				name: "logitron",
+				version: "1.0.0"
+			} }
+		};
+		await this.makeRequest("/v1/group", payload);
+	}
+	async alias(userId, previousId) {
+		const payload = {
+			type: "alias",
+			userId,
+			previousId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			context: { library: {
+				name: "logitron",
+				version: "1.0.0"
+			} }
+		};
+		await this.makeRequest("/v1/alias", payload);
+	}
+	async trackCustomEvent(eventName, properties = {}, userId) {
+		const payload = {
+			type: "track",
+			event: eventName,
+			userId,
+			anonymousId: this.generateAnonymousId(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			properties,
+			context: { library: {
+				name: "logitron",
+				version: "1.0.0"
+			} }
+		};
+		await this.makeRequest("/v1/track", payload);
+	}
+	async trackPurchase(orderId, products, revenue, currency = "USD") {
+		const payload = {
+			type: "track",
+			event: "Order Completed",
+			anonymousId: this.generateAnonymousId(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			properties: {
+				orderId,
+				revenue,
+				currency,
+				products
+			},
+			context: { library: {
+				name: "logitron",
+				version: "1.0.0"
+			} }
+		};
+		await this.makeRequest("/v1/track", payload);
+	}
+	async trackProductViewed(product) {
+		const payload = {
+			type: "track",
+			event: "Product Viewed",
+			anonymousId: this.generateAnonymousId(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			properties: product,
+			context: { library: {
+				name: "logitron",
+				version: "1.0.0"
+			} }
+		};
+		await this.makeRequest("/v1/track", payload);
+	}
+};
+
+//#endregion
+//#region src/transports/transport.manager.ts
+var TransportManager = class extends node_events.EventEmitter {
+	constructor(config = {}) {
+		super();
+		this.transports = /* @__PURE__ */ new Map();
+		this.metrics = /* @__PURE__ */ new Map();
+		this.isShuttingDown = false;
+		this.transportLevelPreferences = /* @__PURE__ */ new Map();
+		this.promptForLevels = false;
+		this.setupTransports(config);
+	}
+	setupTransports(config) {
+		if (config.console) {
+			const consoleTransport = new ConsoleTransport(typeof config.console === "object" ? config.console : {});
+			this.addTransport(consoleTransport, "console");
+		}
+		if (config.file) {
+			const fileConfigs = Array.isArray(config.file) ? config.file : [config.file];
+			for (const [index, fileConfig] of fileConfigs.entries()) {
+				const fileTransport = new FileTransport(fileConfig);
+				this.addTransport(fileTransport, `file-${index}`);
+			}
+		}
+		if (config.database) {
+			const dbConfigs = Array.isArray(config.database) ? config.database : [config.database];
+			for (const [index, dbConfig] of dbConfigs.entries()) {
+				const dbTransport = new DatabaseTransport(dbConfig);
+				this.addTransport(dbTransport, `database-${index}`);
+			}
+		}
+		if (config.analytics) {
+			if (config.analytics.mixpanel) {
+				const mixpanelConfigs = Array.isArray(config.analytics.mixpanel) ? config.analytics.mixpanel : [config.analytics.mixpanel];
+				for (const [index, mixpanelConfig] of mixpanelConfigs.entries()) {
+					const mixpanelTransport = new MixpanelTransport(mixpanelConfig);
+					this.addTransport(mixpanelTransport, `mixpanel-${index}`);
+				}
+			}
+			if (config.analytics.datadog) {
+				const datadogConfigs = Array.isArray(config.analytics.datadog) ? config.analytics.datadog : [config.analytics.datadog];
+				for (const [index, datadogConfig] of datadogConfigs.entries()) {
+					const datadogTransport = new DataDogTransport(datadogConfig);
+					this.addTransport(datadogTransport, `datadog-${index}`);
+				}
+			}
+			if (config.analytics.googleAnalytics) {
+				const gaConfigs = Array.isArray(config.analytics.googleAnalytics) ? config.analytics.googleAnalytics : [config.analytics.googleAnalytics];
+				for (const [index, gaConfig] of gaConfigs.entries()) {
+					const gaTransport = new GoogleAnalyticsTransport(gaConfig);
+					this.addTransport(gaTransport, `google-analytics-${index}`);
+				}
+			}
+			if (config.analytics.segment) {
+				const segmentConfigs = Array.isArray(config.analytics.segment) ? config.analytics.segment : [config.analytics.segment];
+				for (const [index, segmentConfig] of segmentConfigs.entries()) {
+					const segmentTransport = new SegmentTransport(segmentConfig);
+					this.addTransport(segmentTransport, `segment-${index}`);
+				}
+			}
+		}
+		if (config.custom) for (const [index, transport] of config.custom.entries()) this.addTransport(transport, `custom-${index}`);
+	}
+	addTransport(transport, id) {
+		const transportId = id || `${transport.name}-${Date.now()}`;
+		this.transports.set(transportId, transport);
+		this.metrics.set(transportId, {
+			name: transportId,
+			type: this.getTransportType(transport),
+			logsWritten: 0,
+			errors: 0,
+			lastWrite: /* @__PURE__ */ new Date(),
+			averageWriteTime: 0
+		});
+		this.emit("transport:added", transportId, transport);
+	}
+	removeTransport(id) {
+		const transport = this.transports.get(id);
+		if (!transport) return false;
+		this.transports.delete(id);
+		this.metrics.delete(id);
+		if (transport.close) transport.close().catch((error) => {
+			this.emit("error", error, id);
+		});
+		this.emit("transport:removed", id);
+		return true;
+	}
+	async write(entry) {
+		const transportEntry = {
+			timestamp: new Date(entry.timestamp),
+			level: entry.level,
+			message: entry.message,
+			appName: entry.appName
+		};
+		if (entry.payload !== void 0) transportEntry.data = entry.payload;
+		if (entry.context !== void 0) transportEntry.context = entry.context;
+		if (entry.traceId !== void 0) transportEntry.traceId = entry.traceId;
+		if (entry.environment !== void 0) transportEntry.environment = entry.environment;
+		if (this.isShuttingDown) throw new Error("TransportManager is shutting down");
+		const writePromises = [];
+		for (const [id, transport] of this.transports) {
+			if (this.promptForLevels && !this.transportLevelPreferences.has(id)) await this.configureTransportLevels(id);
+			if (!this.shouldTransportHandle(transport, transportEntry.level, id)) continue;
+			const writePromise = this.writeToTransport(id, transport, transportEntry);
+			writePromises.push(writePromise);
+		}
+		const failures = (await Promise.allSettled(writePromises)).filter((result) => result.status === "rejected");
+		if (failures.length > 0) {
+			const errors = failures.map((failure) => failure.reason);
+			this.emit("error", /* @__PURE__ */ new Error(`Transport write failures: ${errors.join(", ")}`), "multiple");
+		}
+	}
+	async writeToTransport(id, transport, entry) {
+		const startTime = Date.now();
+		const metrics = this.metrics.get(id);
+		try {
+			await transport.write(entry);
+			const writeTime = Date.now() - startTime;
+			metrics.logsWritten++;
+			metrics.lastWrite = new Date(startTime);
+			metrics.averageWriteTime = (metrics.averageWriteTime + writeTime) / 2;
+			this.emit("log", entry);
+		} catch (error) {
+			metrics.errors++;
+			this.emit("error", error, id);
+			throw error;
+		}
+	}
+	shouldTransportHandle(transport, level, transportId) {
+		if (transportId && this.transportLevelPreferences.has(transportId)) return this.transportLevelPreferences.get(transportId).includes(level.toLowerCase());
+		if (!transport.level) return true;
+		const levels = [
+			"error",
+			"warn",
+			"info",
+			"debug",
+			"trace",
+			"verbose"
+		];
+		const transportLevelIndex = levels.indexOf(transport.level.toLowerCase());
+		const entryLevelIndex = levels.indexOf(level.toLowerCase());
+		if (transportLevelIndex === -1 || entryLevelIndex === -1) return true;
+		return entryLevelIndex <= transportLevelIndex;
+	}
+	getTransportType(transport) {
+		if (transport.name === "console") return "console";
+		if (transport.name === "file") return "file";
+		if (transport.name === "database") return "database";
+		if (transport.name === "mixpanel" || transport.name === "datadog" || transport.name === "google-analytics" || transport.name === "segment") return "analytics";
+		return "custom";
+	}
+	async waitForReady() {
+		const readyPromises = [];
+		for (const transport of this.transports.values()) if (this.isAsyncTransport(transport)) readyPromises.push(transport.isReady());
+		if (readyPromises.length > 0) await Promise.all(readyPromises);
+	}
+	async flush() {
+		const flushPromises = [];
+		for (const [id, transport] of this.transports) if (this.isBatchTransport(transport)) {
+			const flushPromise = transport.flush().catch((error) => {
+				this.emit("error", error, id);
+			});
+			flushPromises.push(flushPromise);
+		}
+		await Promise.allSettled(flushPromises);
+		this.emit("flush", "all", this.transports.size);
+	}
+	async close() {
+		this.isShuttingDown = true;
+		await this.flush();
+		const closePromises = [];
+		for (const [id, transport] of this.transports) if (transport.close) {
+			const closePromise = transport.close().catch((error) => {
+				this.emit("error", error, id);
+			});
+			closePromises.push(closePromise);
+		}
+		await Promise.allSettled(closePromises);
+		this.transports.clear();
+		this.metrics.clear();
+		this.removeAllListeners();
+	}
+	getTransports() {
+		return Array.from(this.transports.keys());
+	}
+	getTransport(id) {
+		return this.transports.get(id);
+	}
+	getMetrics() {
+		return Array.from(this.metrics.values());
+	}
+	getMetricsForTransport(id) {
+		return this.metrics.get(id);
+	}
+	isTransportReady(id) {
+		const transport = this.transports.get(id);
+		if (!transport) return Promise.resolve(false);
+		if (this.isAsyncTransport(transport)) return transport.isReady();
+		return Promise.resolve(true);
+	}
+	isAsyncTransport(transport) {
+		return "isReady" in transport && typeof transport.isReady === "function";
+	}
+	isBatchTransport(transport) {
+		return "flush" in transport && typeof transport.flush === "function";
+	}
+	onLog(callback) {
+		this.on("log", callback);
+	}
+	onError(callback) {
+		this.on("error", callback);
+	}
+	onFlush(callback) {
+		this.on("flush", callback);
+	}
+	onTransportAdded(callback) {
+		this.on("transport:added", callback);
+	}
+	onTransportRemoved(callback) {
+		this.on("transport:removed", callback);
+	}
+	async healthCheck() {
+		const details = {};
+		let healthy = true;
+		for (const [id] of this.transports) try {
+			const isReady = await this.isTransportReady(id);
+			details[id] = {
+				ready: isReady,
+				metrics: this.metrics.get(id)
+			};
+			if (!isReady) healthy = false;
+		} catch (error) {
+			details[id] = { error: error instanceof Error ? error.message : "Unknown error" };
+			healthy = false;
+		}
+		return {
+			healthy,
+			details
+		};
+	}
+	enableLevelPrompting() {
+		this.promptForLevels = true;
+		internalLog("Transport level prompting enabled");
+	}
+	disableLevelPrompting() {
+		this.promptForLevels = false;
+		internalLog("Transport level prompting disabled");
+	}
+	async promptUserForTransportLevels(transportId) {
+		const availableLevels = [
+			"error",
+			"warn",
+			"info",
+			"debug",
+			"trace",
+			"verbose"
+		];
+		return new Promise((resolve) => {
+			const rl = node_readline.createInterface({
+				input: process.stdin,
+				output: process.stdout
+			});
+			process.stdout.write(`\nConfigure log levels for transport '${transportId}'\n`);
+			process.stdout.write(`Available levels: ${availableLevels.join(", ")}\n`);
+			process.stdout.write("Enter levels separated by commas (e.g., error,warn,info) or \"all\" for all levels:\n");
+			rl.question("> ", (answer) => {
+				rl.close();
+				if (answer.toLowerCase().trim() === "all") resolve(availableLevels);
+				else {
+					const selectedLevels = answer.split(",").map((level) => level.trim().toLowerCase()).filter((level) => availableLevels.includes(level));
+					if (selectedLevels.length === 0) {
+						internalWarn("No valid levels selected, using all levels");
+						resolve(availableLevels);
+					} else {
+						internalLog(`Selected levels for ${transportId}: ${selectedLevels.join(", ")}`);
+						resolve(selectedLevels);
+					}
+				}
+			});
+		});
+	}
+	async configureTransportLevels(transportId) {
+		if (this.promptForLevels && !this.transportLevelPreferences.has(transportId)) {
+			const selectedLevels = await this.promptUserForTransportLevels(transportId);
+			this.transportLevelPreferences.set(transportId, selectedLevels);
+		}
+	}
+	setTransportLevels(transportId, levels) {
+		this.transportLevelPreferences.set(transportId, levels);
+		internalLog(`Transport '${transportId}' configured for levels: ${levels.join(", ")}`);
+	}
+	getTransportLevels(transportId) {
+		return this.transportLevelPreferences.get(transportId);
+	}
+	clearTransportLevelPreferences() {
+		this.transportLevelPreferences.clear();
+		internalLog("Transport level preferences cleared");
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'AnalyticsTransport', {
+  enumerable: true,
+  get: function () {
+    return AnalyticsTransport;
+  }
+});
+Object.defineProperty(exports, 'ConsoleTransport', {
+  enumerable: true,
+  get: function () {
+    return ConsoleTransport;
+  }
+});
+Object.defineProperty(exports, 'DataDogTransport', {
+  enumerable: true,
+  get: function () {
+    return DataDogTransport;
+  }
+});
+Object.defineProperty(exports, 'DatabaseTransport', {
+  enumerable: true,
+  get: function () {
+    return DatabaseTransport;
+  }
+});
+Object.defineProperty(exports, 'FileTransport', {
+  enumerable: true,
+  get: function () {
+    return FileTransport;
+  }
+});
+Object.defineProperty(exports, 'GoogleAnalyticsTransport', {
+  enumerable: true,
+  get: function () {
+    return GoogleAnalyticsTransport;
+  }
+});
+Object.defineProperty(exports, 'MixpanelTransport', {
+  enumerable: true,
+  get: function () {
+    return MixpanelTransport;
+  }
+});
+Object.defineProperty(exports, 'SegmentTransport', {
+  enumerable: true,
+  get: function () {
+    return SegmentTransport;
+  }
+});
+Object.defineProperty(exports, 'TransportManager', {
+  enumerable: true,
+  get: function () {
+    return TransportManager;
+  }
+});
+Object.defineProperty(exports, 'internalError', {
+  enumerable: true,
+  get: function () {
+    return internalError;
+  }
+});
+Object.defineProperty(exports, 'internalLog', {
+  enumerable: true,
+  get: function () {
+    return internalLog;
+  }
+});
+Object.defineProperty(exports, 'internalWarn', {
+  enumerable: true,
+  get: function () {
+    return internalWarn;
+  }
+});
+//# sourceMappingURL=transport.manager-C3Xr7Tvi.js.map