@mark1russell7/kind 0.12.1 → 0.12.3

package/build/{judge-BdykXjF2.js → judge-2EZajeXa.js}

@@ -23,6 +23,33 @@ 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 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.
+*/
+const requestBand = (term, span, mean, connections, sessions) => {
+	const turn = valueIn(mean, "s") * connections;
+	if (!(turn > 0)) throw new RangeError(`a turn of ${turn} s cannot count requests`);
+	const each = Math.round(valueIn(span, "s") / turn * 1e6) / 1e6;
+	return {
+		lo: sessions * (Math.floor(each) - 1 + term.requests.lo),
+		hi: sessions * (Math.ceil(each) + 1 + term.requests.hi)
+	};
+};
 //#endregion
 //#region src/names.ts
 /** These are the ports of the app: its server, and its health server for the probes. */
@@ -97,6 +124,48 @@ const sessionsAt = (lines, at, target, connections) => {
 		byClient
 	};
 };
+const medianOf = (sorted) => {
+	const middle = Math.floor(sorted.length / 2);
+	return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+};
+/**
+* This function gives the measured period of the clients from their request lines that start from
+* `from` to `to`. The timer of a client is late by a different amount at each tick. Thus the median
+* stays near the setting of the client (`every`), but the lateness adds up in the mean.
+*
+* The mean is the span of the requests of each client over its intervals. A band can count the requests of a client in a window from the
+* mean. A client with fewer than 2 requests gives no interval. A run with no interval gives null.
+*/
+const periodOf = (lines, from, to) => {
+	const starts = /* @__PURE__ */ new Map();
+	for (const request of requestsOf(lines)) {
+		if (request.t < from || request.t > to) continue;
+		const mine = starts.get(request.p) ?? [];
+		mine.push(request.t);
+		starts.set(request.p, mine);
+	}
+	const all = [];
+	const byClient = {};
+	let span = 0;
+	for (const client of [...starts.keys()].sort()) {
+		const mine = starts.get(client).sort((a, b) => a - b);
+		if (mine.length < 2) continue;
+		const intervals = mine.slice(1).map((t, at) => t - mine[at]);
+		span += mine.at(-1) - mine[0];
+		all.push(...intervals);
+		byClient[client] = medianOf(intervals.sort((a, b) => a - b));
+	}
+	if (all.length === 0) return null;
+	all.sort((a, b) => a - b);
+	return {
+		median: medianOf(all),
+		mean: span / all.length,
+		low: all[0],
+		high: all.at(-1),
+		intervals: all.length,
+		byClient
+	};
+};
 /** This function gives the requests of each node, by the name of the node. */
 const byNode = (requests) => {
 	const out = /* @__PURE__ */ new Map();
@@ -385,7 +454,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
@@ -424,6 +494,7 @@ const factsOf = (cell, run) => {
 	const intake = referenceOf(run, "intake");
 	const crash = cell.trigger.kind === "crash" ? run.acts.fault : null;
 	const from = deletion ?? crash;
+	const period = periodOf(lines, run.start, run.end);
 	return {
 		failures: failures.length,
 		outcomes: outcomesOf(failures),
@@ -443,9 +514,21 @@ const factsOf = (cell, run) => {
 			healUpdates: updatesOf(run, run.acts.heal)
 		} : {},
 		...cell.workload.connections !== void 0 && run.target !== null && run.acts.fault !== null ? { sessions: sessionsAt(lines, run.acts.fault, run.target.pod, cell.workload.connections) } : {},
-		...cell.trigger.kind === "app-stall" ? { stall: stallFactOf(run) } : {}
+		...cell.trigger.kind === "app-stall" ? { stall: stallFactOf(run) } : {},
+		...period === null ? {} : { period: periodFact(period) }
 	};
 };
+/** This function gives a time in milliseconds in seconds, to the microsecond. A period of a client is approximately 10 ms, thus a whole millisecond is too coarse. */
+const fine = (ms) => seconds(Math.round(ms * 1e3) / 1e6);
+/** This function gives the period of the clients (`periodOf`) with each time in seconds. */
+const periodFact = (period) => ({
+	median: fine(period.median),
+	mean: fine(period.mean),
+	low: fine(period.low),
+	high: fine(period.high),
+	intervals: period.intervals,
+	byClient: Object.fromEntries(Object.entries(period.byClient).map(([client, ms]) => [client, fine(ms)]))
+});
 /**
 * This function gives the stall of the target in a run. It is the start of its line `stall` after the
 * fault, and the time that the app gives in its end line (`held`). A time that the run does not have is null.
@@ -530,6 +613,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;
@@ -559,7 +663,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");
@@ -653,6 +760,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);
@@ -670,7 +779,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 = [];
@@ -1100,7 +1209,7 @@ const upgradeTrigger = (trigger) => {
 	};
 };
 const upgradeWindow = (window) => {
-	const { afterReset, propagation, ...rest } = window;
+	const { afterReset, propagation, backlog, ...rest } = window;
 	return {
 		...rest,
 		start: {
@@ -1115,7 +1224,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) => {
@@ -1165,7 +1278,7 @@ const upgradeFacts = (facts) => {
 		by: seconds(old.by)
 	};
 	const byKey = (record) => Object.fromEntries(Object.entries(record).map(([key, old]) => [key, propagated(old)]));
-	const { sliceEmpty, rules, left, signals, updates, healUpdates, closes, cycles, stall, ...rest } = facts;
+	const { sliceEmpty, rules, left, signals, updates, healUpdates, closes, cycles, stall, period, ...rest } = facts;
 	return {
 		...rest,
 		intakeAfterDeletion: time$1(facts.intakeAfterDeletion),
@@ -1185,6 +1298,14 @@ const upgradeFacts = (facts) => {
 		...stall === void 0 ? {} : { stall: {
 			start: time$1(stall.start),
 			held: time$1(stall.held)
+		} },
+		...period === void 0 ? {} : { period: {
+			...period,
+			median: seconds(period.median),
+			mean: seconds(period.mean),
+			low: seconds(period.low),
+			high: seconds(period.high),
+			byClient: Object.fromEntries(Object.entries(period.byClient).map(([client, old]) => [client, seconds(old)]))
 		} }
 	};
 };
@@ -1255,7 +1376,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, 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)}`;
@@ -1555,6 +1676,14 @@ 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
+		}).optional(),
 		why: z.string()
 	});
 	const none = z.object({
@@ -1710,6 +1839,14 @@ const recordOf = (a, main) => {
 		stall: z.object({
 			start: a.nullable(),
 			held: a.nullable()
+		}).optional(),
+		period: z.object({
+			median: a,
+			mean: a,
+			low: a,
+			high: a,
+			intervals: count,
+			byClient: z.record(z.string(), a)
 		}).optional()
 	});
 	return {
@@ -1772,6 +1909,6 @@ const readRecord = (data) => {
 	throw new Error(`a kind cell record has the format ${FORMAT} or ${FORMAT_V1}, not ${String(format)}`);
 };
 //#endregion
-export { rulesOf as $, RELATIVE as A, dropOf as B, observationEnd as C, showBand as Ct, reusesReset as D, referenceOf as E, TCP_STATE as F, kernelCounts as G, failuresOf as H, backendsAt as I, podsOf as J, outcomesOf as K, byClients as L, middle as M, quantileOf as N, unitOf as O, HBONE_PORT as P, restartsAt as Q, byNode as R, observationAfter as S, secondsOf as St, propagationSource as T, intakeOf as U, emptyOf as V, isTunnelState as W, requestsOf as X, recordsOf as Y, restartOf as Z, checkRun as _, PORT as _t, calibrationOf as a, sliceReadyAt as at, factsOf as b, bandOf as bt, predictionText as c, socketsOf as ct, FORMAT_V1 as d, tunnelsOf as dt, sessionsAt as et, judge as f, ztunnelPodsOf as ft, LAST_SLACK as g, LOG_LABEL as gt, KIND_NOISE as h, HEALTH_PORT as ht, readRecord as i, sliceEmptyOf as it, medianInterval as j, updatesOf as k, timeSpread as l, stoppingOf as lt, upgradeCell as m, CLIENT as mt, kindCellRecordSchema as n, signalsOf as nt, cellsTable as o, sliceReadyOf as ot, upgrade as p, ztunnelReplaced as pt, podsAt as q, kindCellRecordV1Schema as r, sliceDropOf as rt, medianText as s, slicesOf as st, STAGES as t, signalOf as tt, FORMAT as u, transitionOf as ut, cyclesOf as v, REDIS as vt, propagationOf as w, judgeKind as x, seconds as xt, deletionsOf as y, SERVER as yt, deletionOf as z };
+export { restartsAt as $, RELATIVE as A, dropOf as B, observationEnd as C, requestBand as Ct, reusesReset as D, referenceOf as E, showBand 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, secondsOf 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, seconds as wt, judgeKind as x, backlogEnd as xt, deletionsOf as y, REDIS as yt, deletionOf as z };
 
-//# sourceMappingURL=judge-BdykXjF2.js.map
+//# sourceMappingURL=judge-2EZajeXa.js.map