@mark1russell7/kind 0.12.2 → 0.12.4

package/build/{judge-BRxKwiSp.js → judge-45z0yZ-r.js}

@@ -23,6 +23,61 @@ const showBand = (band) => {
 	const { lo, hi } = secondsOf(band);
 	return `[${lo}, ${hi}] s`;
 };
+/** This function rounds a time to the microsecond, thus a band has no float residue. */
+const us = (value) => Math.round(value * 1e6) / 1e6;
+/**
+* This function gives the end band of a window with the backlog term (`BacklogTerm`). It adds n × d
+* to each end of `end`, the end band without the term. The value n is the sessions on the target.
+*/
+const backlogEnd = (end, term, sessions) => {
+	const ends = secondsOf(end);
+	const drain = secondsOf(term.drain);
+	return bandOf(us(ends.lo + sessions * drain.lo), us(ends.hi + sessions * drain.hi));
+};
+/** This function gives a count rounded to six places, thus 10 s / 20 ms gives 500 and not 499.99999. */
+const counted = (value) => Math.round(value * 1e6) / 1e6;
+/** This function gives the turn of a session in seconds: the mean period of a client times its sessions. */
+const turnOf = (mean, connections) => {
+	const turn = valueIn(mean, "s") * connections;
+	if (!(turn > 0)) throw new RangeError(`a turn of ${turn} s cannot count requests`);
+	return turn;
+};
+/**
+* This function gives the drain failures of one session on the target (SYS-43). A session fails a
+* request each turn until the window closes. With n sessions on the target, the window closes up to
+* n × d.hi after the band end (`backlogEnd`). Thus one session fails 0 to ceil(n × d.hi / turn)
+* requests in the drain. The turn is the mean period of a client (`mean`) times its sessions
+* (`connections`). The term r is not in this band.
+*/
+const drainBand = (term, mean, connections, sessions) => {
+	const turn = turnOf(mean, connections);
+	return {
+		lo: 0,
+		hi: Math.ceil(counted(sessions * valueIn(term.drain.hi, "s") / turn))
+	};
+};
+/**
+* This function gives the failed requests that the backlog term predicts (`BacklogTerm`). Each of
+* the n sessions on the target gets a request each turn. The turn is the measured mean period of a
+* client (`mean`) times the sessions of the client (`connections`). The requests of a session fail
+* from the start of the window to the band end (`span`). That span holds `span / turn` requests, one
+* less at its low edge and one more at its high edge. Each session fails r more requests in its drain time.
+*
+* A term with `drains` (SYS-43) also adds the drain failures of each session (`drainBand`).
+*/
+const requestBand = (term, span, mean, connections, sessions) => {
+	const turn = turnOf(mean, connections);
+	const each = counted(valueIn(span, "s") / turn);
+	if (term.drains === true && term.drain === void 0) throw new RangeError("a term with drains has no drain time d");
+	const drained = term.drains === true ? drainBand({ drain: term.drain }, mean, connections, sessions) : {
+		lo: 0,
+		hi: 0
+	};
+	return {
+		lo: sessions * (Math.floor(each) - 1 + term.requests.lo + drained.lo),
+		hi: sessions * (Math.ceil(each) + 1 + term.requests.hi + drained.hi)
+	};
+};
 //#endregion
 //#region src/names.ts
 /** These are the ports of the app: its server, and its health server for the probes. */
