Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Show each bucket's min-max range behind drawer chart lines
rcourtman77131c19b1de
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.mdindex 7fdec8974e..3cf539efc4 100644--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md@@ -5465,7 +5465,12 @@ reading, qualified "current" or "last known". An active alert on a chartedmetric tones that reading and, when it carries a numeric trigger, draws it asa dashed line in its severity colour; `getDrawerChartAlerts` maps alert typesto chart metrics and converts I/O triggers from the alert engine's MiB/s to-the charts' bytes per second. Any+the charts' bytes per second. Each line is a bucket average, so a tinted band+behind it spans every bucket's own lowest and highest reading+(`buildGuestDrawerHistoryBandPath`): a short spike stays visible after+downsampling. While a time is inspected the readout names that bucket's peak+when it rises at least a tenth of the plot above the average, and the+accessible value states each reading's average and range. Anywarning- or danger-toned detail rowis lifted into a "Worth checking" section in front, whichever section owns it,so demotion never hides a reason a reading cannot be trusted. Guestdiff --git a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md b/docs/release-control/v6/internal/subsystems/performance-and-scalability.mdindex e3cfaef27d..bb7beb15bb 100644--- a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md+++ b/docs/release-control/v6/internal/subsystems/performance-and-scalability.md@@ -4013,8 +4013,9 @@ node per observation beyond the marker's two paths, and the readout no longerinserts or removes a line as the inspected time changes.Numeric gridline labels are computed from the scale the panel already holds;the compact "Worth checking" list reuses rows already derived, and an alert's-dashed trigger line reuses the alert the drawer already holds. None adds a read-or timer.+dashed trigger line reuses the alert the drawer already holds. The min-max band+reads the `min`/`max` each stored bucket already carries: one extra path per+series with any spread (none for flat data). None adds a read or timer.The default stored-history legend resolves one latest timestamp from thatsame bounded, normalized panel index, then looks up each configured series atdiff --git a/frontend-modern/browser-verification/35189f0b76ceee53.json b/frontend-modern/browser-verification/35189f0b76ceee53.jsonnew file mode 100644index 0000000000..5f80e6e9c8--- /dev/null+++ b/frontend-modern/browser-verification/35189f0b76ceee53.json@@ -0,0 +1,37 @@+{+ "version": 1,+ "base_sha": "b837a8a98d113aa2f06008afc329912eee19b7f4",+ "verified_at": "2026-10-13T21:56:00Z",+ "result": "passed",+ "changed_paths": [+ "frontend-modern/src/components/Workloads/GuestDrawerHistory.tsx",+ "frontend-modern/src/components/Workloads/guestDrawerModel.ts"+ ],+ "content_sha256": {+ "frontend-modern/src/components/Workloads/GuestDrawerHistory.tsx": "63d543738ffb71ca86a8f9786d75c6479ae7ed0673a4f96b81620a549be63a82",+ "frontend-modern/src/components/Workloads/guestDrawerModel.ts": "9e46fe5e7adc08b9199248516583745af18c3a08d225367645d0e8b47b86c64a"+ },+ "routes": [+ "/proxmox/overview"+ ],+ "viewports": [+ {+ "width": 1440,+ "height": 900+ },+ {+ "width": 390,+ "height": 844+ }+ ],+ "states": [+ "final built bytes of this tree (origin/main b837a8a98d plus this change) embedded in a darwin binary, mock mode, headless Chromium on pulse-dev through a reverse tunnel, full-resolution element screenshots read by eye",+ "mock history first: its stored buckets barely spread (10 of 102 points, by under 0.1 percentage points), so bands there are a hairline halo and no peak is named",+ "then /api/metrics-store/history intercepted with 96 synthetic 24h buckets: CPU averaging 14-22% with two buckets peaking at 97%, network in peaking at 40 MB/s once, disk read peaking at 30 MB/s twice, memory and disk flat. Each spike shows as a tinted, outlined spire from its average line up to its peak on the Utilization, Network I/O and Disk I/O charts, while flat series draw no band",+ "1440px: three charts side by side, spires visible at every spike; 390px: charts stacked, the same spires visible, no horizontal overflow"+ ],+ "interactions": [+ "expanded the first guest row; hovered the Utilization plot over the CPU spike bucket at 1440 and 390px: the header read \"Stored · <time>\" and the legend read \"CPU 22.0% peak 97.0%\" with Memory and Disk showing a single value each",+ "moved the pointer away: the legend returned to \"Latest stored\" with one value per series and no peak label"+ ]+}diff --git a/frontend-modern/src/components/Workloads/GuestDrawer.test.tsx b/frontend-modern/src/components/Workloads/GuestDrawer.test.tsxindex f08af4e0e4..9fbb67d401 100644--- a/frontend-modern/src/components/Workloads/GuestDrawer.test.tsx+++ b/frontend-modern/src/components/Workloads/GuestDrawer.test.tsx@@ -636,6 +636,36 @@ describe('GuestDrawer', () => {expect(screen.queryByText('Open related infrastructure')).toBeNull();});+ it('adds one min-max band per series whose buckets spread, and none for flat ones', async () => {+ const points = makeHistoryPoints(10);+ chartsApiMocks.getMetricsHistory.mockResolvedValue({+ resourceType: 'vm',+ resourceId: 'inst1:node1:100',+ range: '24h',+ start: 1,+ end: 3,+ source: 'store',+ metrics: {+ cpu: [points[0], { ...points[1], max: 95 }, points[2]],+ memory: makeHistoryPoints(20),+ disk: makeHistoryPoints(30),+ },+ });+ render(() => <GuestDrawer guest={makeGuest()} onClose={vi.fn()} />);+ await fireEvent.click(screen.getByRole('tab', { name: 'Overview' }));+ await waitFor(() =>+ expect(+ screen+ .getAllByTestId('guest-history-group-chart')[0]+ .querySelector('path[data-history-band="cpu"]'),+ ).not.toBeNull(),+ );+ const charts = screen.getAllByTestId('guest-history-group-chart');+ expect(charts[0].querySelectorAll('path[data-history-band]')).toHaveLength(1);+ expect(charts[0].querySelectorAll('path[data-history-series]')).toHaveLength(3);+ expect(charts[1].querySelectorAll('path[data-history-band]')).toHaveLength(0);+ });+it('shows current readings without fabricating history points', async () => {chartsApiMocks.getMetricsHistory.mockResolvedValue({resourceType: 'vm',diff --git a/frontend-modern/src/components/Workloads/GuestDrawerHistory.tsx b/frontend-modern/src/components/Workloads/GuestDrawerHistory.tsxindex 25caeea179..15fbd6d413 100644--- a/frontend-modern/src/components/Workloads/GuestDrawerHistory.tsx+++ b/frontend-modern/src/components/Workloads/GuestDrawerHistory.tsx@@ -27,6 +27,7 @@ import { formatCompactSpeed } from '@/utils/format';import {GUEST_DRAWER_HISTORY_GROUPS,+ buildGuestDrawerHistoryBandPath,buildGuestDrawerHistoryPath,getGuestDrawerHistoryRangeBounds,getGuestDrawerHistoryScale,@@ -309,7 +310,13 @@ const GuestDrawerHistoryGroupChart: Component<GuestDrawerHistoryGroupChartProps>if (timestamp === undefined) return 'No stored history observations.';const values = series().map((item) => {const point = item.points.find((point) => point.timestamp === timestamp);- return `${item.label} ${point ? formatHistoryChartTooltipValue(point.value, item.unit) : 'no observation'}`;+ if (!point) return `${item.label} no observation`;+ const value = formatHistoryChartTooltipValue(point.value, item.unit);+ const low = formatHistoryChartTooltipValue(point.min ?? point.value, item.unit);+ const high = formatHistoryChartTooltipValue(point.max ?? point.value, item.unit);+ return low === high+ ? `${item.label} ${value}`+ : `${item.label} ${value} average, ${low} to ${high}`;});return `${new Date(timestamp).toLocaleString()}. ${values.join('. ')}.`;};@@ -425,8 +432,19 @@ const GuestDrawerHistoryGroupChart: Component<GuestDrawerHistoryGroupChartProps>: props.currentMetrics?.[item.metric];const isFallback =timestamp === null && typeof fallbackValue === 'number' && Number.isFinite(fallbackValue);+ // While a time is inspected, name the bucket's peak when it rises a+ // visible distance (a tenth of the plot) above the average the line+ // shows. The default readout stays one number per series.+ const peakVisible =+ point !== undefined &&+ activeTimestamp() !== null &&+ (point.max ?? point.value) - point.value >= 0.1 * (scale().maxValue - scale().minValue);return {...item,+ peakLabel:+ point && peakVisible+ ? `peak ${formatHistoryChartTooltipValue(point.max ?? point.value, item.unit)}`+ : null,deferred,descriptionId: `${inspectionId}-deferred-${index}`,isCurrent: isFallback && !deferred,@@ -517,6 +535,9 @@ const GuestDrawerHistoryGroupChart: Component<GuestDrawerHistoryGroupChartProps><span class={alertToneClass(props.alerts?.[item.metric]?.severity)}>{item.valueLabel}</span>+ <Show when={item.peakLabel}>+ {(label) => <span data-history-peak={item.metric}>{label()}</span>}+ </Show><Show when={item.isCurrent}><span>current</span></Show>@@ -605,6 +626,34 @@ const GuestDrawerHistoryGroupChart: Component<GuestDrawerHistoryGroupChartProps><Show when={bounds()}>{(rangeBounds) => (<>+ <For each={drawableSeries()}>+ {(item) => (+ <Show+ when={buildGuestDrawerHistoryBandPath(+ item.points,+ scale(),+ rangeBounds().startTime,+ rangeBounds().endTime,+ GUEST_DRAWER_HISTORY_CHART_WIDTH,+ GUEST_DRAWER_HISTORY_CHART_HEIGHT,+ )}+ >+ {(band) => (+ <path+ data-history-band={item.metric}+ d={band()}+ fill={item.color}+ fill-opacity="0.2"+ stroke={item.color}+ stroke-opacity="0.45"+ stroke-width="1"+ stroke-linejoin="round"+ vector-effect="non-scaling-stroke"+ />+ )}+ </Show>+ )}+ </For><For each={drawableSeries()}>{(item) => (<pathdiff --git a/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.inspection.test.tsx b/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.inspection.test.tsxindex 6074b5caf5..ad3e24771a 100644--- a/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.inspection.test.tsx+++ b/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.inspection.test.tsx@@ -5,7 +5,10 @@ import { ChartsAPI, type AllMetricsHistoryResponse, type HistoryTimeRange } fromimport { resetCreateNonSuspendingQueryCacheForTest } from '@/hooks/createNonSuspendingQuery';import { GuestDrawerHistory } from '../GuestDrawerHistory';import { HOST_METRICS_HISTORY_GROUPS } from '@/components/shared/hostMetricsHistoryModel';-import type { GuestDrawerHistoryTarget } from '../guestDrawerModel';+import {+ buildGuestDrawerHistoryBandPath,+ type GuestDrawerHistoryTarget,+} from '../guestDrawerModel';vi.mock('@/stores/license', () => ({loadRuntimeCapabilities: vi.fn(async () => undefined),@@ -272,3 +275,118 @@ describe('GuestDrawerHistory stored-observation inspection', () => {expect(fetch).not.toHaveBeenCalled();});});++// Min-max band: each stored point is a bucket average carrying its extremes.+const bandStart = Date.UTC(2026, 9, 12, 12);+const bandTarget = { resourceType: 'vm' as const, resourceId: 'fixture:pve:101' };+const bandPoint = (minute: number, value: number, min = value, max = value) => ({+ timestamp: bandStart + minute * 60_000,+ value,+ min,+ max,+});+const bandResponse = (+ metrics: AllMetricsHistoryResponse['metrics'],+): AllMetricsHistoryResponse => ({+ ...bandTarget,+ range: '1h',+ start: bandStart,+ end: bandStart + 3 * 60_000,+ source: 'store',+ metrics,+});+const bandUtilization = () =>+ screen+ .getAllByTestId('guest-history-group-chart')+ .find((el) => el.dataset.historyGroup === 'utilization')!;++// A 99% CPU burst inside a bucket that averages 20%.+const bandSpiky = {+ cpu: [bandPoint(0, 10), bandPoint(1, 20, 10, 99), bandPoint(2, 12)],+ memory: [bandPoint(0, 40), bandPoint(1, 40, 39.5, 41.5), bandPoint(2, 40)],+};++describe('drawer History min-max band', () => {+ it("draws a band up to a bucket's peak so a short spike is not averaged away", async () => {+ vi.spyOn(ChartsAPI, 'getMetricsHistory').mockResolvedValue(bandResponse(bandSpiky));+ render(() => <GuestDrawerHistory target={bandTarget} range="1h" />);+ await screen.findByRole('slider', { name: 'Inspect Utilization history' });+ const band = bandUtilization().querySelector('path[data-history-band="cpu"]');+ expect(band).not.toBeNull();+ // 99% on the 0-100 scale sits at y = 8 + (1 - 0.99) * 66 = 8.66 of the viewBox.+ expect(band?.getAttribute('d')).toContain(',8.66');+ expect(band?.getAttribute('d')).toMatch(/ Z$/);+ // The average line itself still passes through 20%, not the peak.+ const line = bandUtilization().querySelector('path[data-history-series="cpu"]');+ expect(line?.getAttribute('d')).not.toContain(',8.66');+ });++ it('draws no band for buckets whose readings never spread', async () => {+ vi.spyOn(ChartsAPI, 'getMetricsHistory').mockResolvedValue(+ bandResponse({+ ...bandSpiky,+ memory: [bandPoint(0, 40), bandPoint(1, 40), bandPoint(2, 40)],+ }),+ );+ render(() => <GuestDrawerHistory target={bandTarget} range="1h" />);+ await screen.findByRole('slider', { name: 'Inspect Utilization history' });+ expect(bandUtilization().querySelector('path[data-history-band="memory"]')).toBeNull();+ expect(bandUtilization().querySelectorAll('path[data-history-band]')).toHaveLength(1);+ });++ it('names the peak only while a time is inspected, and to assistive technology', async () => {+ vi.spyOn(ChartsAPI, 'getMetricsHistory').mockResolvedValue(bandResponse(bandSpiky));+ render(() => <GuestDrawerHistory target={bandTarget} range="1h" />);+ const slider = await screen.findByRole('slider', { name: 'Inspect Utilization history' });+ // The default readout is the latest stored time: one number per series.+ expect(bandUtilization().querySelector('[data-history-peak]')).toBeNull();++ fireEvent.focus(slider);+ fireEvent.input(slider, { target: { value: '1' } });+ expect(bandUtilization().querySelector('[data-history-peak="cpu"]')).toHaveTextContent(+ 'peak 99.0%',+ );+ // Memory's bucket spread is too small to see, so it is not called a peak.+ expect(bandUtilization().querySelector('[data-history-peak="memory"]')).toBeNull();+ expect(slider).toHaveAttribute(+ 'aria-valuetext',+ expect.stringContaining(+ 'CPU 20.0% average, 10.0% to 99.0%. Memory 40.0% average, 39.5% to 41.5%.',+ ),+ );++ fireEvent.blur(slider);+ expect(bandUtilization().querySelector('[data-history-peak]')).toBeNull();+ expect(+ within(bandUtilization()).getByRole('img', { name: 'Utilization history' }),+ ).toBeTruthy();+ });+});++describe('buildGuestDrawerHistoryBandPath', () => {+ const scale = { minValue: 0, maxValue: 100 };++ it('needs two points and some spread', () => {+ expect(+ buildGuestDrawerHistoryBandPath([bandPoint(0, 5, 1, 9)], scale, bandStart, bandStart + 1),+ ).toBe('');+ expect(+ buildGuestDrawerHistoryBandPath(+ [bandPoint(0, 5), bandPoint(1, 6)],+ scale,+ bandStart,+ bandStart + 60_000,+ ),+ ).toBe('');+ });++ it('runs forward along the highs and back along the lows', () => {+ const path = buildGuestDrawerHistoryBandPath(+ [bandPoint(0, 50, 0, 100), bandPoint(1, 50, 0, 100)],+ scale,+ bandStart,+ bandStart + 60_000,+ );+ expect(path).toBe('M34.00,8.00 L352.00,8.00 L352.00,74.00 L34.00,74.00 Z');+ });+});diff --git a/frontend-modern/src/components/Workloads/guestDrawerModel.ts b/frontend-modern/src/components/Workloads/guestDrawerModel.tsindex 0f0a52519f..45e1f6af13 100644--- a/frontend-modern/src/components/Workloads/guestDrawerModel.ts+++ b/frontend-modern/src/components/Workloads/guestDrawerModel.ts@@ -361,6 +361,49 @@ export const buildGuestDrawerHistoryPath = (.join(' ');};+// Each stored point is a bucket average carrying its own lowest and highest+// reading. The band spans those extremes behind the average line, so a short+// spike stays visible after downsampling instead of averaging away. A segment+// whose buckets never spread draws nothing.+export const buildGuestDrawerHistoryBandPath = (+ points: readonly AggregatedMetricPoint[],+ scale: GuestDrawerHistoryScale,+ startTime: number,+ endTime: number,+ width = 360,+ height = 92,+): string => {+ if (points.length < 2) return '';+ const spreads = points.some((point) => (point.max ?? point.value) > (point.min ?? point.value));+ if (!spreads) return '';++ const left = 34;+ const right = 8;+ const top = 8;+ const bottom = 18;+ const plotWidth = width - left - right;+ const plotHeight = height - top - bottom;+ const timeSpan = Math.max(1, endTime - startTime);+ const valueSpan = Math.max(1, scale.maxValue - scale.minValue);+ const coordinate = (timestamp: number, value: number) => {+ const x = left + ((timestamp - startTime) / timeSpan) * plotWidth;+ const bounded = Math.min(Math.max(value, scale.minValue), scale.maxValue);+ const y = top + (1 - (bounded - scale.minValue) / valueSpan) * plotHeight;+ return `${x.toFixed(2)},${y.toFixed(2)}`;+ };++ const upper = points.map(+ (point, index) =>+ `${index === 0 ? 'M' : 'L'}${coordinate(point.timestamp, Math.max(point.max ?? point.value, point.value))}`,+ );+ const lower = [...points]+ .reverse()+ .map(+ (point) => `L${coordinate(point.timestamp, Math.min(point.min ?? point.value, point.value))}`,+ );+ return `${[...upper, ...lower].join(' ')} Z`;+};+export const getGuestDrawerHistoryValueLabel = (points: readonly AggregatedMetricPoint[],unit: string,diff --git a/tests/integration/tests/86-hybrid-memory-browser.spec.ts b/tests/integration/tests/86-hybrid-memory-browser.spec.tsindex a7c559bc90..67658db0f5 100644--- a/tests/integration/tests/86-hybrid-memory-browser.spec.ts+++ b/tests/integration/tests/86-hybrid-memory-browser.spec.ts@@ -227,7 +227,10 @@ test("hybrid guest memory follows canonical snapshots in the browser", async ({const box = await memoryDetails.boundingBox();return box ? box.y + box.height : Infinity;}).toBeLessThan(viewport.height - 64);- await expect(memoryDetails).toBeInViewport({ ratio: 1 });+ // Fully readable, allowing the fraction of a pixel the rounded table+ // border can clip when earlier drawer content lands on a sub-pixel offset+ // (0.9956 was seen at 390px once the charts moved onto Overview).+ await expect(memoryDetails).toBeInViewport({ ratio: 0.98 });await expect(memoryDetails).toContainText("100 MB");await expect(memoryDetails.locator("tr").filter({