@mark1russell7/kind 0.12.0 → 0.12.2

package/build/{judge-BH4WtL3f.d.ts → judge-3auejM2S.d.ts}

@@ -360,6 +360,12 @@ interface Workload {
    * then closes the session, and the next stream opens a new one. Without them, a session has no check.
    */
   readonly sessionCheck?: SessionCheckKnobs | undefined;
+  /**
+   * This count is the sessions of all clients that the lab places on the target before each run
+   * (`placementOf`). The other sessions go to the other replicas. Each client opens each session again
+   * until its first answer comes from its backend. With no value, the rules pick the backend of each session.
+   */
+  readonly onTarget?: number | undefined;
 }
 /**
  * A band is a range of times after a reference event of the run. The format `/1` gives each end
@@ -771,6 +777,44 @@ declare const outcomesOf: (requests: readonly Request[]) => Record<string, numbe
 declare const byClients: <T extends {
   readonly pod: string;
 }>(replicas: readonly T[], answers: ReadonlyMap<string, string>) => T[];
+/** These are the sessions of the clients at an instant: those on the target, of all, and those on the target by client. */
+interface Sessions {
+  readonly onTarget: number;
+  readonly of: number;
+  readonly byClient: Readonly<Record<string, number>>;
+}
+/**
+ * This function gives the sessions of the clients at an instant (`at`), and how many of them are on
+ * the target pod. A client sends each request on its next session in turn. Thus its last `connections`
+ * requests that started before the instant name its sessions, each by its local port. The backend of
+ * a session is the body of the last answer on its port before the instant: the name of the pod. A
+ * session with no such answer is not on the target. A request with no port names no session.
+ */
+declare const sessionsAt: (lines: readonly Line[], at: number, target: string, connections: number) => Sessions;
+/**
+ * The period of the clients is the interval between the starts of two requests in sequence of one
+ * client. Each time is in milliseconds when `A` is a number. The median and the mean are of all the
+ * intervals of all the clients, and `low` and `high` are the smallest and the largest interval.
+ * `intervals` is their count, and `byClient` is the median of each client. A client with c kept
+ * connections sends on each one in turn, thus each of its sessions gets a request each c periods.
+ */
+interface Period<A = number> {
+  readonly median: A;
+  readonly mean: A;
+  readonly low: A;
+  readonly high: A;
+  readonly intervals: number;
+  readonly byClient: Readonly<Record<string, A>>;
+}
+/**
+ * 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.
+ */
+declare const periodOf: (lines: readonly Line[], from: number, to: number) => Period | null;
 /** This function gives the requests of each node, by the name of the node. */
 declare const byNode: (requests: readonly Request[]) => Map<string, Request[]>;
 /** This function gives the time that the watcher first received a deletion timestamp of one of the pods, after a time. */
@@ -906,6 +950,25 @@ interface RunFacts<A = Quantity> {
     readonly empty: A | null;
     readonly ready: A | null;
   }> | undefined;
