@sentio/runtime 4.5.0-rc.2 → 4.5.0-rc.3

package/dist/processor-runner.js

@@ -15202,21 +15202,153 @@ function stringify(obj) {
 		return value;
 	});
 }
-function setupLogger(json, enableDebug, workerId) {
+const DEFAULT_LOG_GUARD_OPTIONS = {
+	maxLineBytes: 16 * 1024,
+	maxLinesPerSecond: 1e3,
+	maxBytesPerSecond: 1024 * 1024
+};
+const LOG_GUARD_ENV = {
+	maxLineBytes: "SENTIO_LOG_MAX_LINE_BYTES",
+	maxLinesPerSecond: "SENTIO_LOG_MAX_LINES_PER_SECOND",
+	maxBytesPerSecond: "SENTIO_LOG_MAX_BYTES_PER_SECOND"
+};
+/** Reads the guard limits from the environment, falling back to the defaults for unset or invalid values. */
+function logGuardOptionsFromEnv(env = process.env) {
+	const read = (key) => {
+		const raw = env[LOG_GUARD_ENV[key]]?.trim();
+		if (!raw) return DEFAULT_LOG_GUARD_OPTIONS[key];
+		const value = Number(raw);
+		return Number.isSafeInteger(value) && value >= 0 ? value : DEFAULT_LOG_GUARD_OPTIONS[key];
+	};
+	return {
+		maxLineBytes: read("maxLineBytes"),
+		maxLinesPerSecond: read("maxLinesPerSecond"),
+		maxBytesPerSecond: read("maxBytesPerSecond")
+	};
+}
+const WINDOW_MS = 1e3;
+/**
+* Per-process accounting behind {@link LogGuardOptions}: truncates oversized text and decides,
+* per one-second window, whether another line still fits. Lines that do not fit are dropped;
+* once the window ends a single summary line reports how many were lost, via `onSummary`.
+*/
+var LogGuard = class {
+	options;
+	onSummary;
+	now;
+	windowStart = -Infinity;
+	lines = 0;
+	bytes = 0;
+	droppedLines = 0;
+	droppedBytes = 0;
+	summaryTimer;
+	constructor(options, onSummary, now = Date.now) {
+		this.options = options;
+		this.onSummary = onSummary;
+		this.now = now;
+	}
+	/** Returns `text` unchanged when it fits in `maxLineBytes`, otherwise its head plus a notice. */
+	truncate(text) {
+		const max = this.options.maxLineBytes;
+		if (max <= 0 || text.length * 3 <= max) return text;
+		const size = Buffer.byteLength(text);
+		if (size <= max) return text;
+		return `${new TextDecoder().decode(Buffer.from(text).subarray(0, max), { stream: true })} ...[truncated by sentio runtime: line was ${size} bytes, limit ${max}]`;
+	}
+	/** Accounts a line of `size` bytes against the current window; `false` means the line must be dropped. */
+	admit(size) {
+		const t = this.now();
+		if (t - this.windowStart >= WINDOW_MS) this.rollWindow(t);
+		const { maxLinesPerSecond, maxBytesPerSecond } = this.options;
+		const overLines = maxLinesPerSecond > 0 && this.lines + 1 > maxLinesPerSecond;
+		const overBytes = maxBytesPerSecond > 0 && this.bytes + size > maxBytesPerSecond;
+		if (overLines || overBytes) {
+			this.droppedLines++;
+			this.droppedBytes += size;
+			this.scheduleSummary(this.windowStart + WINDOW_MS - t);
+			return false;
+		}
+		this.lines++;
+		this.bytes += size;
+		return true;
+	}
+	/** Emits the pending drop summary, if any, without waiting for the window to end. */
+	flush() {
+		if (this.summaryTimer) {
+			clearTimeout(this.summaryTimer);
+			this.summaryTimer = void 0;
+		}
+		if (this.droppedLines === 0) return;
+		const { droppedLines, droppedBytes } = this;
+		this.droppedLines = 0;
+		this.droppedBytes = 0;
+		const { maxLinesPerSecond, maxBytesPerSecond } = this.options;
+		this.onSummary(`[sentio runtime] dropped ${droppedLines} console log lines (${droppedBytes} bytes) in the last second: output rate limit exceeded (max ${maxLinesPerSecond} lines/s, ${maxBytesPerSecond} bytes/s)`);
+	}
+	rollWindow(t) {
+		this.flush();
+		this.windowStart = t;
+		this.lines = 0;
+		this.bytes = 0;
+	}
+	scheduleSummary(delayMs) {
+		if (this.summaryTimer) return;
+		this.summaryTimer = setTimeout(() => {
+			this.summaryTimer = void 0;
+			this.flush();
+		}, Math.max(delayMs, 0));
+		this.summaryTimer.unref?.();
+	}
+};
+const GUARD_BYPASS = Symbol.for("sentio.logGuardBypass");
+const MESSAGE = Symbol.for("message");
+const OWN_INFO_FIELDS = /* @__PURE__ */ new Set(["level", "timestamp"]);
+function setupLogger(json, enableDebug, workerId, guardOptions = logGuardOptionsFromEnv()) {
+	const utilFormatter = { transform: (info) => {
+		const stringRes = [];
+		if (typeof info.message === "object") stringRes.push(stringify(info.message));
+		else stringRes.push(info.message);
+		const args = info[Symbol.for("splat")];
+		if (args) for (const idx in args) {
+			const arg = args[idx];
+			if (typeof arg === "object") stringRes.push(stringify(arg));
+			else stringRes.push(arg);
+		}
+		info.message = stringRes.join(" ");
+		return info;
+	} };
+	const guard = new LogGuard(guardOptions, (summary) => {
+		logger.warn({
+			message: summary,
+			[GUARD_BYPASS]: true
+		});
+	});
+	const render = json ? import_winston.format.json() : import_winston.format.simple();
 	const logger = (0, import_winston.createLogger)({
-		format: import_winston.format.combine(import_winston.format.timestamp({ format: "YYYY-MM-DDTHH:mm:ss.SSSZ" }), { transform: (info) => {
-			const stringRes = [];
-			if (typeof info.message === "object") stringRes.push(stringify(info.message));
-			else stringRes.push(info.message);
-			const args = info[Symbol.for("splat")];
-			if (args) for (const idx in args) {
-				const arg = args[idx];
-				if (typeof arg === "object") stringRes.push(stringify(arg));
-				else stringRes.push(arg);
-			}
-			info.message = stringRes.join(" ");
-			return info;
-		} }, import_winston.format.errors({ stack: true }), json ? import_winston.format.json() : import_winston.format.simple(), import_winston.format.label({ label: workerId ? `worker #{workerId}` : "" })),
+		format: import_winston.format.combine(import_winston.format.timestamp({ format: "YYYY-MM-DDTHH:mm:ss.SSSZ" }), utilFormatter, import_winston.format.errors({ stack: true }), render, { transform: (info) => {
+			if (info[GUARD_BYPASS] || info.level === "debug" && !enableDebug) return info;
+			let size = Buffer.byteLength(String(info[MESSAGE]));
+			const max = guardOptions.maxLineBytes;
+			if (max > 0 && size > max) {
+				let dropped = 0;
+				for (const key of Object.keys(info)) {
+					const keepAsText = (key === "message" || key === "stack") && typeof info[key] === "string";
+					if (!OWN_INFO_FIELDS.has(key) && !keepAsText) {
+						delete info[key];
+						dropped++;
+					}
+				}
+				info.message = guard.truncate(String(info.message ?? ""));
+				if (typeof info.stack === "string") info.stack = guard.truncate(info.stack);
+				if (dropped > 0) {
+					const note = `${dropped} metadata fields dropped by sentio runtime: line was ${size} bytes, limit ${max}`;
+					info.message += ` ...[${note}]`;
+				}
+				info = render.transform(info, render.options);
+				size = Buffer.byteLength(String(info[MESSAGE]));
+			}
+			return guard.admit(size) ? info : false;
+		} }, import_winston.format.label({ label: workerId ? `worker #{workerId}` : "" })),
 		level: enableDebug ? "debug" : "info",
 		transports: [new import_winston.transports.Console()]
 	});