@rocicorp/zero 1.11.0-canary.4 → 1.11.0-canary.40

package/out/zero-cache/src/services/view-syncer/query-stats.d.ts

@@ -0,0 +1,89 @@
+import type { LogContext } from '@rocicorp/logger';
+import type { PlanWarning } from '../../../../zql/src/planner/planner-warnings.ts';
+import type { QueryShape } from './query-shape.ts';
+/** The query that work is accounted to. */
+export type QueryIdentity = {
+    readonly queryName?: string | undefined;
+    readonly shape: QueryShape;
+};
+export type HydrationOutcome = 'finished' | 'aborted' | 'failed';
+export type HydrationRecord = {
+    readonly outcome: HydrationOutcome;
+    readonly timeMs: number;
+    /** Only for a finished hydration. */
+    readonly rowCount?: number | undefined;
+    /** Only for a finished hydration. */
+    readonly rowsRead?: number | undefined;
+    readonly planWarnings?: readonly PlanWarning[] | undefined;
+};
+export type AdvanceRecord = {
+    /** The time spent processing the pushes to the query. */
+    readonly timeMs: number;
+    /** The number of changes pushed to the query. */
+    readonly changes: number;
+    /** Whether the advancement timed out and reset the pipelines. */
+    readonly timedOut: boolean;
+};
+/** Why an advancement stopped pushing to a query and hydrated it again. */
+export type AbandonReason = 'estimate' | 'read' | 'cutoff';
+export type QueryStatsOptions = {
+    /**
+     * The most query shapes tracked per interval. Work on shapes beyond this is
+     * accounted to the interval's totals only, which bounds memory when the
+     * shape space is unbounded (e.g. dynamically built queries).
+     */
+    readonly maxShapes?: number | undefined;
+    /**
+     * The most query shapes logged per interval, those that took the most
+     * time. The rest are included in the interval's totals.
+     */
+    readonly maxReported?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    /** Returns the index uses since the last call. See `recordIndexUsage()`. */
+    readonly takeIndexUsage?: (() => Map<string, number>) | undefined;
+};
+/**
+ * Aggregates the work done for each query shape (the query with its values
+ * redacted, see {@link QueryShape}) on a worker, and periodically logs it,
+ * like `pg_stat_statements` does for Postgres.
+ *
+ * Unlike the slow query logs, which are throttled and only written above a
+ * threshold, every hydration and advancement is counted, so the logs can be
+ * summed over any time range and across workers to rank queries by the time
+ * they take.
+ *
+ * Each {@link flush} logs the interval since the previous one:
+ *
+ * - a `query-stats` event per query shape, for the {@link
+ *   QueryStatsOptions.maxReported} shapes that took the most time, and
+ * - a `query-stats-summary` event with the totals of all shapes, including
+ *   those not reported individually, and the `indexUses`: how often the
+ *   process read each index of the replica, like `pg_stat_user_indexes`. An
+ *   index that is never read is absent. The workers of a single-process
+ *   zero-cache share these counts, which the first of them to flush reports.
+ *
+ * The events carry counts, sums, minimums and maximums, which compose across
+ * intervals and workers.
+ */
+export declare class QueryStats {
+    #private;
+    constructor({ maxShapes, maxReported, now, takeIndexUsage: takeIndexUsageFn, }?: QueryStatsOptions);
+    recordHydration(query: QueryIdentity, record: HydrationRecord): void;
+    recordAdvance(query: QueryIdentity, record: AdvanceRecord): void;
+    /**
+     * Records that an advancement abandoned the query's pipeline, to hydrate
+     * the query again.
+     */
+    recordAbandoned(query: QueryIdentity, reason: AbandonReason): void;
+    /**
+     * Logs the stats of the interval since the previous flush, and starts a
+     * new interval. Nothing is logged for an interval without any work.
+     */
+    flush(lc: LogContext): void;
+    /**
+     * Flushes every `intervalMs` until the returned function is called, which
+     * flushes one last time.
+     */
+    start(lc: LogContext, intervalMs: number): () => void;
+}
+//# sourceMappingURL=query-stats.d.ts.map