+  /**
+   * These are the sessions of the clients at the fault (`sessionsAt`): those on the target, of all,
+   * and those on the target by client. A run of a workload with kept connections and a target has them.
+   */
+  readonly sessions?: Sessions | undefined;
+  /**
+   * This is the stall of the target (`app-stall`): its start after the fault, and how long its loop
+   * stayed blocked. The app writes a line at each end of the stall. A run with no such line gives null.
+   */
+  readonly stall?: {
+    readonly start: A | null;
+    readonly held: A | null;
+  } | undefined;
+  /**
+   * This is the measured period of the clients (`periodOf`): the interval between two requests in
+   * sequence of one client. It comes from the request lines of the counted span of the run. A run
+   * with fewer than 2 requests of each client does not have it. A record before SYS-41 does not have it.
+   */
+  readonly period?: Period<A> | undefined;
 }
 /** A deleted replica is a replica of a run that got a deletion. It gives its pod, and the stamps of its intake (or null) and of its deletion. */
 interface Deleted {
@@ -1180,5 +1243,5 @@ declare const quantileOf: (sorted: readonly number[], p: number) => number;
  */
 declare const medianInterval: (sorted: readonly number[]) => [number, number];
 //#endregion
-export { unitOf as $, secondsOf as $t, TriggerV1 as A, KubeProxyMode as An, restartsAt as At, RunCheck as B, kindConfig as Bn, stoppingOf as Bt, KindCellResult as C, WindowPrediction as Cn, kernelCounts as Ct, PredictionV1 as D, KUBE_PROXY_MODES as Dn, recordsOf as Dt, LoadSample as E, Dataplane as En, podsOf as Et, KIND_NOISE as F, ZONE_LOST as Fn, sliceEmptyOf as Ft, factsOf as G, zoneOf as Gn, CLIENT as Gt, checkRun as H, nodeNames as Hn, tunnelsOf as Ht, KindDecision as I, cidrOverlap as In, sliceReadyAt as It, observationEnd as J, PORT as Jt, judgeKind as K, HEALTH_PORT as Kt, KindVerdict as L, cidrRange as Ln, sliceReadyOf as Lt, upgrade as M, NodeImage as Mn, signalOf as Mt, upgradeCell as N, ZONE_KEPT as Nn, signalsOf as Nt, RunCheckV1 as O, KindConfig as On, requestsOf as Ot, Deleted as P, ZONE_LABEL as Pn, sliceDropOf as Pt, reusesReset as Q, seconds as Qt, LAST_SLACK as R, goDuration as Rn, slicesOf as Rt, KindCellRecordV1 as S, TriggerKind as Sn, isTunnelState as St, KindVerdictV1 as T, DATAPLANES as Tn, podsAt as Tt, cyclesOf as U, scenario as Un, ztunnelPodsOf as Ut, RunFacts as V, kubeProxyPatch as Vn, transitionOf as Vt, deletionsOf as W, scenarioProblems as Wn, ztunnelReplaced as Wt, propagationSource as X, SERVER as Xt, propagationOf as Y, REDIS as Yt, referenceOf as Z, bandOf as Zt, ClusterManifest as _, Replica as _n, deletionOf as _t, STAGES as a, Flap as an, PropagationSource as at, FORMAT_V1 as b, Template as bn, failuresOf as bt, readRecord as c, KubeletProbe as cn, RulesLine as ct, calibrationOf as d, MeshMode as dn, TCP_STATE as dt, showBand as en, updatesOf as et, cellsTable as f, NonePrediction as fn, TunnelLine as ft, BandV1 as g, Reference as gn, byNode as gt, timeSpread as h, RedisDeclaration as hn, byClients as ht, quantileOf as i, EdgeProtocol as in, PodLine as it, judge as j, NODE_IMAGES as jn, rulesOf as jt, RunFactsV1 as k, KindScenario as kn, restartOf as kt, Judged as l, Mesh as ln, SliceLine as lt, predictionText as m, Prediction as mn, backendsAt as mt, medianInterval as n, Cycle as nn, HBONE_PORT as nt, kindCellRecordSchema as o, KindCell as on, RecordLine as ot, medianText as p, PodSettings as pn, ZtunnelPodLine as pt, observationAfter as q, LOG_LABEL as qt, middle as r, Declaration as rn, Line as rt, kindCellRecordV1Schema as s, KindRun as sn, Request as st, RELATIVE as t, Band as tn, Endpoint as tt, TimeSpread as u, MeshFlavor as un, SocketLine as ut, EnvironmentManifest as v, ResetReuse as vn, dropOf as vt, KindCellV1 as w, Workload as wn, outcomesOf as wt, KindCellRecord as x, Trigger as xn, intakeOf as xt, FORMAT as y, Stack as yn, emptyOf as yt, Propagated as z, isKubeProxyMode as zn, socketsOf as zt };
-//# sourceMappingURL=judge-BH4WtL3f.d.ts.map
+export { unitOf as $, REDIS as $t, TriggerV1 as A, Dataplane as An, recordsOf as At, RunCheck as B, cidrOverlap as Bn, sliceReadyAt as Bt, KindCellResult as C, Stack as Cn, intakeOf as Ct, PredictionV1 as D, WindowPrediction as Dn, periodOf as Dt, LoadSample as E, TriggerKind as En, outcomesOf as Et, KIND_NOISE as F, NODE_IMAGES as Fn, sessionsAt as Ft, factsOf as G, kubeProxyPatch as Gn, transitionOf as Gt, checkRun as H, goDuration as Hn, slicesOf as Ht, KindDecision as I, NodeImage as In, signalOf as It, observationEnd as J, scenarioProblems as Jn, ztunnelReplaced as Jt, judgeKind as K, nodeNames as Kn, tunnelsOf as Kt, KindVerdict as L, ZONE_KEPT as Ln, signalsOf as Lt, upgrade as M, KindConfig as Mn, restartOf as Mt, upgradeCell as N, KindScenario as Nn, restartsAt as Nt, RunCheckV1 as O, Workload as On, podsAt as Ot, Deleted as P, KubeProxyMode as Pn, rulesOf as Pt, reusesReset as Q, PORT as Qt, LAST_SLACK as R, ZONE_LABEL as Rn, sliceDropOf as Rt, KindCellRecordV1 as S, ResetReuse as Sn, failuresOf as St, KindVerdictV1 as T, Trigger as Tn, kernelCounts as Tt, cyclesOf as U, isKubeProxyMode as Un, socketsOf as Ut, RunFacts as V, cidrRange as Vn, sliceReadyOf as Vt, deletionsOf as W, kindConfig as Wn, stoppingOf as Wt, propagationSource as X, HEALTH_PORT as Xt, propagationOf as Y, zoneOf as Yn, CLIENT as Yt, referenceOf as Z, LOG_LABEL as Zt, ClusterManifest as _, PodSettings as _n, byClients as _t, STAGES as a, Band as an, PodLine as at, FORMAT_V1 as b, Reference as bn, dropOf as bt, readRecord as c, EdgeProtocol as cn, Request as ct, calibrationOf as d, KindRun as dn, SliceLine as dt, SERVER as en, updatesOf as et, cellsTable as f, KubeletProbe as fn, SocketLine as ft, BandV1 as g, NonePrediction as gn, backendsAt as gt, timeSpread as h, MeshMode as hn, ZtunnelPodLine as ht, quantileOf as i, showBand as in, Period as it, judge as j, KUBE_PROXY_MODES as jn, requestsOf as jt, RunFactsV1 as k, DATAPLANES as kn, podsOf as kt, Judged as l, Flap as ln, RulesLine as lt, predictionText as m, MeshFlavor as mn, TunnelLine as mt, medianInterval as n, seconds as nn, HBONE_PORT as nt, kindCellRecordSchema as o, Cycle as on, PropagationSource as ot, medianText as p, Mesh as pn, TCP_STATE as pt, observationAfter as q, scenario as qn, ztunnelPodsOf as qt, middle as r, secondsOf as rn, Line as rt, kindCellRecordV1Schema as s, Declaration as sn, RecordLine as st, RELATIVE as t, bandOf as tn, Endpoint as tt, TimeSpread as u, KindCell as un, Sessions as ut, EnvironmentManifest as v, Prediction as vn, byNode as vt, KindCellV1 as w, Template as wn, isTunnelState as wt, KindCellRecord as x, Replica as xn, emptyOf as xt, FORMAT as y, RedisDeclaration as yn, deletionOf as yt, Propagated as z, ZONE_LOST as zn, sliceEmptyOf as zt };
+//# sourceMappingURL=judge-3auejM2S.d.ts.map

package/build/{judge-CMQeiw8k.js → judge-BRxKwiSp.js}

@@ -73,6 +73,72 @@ const byClients = (replicas, answers) => {
 	const count = (pod) => [...answers.values()].filter((backend) => backend === pod).length;
 	return [...replicas].sort((a, b) => count(b.pod) - count(a.pod) || a.pod.localeCompare(b.pod));
 };
+/**
+* This function gives the sessions of the clients at an instant (`at`), and how many of them are on
+* the target pod. A client sends each request on its next session in turn. Thus its last `connections`
+* requests that started before the instant name its sessions, each by its local port. The backend of
+* a session is the body of the last answer on its port before the instant: the name of the pod. A
+* session with no such answer is not on the target. A request with no port names no session.
+*/
+const sessionsAt = (lines, at, target, connections) => {
+	const before = requestsOf(lines).filter((request) => request.t < at).sort((a, b) => a.t - b.t);
+	const byClient = {};
+	let of = 0;
+	for (const client of [...new Set(before.map((request) => request.p))].sort()) {
+		const mine = before.filter((request) => request.p === client);
+		const ports = new Set(mine.slice(-connections).flatMap((request) => typeof request.lp === "number" ? [request.lp] : []));
+		const backend = (port) => mine.filter((request) => request.lp === port && request.o === "ok" && request.b !== void 0).at(-1)?.b;
+		byClient[client] = [...ports].filter((port) => backend(port) === target).length;
+		of += ports.size;
+	}
+	return {
+		onTarget: Object.values(byClient).reduce((sum, count) => sum + count, 0),
+		of,
+		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();
@@ -400,6 +466,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),
@@ -417,7 +484,37 @@ const factsOf = (cell, run) => {
 		...listens(cell) ? {
 			updates: updatesOf(run, run.acts.fault),
 			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) } : {},
+		...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.
+*/
+const stallFactOf = (run) => {
+	const fault = run.acts.fault;
+	const pod = run.target?.pod;
+	const mine = run.lines.filter((line) => line.ev === "stall" && (pod === void 0 || line["p"] === pod) && line.t >= run.start);
+	const start = mine.find((line) => line["phase"] === "start");
+	const end = mine.find((line) => line["phase"] === "end");
+	const held = end === void 0 ? void 0 : Number(end["held"]);
+	return {
+		start: start === void 0 || fault === null ? null : seconds(sec(start.t - fault)),
+		held: held === void 0 || !Number.isFinite(held) ? null : seconds(sec(held))
 	};
 };
 /**
@@ -1123,7 +1220,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, ...rest } = facts;
+	const { sliceEmpty, rules, left, signals, updates, healUpdates, closes, cycles, stall, period, ...rest } = facts;
 	return {
 		...rest,
 		intakeAfterDeletion: time$1(facts.intakeAfterDeletion),
@@ -1139,7 +1236,19 @@ const upgradeFacts = (facts) => {
 		...cycles === void 0 ? {} : { cycles: cycles.map((old) => ({
 			empty: time$1(old.empty),
 			ready: time$1(old.ready)
-		})) }
+		})) },
+		...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)]))
+		} }
 	};
 };
 /**
@@ -1614,7 +1723,8 @@ const recordOf = (a, main) => {
 			sessionCheck: z.object({
 				keepalive_time: extent,
 				keepalive_timeout: time
-			}).optional()
+			}).optional(),
+			onTarget: count.optional()
 		}),
 		prediction,
 		calibrates: z.boolean(),
@@ -1654,7 +1764,24 @@ const recordOf = (a, main) => {
 		cycles: z.array(z.object({
 			empty: a.nullable(),
 			ready: a.nullable()
-		})).optional()
+		})).optional(),
+		sessions: z.object({
+			onTarget: count,
+			of: count,
+			byClient: z.record(z.string(), count)
+		}).optional(),
+		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 {
 		cell,
@@ -1716,6 +1843,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, 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, showBand 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 _, REDIS as _t, calibrationOf as a, sliceReadyOf as at, factsOf as b, seconds as bt, predictionText as c, stoppingOf as ct, FORMAT_V1 as d, ztunnelPodsOf as dt, signalOf as et, judge as f, ztunnelReplaced as ft, LAST_SLACK as g, PORT as gt, KIND_NOISE as h, LOG_LABEL as ht, readRecord as i, sliceReadyAt as it, medianInterval as j, updatesOf as k, timeSpread as l, transitionOf as lt, upgradeCell as m, HEALTH_PORT as mt, kindCellRecordSchema as n, sliceDropOf as nt, cellsTable as o, slicesOf as ot, upgrade as p, CLIENT as pt, podsAt as q, kindCellRecordV1Schema as r, sliceEmptyOf as rt, medianText as s, socketsOf as st, STAGES as t, signalsOf as tt, FORMAT as u, tunnelsOf as ut, cyclesOf as v, SERVER as vt, propagationOf as w, judgeKind as x, secondsOf as xt, deletionsOf as y, bandOf as yt, deletionOf as z };
+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 };
 
-//# sourceMappingURL=judge-CMQeiw8k.js.map
+//# sourceMappingURL=judge-BRxKwiSp.js.map