logixia 1.13.3 → 2.0.0

package/dist/{transport.manager-Crau3Rle.js → transport.manager-CXbKKdVE.js}

@@ -9,12 +9,12 @@ let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let node_events = require("node:events");
 node_events = require_chunk.__toESM(node_events);
-let node_stream_promises = require("node:stream/promises");
-node_stream_promises = require_chunk.__toESM(node_stream_promises);
 let node_util = require("node:util");
 node_util = require_chunk.__toESM(node_util);
 let node_zlib = require("node:zlib");
 node_zlib = require_chunk.__toESM(node_zlib);
+let node_stream_promises = require("node:stream/promises");
+node_stream_promises = require_chunk.__toESM(node_stream_promises);
 
 //#region src/utils/sanitize.utils.ts
 /**
@@ -772,6 +772,17 @@ var DatabaseTransport = class {
 
 //#endregion
 //#region src/transports/analytics.transport.ts
+/**
+* Thrown by sendBatch() when part of a batch was already delivered. drain()
+* requeues only `unsent`, so delivered entries are not sent twice.
+*/
+var PartialBatchError = class extends Error {
+	constructor(message, unsent, options) {
+		super(message, options);
+		this.unsent = unsent;
+		this.name = "PartialBatchError";
+	}
+};
 var AnalyticsTransport = class {
 	constructor(name, config) {
 		this.batch = [];
@@ -832,7 +843,7 @@ var AnalyticsTransport = class {
 				await this.sendBatch(entriesToSend);
 			} catch (error) {
 				require_internal_log.internalError(`Analytics transport ${this.name} flush failed`, error);
-				this.batch.unshift(...entriesToSend);
+				this.batch.unshift(...error instanceof PartialBatchError ? error.unsent : entriesToSend);
 				this.cap.enforce(this.batch);
 				return;
 			}
@@ -895,8 +906,71 @@ var AnalyticsTransport = class {
 
 //#endregion
 //#region src/transports/datadog.transport.ts
+const gzipAsync = (0, node_util.promisify)(node_zlib.gzip);
+const MAX_LOGS_PER_REQUEST = 1e3;
+const MAX_LOGS_PAYLOAD_BYTES = 5e6;
+const MAX_LOG_BYTES = 1e6;
+const MAX_TRUNCATED_MESSAGE_CHARS = 15e4;
+const TRUNCATED_LOG_KEYS = [
+	"ddsource",
+	"ddtags",
+	"hostname",
+	"service",
+	"status",
+	"timestamp",
+	"level",
+	"context",
+	"traceId",
+	"appName",
+	"environment",
+	"env",
+	"version",
+	"logger",
+	"dd.trace_id",
+	"dd.span_id"
+];
+const STATUS_MAP = {
+	fatal: "critical",
+	critical: "critical",
+	error: "error",
+	warn: "warn",
+	warning: "warn",
+	info: "info",
+	debug: "debug",
+	trace: "debug",
+	verbose: "debug"
+};
+const MAX_UINT64 = (1n << 64n) - 1n;
+const DASHED_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const HEX = /^[0-9a-f]+$/i;
+const DIGITS = /^\d+$/;
+/**
+* Datadog correlates on a decimal 64-bit id. Accepts:
+* - a dashed UUID (logixia's default trace id): dashes stripped, then 32-hex;
+* - 32 hex chars (W3C trace id) or 16 hex chars containing a-f: low 64 bits as decimal;
+* - an all-digit string: already decimal (dd-trace's native format), passed through.
+* An all-digit string is ambiguous when it is 16 or 32 long: 32 is read as hex (a
+* decimal id has at most 20 digits), 16 is read as decimal.
+* Anything else yields the raw string for trace ids (`passthrough`) and nothing for span ids.
+*/
+function toDatadogId(id, passthrough) {
+	if (typeof id !== "string" || id === "") return void 0;
+	const fallback = passthrough ? id : void 0;
+	const compact = DASHED_UUID.test(id) ? id.replaceAll("-", "") : id;
+	const isHexId = HEX.test(compact) && (compact.length === 32 || compact.length === 16);
+	if (DIGITS.test(compact) && compact.length !== 32) {
+		const value = BigInt(compact);
+		return value <= MAX_UINT64 ? value.toString() : fallback;
+	}
+	if (isHexId) return BigInt(`0x${compact.slice(-16)}`).toString();
+	return fallback;
+}
+/** Datadog tags: no commas or whitespace, lowercase, at most 200 chars. */
+function tag(key, value) {
+	return `${key}:${value}`.replaceAll(/[\s,]+/g, "_").toLowerCase().slice(0, 200);
+}
 /**
-* Sends log entries and metrics to Datadog via the Logs and Metrics HTTP APIs.
+* Sends log entries and metrics to Datadog via the Logs (v2) and Metrics HTTP APIs.
 *
 * The API key is transmitted via the `DD-API-KEY` request header — never in the URL.
 *
@@ -922,29 +996,68 @@ var DataDogTransport = class extends AnalyticsTransport {
 		}
 	}
 	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);
+		await this.sendBatch([entry]);
 	}
+	/**
+	* Logs go first, chunk by chunk; metrics follow once every log chunk is out.
+	* A failure part-way throws PartialBatchError naming only the entries that were
+	* not delivered, so a retry never re-posts a chunk Datadog already accepted.
+	*/
 	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));
+		if (this.datadogConfig.enableLogs !== false) await this.sendLogBatch(entries);
+		if (this.datadogConfig.enableMetrics) try {
+			await this.sendMetricBatch(entries);
+		} catch (error) {
+			if (this.datadogConfig.enableLogs === false) throw error;
+			throw new PartialBatchError(error.message, [], { cause: error });
 		}
-		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", payload);
+		const items = entries.map((entry) => ({
+			entry,
+			json: this.serializeLog(entry)
+		}));
+		const chunks = this.chunkLogs(items);
+		for (let i = 0; i < chunks.length; i += 1) {
+			const chunk$1 = chunks[i];
+			try {
+				await this.makeLogsRequest("/api/v2/logs", `[${chunk$1.map((item) => item.json).join(",")}]`);
+			} catch (error) {
+				if (i === 0) throw error;
+				const unsent = chunks.slice(i).flatMap((c) => c.map((item) => item.entry));
+				throw new PartialBatchError(error.message, unsent, { cause: error });
+			}
+		}
+	}
+	/** Splits into requests of at most 1000 entries and about 5MB of JSON. */
+	chunkLogs(items) {
+		const chunks = [];
+		let current = [];
+		let currentBytes = 2;
+		for (const item of items) {
+			const bytes = Buffer.byteLength(item.json) + 1;
+			if (current.length > 0 && (current.length >= MAX_LOGS_PER_REQUEST || currentBytes + bytes > MAX_LOGS_PAYLOAD_BYTES)) {
+				chunks.push(current);
+				current = [];
+				currentBytes = 2;
+			}
+			current.push(item);
+			currentBytes += bytes;
+		}
+		if (current.length > 0) chunks.push(current);
+		return chunks;
+	}
+	/** Serializes once. A log over 1MB keeps its identity and correlation fields but loses its attributes and most of its message. */
+	serializeLog(entry) {
+		const log = this.transformToDataDogLog(entry);
+		const json = require_safe_stringify.stringifyForLog(log);
+		if (Buffer.byteLength(json) <= MAX_LOG_BYTES) return json;
+		const kept = {};
+		for (const key of TRUNCATED_LOG_KEYS) if (log[key] !== void 0) kept[key] = log[key];
+		kept["message"] = String(log["message"]).slice(0, MAX_TRUNCATED_MESSAGE_CHARS);
+		kept["truncated"] = true;
+		return require_safe_stringify.stringifyForLog(kept);
 	}
 	async sendMetric(entry) {
 		await this.sendMetricBatch([entry]);
@@ -953,29 +1066,35 @@ var DataDogTransport = class extends AnalyticsTransport {
 		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) {
+		var _entry$data, _entry$data2;
+		const transformed = this.transformEntry(entry);
+		const service = this.datadogConfig.service || "logixia";
+		const env = this.datadogConfig.env || "production";
+		const version = this.datadogConfig.version;
+		const tags = [
+			tag("env", env),
+			tag("service", service),
+			...version ? [tag("version", version)] : []
+		];
+		const spanId = toDatadogId(((_entry$data = entry.data) === null || _entry$data === void 0 ? void 0 : _entry$data["spanId"]) ?? ((_entry$data2 = entry.data) === null || _entry$data2 === void 0 ? void 0 : _entry$data2["span_id"]), false);
+		const traceId = toDatadogId(entry.traceId, true);
 		return {
-			...this.transformEntry(entry),
-			"dd.trace_id": entry.traceId,
-			"dd.span_id": this.generateSpanId(),
-			host: this.getHostname(),
-			source: "nodejs",
-			timestamp: entry.timestamp.toISOString(),
-			level: this.mapLogLevel(entry.level),
+			...transformed,
+			ddsource: "nodejs",
+			ddtags: tags.join(","),
+			hostname: this.getHostname(),
+			service,
+			status: this.mapLogLevel(entry.level),
 			message: entry.message,
-			service: this.datadogConfig.service || "logixia",
-			version: this.datadogConfig.version,
-			env: this.datadogConfig.env || "production",
+			env,
+			version,
 			logger: {
 				name: "logixia",
 				thread_name: "main"
-			}
+			},
+			...traceId && { "dd.trace_id": traceId },
+			...traceId && spanId && { "dd.span_id": spanId }
 		};
 	}
 	reservedKeys() {
@@ -1001,58 +1120,29 @@ var DataDogTransport = class extends AnalyticsTransport {
 			type: "count",
 			host: this.getHostname(),
 			tags: [
-				`level:${entry.level}`,
-				`service:${this.datadogConfig.service || "logixia"}`,
-				`env:${this.datadogConfig.env || "production"}`,
-				...entry.context ? [`context:${entry.context}`] : [],
-				...entry.appName ? [`app:${entry.appName}`] : []
+				tag("level", entry.level),
+				tag("service", this.datadogConfig.service || "logixia"),
+				tag("env", this.datadogConfig.env || "production"),
+				...entry.context ? [tag("context", entry.context)] : [],
+				...entry.appName ? [tag("app", entry.appName)] : []
 			]
 		};
 	}