package/out/zero-cache/src/services/view-syncer/query-stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-stats.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/query-stats.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,iDAAiD,CAAC;AAEjF,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,2CAA2C;AAC3C,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEjE,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qCAAqC;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,qCAAqC;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,WAAW,EAAE,GAAG,SAAS,CAAC;CAC5D,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,2EAA2E;AAC3E,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE3D,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAExC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE1C,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;IAE1C,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;CACnE,CAAC;AA4HF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,UAAU;;IAWrB,YAAY,EACV,SAAgB,EAChB,WAAiB,EACjB,GAAc,EACd,cAAc,EAAE,gBAAiC,GAClD,GAAE,iBAAsB,EAQxB;IAED,eAAe,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CASnE;IAED,aAAa,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI,CAG/D;IAED;;;OAGG;IACH,eAAe,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI,CAMjE;IAgBD;;;OAGG;IACH,KAAK,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI,CAuC1B;IAED;;;OAGG;IACH,KAAK,CAAC,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,IAAI,CAOpD;CACF"}

package/out/zero-cache/src/services/view-syncer/query-stats.js

@@ -0,0 +1,233 @@
+import { assert } from "../../../../shared/src/asserts.js";
+import { takeIndexUsage } from "../../../../zqlite/src/index-usage.js";
+//#region ../zero-cache/src/services/view-syncer/query-stats.ts
+var Distribution = class {
+	count = 0;
+	sumMs = 0;
+	minMs = Infinity;
+	maxMs = 0;
+	add(ms) {
+		this.count++;
+		this.sumMs += ms;
+		this.minMs = Math.min(this.minMs, ms);
+		this.maxMs = Math.max(this.maxMs, ms);
+	}
+	toJSON() {
+		return {
+			count: this.count,
+			sumMs: round(this.sumMs),
+			minMs: round(this.count === 0 ? 0 : this.minMs),
+			maxMs: round(this.maxMs)
+		};
+	}
+};
+var Totals = class {
+	hydrations = new Distribution();
+	hydrationsAborted = 0;
+	hydrationsFailed = 0;
+	hydrationRowCount = 0;
+	hydrationRowsRead = 0;
+	advances = new Distribution();
+	advanceChanges = 0;
+	advanceTimeouts = 0;
+	/**
+	* The advancements that hydrated the query again instead of pushing (all
+	* of) their changes to it, by why. The hydrations are in `hydrations`.
+	*/
+	advancesAbandoned = {
+		estimate: 0,
+		read: 0,
+		cutoff: 0
+	};
+	get timeMs() {
+		return this.hydrations.sumMs + this.advances.sumMs;
+	}
+	addHydration({ outcome, timeMs, rowCount, rowsRead }) {
+		this.hydrations.add(timeMs);
+		if (outcome === "aborted") this.hydrationsAborted++;
+		else if (outcome === "failed") this.hydrationsFailed++;
+		this.hydrationRowCount += rowCount ?? 0;
+		this.hydrationRowsRead += rowsRead ?? 0;
+	}
+	addAdvance({ timeMs, changes, timedOut }) {
+		this.advances.add(timeMs);
+		this.advanceChanges += changes;
+		if (timedOut) this.advanceTimeouts++;
+	}
+	toJSON() {
+		return {
+			timeMs: round(this.timeMs),
+			hydrations: this.hydrations.toJSON(),
+			hydrationsAborted: this.hydrationsAborted,
+			hydrationsFailed: this.hydrationsFailed,
+			hydrationRowCount: this.hydrationRowCount,
+			hydrationRowsRead: this.hydrationRowsRead,
+			advances: this.advances.toJSON(),
+			advanceChanges: this.advanceChanges,
+			advanceTimeouts: this.advanceTimeouts,
+			...Object.values(this.advancesAbandoned).some((n) => n > 0) && { advancesAbandoned: { ...this.advancesAbandoned } }
+		};
+	}
+};
+var ShapeStats = class extends Totals {
+	query;
+	planWarnings;
+	constructor(query) {
+		super();
+		this.query = query;
+	}
+};
+/** A fixed-size linear-counting sketch for shapes beyond the tracking limit. */
+var OverflowShapeCounter = class {
+	#buckets = new Uint8Array(4096);
+	#occupied = 0;
+	add(key) {
+		let hash = 2166136261;
+		for (let i = 0; i < key.length; i++) hash = Math.imul(hash ^ key.charCodeAt(i), 16777619);
+		const bucket = (hash >>> 0) % this.#buckets.length;
+		if (this.#buckets[bucket] === 0) {
+			this.#buckets[bucket] = 1;
+			this.#occupied++;
+		}
+	}
+	get estimatedCount() {
+		const empty = this.#buckets.length - this.#occupied;
+		return empty === 0 ? this.#buckets.length : Math.round(-this.#buckets.length * Math.log(empty / this.#buckets.length));
+	}
+};
+/**
+* Aggregates the work done for each query shape (the query with its values
+* redacted, see {@link QueryShape}) on a worker, and periodically logs it,
+* like `pg_stat_statements` does for Postgres.
+*
+* Unlike the slow query logs, which are throttled and only written above a
+* threshold, every hydration and advancement is counted, so the logs can be
+* summed over any time range and across workers to rank queries by the time
+* they take.
+*
+* Each {@link flush} logs the interval since the previous one:
+*
+* - a `query-stats` event per query shape, for the {@link
+*   QueryStatsOptions.maxReported} shapes that took the most time, and
+* - a `query-stats-summary` event with the totals of all shapes, including
+*   those not reported individually, and the `indexUses`: how often the
+*   process read each index of the replica, like `pg_stat_user_indexes`. An
+*   index that is never read is absent. The workers of a single-process
+*   zero-cache share these counts, which the first of them to flush reports.
+*
+* The events carry counts, sums, minimums and maximums, which compose across
+* intervals and workers.
+*/
+var QueryStats = class {
+	#maxShapes;
+	#maxReported;
+	#now;
+	#takeIndexUsage;
+	#shapes = /* @__PURE__ */ new Map();
+	#totals = new Totals();
+	#overflowShapes = new OverflowShapeCounter();
+	#intervalStart;
+	constructor({ maxShapes = 1e3, maxReported = 100, now = Date.now, takeIndexUsage: takeIndexUsageFn = takeIndexUsage } = {}) {
+		assert(maxShapes > 0, "maxShapes must be positive");
+		assert(maxReported > 0, "maxReported must be positive");
+		this.#maxShapes = maxShapes;
+		this.#maxReported = maxReported;
+		this.#now = now;
+		this.#takeIndexUsage = takeIndexUsageFn;
+		this.#intervalStart = now();
+	}
+	recordHydration(query, record) {
+		this.#totals.addHydration(record);
+		const stats = this.#stats(query);
+		if (stats) {
+			stats.addHydration(record);
+			if (record.planWarnings !== void 0) stats.planWarnings = record.planWarnings;
+		}
+	}
+	recordAdvance(query, record) {
+		this.#totals.addAdvance(record);
+		this.#stats(query)?.addAdvance(record);
+	}
+	/**
+	* Records that an advancement abandoned the query's pipeline, to hydrate
+	* the query again.
+	*/
+	recordAbandoned(query, reason) {
+		this.#totals.advancesAbandoned[reason]++;
+		const stats = this.#stats(query);
+		if (stats) stats.advancesAbandoned[reason]++;
+	}
+	#stats(query) {
+		const key = `${query.queryName ?? ""}:${query.shape.hash}`;
+		let stats = this.#shapes.get(key);
+		if (stats === void 0) {
+			if (this.#shapes.size >= this.#maxShapes) {
+				this.#overflowShapes.add(key);
+				return;
+			}
+			stats = new ShapeStats({
+				queryName: query.queryName,
+				shape: query.shape
+			});
+			this.#shapes.set(key, stats);
+		}
+		return stats;
+	}
+	/**
+	* Logs the stats of the interval since the previous flush, and starts a
+	* new interval. Nothing is logged for an interval without any work.
+	*/
+	flush(lc) {
+		const now = this.#now();
+		const intervalMs = now - this.#intervalStart;
+		const shapes = this.#shapes;
+		const totals = this.#totals;
+		const overflowShapes = this.#overflowShapes.estimatedCount;
+		const indexUses = this.#takeIndexUsage();
+		this.#shapes = /* @__PURE__ */ new Map();
+		this.#totals = new Totals();
+		this.#overflowShapes = new OverflowShapeCounter();
+		this.#intervalStart = now;
+		if (shapes.size === 0 && overflowShapes === 0 && indexUses.size === 0) return;
+		const reported = [...shapes.values()].toSorted((a, b) => b.timeMs - a.timeMs).slice(0, this.#maxReported);
+		for (const stats of reported) {
+			const { queryName, shape } = stats.query;
+			lc.info?.("query stats", {
+				zeroEvent: "query-stats",
+				intervalMs,
+				...queryName !== void 0 && { queryName },
+				queryShape: shape.hash,
+				...stats.toJSON(),
+				...stats.planWarnings !== void 0 && stats.planWarnings.length > 0 && { planWarnings: stats.planWarnings },
+				zql: shape.zql
+			});
+		}
+		lc.info?.("query stats summary", {
+			zeroEvent: "query-stats-summary",
+			intervalMs,
+			shapes: shapes.size + overflowShapes,
+			shapesReported: reported.length,
+			...totals.toJSON(),
+			...indexUses.size > 0 && { indexUses: Object.fromEntries(indexUses) }
+		});
+	}
+	/**
+	* Flushes every `intervalMs` until the returned function is called, which
+	* flushes one last time.
+	*/
+	start(lc, intervalMs) {
+		const timer = setInterval(() => this.flush(lc), intervalMs);
+		timer.unref?.();
+		return () => {
+			clearInterval(timer);
+			this.flush(lc);
+		};
+	}
+};
+function round(ms) {
+	return Math.round(ms * 100) / 100;
+}
+//#endregion
+export { QueryStats };
+
+//# sourceMappingURL=query-stats.js.map

