watch-tail 0.1.0

package/build/server/chunks/entries/endpoints/api/stream/_server.ts.js-D_i-xW6_.js

@@ -0,0 +1,610 @@
+import { a as apiError, p as parseRegionParam, b as readEnv, r as resolveAwsConfig, c as createLogsClient, d as resolveEffectiveRegion, e as describeAwsError, R as REGION_PARAM_HINT } from '../../../../chunks/env2.js-D7xrfc37.js';
+import { H as HISTORIC_PRESETS, p as presetDurationMs, i as isHistoricPreset } from '../../../../chunks/time-range.js-BLMT8aU3.js';
+import '../../../../chunks/utils.js-BIlHjgGW.js';
+import { FilterLogEventsCommand } from '@aws-sdk/client-cloudwatch-logs';
+import '../../../../chunks/shared-server.js-Dn5XheXH.js';
+import 'node:fs';
+import 'node:path';
+import '../../../../chunks/shared.js-CgjUIvRK.js';
+import '../../../../chunks/uneval.js-DaakSYFQ.js';
+
+//#region src/lib/server/filter.ts
+/** Default lookback window when neither `startTime` nor `lookback` is usable. */
+var DEFAULT_LOOKBACK_MS = 3e5;
+/** CloudWatch Logs rejects `startTime` older than 14 days. */
+var MAX_LOOKBACK_MS = 12096e5;
+var DEFAULT_POLL_MS$1 = 1e3;
+var MIN_POLL_MS = 250;
+var MAX_POLL_MS = 15e3;
+var DURATION_UNITS = {
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5,
+	d: 864e5,
+	w: 6048e5
+};
+var DURATION_PATTERN = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)$/i;
+var EPOCH_PATTERN = /^\d+$/;
+/**
+* Parses a single-unit duration such as `500ms`, `30s`, `15m`, `2h`, `3d` or
+* `1w`. Returns `null` for anything invalid, negative or zero.
+*/
+function parseDurationMs(value) {
+	if (typeof value !== "string") return null;
+	const match = DURATION_PATTERN.exec(value.trim());
+	if (match === null) return null;
+	const amount = Number(match[1]);
+	const unit = DURATION_UNITS[match[2].toLowerCase()];
+	if (unit === void 0 || !Number.isFinite(amount)) return null;
+	const ms = amount * unit;
+	if (!Number.isFinite(ms) || ms <= 0) return null;
+	return Math.round(ms);
+}
+/**
+* Parses a start point into epoch milliseconds.
+*
+* Accepts epoch milliseconds (`1700000000000`), a duration relative to `now`
+* (`15m`) and ISO 8601 timestamps. Returns `null` when the value is missing or
+* cannot be understood.
+*/
+function parseStartTime(value, now) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return null;
+	if (EPOCH_PATTERN.test(trimmed)) return Number(trimmed);
+	const duration = parseDurationMs(trimmed);
+	if (duration !== null) return now - duration;
+	const parsed = Date.parse(trimmed);
+	return Number.isNaN(parsed) ? null : parsed;
+}
+/** Resolves the effective start time, clamped to the last 14 days and to `now`. */
+function resolveStartTime(input) {
+	const { now } = input;
+	let start = parseStartTime(input.startTime, now);
+	if (start === null) start = now - (parseDurationMs(input.lookback ?? "") ?? DEFAULT_LOOKBACK_MS);
+	const oldestAllowed = now - MAX_LOOKBACK_MS;
+	if (start > now) start = now;
+	if (start < oldestAllowed) start = oldestAllowed;
+	return Math.round(start);
+}
+/** Parses a poll interval in milliseconds, defaulting to 1000 and clamped to 250..15000. */
+function clampPollMs(value) {
+	if (typeof value !== "string") return DEFAULT_POLL_MS$1;
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return DEFAULT_POLL_MS$1;
+	const parsed = Number(trimmed);
+	if (!Number.isFinite(parsed)) return DEFAULT_POLL_MS$1;
+	return Math.min(Math.max(Math.round(parsed), MIN_POLL_MS), MAX_POLL_MS);
+}
+/** Default historic window when neither `range` nor `from`/`to` is given. */
+var DEFAULT_HISTORIC_PRESET = "15m";
+/** Parses the `mode` parameter; `null` for an unrecognised value. */
+function parseMode(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim().toLowerCase();
+	if (trimmed === "live" || trimmed === "historic") return trimmed;
+	return null;
+}
+/**
+* Parses an absolute instant: epoch milliseconds or an ISO 8601 timestamp.
+*
+* Relative durations are deliberately rejected here so an end bound can never
+* move with the clock.
+*/
+function parseInstant(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return null;
+	if (EPOCH_PATTERN.test(trimmed)) return Number(trimmed);
+	const parsed = Date.parse(trimmed);
+	return Number.isNaN(parsed) ? null : parsed;
+}
+/**
+* Clamps a window to what CloudWatch Logs can return: 14 days back, ending now.
+*
+* Returns `null` when the requested window ends before the retention floor, so
+* a request for month-old data fails loudly instead of returning a stub window.
+*/
+function clampWindow(start, end, now) {
+	const oldest = now - MAX_LOOKBACK_MS;
+	if (end <= oldest) return null;
+	const clampedStart = Math.min(Math.max(start, oldest), now);
+	const clampedEnd = Math.min(Math.max(end, clampedStart + 1), now);
+	return {
+		start: Math.round(clampedStart),
+		end: Math.round(clampedEnd),
+		clamped: clampedStart !== Math.round(start) || clampedEnd !== Math.round(end)
+	};
+}
+/**
+* Resolves the request window into a start time plus, for historic mode, an end
+* time.
+*
+* Historic windows come from a preset (`range=24h`), from explicit bounds
+* (`from`/`to`, epoch ms or ISO 8601) or, when neither is given, from the
+* smallest preset. Windows are clamped to the last 14 days and to `now` so the
+* request can never ask CloudWatch for data it will not return.
+*/
+function resolveWindow(input) {
+	const { now } = input;
+	const requestedMode = input.mode === null || input.mode === void 0 ? "live" : input.mode.trim();
+	const mode = requestedMode === "" ? "live" : parseMode(requestedMode);
+	if (mode === null) return {
+		ok: false,
+		code: "invalid-mode",
+		message: "Invalid mode: expected \"live\" or \"historic\""
+	};
+	if (mode === "live") return {
+		ok: true,
+		mode,
+		startTime: resolveStartTime({
+			startTime: input.startTime,
+			lookback: input.lookback,
+			now
+		}),
+		endTime: null,
+		preset: null,
+		clamped: false
+	};
+	const from = input.from?.trim() ?? "";
+	const to = input.to?.trim() ?? "";
+	if (from.length > 0 || to.length > 0) {
+		if (from.length === 0 || to.length === 0) return {
+			ok: false,
+			code: "invalid-window",
+			message: "A custom window needs both \"from\" and \"to\""
+		};
+		const parsedFrom = parseStartTime(from, now);
+		const parsedTo = parseInstant(to);
+		if (parsedFrom === null) return {
+			ok: false,
+			code: "invalid-time",
+			message: `Invalid "from": expected epoch milliseconds, a duration such as 3h, or an ISO 8601 timestamp`
+		};
+		if (parsedTo === null) return {
+			ok: false,
+			code: "invalid-time",
+			message: "Invalid \"to\": expected epoch milliseconds or an ISO 8601 timestamp"
+		};
+		if (parsedTo <= parsedFrom) return {
+			ok: false,
+			code: "invalid-window",
+			message: "The end of the window must be after its start"
+		};
+		const clamped = clampWindow(parsedFrom, parsedTo, now);
+		if (clamped === null || clamped.end <= clamped.start) return {
+			ok: false,
+			code: "invalid-window",
+			message: "The requested window is outside the 14 days CloudWatch Logs keeps"
+		};
+		return {
+			ok: true,
+			mode,
+			startTime: clamped.start,
+			endTime: clamped.end,
+			preset: null,
+			clamped: clamped.clamped
+		};
+	}
+	const requestedRange = input.range?.trim() ?? "";
+	const preset = requestedRange === "" ? DEFAULT_HISTORIC_PRESET : isHistoricPreset(requestedRange) ? requestedRange : null;
+	if (preset === null) return {
+		ok: false,
+		code: "invalid-range",
+		message: `Invalid range: expected one of ${HISTORIC_PRESETS.join(", ")} or an explicit from/to window`
+	};
+	const end = Math.round(now);
+	return {
+		ok: true,
+		mode,
+		startTime: Math.round(now - presetDurationMs(preset)),
+		endTime: end,
+		preset,
+		clamped: false
+	};
+}
+//#endregion
+//#region src/lib/server/sse.ts
+var NEWLINE_PATTERN = /\r?\n/g;
+/**
+* Encodes a single server-sent event frame.
+*
+* The JSON payload is always kept on one line, so the frame is
+* `event: <name>\ndata: <json>\n\n`.
+*/
+function sseFrame(event, data) {
+	return `event: ${event.replace(NEWLINE_PATTERN, " ").trim()}\ndata: ${(JSON.stringify(data) ?? "null").replace(NEWLINE_PATTERN, " ")}\n\n`;
+}
+//#endregion
+//#region src/lib/server/tail.ts
+var DEFAULT_SEEN_CAPACITY = 5e3;
+var DEFAULT_POLL_MS = 1e3;
+var DEFAULT_LIMIT = 1e3;
+var DEFAULT_MAX_CONSECUTIVE_ERRORS = 8;
+var MAX_BACKOFF_MS = 15e3;
+/** Empty polls that end a historic window: CloudWatch can lag behind ingestion. */
+var DEFAULT_IDLE_POLLS = 2;
+/** Upper bound on events yielded for one historic window. */
+var DEFAULT_MAX_EVENTS = 1e4;
+/** Returns true when the value is an abort error raised by the fetch/SDK layer. */
+function isAbortError(error) {
+	if (error instanceof Error) return error.name === "AbortError" || error.code === "ABORT_ERR";
+	return false;
+}
+/**
+* Abort-aware sleep used by default.
+*
+* Resolves after `ms`, resolves immediately when the signal aborts and always
+* clears its timer. An injected sleep may instead reject on abort, which
+* {@link tailLogEvents} handles by re-checking the signal.
+*/
+var defaultSleep = (ms, signal) => new Promise((resolve) => {
+	if (signal?.aborted === true || !Number.isFinite(ms) || ms <= 0) {
+		resolve();
+		return;
+	}
+	const onAbort = () => {
+		clearTimeout(timer);
+		resolve();
+	};
+	const timer = setTimeout(() => {
+		signal?.removeEventListener("abort", onAbort);
+		resolve();
+	}, ms);
+	timer.unref?.();
+	signal?.addEventListener("abort", onAbort, { once: true });
+});
+/**
+* Bounded first-in-first-out set of event ids.
+*
+* Keeps at most `capacity` ids (default 5000) so memory stays flat on long
+* streams. The oldest id is evicted first.
+*/
+var SeenEventIds = class {
+	ids = /* @__PURE__ */ new Set();
+	capacity;
+	constructor(capacity = DEFAULT_SEEN_CAPACITY) {
+		const parsed = Number.isFinite(capacity) ? Math.floor(capacity) : DEFAULT_SEEN_CAPACITY;
+		this.capacity = parsed > 0 ? parsed : DEFAULT_SEEN_CAPACITY;
+	}
+	/** True when the id was recorded before. Null and empty ids are never recorded. */
+	has(id) {
+		return id !== null && id.length > 0 && this.ids.has(id);
+	}
+	/** Records an id, evicting the oldest entry when the capacity is reached. */
+	add(id) {
+		if (id === null || id.length === 0 || this.ids.has(id)) return;
+		if (this.ids.size >= this.capacity) {
+			const oldest = this.ids.values().next();
+			if (!oldest.done) this.ids.delete(oldest.value);
+		}
+		this.ids.add(id);
+	}
+	/** Number of ids currently remembered. */
+	get size() {
+		return this.ids.size;
+	}
+};
+/**
+* Converts a poll result into the events worth sending downstream.
+*
+* Drops ids seen in earlier polls and duplicates inside the same batch, then
+* records the ids of the accepted events. Events without an id are always kept
+* and never recorded.
+*/
+function selectNewEvents(events, seen) {
+	const selected = [];
+	if (events === void 0 || events.length === 0) return selected;
+	const freshIds = /* @__PURE__ */ new Set();
+	for (const event of events) {
+		const id = event.eventId !== void 0 && event.eventId.length > 0 ? event.eventId : null;
+		if (id !== null) {
+			if (seen.has(id) || freshIds.has(id)) continue;
+			freshIds.add(id);
+		}
+		const dto = {
+			id,
+			timestamp: typeof event.timestamp === "number" ? event.timestamp : 0,
+			message: event.message ?? ""
+		};
+		if (event.logStreamName !== void 0) dto.streamName = event.logStreamName;
+		if (typeof event.ingestionTime === "number") dto.ingestionTime = event.ingestionTime;
+		selected.push(dto);
+	}
+	for (const id of freshIds) seen.add(id);
+	return selected;
+}
+/** Highest timestamp in `events`, never lower than `previous`. */
+function nextCursor(previous, events) {
+	let cursor = Number.isFinite(previous) ? previous : 0;
+	for (const event of events) if (Number.isFinite(event.timestamp) && event.timestamp > cursor) cursor = event.timestamp;
+	return cursor;
+}
+/**
+* Polls `FilterLogEvents` and yields batches as they arrive.
+*
+* `startTime` is inclusive upstream, so the cursor advances to the newest
+* timestamp seen and repeated events are removed by {@link SeenEventIds}.
+* Nothing is new in a poll => sleep `pollIntervalMs`. Errors are yielded as
+* `error` batches and retried with exponential backoff
+* (`pollIntervalMs * 2^consecutiveErrors`, capped at 15000 ms) until
+* `maxConsecutiveErrors` (default 8) failures in a row, then the generator
+* returns. An aborted signal ends the generator without throwing.
+*/
+async function* tailLogEvents(options) {
+	const { client, logGroupName, startTime, pollIntervalMs = DEFAULT_POLL_MS, limit = DEFAULT_LIMIT, filterPattern, signal, sleep = defaultSleep, maxConsecutiveErrors = DEFAULT_MAX_CONSECUTIVE_ERRORS, logStreamNamePrefix, endTime = null, idlePolls = DEFAULT_IDLE_POLLS, maxEvents = DEFAULT_MAX_EVENTS } = options;
+	const historic = typeof endTime === "number" && Number.isFinite(endTime);
+	const windowEnd = historic ? endTime : null;
+	const idlePollsAllowed = Number.isFinite(idlePolls) && idlePolls > 0 ? Math.floor(idlePolls) : DEFAULT_IDLE_POLLS;
+	const eventCap = Number.isFinite(maxEvents) && maxEvents > 0 ? Math.floor(maxEvents) : DEFAULT_MAX_EVENTS;
+	const pollMs = Number.isFinite(pollIntervalMs) && pollIntervalMs > 0 ? Math.min(Math.round(pollIntervalMs), MAX_BACKOFF_MS) : DEFAULT_POLL_MS;
+	const pageLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : DEFAULT_LIMIT;
+	const maxErrors = Number.isFinite(maxConsecutiveErrors) && maxConsecutiveErrors > 0 ? Math.floor(maxConsecutiveErrors) : DEFAULT_MAX_CONSECUTIVE_ERRORS;
+	const baseInput = {
+		logGroupName,
+		startTime,
+		limit: pageLimit
+	};
+	if (windowEnd !== null) baseInput.endTime = windowEnd;
+	if (filterPattern !== void 0 && filterPattern.length > 0) baseInput.filterPattern = filterPattern;
+	if (logStreamNamePrefix !== void 0 && logStreamNamePrefix.length > 0) baseInput.logStreamNamePrefix = logStreamNamePrefix;
+	const isAborted = () => signal?.aborted === true;
+	const wait = async (ms) => {
+		if (isAborted()) return true;
+		try {
+			await sleep(ms, signal);
+		} catch {}
+		return isAborted();
+	};
+	const seen = new SeenEventIds();
+	let cursor = Number.isFinite(startTime) ? startTime : 0;
+	let consecutiveErrors = 0;
+	let emitted = 0;
+	let emptyPolls = 0;
+	for (;;) {
+		if (isAborted()) return;
+		try {
+			const input = {
+				...baseInput,
+				startTime: cursor
+			};
+			const response = await client.send(new FilterLogEventsCommand(input), { abortSignal: signal });
+			consecutiveErrors = 0;
+			const events = selectNewEvents(response.events, seen);
+			if (events.length > 0) {
+				emptyPolls = 0;
+				cursor = nextCursor(cursor, events);
+				emitted += events.length;
+				yield {
+					type: "events",
+					events
+				};
+				if (historic && emitted >= eventCap) {
+					yield {
+						type: "end",
+						reason: "event-limit"
+					};
+					return;
+				}
+				if (windowEnd !== null && cursor >= windowEnd) {
+					yield {
+						type: "end",
+						reason: "window-complete"
+					};
+					return;
+				}
+				continue;
+			}
+			if (historic) {
+				emptyPolls += 1;
+				if (emptyPolls >= idlePollsAllowed) {
+					yield {
+						type: "end",
+						reason: "window-complete"
+					};
+					return;
+				}
+			}
+		} catch (error) {
+			if (isAborted() || isAbortError(error)) return;
+			consecutiveErrors += 1;
+			const described = describeAwsError(error);
+			yield {
+				type: "error",
+				message: described.message,
+				code: described.code
+			};
+			if (consecutiveErrors >= maxErrors) {
+				if (historic) yield {
+					type: "end",
+					reason: "repeated-errors"
+				};
+				return;
+			}
+			if (await wait(Math.min(pollMs * 2 ** consecutiveErrors, MAX_BACKOFF_MS))) return;
+			continue;
+		}
+		if (await wait(pollMs)) return;
+	}
+}
+//#endregion
+//#region src/routes/api/stream/+server.ts
+/** Send a `ping` after this much silence. */
+var PING_INTERVAL_MS = 15e3;
+/** Stop the stream after this many consecutive failed polls. */
+var MAX_CONSECUTIVE_ERRORS = 8;
+var SSE_HEADERS = {
+	"content-type": "text/event-stream; charset=utf-8",
+	"cache-control": "no-cache, no-transform",
+	connection: "keep-alive",
+	"x-accel-buffering": "no"
+};
+/**
+* `GET /api/stream` - server-sent events for one log group.
+*
+* Emits `ready` first, then `log` per batch, `ping` after 15 s of silence and
+* a final `end`. The region is optional: without it the tailer uses a client
+* that resolves the region from the ambient AWS configuration. The tailer is
+* cancelled through `request.signal`, and every timer and listener is removed
+* so the dev server can exit.
+*/
+var GET = async ({ url, request }) => {
+	const logGroupName = url.searchParams.get("group")?.trim() ?? "";
+	if (logGroupName.length === 0) return apiError(400, "Query parameter \"group\" is required", "missing-group");
+	const parsedRegion = parseRegionParam(url.searchParams.get("region"));
+	if (!parsedRegion.ok) return apiError(400, REGION_PARAM_HINT, "invalid-region");
+	const env = readEnv();
+	const config = resolveAwsConfig(env, parsedRegion.region);
+	const filterPattern = url.searchParams.get("filterPattern")?.trim();
+	const streamWindow = resolveWindow({
+		mode: url.searchParams.get("mode"),
+		range: url.searchParams.get("range"),
+		from: url.searchParams.get("from"),
+		to: url.searchParams.get("to"),
+		startTime: url.searchParams.get("startTime"),
+		lookback: url.searchParams.get("lookback"),
+		now: Date.now()
+	});
+	if (!streamWindow.ok) return apiError(400, streamWindow.message, streamWindow.code);
+	const pollIntervalMs = clampPollMs(url.searchParams.get("poll"));
+	let client;
+	let region;
+	try {
+		client = createLogsClient(config);
+		region = await resolveEffectiveRegion(client, config);
+	} catch (error) {
+		const described = describeAwsError(error);
+		return apiError(502, described.message, described.code);
+	}
+	const encoder = new TextEncoder();
+	const bodyAbort = new AbortController();
+	let streamController;
+	let closed = false;
+	let pingTimer;
+	let cleanedUp = false;
+	const clearPing = () => {
+		if (pingTimer !== void 0) {
+			clearTimeout(pingTimer);
+			pingTimer = void 0;
+		}
+	};
+	const armPing = () => {
+		if (closed) return;
+		clearPing();
+		pingTimer = setTimeout(() => {
+			pingTimer = void 0;
+			if (closed) return;
+			enqueue(sseFrame("ping", { at: Date.now() }), false);
+			armPing();
+		}, PING_INTERVAL_MS);
+		pingTimer.unref?.();
+	};
+	const enqueue = (chunk, rearm = true) => {
+		if (closed || streamController === void 0) return;
+		try {
+			streamController.enqueue(encoder.encode(chunk));
+		} catch {
+			closed = true;
+			return;
+		}
+		if (rearm) armPing();
+	};
+	const closeStream = () => {
+		closed = true;
+		try {
+			streamController?.close();
+		} catch {}
+	};
+	const writeEnd = (reason) => {
+		clearPing();
+		const payload = { reason };
+		try {
+			streamController?.enqueue(encoder.encode(sseFrame("end", payload)));
+		} catch {}
+		closeStream();
+	};
+	const onAbort = () => {
+		bodyAbort.abort();
+	};
+	const cleanup = () => {
+		if (cleanedUp) return;
+		cleanedUp = true;
+		clearPing();
+		request.signal.removeEventListener("abort", onAbort);
+		client.destroy();
+	};
+	const pump = async () => {
+		let consecutiveErrors = 0;
+		let reason = "completed";
+		try {
+			for await (const batch of tailLogEvents({
+				client,
+				logGroupName,
+				startTime: streamWindow.startTime,
+				endTime: streamWindow.endTime,
+				pollIntervalMs,
+				filterPattern,
+				signal: bodyAbort.signal,
+				maxConsecutiveErrors: MAX_CONSECUTIVE_ERRORS
+			})) {
+				if (closed || bodyAbort.signal.aborted) break;
+				if (batch.type === "events") {
+					const payload = { events: batch.events };
+					consecutiveErrors = 0;
+					enqueue(sseFrame("log", payload));
+				} else if (batch.type === "end") {
+					reason = batch.reason;
+					break;
+				} else {
+					const payload = { message: batch.message };
+					if (batch.code !== void 0) payload.code = batch.code;
+					consecutiveErrors += 1;
+					enqueue(sseFrame("error", payload));
+				}
+			}
+			if (reason === "completed") {
+				if (bodyAbort.signal.aborted) reason = "client-disconnected";
+				else if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) reason = "repeated-errors";
+			}
+		} catch (error) {
+			const described = describeAwsError(error);
+			const payload = { message: described.message };
+			if (described.code !== void 0) payload.code = described.code;
+			enqueue(sseFrame("error", payload));
+			reason = "failed";
+		} finally {
+			cleanup();
+		}
+		writeEnd(reason);
+	};
+	request.signal.addEventListener("abort", onAbort, { once: true });
+	const stream = new ReadableStream({
+		start(controller) {
+			streamController = controller;
+			const payload = {
+				region,
+				logGroupName,
+				endpoint: config.endpoint,
+				startTime: streamWindow.startTime,
+				endTime: streamWindow.endTime,
+				mode: streamWindow.mode,
+				preset: streamWindow.preset,
+				clamped: streamWindow.clamped
+			};
+			enqueue(sseFrame("ready", payload));
+			armPing();
+			pump();
+		},
+		cancel() {
+			bodyAbort.abort();
+			clearPing();
+			closeStream();
+			cleanup();
+		}
+	});
+	return new Response(stream, { headers: SSE_HEADERS });
+};
+
+export { GET };
+//# sourceMappingURL=_server.ts.js-D_i-xW6_.js.map