-	transformToDataDogTrace(entry) {
-		return {
-			trace_id: entry.traceId,
-			span_id: this.generateSpanId(),
-			parent_id: null,
-			name: "log.entry",
-			service: this.datadogConfig.service || "logixia",
-			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) {
+		return STATUS_MAP[level.toLowerCase()] || "info";
+	}
+	async makeLogsRequest(endpoint, json) {
 		const url = `${this.logsUrl}${endpoint}`;
 		try {
+			const compress = this.datadogConfig.compress === true;
 			const response = await fetch(url, {
 				method: "POST",
 				headers: {
 					"Content-Type": "application/json",
-					"DD-API-KEY": this.datadogConfig.apiKey
+					"DD-API-KEY": this.datadogConfig.apiKey,
+					...compress && { "Content-Encoding": "gzip" }
 				},
-				body: require_safe_stringify.stringifyForLog(data)
+				body: compress ? await gzipAsync(json) : json
 			});
 			if (!response.ok) throw new Error(`DataDog Logs API error: ${response.status} ${response.statusText}`);
 		} catch (error) {
@@ -1075,9 +1165,6 @@ var DataDogTransport = class extends AnalyticsTransport {
 			throw new Error(`Failed to send metrics to DataDog: ${error.message}`, { cause: error });
 		}
 	}
-	generateSpanId() {
-		return Math.floor(Math.random() * 0xffffffffffff).toString(16);
-	}
 	getHostname() {
 		try {
 			return require("node:os").hostname();
@@ -2576,6 +2663,12 @@ Object.defineProperty(exports, 'AnalyticsTransport', {
     return AnalyticsTransport;
   }
 });
+Object.defineProperty(exports, 'BufferCap', {
+  enumerable: true,
+  get: function () {
+    return BufferCap;
+  }
+});
 Object.defineProperty(exports, 'ConsoleTransport', {
   enumerable: true,
   get: function () {
@@ -2630,4 +2723,4 @@ Object.defineProperty(exports, 'stripControlChars', {
     return stripControlChars;
   }
 });
-//# sourceMappingURL=transport.manager-Crau3Rle.js.map
+//# sourceMappingURL=transport.manager-CXbKKdVE.js.map