@@ -427,7 +482,8 @@ const windowOf = (prediction) => prediction.kind === "window" ? prediction : pre
 const observationAfter = (cell) => {
 	const window = windowOf(cell.prediction);
 	if (window === null || window.end === null) return null;
-	return seconds(sec(valueIn(window.end.band.hi, "ms") + valueIn(cell.workload.timeout, "ms") + NOISE));
+	const drained = window.backlog === void 0 ? 0 : window.backlog.most * valueIn(window.backlog.drain.hi, "ms");
+	return seconds(sec(valueIn(window.end.band.hi, "ms") + drained + valueIn(cell.workload.timeout, "ms") + NOISE));
 };
 /**
 * This function gives the earliest end of the observation of a run, as a stamp, or null when its
@@ -585,6 +641,27 @@ const removalOfCycles = (cell, run, prediction, done) => {
 		tail: inner.tail
 	};
 };
+/**
+* This function counts the failed requests of a run with the backlog term (`requestBand`). The span
+* is from the start of the window to the end band without the term. The turn of a session comes
+* from the measured mean period of the clients. A run with no measured period cannot be counted.
+*/
+const countOf = (cell, window, term, onTarget, period, failed) => {
+	if (period === void 0) return {
+		ok: false,
+		why: "the run has no measured period, thus the backlog term cannot count its failed requests"
+	};
+	const span = seconds(Math.round((valueIn(window.end.band.hi, "s") - valueIn(window.start.band.lo, "s")) * 1e6) / 1e6);
+	const band = requestBand(term, span, period.mean, cell.workload.connections ?? 1, onTarget);
+	const at = `the count [${band.lo}, ${band.hi}] of ${onTarget} session${onTarget === 1 ? "" : "s"} on the target at a mean period of ${Math.round(valueIn(period.mean, "ms") * 1e3) / 1e3} ms`;
+	return failed >= band.lo && failed <= band.hi ? {
+		ok: true,
+		why: `in ${at}`
+	} : {
+		ok: false,
+		why: `${failed} failed requests, outside ${at}`
+	};
+};
 /** This function judges one run against the prediction of its cell. */
 const checkRun = (cell, run) => {
 	const lines = run.lines;
@@ -614,7 +691,10 @@ const checkRun = (cell, run) => {
 		case "window": {
 			const each = prediction.each === true;
 			const opens = secondsOf(prediction.start.band);
-			const closes = prediction.end === null ? null : secondsOf(prediction.end.band);
+			const backlog = prediction.backlog;
+			const onTarget = facts.sessions?.onTarget;
+			if (backlog !== void 0 && (prediction.end === null || prediction.end.from !== prediction.start.from || onTarget === void 0)) return done(false, onTarget === void 0 ? "the run has no sessions on the target at the fault, thus the backlog term has no n" : "a window with the backlog term has an end with the reference of its start", null);
+			const closes = prediction.end === null ? null : secondsOf(backlog === void 0 ? prediction.end.band : backlogEnd(prediction.end.band, backlog, onTarget));
 			const droppedAfter = (origin, propagation) => (node) => {
 				const propagated = propagation[node];
 				return origin === null || propagated === void 0 || propagated === null ? null : origin + valueIn(propagated.by, "ms");
@@ -708,6 +788,8 @@ const checkRun = (cell, run) => {
 			if (others.length > 0) problems.push(`${others.length} failed requests on nodes whose kube-proxy did not pause`);
 			if (wrong.length > 0) problems.push(`${wrong.length} failed requests in the window ended ${JSON.stringify(outcomesOf(wrong))}, not ${allowed.join(", ")}`);
 			if (prediction.certain && relevant.length === 0) problems.push("no request failed in a window that the law opens");
+			const counted = backlog === void 0 ? null : countOf(cell, prediction, backlog, onTarget, facts.period, relevant.length);
+			if (counted !== null && !counted.ok) problems.push(counted.why);
 			const final = windows.reduce((a, b) => (b.end ?? Number.NEGATIVE_INFINITY) > (a.end ?? Number.NEGATIVE_INFINITY) ? b : a);
 			if (flaps && prediction.certain && relevant.length > 0) windows.forEach((window, k) => {
 				const own = relevant.filter((request) => request.t >= window.lo && request.t <= window.hi);
@@ -725,7 +807,7 @@ const checkRun = (cell, run) => {
 			const inside = relevant.filter((request) => !late.includes(request));
 			const span = inside.length === 0 ? 0 : sec(inside.at(-1).t - inside[0].t);
 			const where = each ? `the windows of ${windows.length} deleted replicas` : flaps ? `the windows of ${windows.length} cycles` : "the window";
-			const agrees = reused.length === 0 ? `${relevant.length} failed requests, all in ${where} (span ${span} s)` : `${inside.length} failed requests in ${where} (span ${span} s), and ${reused.length} on a port that a reset closed`;
+			const agrees = (reused.length === 0 ? `${relevant.length} failed requests, all in ${where} (span ${span} s)` : `${inside.length} failed requests in ${where} (span ${span} s), and ${reused.length} on a port that a reset closed`) + (counted === null ? "" : `, ${counted.why}`);
 			const checked = done(problems.length === 0, problems.length === 0 ? agrees : problems.join("; "), relevant.length);
 			if (problems.length > 0) return checked;
 			const notes = [];
@@ -1155,7 +1237,7 @@ const upgradeTrigger = (trigger) => {
 	};
 };
 const upgradeWindow = (window) => {
-	const { afterReset, propagation, ...rest } = window;
+	const { afterReset, propagation, backlog, ...rest } = window;
 	return {
 		...rest,
 		start: {
@@ -1170,7 +1252,11 @@ const upgradeWindow = (window) => {
 			life: seconds(afterReset.life),
 			outcome: afterReset.outcome
 		} },
-		...propagation === void 0 ? {} : { propagation: band(propagation) }
+		...propagation === void 0 ? {} : { propagation: band(propagation) },
+		...backlog === void 0 ? {} : { backlog: {
+			...backlog,
+			drain: band(backlog.drain)
+		} }
 	};
 };
 const upgradePrediction = (prediction) => {
@@ -1318,7 +1404,7 @@ const atBand = (from, band) => {
 const predictionText = (prediction) => {
 	switch (prediction.kind) {
 		case "none": return prediction.outcomes === void 0 ? "no failure" : `no ${prediction.outcomes.join(", ")}`;
-		case "window": return `failures only from ${atBand(prediction.start.from, prediction.start.band)}${prediction.end === null ? "" : ` to ${atBand(prediction.end.from, prediction.end.band)}`}${prediction.each === true ? ", of each deleted replica" : ""}${prediction.flaps === true ? ", in each cycle" : ""}${prediction.nodes === "paused" ? ", on the paused node" : ""}${prediction.certain ? ", at least one" : ""}${prediction.outcomes === void 0 ? "" : `, each one ${prediction.outcomes.join(" or ")}`}${prediction.afterReset === void 0 ? "" : `, or a ${prediction.afterReset.outcome} up to ${format(prediction.afterReset.life)} after a reset on its port`}${prediction.propagation === void 0 ? "" : `, the rules drop the replica in ${showBand(prediction.propagation)}`}`;
+		case "window": return `failures only from ${atBand(prediction.start.from, prediction.start.band)}${prediction.end === null ? "" : ` to ${atBand(prediction.end.from, prediction.end.band)}`}${prediction.each === true ? ", of each deleted replica" : ""}${prediction.flaps === true ? ", in each cycle" : ""}${prediction.nodes === "paused" ? ", on the paused node" : ""}${prediction.certain ? ", at least one" : ""}${prediction.outcomes === void 0 ? "" : `, each one ${prediction.outcomes.join(" or ")}`}${prediction.afterReset === void 0 ? "" : `, or a ${prediction.afterReset.outcome} up to ${format(prediction.afterReset.life)} after a reset on its port`}${prediction.propagation === void 0 ? "" : `, the rules drop the replica in ${showBand(prediction.propagation)}`}${prediction.backlog === void 0 ? "" : `, the end n × ${showBand(prediction.backlog.drain)} later and ${prediction.backlog.requests.lo}–${prediction.backlog.requests.hi} more failures for each of the n sessions on the target${prediction.backlog.drains === true ? ", and its failures each turn in the drain of the n sessions" : ""}, counted at the measured period`}`;
 		case "removal": return `Service empty in ${showBand(prediction.band)}${prediction.flaps === true ? " after each fault, and ready again before the next" : ""}${prediction.window === void 0 ? "" : `; ${predictionText(prediction.window)}`}`;
 		case "leaves": return `the replica leaves in ${showBand(prediction.band)}${prediction.window === void 0 ? "" : `; ${predictionText(prediction.window)}`}`;
 		case "restarts": return prediction.band === null ? "no restart" : `each replica SIGTERM in ${showBand(prediction.band)}`;
@@ -1618,6 +1704,15 @@ const recordOf = (a, main) => {
 		propagation: band.optional(),
 		flaps: z.boolean().optional(),
 		outcomes: z.array(z.string()).optional(),
+		backlog: z.object({
+			drain: band,
+			requests: z.object({
+				lo: count,
+				hi: count
+			}),
+			most: count,
+			drains: z.boolean().optional()
+		}).optional(),
 		why: z.string()
 	});
 	const none = z.object({
@@ -1843,6 +1938,6 @@ const readRecord = (data) => {
 	throw new Error(`a kind cell record has the format ${FORMAT} or ${FORMAT_V1}, not ${String(format)}`);
 };
 //#endregion
-export { restartsAt as $, RELATIVE as A, dropOf as B, observationEnd as C, secondsOf as Ct, reusesReset as D, referenceOf as E, TCP_STATE as F, kernelCounts as G, failuresOf as H, backendsAt as I, podsAt as J, outcomesOf as K, byClients as L, middle as M, quantileOf as N, unitOf as O, HBONE_PORT as P, restartOf as Q, byNode as R, observationAfter as S, seconds as St, propagationSource as T, intakeOf as U, emptyOf as V, isTunnelState as W, recordsOf as X, podsOf as Y, requestsOf as Z, checkRun as _, LOG_LABEL as _t, calibrationOf as a, sliceEmptyOf as at, factsOf as b, SERVER as bt, predictionText as c, slicesOf as ct, FORMAT_V1 as d, transitionOf as dt, rulesOf as et, judge as f, tunnelsOf as ft, LAST_SLACK as g, HEALTH_PORT as gt, KIND_NOISE as h, CLIENT as ht, readRecord as i, sliceDropOf as it, medianInterval as j, updatesOf as k, timeSpread as l, socketsOf as lt, upgradeCell as m, ztunnelReplaced as mt, kindCellRecordSchema as n, signalOf as nt, cellsTable as o, sliceReadyAt as ot, upgrade as p, ztunnelPodsOf as pt, periodOf as q, kindCellRecordV1Schema as r, signalsOf as rt, medianText as s, sliceReadyOf as st, STAGES as t, sessionsAt as tt, FORMAT as u, stoppingOf as ut, cyclesOf as v, PORT as vt, propagationOf as w, showBand as wt, judgeKind as x, bandOf as xt, deletionsOf as y, REDIS as yt, deletionOf as z };
+export { restartsAt as $, RELATIVE as A, dropOf as B, observationEnd as C, drainBand as Ct, reusesReset as D, showBand as Dt, referenceOf as E, secondsOf as Et, TCP_STATE as F, kernelCounts as G, failuresOf as H, backendsAt as I, podsAt as J, outcomesOf as K, byClients as L, middle as M, quantileOf as N, unitOf as O, HBONE_PORT as P, restartOf as Q, byNode as R, observationAfter as S, bandOf as St, propagationSource as T, seconds as Tt, intakeOf as U, emptyOf as V, isTunnelState as W, recordsOf as X, podsOf as Y, requestsOf as Z, checkRun as _, LOG_LABEL as _t, calibrationOf as a, sliceEmptyOf as at, factsOf as b, SERVER as bt, predictionText as c, slicesOf as ct, FORMAT_V1 as d, transitionOf as dt, rulesOf as et, judge as f, tunnelsOf as ft, LAST_SLACK as g, HEALTH_PORT as gt, KIND_NOISE as h, CLIENT as ht, readRecord as i, sliceDropOf as it, medianInterval as j, updatesOf as k, timeSpread as l, socketsOf as lt, upgradeCell as m, ztunnelReplaced as mt, kindCellRecordSchema as n, signalOf as nt, cellsTable as o, sliceReadyAt as ot, upgrade as p, ztunnelPodsOf as pt, periodOf as q, kindCellRecordV1Schema as r, signalsOf as rt, medianText as s, sliceReadyOf as st, STAGES as t, sessionsAt as tt, FORMAT as u, stoppingOf as ut, cyclesOf as v, PORT as vt, propagationOf as w, requestBand as wt, judgeKind as x, backlogEnd as xt, deletionsOf as y, REDIS as yt, deletionOf as z };
 
-//# sourceMappingURL=judge-BRxKwiSp.js.map
+//# sourceMappingURL=judge-45z0yZ-r.js.map