From cbc6f6a22e6d76ae7c168daeedd914d5bd24eecd Mon Sep 17 00:00:00 2001 From: Makisuo Date: Mon, 16 Nov 2026 11:17:32 +0100 Subject: [PATCH 1/4] perf(dashboards): auto-refresh keeps the window snapped and skips unmoved tiles An auto-refresh tick went through the same path as the Reload button: it unsnapped the window and refetched every held key. A board left open with a 10s refresh sent a new query per tile per tick, all over unique windows. A tick now resolves the window on the cache grid and asks only for keys it does not hold, so a tile refetches when its window reaches the next grid step. An explicit Reload still unsnaps and refetches. Pinned tile ranges resolve on the same clock read. --- .../src/page/dashboards/kit/widget-data.ts | 3 + apps/web/src/page/dashboards/view/model.ts | 9 +- apps/web/src/page/dashboards/view/plan.ts | 39 +++++++-- .../dashboards/view/refresh.scene.test.ts | 87 +++++++++++++++++-- apps/web/src/page/dashboards/view/update.ts | 22 +++-- 5 files changed, 133 insertions(+), 27 deletions(-) diff --git a/apps/web/src/page/dashboards/kit/widget-data.ts b/apps/web/src/page/dashboards/kit/widget-data.ts index 7b207af16e..b758f32a69 100644 --- a/apps/web/src/page/dashboards/kit/widget-data.ts +++ b/apps/web/src/page/dashboards/kit/widget-data.ts @@ -68,6 +68,8 @@ export interface PlanInput { readonly dataSource: unknown readonly window: { readonly startTime: string; readonly endTime: string } | null readonly widgetTimeRange?: Parameters[0]["widgetTimeRange"] + /** The clock read a pinned relative range resolves on, so a re-plan between reads keeps its key. */ + readonly clock?: Readonly<{ nowMs: number; snap: boolean }> readonly maxDataPoints?: number /** The board's variables: their names, and the values resolved so far. */ readonly variables?: Readonly<{ @@ -135,6 +137,7 @@ export const planWidget = (input: PlanInput): WidgetGate => { request, dashboardWindow: input.window, ...(input.widgetTimeRange === undefined ? undefined : { widgetTimeRange: input.widgetTimeRange }), + ...(input.clock === undefined ? undefined : input.clock), ...(input.maxDataPoints === undefined ? undefined : { maxDataPoints: input.maxDataPoints }), ...(input.variables === undefined ? undefined : { variableValues: input.variables.values }), }) diff --git a/apps/web/src/page/dashboards/view/model.ts b/apps/web/src/page/dashboards/view/model.ts index 686d0eb61d..3f4df52f89 100644 --- a/apps/web/src/page/dashboards/view/model.ts +++ b/apps/web/src/page/dashboards/view/model.ts @@ -154,10 +154,15 @@ export const Model = Schema.Struct({ document: Schema.NullOr(DashboardDocument), /** The live board never answered within `COLLECTION_LOAD_TIMEOUT_MS`: the HTTP snapshot's state. */ snapshot: Snapshot, - /** The clock the window is resolved against: read on entry, Reload and a time range change. */ + /** The clock the window is resolved against: read on entry, a range change, Reload and each tick. */ nowMs: Schema.NullOr(Schema.Number), - /** 0 snaps the window to the cache grid. */ + /** Bumped by every Reload and auto-refresh tick; the Reload spinner ends on its own version. */ refreshVersion: Schema.Number, + /** + * What read `nowMs`. Only an explicit Reload leaves the window unsnapped and refetches held keys; + * an auto-refresh tick snaps, so a tile refetches only once its window reaches the next grid step. + */ + clockRead: Schema.Literals(["Navigation", "AutoRefresh", "Reload"]), isReloading: Schema.Boolean, /** The sections container's width; 0 until measured. */ gridWidth: Schema.Number, diff --git a/apps/web/src/page/dashboards/view/plan.ts b/apps/web/src/page/dashboards/view/plan.ts index e3b3ce6090..2dae1f7337 100644 --- a/apps/web/src/page/dashboards/view/plan.ts +++ b/apps/web/src/page/dashboards/view/plan.ts @@ -43,11 +43,26 @@ export const isSameTimeRange = (a: TimeRange | null, b: TimeRange | null): boole ? b.type === "relative" && a.value === b.value : b.type === "absolute" && a.startTime === b.startTime && a.endTime === b.endTime -/** Snapped on entry, unsnapped after a reload; a bad preset falls back to 1h. */ +/** + * How a pass asks: `Load` fetches keys not held, `Refresh` refetches held ones too. `Tick` is an + * auto-refresh: `Load` for the requests, so a tile whose snapped window has not moved fetches nothing. + */ +export type PlanMode = Keyed.RequestMode | "Tick" + +/** What `read` the clock picks: a tick plans as a `Tick`, a Reload refetches everything held. */ +export const planModeOf = (clockRead: Model["clockRead"]): PlanMode => + clockRead === "Reload" ? "Refresh" : clockRead === "AutoRefresh" ? "Tick" : "Load" + +/** Snapped to the cache grid except after an explicit Reload, which wants "now". */ +const clockOf = (model: Model) => + model.nowMs === null ? null : { nowMs: model.nowMs, snap: model.clockRead !== "Reload" } + +/** The board's window on the current clock; a bad preset falls back to 1h. */ export const windowOf = (model: Model, context: PageContext) => { const timeRange = timeRangeOf(model) - if (timeRange === null || model.nowMs === null) return null - const options = { snap: model.refreshVersion === 0, timeZone: context.timeZone, nowMs: model.nowMs } + const clock = clockOf(model) + if (timeRange === null || clock === null) return null + const options = { ...clock, timeZone: context.timeZone } return ( resolveTimeRangeWindow(timeRange, options) ?? resolveTimeRangeWindow({ type: "relative", value: "1h" }, options) @@ -195,6 +210,7 @@ const sparklineGate = ( widget: Widget, window: ReturnType, variables: ReturnType, + clock: ReturnType, ): WidgetGate | null => { const sparkline = widget.display.sparkline if (widget.visualization !== "stat" || sparkline?.enabled !== true || sparkline.dataSource === undefined) @@ -204,6 +220,7 @@ const sparklineGate = ( dataSource: sparkline.dataSource, window, ...(widget.timeRange === undefined ? undefined : { widgetTimeRange: widget.timeRange }), + ...(clock === null ? undefined : { clock }), variables, }) } @@ -226,11 +243,13 @@ type OptionsPlan = ReturnType const planTiles = ( model: Model, context: PageContext, - mode: Keyed.RequestMode, + mode: PlanMode, widgets: ReadonlyArray, options: OptionsPlan, ): Planned => { const window = windowOf(model, context) + const clock = clockOf(model) + const requestMode = mode === "Tick" ? "Load" : mode const withOptions = { ...model, variableOptions: options.variableOptions } const variables = variablesOf(withOptions, context) const initial: PlanState = { @@ -252,17 +271,18 @@ const planTiles = ( dataSource: widget.dataSource, window, ...(widget.timeRange === undefined ? undefined : { widgetTimeRange: widget.timeRange }), + ...(clock === null ? undefined : { clock }), maxDataPoints: maxDataPointsForWidth(slot.widthPx ?? DEFAULT_WIDGET_WIDTH_PX, panelType), variables, isNarrowed: slot.isNarrowed === true, }) const gate = keptGate(planned, slot.gate) const previousSpark = slot.sparkGate ?? null - const nextSparkGate = sparklineGate(context, widget, window, variables) + const nextSparkGate = sparklineGate(context, widget, window, variables, clock) const sparkGate = nextSparkGate === null ? null : keptGate(nextSparkGate, previousSpark) const isChanged = gate !== slot.gate || sparkGate !== previousSpark // Still loading a window this refresh moved: wait for that answer, which re-plans the tile. - if (mode === "Refresh" && isInFlight(state.requests, slot)) + if (mode !== "Load" && isInFlight(state.requests, slot)) return keep(!isChanged || slot.isStale === true ? slot : { ...slot, isStale: true }) // Off screen: keep what it shows, and fetch the new window once it scrolls back into view. if (slot.isOffscreen === true) @@ -271,7 +291,7 @@ const planTiles = ( ? { ...slot, isStale: true } : slot, ) - const tileMode = slot.isStale === true ? "Refresh" : mode + const tileMode = slot.isStale === true ? "Refresh" : requestMode const asked = ask(ask(state, gate, slot.gate, tileMode), sparkGate, previousSpark, tileMode) const { isStale: _stale, ...fresh } = slot // An unchanged slot keeps its object: the tile's memo compares it by reference. @@ -287,10 +307,11 @@ const planTiles = ( } /** Every revealed tile and the variables' option lists, for a new window, document or variable. */ -export const replan = (model: Model, context: PageContext, mode: Keyed.RequestMode): Planned => { +export const replan = (model: Model, context: PageContext, mode: PlanMode): Planned => { const document = shownDocumentOf(model) if (document === null) return { model, commands: [] } - return planTiles(model, context, mode, document.widgets, planVariableOptions(model, context, mode)) + const options = planVariableOptions(model, context, mode === "Tick" ? "Load" : mode) + return planTiles(model, context, mode, document.widgets, options) } /** One tile revealed, measured or narrowed: no other tile's plan can have moved. */ diff --git a/apps/web/src/page/dashboards/view/refresh.scene.test.ts b/apps/web/src/page/dashboards/view/refresh.scene.test.ts index fb5b8529f4..494506b2bc 100644 --- a/apps/web/src/page/dashboards/view/refresh.scene.test.ts +++ b/apps/web/src/page/dashboards/view/refresh.scene.test.ts @@ -1,5 +1,6 @@ import { OrgId } from "@maple/domain" import { DashboardDocument } from "@maple/domain/http" +import { makeRawSqlDataSource } from "@maple/widgets/dashboard" import { Option, Result, Schema, Array as Arr, Record as Rec } from "effect" import { describe, expect, test } from "vitest" import type { PageContext } from "../../contract" @@ -50,11 +51,11 @@ const throughput = { layout: { x: 3, y: 0, w: 6, h: 4 }, } -const boardOf = (widgets: ReadonlyArray) => +const boardOf = (widgets: ReadonlyArray, range = "6h") => Schema.decodeUnknownSync(DashboardDocument)({ id: "dash_platform", name: "Platform overview", - timeRange: { type: "relative", value: "6h" }, + timeRange: { type: "relative", value: range }, widgets, createdAt: "2026-09-19T12:00:00.000Z", updatedAt: "2026-09-28T12:00:00.000Z", @@ -64,10 +65,10 @@ const boardOf = (widgets: ReadonlyArray) => const run = (model: Model, messages: ReadonlyArray): Model => Arr.reduce(messages, model, (current, message) => pageUpdate(current, message).model) -const ready = (widgets: ReadonlyArray): Model => +const ready = (widgets: ReadonlyArray, range?: string): Model => run(init({ dashboardId: "dash_platform", search: {} }, context).model, [ Message.CompletedReadClock({ nowMs: NOW }), - Message.UpdatedDashboard({ orgId, maybeDocument: Option.some(boardOf(widgets)) }), + Message.UpdatedDashboard({ orgId, maybeDocument: Option.some(boardOf(widgets, range)) }), ]) /** Every held request answered. */ @@ -84,8 +85,33 @@ const requestKeyOf = (model: Model, widgetId: string) => { return gate?._tag === "Request" ? gate.request.key : null } -const tick = (model: Model) => - pageUpdate(run(model, [Message.TickedAutoRefresh()]), Message.CompletedReadClock({ nowMs: NOW + 60_000 })) +const tick = (model: Model, nowMs = NOW + 60_000) => + pageUpdate(run(model, [Message.TickedAutoRefresh()]), Message.CompletedReadClock({ nowMs })) + +const reloadAt = (model: Model, nowMs: number) => + pageUpdate(run(model, [Message.ClickedReload()]), Message.CompletedReadClock({ nowMs })) + +const sqlTile = (id: string, timeRange?: unknown) => ({ + id, + visualization: "stat", + dataSource: makeRawSqlDataSource({ + sql: `SELECT count() AS value, '${id}' AS tile FROM traces WHERE $__orgFilter AND $__timeFilter(Timestamp)`, + }), + display: { title: id, unit: "number" }, + layout: { x: 0, y: 0, w: 3, h: 2 }, + ...(timeRange === undefined ? undefined : { timeRange }), +}) + +/** Answers each tick's fetches, ticking every `everyMs` for `forMs`; returns how many it fetched. */ +const fetchesOverTicks = (start: Model, everyMs: number, forMs: number): number => + Arr.reduce( + Arr.makeBy(Math.floor(forMs / everyMs), (i) => NOW + (i + 1) * everyMs), + { model: start, total: 0 }, + (state, nowMs) => { + const ticked = tick(state.model, nowMs) + return { model: answered(ticked.model), total: state.total + fetches(ticked.commands) } + }, + ).total describe("dashboard refresh", () => { test("an auto-refresh refetches only tiles in view; a scrolled-away tile fetches once it is back", () => { @@ -125,7 +151,54 @@ describe("dashboard refresh", () => { ) expect(fetches(settled.commands)).toBe(1) expect(requestKeyOf(settled.model, "errors")).not.toBe(key) - expect(fetches(tick(answered(settled.model)).commands)).toBe(1) + expect(fetches(tick(answered(settled.model), NOW + 120_000).commands)).toBe(1) + }) + + test("a 30-day raw SQL board ticking every 10s fetches once per 30-minute grid step, not per tick", () => { + const board = answered( + run(ready([sqlTile("orders")], "30d"), [Message.RevealedWidget({ widgetId: "orders" })]), + ) + expect(fetchesOverTicks(board, 10_000, 60 * 60_000)).toBe(2) + }) + + test("a tick that leaves the snapped window where it was asks for nothing", () => { + const board = answered( + run(ready([sqlTile("orders")]), [Message.RevealedWidget({ widgetId: "orders" })]), + ) + const ticked = tick(board, NOW + 30_000) + expect(fetches(ticked.commands)).toBe(0) + expect(requestKeyOf(ticked.model, "orders")).toBe(requestKeyOf(board, "orders")) + }) + + test("an explicit Reload refetches at the true now, even within the same grid step", () => { + const board = answered( + run(ready([sqlTile("orders")]), [Message.RevealedWidget({ widgetId: "orders" })]), + ) + const reloaded = reloadAt(board, NOW + 30_000) + expect(fetches(reloaded.commands)).toBe(1) + expect(requestKeyOf(reloaded.model, "orders")).not.toBe(requestKeyOf(board, "orders")) + }) + + test("ticks after a Reload return to the snapped grid once, then hold until it moves", () => { + const board = answered( + run(ready([sqlTile("orders")]), [Message.RevealedWidget({ widgetId: "orders" })]), + ) + const reloaded = answered(reloadAt(board, NOW + 30_000).model) + const back = tick(reloaded, NOW + 40_000) + expect(fetches(back.commands)).toBe(1) + expect(requestKeyOf(back.model, "orders")).toBe(requestKeyOf(board, "orders")) + expect(fetches(tick(answered(back.model), NOW + 50_000).commands)).toBe(0) + }) + + test("a tile pinned to its own range resolves it on the clock read, so ticks share its key", () => { + const board = answered( + run(ready([sqlTile("recent", { type: "relative", value: "1h" })]), [ + Message.RevealedWidget({ widgetId: "recent" }), + ]), + ) + const sameStep = tick(board, NOW + 10_000) + expect(fetches(sameStep.commands)).toBe(0) + expect(fetches(tick(answered(sameStep.model), NOW + 15_000).commands)).toBe(1) }) test("a resize that keeps the chart's bucket keeps its request; one that changes it refetches", () => { diff --git a/apps/web/src/page/dashboards/view/update.ts b/apps/web/src/page/dashboards/view/update.ts index b7de643f9c..0ff5813cb1 100644 --- a/apps/web/src/page/dashboards/view/update.ts +++ b/apps/web/src/page/dashboards/view/update.ts @@ -46,6 +46,8 @@ import { FallbackReason, FetchDashboardFallback } from "./command-fallback" import { awaitsRefresh, isSameTimeRange, + planModeOf, + type PlanMode, replan, replanTile, shownDocumentOf, @@ -83,6 +85,7 @@ export const init = (route: Route, _context: PageContext): Return => ({ snapshot: { _tag: "Idle" }, nowMs: null, refreshVersion: 0, + clockRead: "Navigation", isReloading: false, gridWidth: 0, widgets: {}, @@ -146,7 +149,8 @@ const isRangeMoved = (before: Model, after: Model): boolean => { /** A `var-*` change re-plans the tiles that read the variable; a `range` change reads the clock first. */ export const routeChanged = (model: Model, route: Route, context: PageContext): Return => { const next = { ...model, search: route.search } - if (isRangeMoved(model, next)) return { model: next, commands: [ReadClock()] } + if (isRangeMoved(model, next)) + return { model: { ...next, clockRead: "Navigation" }, commands: [ReadClock()] } return sameValues(variableValuesFromSearch(model.search), variableValuesFromSearch(route.search)) ? { model: next } : withReplan(next, context, "Load") @@ -182,11 +186,11 @@ const editModeHref = (model: Model): string => { return dashboardHref(model, { ...kept, mode: "edit" }) } -/** A new clock, an unsnapped window and the Reload spinner. */ -const reload = (model: Model): Return => { +/** A new clock and the Reload spinner; a Reload also unsnaps the window, a tick keeps it snapped. */ +const reload = (model: Model, clockRead: "AutoRefresh" | "Reload"): Return => { const refreshVersion = model.refreshVersion + 1 return { - model: { ...model, refreshVersion, isReloading: true }, + model: { ...model, refreshVersion, clockRead, isReloading: true }, commands: [ReadClock(), CompleteReloadSpin({ version: refreshVersion })], } } @@ -294,7 +298,7 @@ const replanAfter = (stepped: Return, context: PageContext): Return => { return { ...stepped, model: planned.model, commands: [...(stepped.commands ?? []), ...planned.commands] } } -const withReplan = (model: Model, context: PageContext, mode: Keyed.RequestMode): Return => { +const withReplan = (model: Model, context: PageContext, mode: PlanMode): Return => { const planned = replan(model, context, mode) return { model: planned.model, commands: planned.commands } } @@ -349,7 +353,7 @@ const receiveDocument = ( const ended = cancelStaleGesture(settled, context) // A new saved range this viewer shows: the clock is read first, and its answer plans. const replanned: Return = isRangeMoved(model, ended.model) - ? { model: ended.model, commands: [ReadClock()] } + ? { model: { ...ended.model, clockRead: "Navigation" }, commands: [ReadClock()] } : withReplan(ended.model, context, "Load") const planned: Return = { ...replanned, @@ -604,7 +608,7 @@ export const update = (model: Model, message: Message, context: PageContext): Re ? readSnapshot(model, "retry") : { model, outMessage: PageOutMessage.RequestedReconnectOrgCollections() }, CompletedReadClock: ({ nowMs }) => - withReplan({ ...model, nowMs }, context, model.refreshVersion > 0 ? "Refresh" : "Load"), + withReplan({ ...model, nowMs }, context, planModeOf(model.clockRead)), MeasuredGrid: ({ width }) => cancelStaleGesture({ ...model, gridWidth: width }, context), MeasuredWidget: ({ widgetId, widthPx }) => { const slot = slotOf(model, widgetId) @@ -703,8 +707,8 @@ export const update = (model: Model, message: Message, context: PageContext): Re }, }) }, - TickedAutoRefresh: () => reload(model), - ClickedReload: () => reload(model), + TickedAutoRefresh: () => reload(model, "AutoRefresh"), + ClickedReload: () => reload(model, "Reload"), CompletedReloadSpin: ({ version }) => version === model.refreshVersion ? { model: { ...model, isReloading: false } } : { model }, ClickedToggleEdit: () => toggleEdit(model), From eec93b6f4a1b8c235fc9cf24f3162e8c69088aed Mon Sep 17 00:00:00 2001 From: Makisuo Date: Mon, 16 Nov 2026 11:21:03 +0100 Subject: [PATCH 2/4] perf(share): auto-refresh on share links keeps the window snapped A share or embed page reset every tile's request key on each auto-refresh tick and resolved the window unsnapped, so each tick refetched every tile. A tick now snaps and keeps the held keys; a Reload still refetches. --- apps/web/src/page/share/model.ts | 4 ++-- apps/web/src/page/share/share.scene.test.ts | 21 +++++++++++++++++++++ apps/web/src/page/share/update.ts | 17 ++++++++++------- 3 files changed, 33 insertions(+), 9 deletions(-) diff --git a/apps/web/src/page/share/model.ts b/apps/web/src/page/share/model.ts index 120bb9662c..abc0af0e10 100644 --- a/apps/web/src/page/share/model.ts +++ b/apps/web/src/page/share/model.ts @@ -99,8 +99,8 @@ export const Model = Schema.Struct({ token: Schema.String, search: ShareSearch, resolve: Resolve, - /** Reloads and auto-refresh ticks so far (non-zero stops snapping). */ - refreshTick: Schema.Number, + /** What read `nowMs`: only a Reload unsnaps the window and refetches tiles whose key held still. */ + clockRead: Schema.Literals(["Navigation", "AutoRefresh", "Reload"]), window: Schema.NullOr(ShareWindow), /** Each mounted tile's measured `maxDataPoints`. */ options: Schema.Record(Schema.String, Schema.Number), diff --git a/apps/web/src/page/share/share.scene.test.ts b/apps/web/src/page/share/share.scene.test.ts index 119e00f088..72b94c59d6 100644 --- a/apps/web/src/page/share/share.scene.test.ts +++ b/apps/web/src/page/share/share.scene.test.ts @@ -132,6 +132,27 @@ describe("share", () => { expect(moved.window?.endTime).toBe("2026-10-01 12:05:00") }) + test("an auto-refresh tick inside the same grid step fetches nothing; the next step refetches", () => { + const settled = update(measured(2), Message.CompletedFlushFrame()).model + const tickAt = (model: Model, nowMs: number) => + update( + update(model, Message.TickedAutoRefresh()).model, + Message.CompletedResolveReloadClock({ nowMs }), + ) + const sameStep = tickAt(settled, NOW + 30_000) + expect(names(sameStep.commands)).not.toContain(FetchBatch.name) + expect(sameStep.model.window?.endTime).toBe(settled.window?.endTime) + expect(names(tickAt(sameStep.model, NOW + 60_000).commands)).toContain(FetchBatch.name) + }) + + test("a reload inside the same grid step still refetches at the true time", () => { + const settled = update(measured(2), Message.CompletedFlushFrame()).model + const clicked = update(settled, Message.ClickedReload()).model + const reloaded = update(clicked, Message.CompletedResolveReloadClock({ nowMs: NOW + 30_000 })) + expect(names(reloaded.commands)).toContain(FetchBatch.name) + expect(reloaded.model.window?.endTime).toBe("2026-10-01 12:00:30") + }) + test("an unknown link renders the unavailable card", () => { scene( { update: (model, message) => update(model, message), view }, diff --git a/apps/web/src/page/share/update.ts b/apps/web/src/page/share/update.ts index 70c1ff8f48..95b9c1bfed 100644 --- a/apps/web/src/page/share/update.ts +++ b/apps/web/src/page/share/update.ts @@ -49,7 +49,7 @@ export const resolveShareWindow = ( ): ShareWindow | null => { const { search } = model const options = { - snap: model.refreshTick === 0, + snap: model.clockRead !== "Reload", nowMs: model.nowMs, timeZone: shareTimeZoneOf(search, pageTimeZone), } @@ -155,10 +155,10 @@ const withWindow = (model: Model, pageTimeZone: string): Model => { : { ...model, window: resolveShareWindow(model, share, pageTimeZone) } } +/** A tick keeps the snapped window, so only tiles whose window reached the next grid step refetch. */ const reload = (model: Model, pageTimeZone: string): Return => { - const refreshTick = model.refreshTick + 1 - const next = withWindow({ ...model, refreshTick, requested: {} }, pageTimeZone) - return flush(next) + const requested = model.clockRead === "Reload" ? {} : model.requested + return flush(withWindow({ ...model, requested }, pageTimeZone)) } export const init = (route: Route): Return => ({ @@ -166,7 +166,7 @@ export const init = (route: Route): Return => ({ token: route.token, search: route.search, resolve: { _tag: "Loading" }, - refreshTick: 0, + clockRead: "Navigation", window: null, options: {}, requested: {}, @@ -250,8 +250,11 @@ export const update = (model: Model, message: Message, pageTimeZone: string): Re : [FetchBatch({ token: model.token, batchId: model.sentBatchId + 1, ...next })], } }, - ClickedReload: () => ({ model, commands: [ResolveReloadClock()] }), - TickedAutoRefresh: () => ({ model, commands: [ResolveReloadClock()] }), + ClickedReload: () => ({ model: { ...model, clockRead: "Reload" }, commands: [ResolveReloadClock()] }), + TickedAutoRefresh: () => ({ + model: { ...model, clockRead: "AutoRefresh" }, + commands: [ResolveReloadClock()], + }), CompletedResolveReloadClock: ({ nowMs }) => reload({ ...model, nowMs }, pageTimeZone), ...chartEnvHandlers(model), GotChartMessage: ({ widgetId, message: inner }) => { From 2d6540af5cd2de38b81a33b9414019f2565b412c Mon Sep 17 00:00:00 2001 From: Makisuo Date: Mon, 16 Nov 2026 11:30:48 +0100 Subject: [PATCH 3/4] fix(share): a tick refetches pinned tiles on their own grid and retries failures Review follow-up: a share tile pinned to its own range keyed only on the board window, so it waited for the board's grid step. Its resolved range is now part of the key. A failed tile is dropped from the held keys on a tick so it is retried. --- apps/web/src/page/share/share.scene.test.ts | 45 +++++++++++++++++++++ apps/web/src/page/share/update.ts | 17 ++++++-- 2 files changed, 59 insertions(+), 3 deletions(-) diff --git a/apps/web/src/page/share/share.scene.test.ts b/apps/web/src/page/share/share.scene.test.ts index 72b94c59d6..1697894048 100644 --- a/apps/web/src/page/share/share.scene.test.ts +++ b/apps/web/src/page/share/share.scene.test.ts @@ -145,6 +145,51 @@ describe("share", () => { expect(names(tickAt(sameStep.model, NOW + 60_000).commands)).toContain(FetchBatch.name) }) + test("a tile pinned to its own range refetches on its grid step while the board window holds", () => { + const pinnedShare = share(1) + const pinned = { + ...pinnedShare, + dashboard: { + ...pinnedShare.dashboard, + widgets: [{ ...widget("w0"), timeRange: { type: "relative" as const, value: "10m" } }], + }, + } + const settled = Arr.reduce( + [ + Message.CompletedResolveClock({ nowMs: NOW }), + Message.CompletedResolveShare({ token: "tok", resolve: { _tag: "Ready", share: pinned } }), + Message.MeasuredWidget({ widgetId: "w0", maxDataPoints: 300 }), + Message.CompletedFlushFrame(), + ], + init({ token: "tok", search: {} }).model, + (model, message) => update(model, message).model, + ) + const ticked = update( + update(settled, Message.TickedAutoRefresh()).model, + Message.CompletedResolveReloadClock({ nowMs: NOW + 30_000 }), + ) + expect(ticked.model.window?.endTime).toBe(settled.window?.endTime) + expect(names(ticked.commands)).toContain(FetchBatch.name) + }) + + test("a tick retries a failed tile even when its window has not moved", () => { + const flushed = update(measured(1), Message.CompletedFlushFrame()).model + const failed = update( + flushed, + Message.CompletedFetchBatch({ + batchId: flushed.sentBatchId, + keys: { w0: flushed.requested.w0 ?? "" }, + states: {}, + }), + ).model + expect(failed.states.w0?._tag).toBe("Error") + const ticked = update( + update(failed, Message.TickedAutoRefresh()).model, + Message.CompletedResolveReloadClock({ nowMs: NOW + 30_000 }), + ) + expect(names(ticked.commands)).toContain(FetchBatch.name) + }) + test("a reload inside the same grid step still refetches at the true time", () => { const settled = update(measured(2), Message.CompletedFlushFrame()).model const clicked = update(settled, Message.ClickedReload()).model diff --git a/apps/web/src/page/share/update.ts b/apps/web/src/page/share/update.ts index 95b9c1bfed..4563c7cf71 100644 --- a/apps/web/src/page/share/update.ts +++ b/apps/web/src/page/share/update.ts @@ -108,7 +108,15 @@ const flush = (model: Model): Return => { const pending = Arr.flatMap(share.dashboard.widgets, (widget) => { const maxDataPoints = model.options[widget.id] if (maxDataPoints === undefined) return [] - const key = encodeJson([window.startTime, window.endTime, variablesKey, maxDataPoints]) + // A pinned range moves on its own grid step, so a tick refetches the tile when it does. + const pinned = + widget.timeRange === undefined + ? null + : resolveTimeRangeWindow(widget.timeRange, { + snap: model.clockRead !== "Reload", + nowMs: model.nowMs, + }) + const key = encodeJson([window.startTime, window.endTime, variablesKey, maxDataPoints, pinned]) return model.requested[widget.id] === key ? [] : [{ widgetId: widget.id, key, maxDataPoints, transform: widget.dataSource.transform }] @@ -155,9 +163,12 @@ const withWindow = (model: Model, pageTimeZone: string): Model => { : { ...model, window: resolveShareWindow(model, share, pageTimeZone) } } -/** A tick keeps the snapped window, so only tiles whose window reached the next grid step refetch. */ +/** A tick keeps the snapped window: only failed tiles and tiles whose window moved refetch. */ const reload = (model: Model, pageTimeZone: string): Return => { - const requested = model.clockRead === "Reload" ? {} : model.requested + const requested = + model.clockRead === "Reload" + ? {} + : Rec.filter(model.requested, (_, widgetId) => model.states[widgetId]?._tag !== "Error") return flush(withWindow({ ...model, requested }, pageTimeZone)) } From 23762ba13e6e2256fe46e3ba9479a7b37b464a6e Mon Sep 17 00:00:00 2001 From: Makisuo Date: Mon, 16 Nov 2026 11:48:10 +0100 Subject: [PATCH 4/4] fix(share): a tick does not resend a retry that is still in flight Review follow-up: the share page remembers the key each tile last failed under. A tick retries that tile once and clears the mark; only a new failed answer sets it again, so a slow retry is not sent on every tick. --- apps/web/src/page/share/model.ts | 2 ++ apps/web/src/page/share/share.scene.test.ts | 7 +++++- apps/web/src/page/share/update.ts | 28 ++++++++++----------- 3 files changed, 22 insertions(+), 15 deletions(-) diff --git a/apps/web/src/page/share/model.ts b/apps/web/src/page/share/model.ts index abc0af0e10..f07eb1d370 100644 --- a/apps/web/src/page/share/model.ts +++ b/apps/web/src/page/share/model.ts @@ -106,6 +106,8 @@ export const Model = Schema.Struct({ options: Schema.Record(Schema.String, Schema.Number), /** The request key each widget was last fetched under. */ requested: Schema.Record(Schema.String, Schema.String), + /** The key each widget's last answer failed under; a tick retries it once, until the retry answers. */ + failedKeys: Schema.Record(Schema.String, Schema.String), isFlushScheduled: Schema.Boolean, /** Batches after the one in flight; each is awaited before the next is sent. */ queuedBatches: Schema.Array(QueuedBatch), diff --git a/apps/web/src/page/share/share.scene.test.ts b/apps/web/src/page/share/share.scene.test.ts index 1697894048..5c484543d4 100644 --- a/apps/web/src/page/share/share.scene.test.ts +++ b/apps/web/src/page/share/share.scene.test.ts @@ -172,7 +172,7 @@ describe("share", () => { expect(names(ticked.commands)).toContain(FetchBatch.name) }) - test("a tick retries a failed tile even when its window has not moved", () => { + test("a tick retries a failed tile once, not again while the retry is in flight", () => { const flushed = update(measured(1), Message.CompletedFlushFrame()).model const failed = update( flushed, @@ -188,6 +188,11 @@ describe("share", () => { Message.CompletedResolveReloadClock({ nowMs: NOW + 30_000 }), ) expect(names(ticked.commands)).toContain(FetchBatch.name) + const again = update( + update(ticked.model, Message.TickedAutoRefresh()).model, + Message.CompletedResolveReloadClock({ nowMs: NOW + 40_000 }), + ) + expect(names(again.commands)).not.toContain(FetchBatch.name) }) test("a reload inside the same grid step still refetches at the true time", () => { diff --git a/apps/web/src/page/share/update.ts b/apps/web/src/page/share/update.ts index 4563c7cf71..6fc6204796 100644 --- a/apps/web/src/page/share/update.ts +++ b/apps/web/src/page/share/update.ts @@ -168,8 +168,8 @@ const reload = (model: Model, pageTimeZone: string): Return => { const requested = model.clockRead === "Reload" ? {} - : Rec.filter(model.requested, (_, widgetId) => model.states[widgetId]?._tag !== "Error") - return flush(withWindow({ ...model, requested }, pageTimeZone)) + : Rec.filter(model.requested, (key, widgetId) => model.failedKeys[widgetId] !== key) + return flush(withWindow({ ...model, requested, failedKeys: {} }, pageTimeZone)) } export const init = (route: Route): Return => ({ @@ -181,6 +181,7 @@ export const init = (route: Route): Return => ({ window: null, options: {}, requested: {}, + failedKeys: {}, isFlushScheduled: false, queuedBatches: [], sentBatchId: 0, @@ -234,9 +235,15 @@ export const update = (model: Model, message: Message, pageTimeZone: string): Re ...Rec.fromEntries(Arr.map(Rec.keys(keys), (widgetId) => [widgetId, missing])), ...states, } - const isLive = Arr.some( - Rec.keys(settled), - (widgetId) => model.requested[widgetId] === keys[widgetId], + const live = Arr.filter( + Rec.toEntries(settled), + ([widgetId]) => model.requested[widgetId] === keys[widgetId], + ) + const isLive = live.length > 0 + const failedKeys = Arr.reduce(live, model.failedKeys, (failed, [widgetId, state]) => + state._tag === "Error" + ? { ...failed, [widgetId]: keys[widgetId] ?? "" } + : Rec.remove(failed, widgetId), ) return { model: { @@ -245,15 +252,8 @@ export const update = (model: Model, message: Message, pageTimeZone: string): Re sentBatchId: next === undefined ? model.sentBatchId : model.sentBatchId + 1, // A batch whose widgets all moved on is skipped whole, its variables included. variables: isLive && variables !== undefined ? variables : model.variables, - states: { - ...model.states, - ...Rec.fromEntries( - Arr.filter( - Rec.toEntries(settled), - ([widgetId]) => model.requested[widgetId] === keys[widgetId], - ), - ), - }, + failedKeys, + states: { ...model.states, ...Rec.fromEntries(live) }, }, commands: next === undefined