package/out/zero-cache/src/services/view-syncer/query-stats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-stats.js","names":["#buckets","#occupied","#maxShapes","#maxReported","#now","#takeIndexUsage","#intervalStart","#totals","#stats","#shapes","#overflowShapes"],"sources":["../../../../../../zero-cache/src/services/view-syncer/query-stats.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport type {PlanWarning} from '../../../../zql/src/planner/planner-warnings.ts';\nimport {takeIndexUsage} from '../../../../zqlite/src/index-usage.ts';\nimport type {QueryShape} from './query-shape.ts';\n\n/** The query that work is accounted to. */\nexport type QueryIdentity = {\n  readonly queryName?: string | undefined;\n  readonly shape: QueryShape;\n};\n\nexport type HydrationOutcome = 'finished' | 'aborted' | 'failed';\n\nexport type HydrationRecord = {\n  readonly outcome: HydrationOutcome;\n  readonly timeMs: number;\n  /** Only for a finished hydration. */\n  readonly rowCount?: number | undefined;\n  /** Only for a finished hydration. */\n  readonly rowsRead?: number | undefined;\n  readonly planWarnings?: readonly PlanWarning[] | undefined;\n};\n\nexport type AdvanceRecord = {\n  /** The time spent processing the pushes to the query. */\n  readonly timeMs: number;\n  /** The number of changes pushed to the query. */\n  readonly changes: number;\n  /** Whether the advancement timed out and reset the pipelines. */\n  readonly timedOut: boolean;\n};\n\n/** Why an advancement stopped pushing to a query and hydrated it again. */\nexport type AbandonReason = 'estimate' | 'read' | 'cutoff';\n\nexport type QueryStatsOptions = {\n  /**\n   * The most query shapes tracked per interval. Work on shapes beyond this is\n   * accounted to the interval's totals only, which bounds memory when the\n   * shape space is unbounded (e.g. dynamically built queries).\n   */\n  readonly maxShapes?: number | undefined;\n\n  /**\n   * The most query shapes logged per interval, those that took the most\n   * time. The rest are included in the interval's totals.\n   */\n  readonly maxReported?: number | undefined;\n\n  readonly now?: (() => number) | undefined;\n\n  /** Returns the index uses since the last call. See `recordIndexUsage()`. */\n  readonly takeIndexUsage?: (() => Map<string, number>) | undefined;\n};\n\nclass Distribution {\n  count = 0;\n  sumMs = 0;\n  minMs = Infinity;\n  maxMs = 0;\n\n  add(ms: number) {\n    this.count++;\n    this.sumMs += ms;\n    this.minMs = Math.min(this.minMs, ms);\n    this.maxMs = Math.max(this.maxMs, ms);\n  }\n\n  toJSON() {\n    return {\n      count: this.count,\n      sumMs: round(this.sumMs),\n      minMs: round(this.count === 0 ? 0 : this.minMs),\n      maxMs: round(this.maxMs),\n    };\n  }\n}\n\nclass Totals {\n  readonly hydrations = new Distribution();\n  hydrationsAborted = 0;\n  hydrationsFailed = 0;\n  hydrationRowCount = 0;\n  hydrationRowsRead = 0;\n  readonly advances = new Distribution();\n  advanceChanges = 0;\n  advanceTimeouts = 0;\n  /**\n   * The advancements that hydrated the query again instead of pushing (all\n   * of) their changes to it, by why. The hydrations are in `hydrations`.\n   */\n  readonly advancesAbandoned: Record<AbandonReason, number> = {\n    estimate: 0,\n    read: 0,\n    cutoff: 0,\n  };\n\n  get timeMs() {\n    return this.hydrations.sumMs + this.advances.sumMs;\n  }\n\n  addHydration({outcome, timeMs, rowCount, rowsRead}: HydrationRecord) {\n    this.hydrations.add(timeMs);\n    if (outcome === 'aborted') {\n      this.hydrationsAborted++;\n    } else if (outcome === 'failed') {\n      this.hydrationsFailed++;\n    }\n    this.hydrationRowCount += rowCount ?? 0;\n    this.hydrationRowsRead += rowsRead ?? 0;\n  }\n\n  addAdvance({timeMs, changes, timedOut}: AdvanceRecord) {\n    this.advances.add(timeMs);\n    this.advanceChanges += changes;\n    if (timedOut) {\n      this.advanceTimeouts++;\n    }\n  }\n\n  toJSON() {\n    return {\n      timeMs: round(this.timeMs),\n      hydrations: this.hydrations.toJSON(),\n      hydrationsAborted: this.hydrationsAborted,\n      hydrationsFailed: this.hydrationsFailed,\n      hydrationRowCount: this.hydrationRowCount,\n      hydrationRowsRead: this.hydrationRowsRead,\n      advances: this.advances.toJSON(),\n      advanceChanges: this.advanceChanges,\n      advanceTimeouts: this.advanceTimeouts,\n      // Only with cost-based sync, without which there are none.\n      ...(Object.values(this.advancesAbandoned).some(n => n > 0) && {\n        advancesAbandoned: {...this.advancesAbandoned},\n      }),\n    };\n  }\n}\n\nclass ShapeStats extends Totals {\n  readonly query: QueryIdentity;\n  planWarnings: readonly PlanWarning[] | undefined;\n\n  constructor(query: QueryIdentity) {\n    super();\n    this.query = query;\n  }\n}\n\n/** A fixed-size linear-counting sketch for shapes beyond the tracking limit. */\nclass OverflowShapeCounter {\n  readonly #buckets = new Uint8Array(4096);\n  #occupied = 0;\n\n  add(key: string): void {\n    // FNV-1a gives a stable bucket without retaining the key.\n    let hash = 0x811c9dc5;\n    for (let i = 0; i < key.length; i++) {\n      hash = Math.imul(hash ^ key.charCodeAt(i), 0x01000193);\n    }\n    const bucket = (hash >>> 0) % this.#buckets.length;\n    if (this.#buckets[bucket] === 0) {\n      this.#buckets[bucket] = 1;\n      this.#occupied++;\n    }\n  }\n\n  get estimatedCount(): number {\n    const empty = this.#buckets.length - this.#occupied;\n    return empty === 0\n      ? this.#buckets.length\n      : Math.round(\n          -this.#buckets.length * Math.log(empty / this.#buckets.length),\n        );\n  }\n}\n\n/**\n * Aggregates the work done for each query shape (the query with its values\n * redacted, see {@link QueryShape}) on a worker, and periodically logs it,\n * like `pg_stat_statements` does for Postgres.\n *\n * Unlike the slow query logs, which are throttled and only written above a\n * threshold, every hydration and advancement is counted, so the logs can be\n * summed over any time range and across workers to rank queries by the time\n * they take.\n *\n * Each {@link flush} logs the interval since the previous one:\n *\n * - a `query-stats` event per query shape, for the {@link\n *   QueryStatsOptions.maxReported} shapes that took the most time, and\n * - a `query-stats-summary` event with the totals of all shapes, including\n *   those not reported individually, and the `indexUses`: how often the\n *   process read each index of the replica, like `pg_stat_user_indexes`. An\n *   index that is never read is absent. The workers of a single-process\n *   zero-cache share these counts, which the first of them to flush reports.\n *\n * The events carry counts, sums, minimums and maximums, which compose across\n * intervals and workers.\n */\nexport class QueryStats {\n  readonly #maxShapes: number;\n  readonly #maxReported: number;\n  readonly #now: () => number;\n  readonly #takeIndexUsage: () => Map<string, number>;\n\n  #shapes = new Map<string, ShapeStats>();\n  #totals = new Totals();\n  #overflowShapes = new OverflowShapeCounter();\n  #intervalStart: number;\n\n  constructor({\n    maxShapes = 1000,\n    maxReported = 100,\n    now = Date.now,\n    takeIndexUsage: takeIndexUsageFn = takeIndexUsage,\n  }: QueryStatsOptions = {}) {\n    assert(maxShapes > 0, 'maxShapes must be positive');\n    assert(maxReported > 0, 'maxReported must be positive');\n    this.#maxShapes = maxShapes;\n    this.#maxReported = maxReported;\n    this.#now = now;\n    this.#takeIndexUsage = takeIndexUsageFn;\n    this.#intervalStart = now();\n  }\n\n  recordHydration(query: QueryIdentity, record: HydrationRecord): void {\n    this.#totals.addHydration(record);\n    const stats = this.#stats(query);\n    if (stats) {\n      stats.addHydration(record);\n      if (record.planWarnings !== undefined) {\n        stats.planWarnings = record.planWarnings;\n      }\n    }\n  }\n\n  recordAdvance(query: QueryIdentity, record: AdvanceRecord): void {\n    this.#totals.addAdvance(record);\n    this.#stats(query)?.addAdvance(record);\n  }\n\n  /**\n   * Records that an advancement abandoned the query's pipeline, to hydrate\n   * the query again.\n   */\n  recordAbandoned(query: QueryIdentity, reason: AbandonReason): void {\n    this.#totals.advancesAbandoned[reason]++;\n    const stats = this.#stats(query);\n    if (stats) {\n      stats.advancesAbandoned[reason]++;\n    }\n  }\n\n  #stats(query: QueryIdentity): ShapeStats | undefined {\n    const key = `${query.queryName ?? ''}:${query.shape.hash}`;\n    let stats = this.#shapes.get(key);\n    if (stats === undefined) {\n      if (this.#shapes.size >= this.#maxShapes) {\n        this.#overflowShapes.add(key);\n        return undefined;\n      }\n      stats = new ShapeStats({queryName: query.queryName, shape: query.shape});\n      this.#shapes.set(key, stats);\n    }\n    return stats;\n  }\n\n  /**\n   * Logs the stats of the interval since the previous flush, and starts a\n   * new interval. Nothing is logged for an interval without any work.\n   */\n  flush(lc: LogContext): void {\n    const now = this.#now();\n    const intervalMs = now - this.#intervalStart;\n    const shapes = this.#shapes;\n    const totals = this.#totals;\n    const overflowShapes = this.#overflowShapes.estimatedCount;\n    const indexUses = this.#takeIndexUsage();\n    this.#shapes = new Map();\n    this.#totals = new Totals();\n    this.#overflowShapes = new OverflowShapeCounter();\n    this.#intervalStart = now;\n\n    if (shapes.size === 0 && overflowShapes === 0 && indexUses.size === 0) {\n      return;\n    }\n    const reported = [...shapes.values()]\n      .toSorted((a, b) => b.timeMs - a.timeMs)\n      .slice(0, this.#maxReported);\n    for (const stats of reported) {\n      const {queryName, shape} = stats.query;\n      lc.info?.('query stats', {\n        zeroEvent: 'query-stats',\n        intervalMs,\n        ...(queryName !== undefined && {queryName}),\n        queryShape: shape.hash,\n        ...stats.toJSON(),\n        ...(stats.planWarnings !== undefined &&\n          stats.planWarnings.length > 0 && {planWarnings: stats.planWarnings}),\n        zql: shape.zql,\n      });\n    }\n    lc.info?.('query stats summary', {\n      zeroEvent: 'query-stats-summary',\n      intervalMs,\n      shapes: shapes.size + overflowShapes,\n      shapesReported: reported.length,\n      ...totals.toJSON(),\n      ...(indexUses.size > 0 && {indexUses: Object.fromEntries(indexUses)}),\n    });\n  }\n\n  /**\n   * Flushes every `intervalMs` until the returned function is called, which\n   * flushes one last time.\n   */\n  start(lc: LogContext, intervalMs: number): () => void {\n    const timer = setInterval(() => this.flush(lc), intervalMs);\n    timer.unref?.();\n    return () => {\n      clearInterval(timer);\n      this.flush(lc);\n    };\n  }\n}\n\nfunction round(ms: number) {\n  return Math.round(ms * 100) / 100;\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/view-syncer/schema/types.d.ts

