@rebasepro/server 0.24.0 → 0.24.1-canary.g19596ef

package/dist/{cron-scheduler-CYQgco86.js → cron-scheduler-D1DT0nw5.js}

@@ -3,8 +3,8 @@ import __rebaseProcess from "process";
 globalThis.process ??= __rebaseProcess;
 __rebaseCreateRequire(import.meta.url);
 import { n as __exportAll } from "./rolldown-runtime-dW7B1o5h.js";
-import "./src-CatHFUym.js";
-import { a as redactSensitiveText, r as logger, s as stringifyForLog } from "./logger-D-S-hO5e.js";
+import "./src-D5Y3N-S4.js";
+import { a as redactSensitiveText, c as stringifyForLog, r as logger } from "./logger-Bt32sHFw.js";
 import { randomUUID } from "node:crypto";
 import { hostname } from "node:os";
 //#region ../types/src/types/env_boolean.ts
@@ -149,6 +149,8 @@ function buildScaleToZeroWarning(jobs, env = process.env) {
 //#region src/cron/cron-scheduler.ts
 var cron_scheduler_exports = /* @__PURE__ */ __exportAll({
 	CronScheduler: () => CronScheduler,
+	MAX_CAPTURED_LOG_BYTES: () => MAX_CAPTURED_LOG_BYTES,
+	MAX_CAPTURED_LOG_LINES: () => 500,
 	findMostRecentSlot: () => findMostRecentSlot,
 	isAlreadyExecutingSkip: () => isAlreadyExecutingSkip,
 	isValidTimeZone: () => isValidTimeZone,
@@ -295,6 +297,7 @@ function wallClockIn(candidate, zone) {
 			timeZone: zone,
 			hourCycle: "h23",
 			weekday: "short",
+			year: "numeric",
 			month: "numeric",
 			day: "numeric",
 			hour: "numeric",
@@ -305,6 +308,7 @@ function wallClockIn(candidate, zone) {
 	const parts = {};
 	for (const part of formatter.formatToParts(candidate)) parts[part.type] = part.value;
 	return {
+		year: Number(parts.year),
 		minute: Number(parts.minute),
 		hour: Number(parts.hour),
 		dom: Number(parts.day),
@@ -313,21 +317,69 @@ function wallClockIn(candidate, zone) {
 	};
 }
 /**
-* Whether a minute-precision instant matches every field of the expression.
-*
-* Read in `zone` when one is named, else in the process's own zone — which is
-* whatever the host is set to, UTC in nearly every container. A schedule that
-* names its zone means the same wall-clock hour on every host it runs on.
+* The wall clock an instant reads in `zone` when one is named, else in the
+* process's own zone — which is whatever the host is set to, UTC in nearly
+* every container. A schedule that names its zone means the same wall-clock
+* hour on every host it runs on.
 */
-function matchesCronFields(candidate, fields, zone) {
-	const wall = zone ? wallClockIn(candidate, zone) : {
+function wallClockOf(instantMs, zone) {
+	const candidate = new Date(instantMs);
+	if (zone) return wallClockIn(candidate, zone);
+	return {
+		year: candidate.getFullYear(),
 		minute: candidate.getMinutes(),
 		hour: candidate.getHours(),
 		dom: candidate.getDate(),
 		month: candidate.getMonth() + 1,
 		dow: candidate.getDay()
 	};
-	return fields.months.includes(wall.month) && fields.doms.includes(wall.dom) && fields.dows.includes(wall.dow) && fields.hours.includes(wall.hour) && fields.minutes.includes(wall.minute);
+}
+/**
+* The zone's offset from UTC at an instant: its wall clock read back as UTC,
+* minus the instant. Two instants with the same offset have wall clocks
+* exactly as far apart as the instants themselves.
+*/
+function offsetAt(instantMs, wall) {
+	return Date.UTC(wall.year, wall.month - 1, wall.dom, wall.hour, wall.minute) - instantMs;
+}
+/** Whether a wall-clock day — month, day of month, weekday — can hold a slot. */
+function dayMatches(wall, fields) {
+	return fields.months.includes(wall.month) && fields.doms.includes(wall.dom) && fields.dows.includes(wall.dow);
+}
+/** Whether a wall-clock minute matches every field of the expression. */
+function wallMatches(wall, fields) {
+	return dayMatches(wall, fields) && fields.hours.includes(wall.hour) && fields.minutes.includes(wall.minute);
+}
+var MINUTES_PER_DAY = 1440;
+/**
+* How many wall-clock minutes from a non-matching `wall` to the first later
+* wall minute that could match. Never past the next wall midnight, so the
+* minutes in between share `wall`'s day and every one of them is a miss.
+*/
+function wallMinutesToNextCandidate(wall, fields) {
+	const minuteOfDay = wall.hour * 60 + wall.minute;
+	if (!dayMatches(wall, fields)) return MINUTES_PER_DAY - minuteOfDay;
+	if (!fields.hours.includes(wall.hour)) {
+		const nextHour = fields.hours.find((hour) => hour > wall.hour);
+		return nextHour === void 0 ? MINUTES_PER_DAY - minuteOfDay : nextHour * 60 - minuteOfDay;
+	}
+	const nextMinute = fields.minutes.find((minute) => minute > wall.minute);
+	return nextMinute === void 0 ? 60 - wall.minute : nextMinute - wall.minute;
+}
+/**
+* The mirror of {@link wallMinutesToNextCandidate}: how many wall-clock
+* minutes back from a non-matching `wall` to the latest earlier wall minute
+* that could match. Never before 23:59 of the previous wall day.
+*/
+function wallMinutesToPreviousCandidate(wall, fields) {
+	const minuteOfDay = wall.hour * 60 + wall.minute;
+	if (!dayMatches(wall, fields)) return minuteOfDay + 1;
+	if (!fields.hours.includes(wall.hour)) {
+		const previousHour = [...fields.hours].reverse().find((hour) => hour < wall.hour);
+		return previousHour === void 0 ? minuteOfDay + 1 : minuteOfDay - (previousHour * 60 + 59);
+	}
+	const previousMinute = [...fields.minutes].reverse().find((minute) => minute < wall.minute);
+	return previousMinute === void 0 ? wall.minute + 1 : wall.minute - previousMinute;
 }
 /**
 * How far forward to look for the next matching slot.
@@ -339,27 +391,86 @@ function matchesCronFields(candidate, fields, zone) {
 var MAX_SLOT_SEARCH_MINUTES = 2105280;
 var MINUTE_MS = 6e4;
 /**
+* The first real minute in `[startMs, endMs)`, stepping in `direction`, whose
+* wall clock matches `fields` — the same answer as testing every minute in
+* turn, without testing every minute.
+*
+* The search moves through *real* minutes and only reads the wall clock, never
+* steps it: across a daylight-saving change a wall-clock minute is not a real
+* one. Falling back, a wall-clock step from 02:59 summer time lands on 03:00
+* winter time and skips the repeated hour; inside it, the "next" minute can be
+* an hour in the past. That is why this used to test one real minute at a
+* time — and a yearly job named in a zone cost half a million `Intl` calls,
+* blocking the event loop for a third of a second on every re-arm, and two
+* seconds for 29 February.
+*
+* Now it hops. From a miss, {@link wallMinutesToNextCandidate} says how many
+* wall minutes cannot match (the rest of a day that is the wrong date, the
+* rest of an hour that is the wrong hour, the minutes before the next listed
+* one). While the zone's offset holds, that many wall minutes are exactly
+* that many real minutes, so the hop is taken when the offset at both ends is
+* the same. When it differs, a transition lies inside the hop: the search
+* bisects for the first minute on the new offset and resumes there — every
+* minute before it is on the old offset, so its wall clock is inside the
+* stretch already known to miss. A hop is at most a day, and the one thing
+* this assumes is that no zone changes its offset and changes it back within
+* a single day, which none in the tz database does. Each day costs one
+* wall-clock read, plus about a dozen for each transition crossed.
+*
+* `direction: -1` walks back from `startMs` to `endMs` (inclusive) with the
+* mirror of the same hop, for {@link findMostRecentSlot}.
+*/
+function searchSlot(fields, startMs, endMs, direction, zone) {
+	const inWindow = (instantMs) => direction === 1 ? instantMs < endMs : instantMs >= endMs;
+	let current = startMs;
+	let wall = wallClockOf(current, zone);
+	while (inWindow(current)) {
+		if (wallMatches(wall, fields)) return current;
+		const skip = direction === 1 ? wallMinutesToNextCandidate(wall, fields) : wallMinutesToPreviousCandidate(wall, fields);
+		const target = current + direction * skip * MINUTE_MS;
+		const targetWall = wallClockOf(target, zone);
+		const offset = offsetAt(current, wall);
+		if (skip === 1 || offsetAt(target, targetWall) === offset) {
+			current = target;
+			wall = targetWall;
+			continue;
+		}
+		let held = current;
+		let changed = target;
+		let changedWall = targetWall;
+		while (Math.abs(changed - held) > MINUTE_MS) {
+			const middle = held + direction * Math.floor(Math.abs(changed - held) / MINUTE_MS / 2) * MINUTE_MS;
+			const middleWall = wallClockOf(middle, zone);
+			if (offsetAt(middle, middleWall) === offset) held = middle;
+			else {
+				changed = middle;
+				changedWall = middleWall;
+			}
+		}
+		current = changed;
+		wall = changedWall;
+	}
+}
+/**
 * Calculate the next Date after `after` that matches the cron expression.
 * Throws on invalid expressions.
 */
 function parseCronExpression(expression, after, timezone) {
 	const fields = parseCronFields(expression);
-	const candidate = new Date(after);
-	candidate.setUTCSeconds(0, 0);
-	candidate.setTime(candidate.getTime() + MINUTE_MS);
-	for (let i = 0; i < MAX_SLOT_SEARCH_MINUTES; i++) {
-		if (matchesCronFields(candidate, fields, timezone)) return candidate;
-		candidate.setTime(candidate.getTime() + MINUTE_MS);
-	}
+	const start = new Date(after);
+	start.setUTCSeconds(0, 0);
+	const startMs = start.getTime() + MINUTE_MS;
+	const slot = searchSlot(fields, startMs, startMs + MAX_SLOT_SEARCH_MINUTES * MINUTE_MS, 1, timezone);
+	if (slot !== void 0) return new Date(slot);
 	throw new Error(`Cron expression "${expression}" has no matching time within ${Math.round(MAX_SLOT_SEARCH_MINUTES / 525960)} years of ${after.toISOString()}. Check the day-of-month and month fields — a date such as 31 February never occurs.`);
 }
 /**
 * The latest slot matching `expression` within the inclusive window
 * `[from, to]`, or `undefined` when the expression has no slot in it.
 *
-* Walks backwards a minute at a time from `to`, so the first hit is already
-* the answer — in the common case (a job that ran normally moments ago) that
-* is a handful of iterations, not a scan of the whole window.
+* Walks backwards from `to`, so the first hit is already the answer — in the
+* common case (a job that ran normally moments ago) that is a handful of
+* steps, not a scan of the whole window.
 *
 * `to`'s own minute is included: an instance booting at 06:00:30 has *not* run
 * the 06:00 slot — `parseCronExpression` already skipped past it to tomorrow —
@@ -371,14 +482,46 @@ function parseCronExpression(expression, after, timezone) {
 */
 function findMostRecentSlot(expression, from, to, timezone) {
 	const fields = parseCronFields(expression);
-	const candidate = new Date(to);
-	candidate.setUTCSeconds(0, 0);
-	for (let i = 0; i < MAX_SLOT_SEARCH_MINUTES && candidate.getTime() >= from.getTime(); i++) {
-		if (matchesCronFields(candidate, fields, timezone)) return candidate;
-		candidate.setTime(candidate.getTime() - MINUTE_MS);
-	}
+	const start = new Date(to);
+	start.setUTCSeconds(0, 0);
+	const startMs = start.getTime();
+	const slot = searchSlot(fields, startMs, Math.max(from.getTime(), startMs - (MAX_SLOT_SEARCH_MINUTES - 1) * MINUTE_MS), -1, timezone);
+	return slot === void 0 ? void 0 : new Date(slot);
 }
 var MAX_LOGS_PER_JOB = 50;
+var MAX_CAPTURED_LOG_BYTES = 64 * 1024;
+/**
+* A run's `ctx.log` capture, capped at {@link MAX_CAPTURED_LOG_LINES} and
+* {@link MAX_CAPTURED_LOG_BYTES}. The kept lines are the first ones: once one
+* line is dropped, every later one is too, so the history reads as a prefix of
+* the run's output and never as lines with gaps between them.
+*/
+function createLogCapture(firstLine) {
+	const lines = [];
+	let bytes = 0;
+	let dropped = 0;
+	let closed = false;
+	const capture = {
+		add(line) {
+			if (closed) return;
+			const size = Buffer.byteLength(line, "utf8");
+			if (dropped === 0 && lines.length < 500 && bytes + size <= 65536) {
+				lines.push(line);
+				bytes += size;
+				return;
+			}
+			dropped++;
+		},
+		/** The lines kept, and the line that says what was not. Later `add`s are ignored. */
+		close() {
+			if (!closed && dropped > 0) lines.push(`… ${dropped} more line${dropped === 1 ? "" : "s"} not kept — see the server log`);
+			closed = true;
+			return lines;
+		}
+	};
+	if (firstLine !== void 0) capture.add(firstLine);
+	return capture;
+}
 /**
 * Minimum milliseconds between scheduled executions of the same job.
 * Prevents tight re-execution loops caused by jitter or clock drift.
@@ -410,6 +553,12 @@ function setLongTimeout(callback, delayMs) {
 /** A run's timeout when its definition names none. */
 var DEFAULT_TIMEOUT_SECONDS = 300;
 /**
+* How often a started scheduler deletes slot claims and run history past
+* retention. Both accrue one row per job per fire, so a scheduler that lives
+* for months needs to prune while it runs, not only when it next boots.
+*/
+var CLAIM_SWEEP_INTERVAL_MS = 60 * 6e4;
+/**
 * How long a run lease outlasts the run's own timeout.
 *
 * The lease is timed on the database's clock from the moment it is taken, the
@@ -469,6 +618,10 @@ var CronScheduler = class {
 	* ever clear the lease that run took.
 	*/
 	instanceLabel = `${hostname()}:${process.pid}`;
+	/** The hourly claim- and log-retention sweep, while the scheduler is started with a store. */
+	claimSweepTimer;
+	sweepingClaims = false;
+	sweepingLogs = false;
 	/**
 	* Set the server singleton to make it available to cron job handlers.
 	*
@@ -559,8 +712,48 @@ var CronScheduler = class {
 		if (!this.store) logger.warn("[cron] No cron store attached — runs are uncoordinated; with multiple app instances every instance will execute every job");
 		this.warnIfScaleToZero();
 		this.catchUpMissedSlots();
+		if (this.store?.sweepClaims || this.store?.sweepLogs) {
+			const sweep = () => {
+				this.sweepClaims();
+				this.sweepLogs();
+			};
+			sweep();
+			this.claimSweepTimer = setInterval(sweep, CLAIM_SWEEP_INTERVAL_MS);
+			this.claimSweepTimer.unref?.();
+		}
 		logger.info(`⏰ Cron scheduler started with ${this.jobs.size} job(s)`);
 	}
+	/** Delete slot claims past retention. Failures are logged; the next hour tries again. */
+	async sweepClaims() {
+		const store = this.store;
+		if (!store?.sweepClaims || this.sweepingClaims) return;
+		this.sweepingClaims = true;
+		try {
+			await store.sweepClaims();
+		} catch (err) {
+			logger.warn("[cron] The claim retention sweep failed; it runs again within the hour", { error: err });
+		} finally {
+			this.sweepingClaims = false;
+		}
+	}
+	/**
+	* Delete run history past retention, and count the runs not counted yet.
+	* Failures are logged; the next hour tries again, from where this one
+	* stopped — each batch it finished is committed.
+	*/
+	async sweepLogs() {
+		const store = this.store;
+		if (!store?.sweepLogs || this.sweepingLogs) return;
+		this.sweepingLogs = true;
+		try {
+			const { counted } = await store.sweepLogs();
+			if (counted > 0) logger.info(`[cron] Counted ${counted} earlier run(s) into the jobs' run totals`);
+		} catch (err) {
+			logger.warn("[cron] The run history sweep failed; it runs again within the hour", { error: err });
+		} finally {
+			this.sweepingLogs = false;
+		}
+	}
 	/**
 	* Stop the scheduler: clear every timer, then wait for the runs executing
 	* right now — for at most `timeoutMs` when given.
@@ -576,6 +769,10 @@ var CronScheduler = class {
 	async stop(timeoutMs) {
 		this.started = false;
 		for (const [id] of this.jobs) this.stopJob(id);
+		if (this.claimSweepTimer) {
+			clearInterval(this.claimSweepTimer);
+			this.claimSweepTimer = void 0;
+		}
 		if (this.inFlight.size === 0) return;
 		const settled = Promise.allSettled([...this.inFlight]).then(() => true);
 		if (timeoutMs === void 0) {
@@ -747,6 +944,46 @@ var CronScheduler = class {
 		return this.executeJob(job, true);
 	}
 	/**
+	* Start a job now and answer as soon as the run has begun, not when it
+	* ends — the manual trigger's `?async=1`.
+	*
+	* The synchronous {@link triggerJob} holds its HTTP request open for the
+	* whole run, and a proxy in front of the server (many stop at 60 s) cuts
+	* a long job's answer while the run carries on. This resolves once the
+	* run lease is held and the handler is about to be called, so a run that
+	* cannot start — already executing here or on the lease holder — is still
+	* answered as the skip it is. The run itself is tracked like any other:
+	* `stop()` waits for it, and its outcome lands in the run history, where
+	* the entry carries `manual: true` and the `startedAt` returned here.
+	*
+	* Returns `undefined` if the job doesn't exist.
+	*/
+	async startJob(id) {
+		const job = this.jobs.get(id);
+		if (!job) return void 0;
+		if (job.executing) {
+			logger.warn(`[cron] Skipping manual trigger of "${id}" — already executing`);
+			return {
+				started: false,
+				log: this.recordSkip(job, "already_executing", true)
+			};
+		}
+		let onStart;
+		const begun = new Promise((resolve) => {
+			onStart = resolve;
+		});
+		const run = this.executeJob(job, true, void 0, onStart);
+		const first = await Promise.race([begun.then((startedAt) => ({ startedAt })), run.then((log) => ({ log }))]);
+		if ("startedAt" in first) return {
+			started: true,
+			startedAt: first.startedAt
+		};
+		return {
+			started: false,
+			log: first.log
+		};
+	}
+	/**
 	* Record a run that did not happen because the previous one had not
 	* finished.
 	*
@@ -899,7 +1136,7 @@ var CronScheduler = class {
 		if (!this.started) {
 			const now = /* @__PURE__ */ new Date();
 			for (const job of jobs) try {
-				viewOf(job.id).nextRunAt = parseCronExpression(job.definition.schedule, now, job.definition.timezone);
+				viewOf(job.id).nextRunAt = this.listedNextRun(job, now);
 			} catch {}
 		}
 		if (store?.fetchRunSummaries && ids.length > 0) try {
@@ -911,6 +1148,34 @@ var CronScheduler = class {
 		return views;
 	}
 	/**
+	* The next slot of `job` after `now`, for a listing on a process whose
+	* scheduler is not started — the `api` role, which Studio's Cron panel
+	* polls every 15 seconds.
+	*
+	* Cached on the job. The key is the job's schedule and zone (a re-register
+	* replaces the job, and with it the cache); the entry holds while
+	* `computedAt <= now < slot`. That is the same answer, not an
+	* approximation: the search found no matching minute between
+	* `computedAt`'s next minute and `slot`, so from any later instant before
+	* `slot` it lands on `slot` again. A clock that moves back, or reaching the
+	* slot, recomputes. The cache holds a pure function of the schedule, so
+	* there is nothing user- or role-scoped in it.
+	*/
+	listedNextRun(job, now) {
+		const { schedule, timezone } = job.definition;
+		const nowMs = now.getTime();
+		const cached = job.listedSlot;
+		if (cached && cached.schedule === schedule && cached.timezone === timezone && cached.computedAt <= nowMs && nowMs < cached.slot.getTime()) return cached.slot;
+		const slot = parseCronExpression(schedule, now, timezone);
+		job.listedSlot = {
+			schedule,
+			timezone,
+			computedAt: nowMs,
+			slot
+		};
+		return slot;
+	}
+	/**
 	* Warn once at start when the process looks like it is running on a
 	* platform that freezes or evicts instances between requests, where the
 	* in-process timers this scheduler relies on never fire.
@@ -1064,10 +1329,10 @@ var CronScheduler = class {
 	* - Persists to store (non-blocking) if available
 	* - Always restores state even on catastrophic errors
 	*/
-	executeJob(job, manual, seedLog) {
+	executeJob(job, manual, seedLog, onStart) {
 		const abort = new AbortController();
 		this.runControllers.add(abort);
-		const run = this.runJob(job, manual, abort, seedLog);
+		const run = this.runJob(job, manual, abort, seedLog, onStart);
 		this.track(run);
 		return run.finally(() => {
 			this.runControllers.delete(abort);
@@ -1081,7 +1346,7 @@ var CronScheduler = class {
 		};
 		work.then(release, release);
 	}
-	async runJob(job, manual, abort, seedLog) {
+	async runJob(job, manual, abort, seedLog, onStart) {
 		if (job.executing) return this.recordSkip(job, "already_executing", manual);
 		job.executing = true;
 		const lease = await this.acquireLease(job);
@@ -1091,14 +1356,14 @@ var CronScheduler = class {
 			return this.recordSkip(job, "already_executing", manual, lease.holder ?? "another process");
 		}
 		const startedAt = /* @__PURE__ */ new Date();
-		const capturedLogs = seedLog ? [seedLog] : [];
+		const capturedLogs = createLogCapture(seedLog || void 0);
 		const ctx = {
 			jobId: job.id,
 			scheduledAt: startedAt,
 			signal: abort.signal,
 			log: (...args) => {
 				const line = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-				capturedLogs.push(line);
+				capturedLogs.add(line);
 				logger.info(args.map((a) => typeof a === "string" ? a : stringifyForLog(a)).join(" "), { cron: job.id });
 			},
 			rebase: this.client
@@ -1106,6 +1371,7 @@ var CronScheduler = class {
 		job.state = "running";
 		job.lastRunAt = startedAt;
 		job.totalRuns++;
+		onStart?.(startedAt.toISOString());
 		let success = true;
 		let error;
 		let result;
@@ -1144,7 +1410,7 @@ var CronScheduler = class {
 			success,
 			error,
 			result: result !== void 0 ? result : void 0,
-			logs: capturedLogs,
+			logs: capturedLogs.close(),
 			manual
 		};
 		job.logs.push(logEntry);
@@ -1188,4 +1454,4 @@ var CronScheduler = class {
 //#endregion
 export { parseEnvBoolean as a, validateCronExpression as i, cron_scheduler_exports as n, isAlreadyExecutingSkip as r, CronScheduler as t };
 
-//# sourceMappingURL=cron-scheduler-CYQgco86.js.map
+//# sourceMappingURL=cron-scheduler-D1DT0nw5.js.map