@@ -82,21 +82,6 @@ export declare const baseQueryRecordSchema: v.ObjectType<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, undefined>;
 /**
  * Internal queries track rows in the database for internal use, such as the
@@ -143,21 +128,6 @@ export declare const internalQueryRecordSchema: v.ObjectType<Omit<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, "ast" | "type"> & {
     type: v.Type<"internal">;
     ast: v.Type<import("../../../../../zero-protocol/src/ast.ts").AST>;
@@ -202,21 +172,6 @@ export declare const clientQueryRecordSchema: v.ObjectType<Omit<Omit<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, "clientState" | "patchVersion"> & {
     /**
      * The client state for this query, which includes the inactivatedAt, ttl and
@@ -280,21 +235,6 @@ export declare const customQueryRecordSchema: v.ObjectType<Omit<Omit<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, "clientState" | "patchVersion"> & {
     /**
      * The client state for this query, which includes the inactivatedAt, ttl and
@@ -358,21 +298,6 @@ export declare const queryRecordSchema: v.UnionType<[v.ObjectType<Omit<Omit<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, "clientState" | "patchVersion"> & {
     /**
      * The client state for this query, which includes the inactivatedAt, ttl and
@@ -434,21 +359,6 @@ export declare const queryRecordSchema: v.UnionType<[v.ObjectType<Omit<Omit<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, "clientState" | "patchVersion"> & {
     /**
      * The client state for this query, which includes the inactivatedAt, ttl and
@@ -510,21 +420,6 @@ export declare const queryRecordSchema: v.UnionType<[v.ObjectType<Omit<Omit<{
         stateVersion: string;
         configVersion?: number | undefined;
     }>;
-    /**
-     * Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-     * of every row currently attached to this query. Maintained incrementally by
-     * `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-     * (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-     * signature-provider callback.
-     *
-     * Used to detect drift on re-hydration of queries containing the `Cap` operator,
-     * which intentionally does not impose ordering and thus may pick a different N-row
-     * subset on re-execution. Comparing the pre-hydration signature with the post-
-     * hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-     * machinery emits the reconciling poke. Absent or `'0'` means the signature is
-     * empty (no rows currently attached).
-     */
-    rowSetSignature: v.Optional<string>;
 }, "ast" | "type"> & {
     type: v.Type<"internal">;
     ast: v.Type<import("../../../../../zero-protocol/src/ast.ts").AST>;
@@ -578,7 +473,7 @@ export declare const rowRecordSchema: v.ObjectType<Omit<{
         rowKey: v.Type<Record<string, import("../../../../../shared/src/bigint-json.ts").JSONValue>>;
     }, undefined>;
     rowVersion: v.Type<string>;
-    refCounts: v.Type<Record<string, number> | null>;
+    refCounts: v.UnionType<[v.Type<null>, v.Type<Record<string, number>>]>;
 }, undefined>;
 export type RowRecord = v.Infer<typeof rowRecordSchema>;
 export declare const patchSchema: v.ObjectType<{
@@ -663,6 +558,6 @@ export declare const metadataPatchSchema: v.ObjectType<Omit<{
 export type MetadataPatch = v.Infer<typeof metadataPatchSchema>;
 export declare function versionString(v: CVRVersion): string;
 export declare function versionFromString(str: string): CVRVersion;
-export declare function queryRecordToQueryRow(clientGroupID: string, query: QueryRecord): QueriesRow;
+export declare function queryRecordToQueryRow(clientGroupID: string, query: QueryRecord, rowSetSignature: string | null): QueriesRow;
 export declare const maybeVersionString: (v: CVRVersion | undefined) => string | null;
 //# sourceMappingURL=types.d.ts.map

package/out/zero-cache/src/services/view-syncer/schema/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/view-syncer/schema/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/view-syncer/schema/types.ts"],"names":[],"mappings":"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"}

package/out/zero-cache/src/services/view-syncer/schema/types.js

@@ -107,22 +107,7 @@ var baseQueryRecordSchema = valita_exports.object({
 	* to the gotten set). Catchup of clients from old CVR versions require executing all
 	* queries with a newer `transformationVersion`.
 	*/
-	transformationVersion: cvrVersionSchema.optional(),
-	/**
-	* Hex-encoded XOR signature over `h64(JSON.stringify([schema, table, rowKey]))`
-	* of every row currently attached to this query. Maintained incrementally by
-	* `PipelineDriver` as ADDs / REMOVEs are yielded from the query's pipeline
-	* (EDITs no-op), and persisted via `CVRQueryDrivenUpdater.flush` by a
-	* signature-provider callback.
-	*
-	* Used to detect drift on re-hydration of queries containing the `Cap` operator,
-	* which intentionally does not impose ordering and thus may pick a different N-row
-	* subset on re-execution. Comparing the pre-hydration signature with the post-
-	* hydration signature lets us force a `configVersion` bump so the standard CVR-diff
-	* machinery emits the reconciling poke. Absent or `'0'` means the signature is
-	* empty (no rows currently attached).
-	*/
-	rowSetSignature: valita_exports.string().optional()
+	transformationVersion: cvrVersionSchema.optional()
 });
 /**
 * Internal queries track rows in the database for internal use, such as the
@@ -228,7 +213,7 @@ function versionFromString(str) {
 		default: throw new TypeError(`Invalid version string ${str}`);
 	}
 }
-function queryRecordToQueryRow(clientGroupID, query) {
+function queryRecordToQueryRow(clientGroupID, query, rowSetSignature) {
 	switch (query.type) {
 		case "internal": return {
 			clientGroupID,
@@ -241,7 +226,7 @@ function queryRecordToQueryRow(clientGroupID, query) {
 			transformationVersion: maybeVersionString(query.transformationVersion),
 			internal: true,
 			deleted: false,
-			rowSetSignature: query.rowSetSignature ?? null
+			rowSetSignature
 		};
 		case "client": return {
 			clientGroupID,
@@ -254,7 +239,7 @@ function queryRecordToQueryRow(clientGroupID, query) {
 			transformationVersion: maybeVersionString(query.transformationVersion),
 			internal: null,
 			deleted: false,
-			rowSetSignature: query.rowSetSignature ?? null
+			rowSetSignature
 		};
 		case "custom": return {
 			clientGroupID,
@@ -267,7 +252,7 @@ function queryRecordToQueryRow(clientGroupID, query) {
 			transformationVersion: maybeVersionString(query.transformationVersion),
 			internal: null,
 			deleted: false,
-			rowSetSignature: query.rowSetSignature ?? null
+			rowSetSignature
 		};
 	}
 }