Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

Keep workload disk measurements distinct from capacity and fractions

pulse-triage[bot]c1a4a8733c92
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
index f570d21620..06473823d4 100644
--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md
+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
@@ -20,6 +20,23 @@
## Purpose
+### Aggregate disk bars preserve percentage-only evidence (14 October 2026)
+
+The shared stacked-disk primitive keeps independently supplied aggregate
+percentages in percentage points, including values below 1%. Without a measured
+filesystem, it uses the aggregate metric admission in `workloadDiskUsage.ts`;
+capacity alone cannot draw a healthy zero. Percentage-only tooltips and labels
+withhold missing bytes rather than inventing empty capacity. Measured filesystem
+byte ratios, omitted-zero DiskInfo rows, unknown sentinels, per-filesystem
+thresholds and source-owned last-known/unavailable decoration remain separate.
+
+Verification: the stacked-disk component/model suites retain filesystem and
+host controls; `workloadDiskUsage.test.ts` and the desktop/narrow
+`workload-disk-metrics` browser fixture cover aggregate low/zero/byte/unknown
+readings through the consuming Workloads row and drawer. A fixture is not a
+native measurement or stored History observation.
+
+
### Pulse Mobile retirement guidance stays readable (14 October 2026)
The existing Pulse Mobile settings surface exposes its retirement guidance as
diff --git a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md b/docs/release-control/v6/internal/subsystems/performance-and-scalability.md
index a37c84232a..80ff5937d1 100644
--- a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md
+++ b/docs/release-control/v6/internal/subsystems/performance-and-scalability.md
@@ -15,6 +15,37 @@
## Purpose
+### Workloads aggregate disk readings keep their units and presence (14 October 2026)
+
+Workload aggregate metrics are percentage points, including values from zero
+through one; selection never guesses a fraction from magnitude. A capacity or
+used-byte scalar alone is not an aggregate utilization reading. The mapper
+preserves missing/invalid aggregate fields, while an explicit finite
+non-negative percentage or finite non-negative used bytes with positive
+capacity supplies usage. An explicit invalid percentage cannot fall back to
+retained byte carriers. Values above 100 are bounded for existing display.
+
+The row (bars and history lens), drawer current/last-known fallback, numeric
+search and capacity sorting share this numeric admission. Source-owned guest
+read deferrals, linked-agent leases and stopped-VM rules still determine
+freshness independently. Unavailable or retained values remain after current
+values in both sort directions and cannot match numeric capacity queries.
+Percentage-only readings show no invented used/capacity bytes; byte-only
+readings and explicit zero remain available. Per-filesystem DiskInfo omitted
+zero bytes retain their existing wire semantics and are not aggregate metrics.
+No collector, guest request, timer, store/history point, threshold or alert
+policy is changed.
+
+Verification: `workloadDiskUsage.test.ts`, `useWorkloads.test.ts` (REST and owning
+snapshot refreshes), `workloadSelectors.test.ts`, `GuestRow.test.ts`,
+`GuestDrawerHistory.disk-provenance.test.tsx` and stacked-disk tests cover low
+percentages, capacity-only absence, explicit zero, byte-only reads and the
+unchanged freshness controls. `browser-tests/workload-disk-metrics.tsx` feeds
+synthetic REST observations through the production mapper, selection, rows and
+full drawer at desktop and phone widths. Its browser result/pixels must be
+recorded separately; it proves neither native recovery nor availability.
+
+
### Existing Workloads snapshots retain guest interface names
The Workloads mapper selects the existing agent interface list, otherwise the
@@ -592,6 +623,8 @@ in-place click and chevron activation over a selection.
## Canonical Files
+- `frontend-modern/src/utils/workloadDiskUsage.ts` — aggregate disk numeric/current-reading admission.
+
- `frontend-modern/src/utils/filesystemByteUsage.ts`: shared finite byte/capacity admission for filesystem utilization.
1. `pkg/metrics/store.go`
diff --git a/docs/release-control/v6/internal/subsystems/unified-resources.md b/docs/release-control/v6/internal/subsystems/unified-resources.md
index 79bea7069e..5d2b3574b7 100644
--- a/docs/release-control/v6/internal/subsystems/unified-resources.md
+++ b/docs/release-control/v6/internal/subsystems/unified-resources.md
@@ -23,6 +23,23 @@ and sort the complete canonical change table while startup and ingestion wait.
## Purpose
+### Workload aggregate disk presence survives projection (14 October 2026)
+
+`useWorkloads` does not default an absent aggregate disk usage/used byte field
+to zero merely because capacity was supplied. Both REST and owning snapshots
+preserve the difference between capacity-only inventory and finite measured
+usage. Explicit zero percentages, percentage-only metrics and valid byte-only
+metrics remain available. This aggregate metric contract is distinct from
+DiskInfo filesystem records whose zero byte fields may be omitted. Identity,
+producer selection, collection, retention and History transport are unchanged.
+
+Verification: `useWorkloads.test.ts` exercises mounted REST and owning-snapshot
+refreshes and `workloadDiskUsage.test.ts` covers numeric admission. The
+`workload-disk-metrics` browser fixture consumes the REST mapper into production
+rows/drawer with synthetic evidence; browser proof is retained separately and
+establishes no installed/native recovery.
+
+
### Workloads preserve platform guest interfaces — issue #2757
Both the `/api/resources` and owning canonical-snapshot Workloads projections
diff --git a/frontend-modern/browser-tests/build-workload-disk-metrics.mjs b/frontend-modern/browser-tests/build-workload-disk-metrics.mjs
new file mode 100644
index 0000000000..93b83dc759
--- /dev/null
+++ b/frontend-modern/browser-tests/build-workload-disk-metrics.mjs
@@ -0,0 +1,99 @@
+// Compile the real workload-disk-metrics fixture before bounded browser execution.
+// Only a bounded static preview runs in the browser tree; no live compiler or guest command.
+import { build } from 'vite';
+import solid from 'vite-plugin-solid';
+import tailwindcss from '@tailwindcss/vite';
+import { stop } from 'esbuild';
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const output = path.resolve(root, '../tmp/workload-disk-metrics-static');
+const hash = (data) => crypto.createHash('sha256').update(data).digest('hex');
+
+try {
+ for (const variant of ['final']) {
+ const sources = {};
+ const artifacts = {};
+ const outDir = path.join(output, variant);
+ await build({
+ root,
+ // Root-relative assets keep the real shipped Docs viewer functional in a new tab.
+ base: '/',
+ configFile: false,
+ publicDir: false,
+ plugins: [
+ {
+ name: 'exact-workload-disk-metrics-fixture-binding',
+ enforce: 'pre',
+ generateBundle(_options, bundle) {
+ for (const id of this.getModuleIds()) {
+ if (!id.startsWith(root + '/') || id.includes('/node_modules/')) continue;
+ const file = id.split('?')[0];
+ if (!fs.existsSync(file) || !fs.statSync(file).isFile()) continue;
+ sources[path.relative(root, file)] = hash(fs.readFileSync(file));
+ }
+ for (const [file, asset] of Object.entries(bundle)) {
+ artifacts[file] = hash(asset.type === 'chunk' ? asset.code : asset.source);
+ }
+ },
+ },
+ tailwindcss(),
+ solid(),
+ ],
+ resolve: {
+ alias: { '@': path.join(root, 'src') },
+ conditions: ['import', 'browser', 'default'],
+ },
+ build: {
+ // Match the application's declared target, not Vite's older default.
+ target: 'esnext',
+ outDir,
+ emptyOutDir: true,
+ rollupOptions: { input: path.join(root, 'browser-tests/workload-disk-metrics.html') },
+ },
+ });
+ sources['browser-tests/build-workload-disk-metrics.mjs'] = hash(
+ fs.readFileSync(fileURLToPath(import.meta.url)),
+ );
+ const importedSources = { ...sources };
+ const scanInputs = (dir) => {
+ for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+ const file = path.join(dir, entry.name);
+ if (entry.isDirectory()) scanInputs(file);
+ else if (/\.(tsx?|css|html)$/.test(file))
+ sources[path.relative(root, file)] = hash(fs.readFileSync(file));
+ }
+ };
+ scanInputs(path.join(root, 'src'));
+ scanInputs(path.join(root, 'browser-tests'));
+ // Hash the bytes actually written, including HTML post-processing.
+ const walk = (dir) => {
+ for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+ const file = path.join(dir, entry.name);
+ if (entry.isDirectory()) walk(file);
+ else artifacts[path.relative(outDir, file)] = hash(fs.readFileSync(file));
+ }
+ };
+ walk(outDir);
+ fs.writeFileSync(
+ path.join(outDir, 'binding.json'),
+ JSON.stringify(
+ {
+ variant,
+ graph: hash(fs.readFileSync(path.join(root, 'package-lock.json'))),
+ builder: hash(fs.readFileSync(fileURLToPath(import.meta.url))),
+ sources,
+ importedSources,
+ artifacts,
+ },
+ null,
+ 2,
+ ) + '\n',
+ );
+ }
+} finally {
+ stop();
+}
diff --git a/frontend-modern/browser-tests/workload-disk-metrics.cjs b/frontend-modern/browser-tests/workload-disk-metrics.cjs
new file mode 100644
index 0000000000..05726a1171
--- /dev/null
+++ b/frontend-modern/browser-tests/workload-disk-metrics.cjs
@@ -0,0 +1,294 @@
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const http = require('node:http');
+const path = require('node:path');
+const { chromium, webkit } = require('playwright');
+const root = '/workspace';
+const compiled = path.join(root, 'tmp/workload-disk-metrics-static/final');
+const output = path.join(root, 'tmp/disk-reading-proof/browser');
+const origin = 'http://127.0.0.1:5321';
+const hash = (bytes) => crypto.createHash('sha256').update(bytes).digest('hex');
+const binding = JSON.parse(fs.readFileSync(path.join(compiled, 'binding.json')));
+const result = {
+ result: 'incomplete',
+ playwright: require('playwright/package.json').version,
+ scope:
+ 'Synthetic Resources REST metrics through production useWorkloads, selection, GuestRow/GuestDrawer/History/CSS. Fixture selection controls, local empty History and supporting APIs, not full-app authentication, native measurements or recovery.',
+ binding,
+ driver_sha256: hash(fs.readFileSync(__filename)),
+ cases: [],
+ requests: [],
+ captures: [],
+ errors: [],
+ cleanup: {},
+};
+const baseMetrics = [
+ ['empty', { percent: 0, used: 0, total: 100 }],
+ ['half-percent', { percent: 0.5, used: 0.5, total: 100 }],
+ ['one-percent', { percent: 1, used: 1, total: 100 }],
+ ['forty-percent', { percent: 40, used: 40, total: 100 }],
+ ['critical', { percent: 95, used: 95, total: 100 }],
+ ['capacity-only', { total: 100 }],
+];
+const resource = (name, metric, extras = {}) => ({
+ id: `fixture-${name}`,
+ type: 'vm',
+ name,
+ status: 'online',
+ sources: ['proxmox'],
+ platformType: 'proxmox-pve',
+ lastSeen: '2026-10-14T19:00:00Z',
+ metricsTarget: { resourceType: 'vm', resourceId: `fixture-${name}` },
+ metrics: { cpu: { percent: 10 }, memory: { percent: 25, used: 25, total: 100 }, disk: metric },
+ proxmox: {
+ vmid: 101,
+ instance: 'lab',
+ nodeName: 'fixture-node',
+ runtimeStatus: 'running',
+ guestAgentStatus: 'available',
+ ...extras,
+ },
+});
+let server;
+let browser;
+(async () => {
+ fs.mkdirSync(output, { recursive: true });
+ assert.equal(
+ result.playwright,
+ JSON.parse(fs.readFileSync(root + '/tests/integration/package-lock.json')).packages[
+ 'node_modules/@playwright/test'
+ ].version,
+ );
+ for (const [file, sha] of Object.entries(binding.importedSources))
+ assert.equal(hash(fs.readFileSync(root + '/frontend-modern/' + file)), sha, file);
+ for (const [file, sha] of Object.entries(binding.artifacts))
+ assert.equal(hash(fs.readFileSync(compiled + '/' + file)), sha, file);
+ server = http.createServer((req, res) => {
+ const pathname = decodeURIComponent(new URL(req.url, origin).pathname);
+ const file = path.join(compiled, pathname);
+ if (!file.startsWith(compiled + '/') || !fs.existsSync(file) || !fs.statSync(file).isFile()) {
+ res.writeHead(404);
+ res.end();
+ return;
+ }
+ res.setHeader(
+ 'Content-Type',
+ file.endsWith('.js') ? 'text/javascript' : file.endsWith('.css') ? 'text/css' : 'text/html',
+ );
+ res.end(fs.readFileSync(file));
+ });
+ await new Promise((resolve) => server.listen(5321, '127.0.0.1', resolve));
+ try {
+ for (const [label, engine, width, dark] of [
+ ['desktop', chromium, 1280, false],
+ ['phone', webkit, 390, true],
+ ]) {
+ browser = await engine.launch(
+ engine === chromium
+ ? { headless: true, channel: 'chromium', args: ['--no-sandbox'] }
+ : { headless: true },
+ );
+ const page = await browser.newPage({
+ viewport: { width, height: 1000 },
+ hasTouch: width < 640,
+ isMobile: width < 640,
+ locale: 'en-GB',
+ timezoneId: 'UTC',
+ });
+ page.setDefaultTimeout(12000);
+ let resources = baseMetrics.map(([name, metric]) => resource(name, metric));
+ const record = { label, width, height: 1000, dark, browser: browser.version(), states: [] };
+ result.cases.push(record);
+ page.on('pageerror', (error) => result.errors.push({ label, message: error.message }));
+ await page.route('**/*', async (route) => {
+ const url = new URL(route.request().url());
+ assert.equal(url.origin, origin);
+ if (!url.pathname.startsWith('/api/')) return route.continue();
+ const method = route.request().method();
+ result.requests.push({ label, path: url.pathname, method });
+ assert.ok(
+ method === 'GET' || (method === 'POST' && url.pathname === '/api/usage/workload-history'),
+ );
+ if (url.pathname === '/api/resources')
+ return route.fulfill({ json: { data: resources, meta: { totalPages: 1 } } });
+ if (url.pathname === '/api/metrics-store/history')
+ return route.fulfill({
+ json: {
+ resourceType: 'vm',
+ resourceId: url.searchParams.get('resourceId'),
+ range: url.searchParams.get('range'),
+ start: Date.UTC(2026, 9, 14, 18),
+ end: Date.UTC(2026, 9, 14, 19),
+ source: 'store',
+ metrics: {},
+ },
+ });
+ if (url.pathname === '/api/license/runtime-capabilities')
+ return route.fulfill({
+ json: {
+ capabilities: [],
+ limits: [],
+ max_history_days: 7,
+ hosted_mode: false,
+ runtime: { build: 'community' },
+ blocked_capabilities: [],
+ },
+ });
+ return route.fulfill({
+ json: { success: true, data: [], alerts: [], anomalies: [], config: null },
+ });
+ });
+ await page.addInitScript((isDark) => {
+ if (isDark)
+ document.addEventListener('DOMContentLoaded', () =>
+ document.documentElement.classList.add('dark'),
+ );
+ }, dark);
+ await page.goto(origin + '/browser-tests/workload-disk-metrics.html');
+ const table = page.getByRole('region', { name: 'Workload readings' });
+ const order = () =>
+ table
+ .locator('tbody tr[data-guest-id]')
+ .evaluateAll((rows) =>
+ rows.map((row) => row.getAttribute('data-guest-id').replace('fixture-', '')),
+ );
+ const settle = () =>
+ page.evaluate(async () => {
+ await document.fonts.ready;
+ await new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
+ });
+ const capture = async (name) => {
+ await settle();
+ assert.equal(
+ await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth),
+ true,
+ );
+ const file = path.join(output, `${label}-${name}.png`);
+ await page.screenshot({ path: file, fullPage: true });
+ result.captures.push({ label, name, file, sha256: hash(fs.readFileSync(file)) });
+ };
+ await table.locator('tr[data-guest-id="fixture-capacity-only"]').waitFor();
+ assert.deepEqual(await order(), [
+ 'critical',
+ 'forty-percent',
+ 'one-percent',
+ 'half-percent',
+ 'empty',
+ 'capacity-only',
+ ]);
+ const capacityCell = table.locator(
+ '[data-guest-id="fixture-capacity-only"] [data-workload-col="disk"]',
+ );
+ assert.equal(await capacityCell.locator('[data-animated-number]').count(), 0);
+ await capture('descending');
+ await page.getByRole('combobox', { name: 'Disk order' }).selectOption('asc');
+ assert.deepEqual(await order(), [
+ 'empty',
+ 'half-percent',
+ 'one-percent',
+ 'forty-percent',
+ 'critical',
+ 'capacity-only',
+ ]);
+ await page.getByRole('textbox', { name: 'Search fixtures' }).fill('disk>90');
+ assert.deepEqual(await order(), ['critical']);
+ await page.getByRole('textbox', { name: 'Search fixtures' }).fill('disk<=1');
+ assert.deepEqual(await order(), ['empty', 'half-percent', 'one-percent']);
+ await page.getByRole('textbox', { name: 'Search fixtures' }).fill('');
+ await page.getByRole('combobox', { name: 'Metrics', exact: true }).selectOption('sparklines');
+ const one = table.locator('[data-guest-id="fixture-one-percent"]');
+ assert.equal(
+ await one.getByRole('img', { name: 'one-percent disk usage history, current 1%' }).count(),
+ 1,
+ );
+ if (width < 640) await table.getByText('capacity-only', { exact: true }).tap();
+ else {
+ await table.getByRole('button', { name: /capacity-only/ }).focus();
+ await page.keyboard.press('Enter');
+ }
+ const drawer = page.getByRole('region', { name: 'Selected guest' });
+ await drawer.locator('[data-history-group="utilization"]').waitFor();
+ const current = () => drawer.locator('[data-history-current="disk"]');
+ assert.equal(await current().count(), 0);
+ assert.equal(await drawer.locator('path[data-history-series]').count(), 0);
+ await capture('capacity-only');
+ const observe = async (name, metric, extras, expected) => {
+ resources = resources.map((row) =>
+ row.id === 'fixture-capacity-only'
+ ? { ...resource('capacity-only', metric, extras) }
+ : row,
+ );
+ await page.evaluate(() => window.__diskMetrics.refresh());
+ await settle();
+ const evidence = await page.evaluate(() =>
+ window.__diskMetrics.evidence().find((row) => row.id === 'fixture-capacity-only'),
+ );
+ assert.equal(evidence.current ?? null, expected);
+ record.states.push({ name, metric, extras, evidence });
+ };
+ await observe('percentage-only-low', { percent: 0.5 }, {}, 0.5);
+ assert.match(await current().innerText(), /0.5%/);
+ assert.equal((await drawer.innerText()).includes('0 B of'), false);
+ await capture('percentage-only');
+ await observe('explicit-zero', { percent: 0 }, {}, 0);
+ assert.match(await current().innerText(), /0.0%/);
+ await observe('byte-only', { used: 50, total: 100 }, {}, 50);
+ assert.match(await current().innerText(), /50.0%/);
+ await page.getByRole('combobox', { name: 'Metrics', exact: true }).selectOption('bars');
+ await observe('capacity-only-restored', { total: 100 }, {}, null);
+ assert.equal(await current().count(), 0);
+ await observe(
+ 'retained',
+ { percent: 95, used: 95, total: 100 },
+ { diskStatusReason: 'prev-agent-busy', guestAgentStatus: 'deferred' },
+ null,
+ );
+ assert.match(await drawer.locator('[data-history-last-known="disk"]').innerText(), /95.0%/);
+ await page.getByRole('textbox', { name: 'Search fixtures' }).fill('disk>90');
+ assert.deepEqual(await order(), ['critical']);
+ await page.getByRole('textbox', { name: 'Search fixtures' }).fill('');
+ await capture('retained');
+ await observe(
+ 'unavailable',
+ { percent: 95, used: 95, total: 100 },
+ { diskStatusReason: 'agent-timeout' },
+ null,
+ );
+ assert.equal(await drawer.locator('[data-history-last-known="disk"]').count(), 0);
+ await observe('recovered-current', { percent: 1, used: 1, total: 100 }, {}, 1);
+ assert.match(await current().innerText(), /1.0%/);
+ assert.equal(await drawer.locator('path[data-history-series]').count(), 0);
+ await capture('recovered');
+ await drawer.getByRole('button', { name: 'Collapse capacity-only details' }).click();
+ assert.equal(await drawer.count(), 0);
+ assert.deepEqual(result.errors, []);
+ await page.close();
+ await browser.close();
+ browser = undefined;
+ }
+ result.result = 'passed';
+ } finally {
+ if (browser) await browser.close();
+ result.cleanup.browser_closed = true;
+ await new Promise((resolve) => server.close(resolve));
+ result.cleanup.server_closed = true;
+ }
+})()
+ .catch((error) => {
+ result.errors.push({ driver: error.stack });
+ process.exitCode = 1;
+ })
+ .finally(() => {
+ fs.mkdirSync(output, { recursive: true });
+ fs.writeFileSync(path.join(output, 'result.json'), JSON.stringify(result, null, 2) + '\n');
+ console.log(
+ JSON.stringify({
+ result: result.result,
+ output,
+ captures: result.captures.length,
+ errors: result.errors,
+ cleanup: result.cleanup,
+ }),
+ );
+ });
diff --git a/frontend-modern/browser-tests/workload-disk-metrics.html b/frontend-modern/browser-tests/workload-disk-metrics.html
new file mode 100644
index 0000000000..62ad1e996f
--- /dev/null
+++ b/frontend-modern/browser-tests/workload-disk-metrics.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+ <head>
+ <meta charset="UTF-8" />
+ <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+ <title>Workload disk metrics fixture</title>
+ </head>
+ <body>
+ <div id="root"></div>
+ <script type="module" src="/browser-tests/workload-disk-metrics.tsx"></script>
+ </body>
+</html>
diff --git a/frontend-modern/browser-tests/workload-disk-metrics.tsx b/frontend-modern/browser-tests/workload-disk-metrics.tsx
new file mode 100644
index 0000000000..0aa90502b2
--- /dev/null
+++ b/frontend-modern/browser-tests/workload-disk-metrics.tsx
@@ -0,0 +1,134 @@
+// Synthetic REST observations -> production mapper, selection, row and drawer.
+// The fixture controls only selection/display, never a guest or backup operation.
+import { createMemo, createSignal, For, Show } from 'solid-js';
+import { render } from 'solid-js/web';
+import { Route, Router } from '@solidjs/router';
+import { useWorkloads } from '../src/hooks/useWorkloads';
+import { GuestRow } from '../src/components/Workloads/GuestRow';
+import { GuestDrawer } from '../src/components/Workloads/GuestDrawer';
+import {
+ filterWorkloads,
+ createWorkloadSortComparator,
+} from '../src/components/Workloads/workloadSelectors';
+import { getGuestDrawerCurrentMetrics } from '../src/components/Workloads/guestDrawerModel';
+import { DarkModeContext } from '../src/contexts/appRuntime';
+import '../src/index.css';
+
+function Fixture() {
+ const state = useWorkloads(() => true);
+ const [search, setSearch] = createSignal('');
+ const [direction, setDirection] = createSignal<'asc' | 'desc'>('desc');
+ const [mode, setMode] = createSignal<'bars' | 'sparklines'>('bars');
+ const [selected, setSelected] = createSignal<string | null>(null);
+ const phone = matchMedia('(max-width: 639px)').matches;
+ const ordered = createMemo(() =>
+ [
+ ...filterWorkloads({
+ guests: state.workloads(),
+ searchTerm: search(),
+ viewMode: 'all',
+ statusMode: 'all',
+ selectedNode: null,
+ selectedHostHint: null,
+ selectedKubernetesContext: null,
+ }),
+ ].sort(createWorkloadSortComparator('disk', direction())!),
+ );
+ const guest = () => state.workloads().find((row) => row.id === selected());
+ (window as any).__diskMetrics = {
+ refresh: state.refetch,
+ evidence: () =>
+ state
+ .workloads()
+ .map((row) => ({
+ id: row.id,
+ disk: row.disk,
+ available: row.telemetryAvailability?.disk,
+ current: getGuestDrawerCurrentMetrics(row).disk,
+ })),
+ };
+ return (
+ <main class="min-h-screen space-y-3 bg-surface p-3 text-base-content pulse-wide-data-surface">
+ <h1 class="text-base font-semibold">Workload disk readings</h1>
+ <p class="text-xs text-muted">
+ Synthetic observations; fixture selection controls. No guest operations.
+ </p>
+ <div class="flex flex-wrap gap-2 text-sm">
+ <label>
+ Search{' '}
+ <input
+ aria-label="Search fixtures"
+ value={search()}
+ onInput={(e) => setSearch(e.currentTarget.value)}
+ class="w-32 rounded-sm border border-border bg-surface px-2 py-2"
+ />
+ </label>
+ <label>
+ Disk order{' '}
+ <select
+ aria-label="Disk order"
+ value={direction()}
+ onChange={(e) => setDirection(e.currentTarget.value as 'asc' | 'desc')}
+ class="rounded-sm border border-border bg-surface px-2 py-2"
+ >
+ <option value="asc">Ascending</option>
+ <option value="desc">Descending</option>
+ </select>
+ </label>
+ <label>
+ Metrics{' '}
+ <select
+ aria-label="Metrics"
+ value={mode()}
+ onChange={(e) => setMode(e.currentTarget.value as 'bars' | 'sparklines')}
+ class="rounded-sm border border-border bg-surface px-2 py-2"
+ >
+ <option value="bars">Bars</option>
+ <option value="sparklines">Sparklines</option>
+ </select>
+ </label>
+ </div>
+ <section aria-label="Workload readings" class="rounded-sm border border-border">
+ <table class="workload-table platform-table w-full table-fixed">
+ <thead>
+ <tr>
+ <th class="p-2 text-left">Name</th>
+ <th class="p-2 text-center">Disk</th>
+ </tr>
+ </thead>
+ <tbody>
+ <For each={ordered()}>
+ {(row) => (
+ <GuestRow
+ guest={row}
+ visibleColumnIds={['name', 'disk']}
+ metricDisplayMode={mode()}
+ workloadTableLayoutMode={phone ? 'phone' : 'wide'}
+ onClick={() => setSelected(row.id)}
+ />
+ )}
+ </For>
+ </tbody>
+ </table>
+ </section>
+ <Show when={guest()}>
+ {(_row) => (
+ <section aria-label="Selected guest" class="rounded-sm border border-border p-3">
+ <GuestDrawer guest={guest()!} onClose={() => setSelected(null)} />
+ </section>
+ )}
+ </Show>
+ </main>
+ );
+}
+
+render(
+ () => (
+ <DarkModeContext.Provider value={() => document.documentElement.classList.contains('dark')}>
+ <Router>
+ <Route path="*" component={Fixture} />
+ </Router>
+ </DarkModeContext.Provider>
+ ),
+ document.getElementById('root')!,
+);
diff --git a/frontend-modern/src/components/Workloads/GuestDrawerOverview.tsx b/frontend-modern/src/components/Workloads/GuestDrawerOverview.tsx
index 4788c6317a..8fea970dea 100644
--- a/frontend-modern/src/components/Workloads/GuestDrawerOverview.tsx
+++ b/frontend-modern/src/components/Workloads/GuestDrawerOverview.tsx
@@ -409,7 +409,14 @@ export function GuestDrawerOverview(props: GuestDrawerOverviewProps) {
};
const diskFact = () => {
const disk = props.guest.disk;
- if (!disk || !((disk.total ?? 0) > 0) || typeof props.currentMetrics?.disk !== 'number') {
+ if (
+ !disk ||
+ !((disk.total ?? 0) > 0) ||
+ typeof disk.used !== 'number' ||
+ !Number.isFinite(disk.used) ||
+ disk.used < 0 ||
+ typeof props.currentMetrics?.disk !== 'number'
+ ) {
return '';
}
return `${formatBytes(disk.used ?? 0)} of ${formatBytes(disk.total ?? 0)} disk`;
diff --git a/frontend-modern/src/components/Workloads/GuestRow.tsx b/frontend-modern/src/components/Workloads/GuestRow.tsx
index 0ef546b08e..1c174006a5 100644
--- a/frontend-modern/src/components/Workloads/GuestRow.tsx
+++ b/frontend-modern/src/components/Workloads/GuestRow.tsx
@@ -80,6 +80,7 @@ export function GuestRow(props: GuestRowProps) {
customUrl,
diskAnomaly,
diskIOEmphasis,
+ diskPercent,
diskRead,
diskThresholds,
diskUsageRead,
@@ -344,7 +345,7 @@ export function GuestRow(props: GuestRowProps) {
});
const renderDiskSparkline = () =>
renderMetricSparkline('disk', {
- valueLabel: () => (hasDiskUsage() ? formatMetricPercent(props.guest.disk?.usage) : '—'),
+ valueLabel: () => (hasDiskUsage() ? formatMetricPercent(diskPercent()) : '—'),
title: () => `${props.guest.name} disk usage history`,
tooltip: () => diskReadStatus()?.message,
formatValue: formatMetricPercent,
diff --git a/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.disk-provenance.test.tsx b/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.disk-provenance.test.tsx
index 783bd12592..0deaa7576d 100644
--- a/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.disk-provenance.test.tsx
+++ b/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.disk-provenance.test.tsx
@@ -92,6 +92,24 @@ const utilization = () => screen.getAllByTestId('guest-history-group-chart')[0];
// Actual backend provenance remains authoritative. Removing a VM lock alone
// cannot turn retained readings into current data or prove native thaw.
describe('GuestDrawerHistory filesystem provenance', () => {
+ it('keeps capacity-only aggregates unknown and accepts explicit zero/byte-only fallback without chart points', async () => {
+ const fetch = vi.spyOn(ChartsAPI, 'getMetricsHistory').mockResolvedValue(response());
+ const [value, setValue] = createSignal<WorkloadGuest>({ ...guest(''), disk: { total: 100 } });
+ mount(value);
+ await settledHistory();
+ expect(utilization().querySelector('[data-history-current="disk"]')).toBeNull();
+ setValue({ ...value(), disk: { total: 100, used: 50 } });
+ expect(utilization().querySelector('[data-history-current="disk"]')).toHaveTextContent(
+ 'Disk50.0%current',
+ );
+ setValue({ ...value(), disk: { usage: 0 } });
+ expect(utilization().querySelector('[data-history-current="disk"]')).toHaveTextContent(
+ 'Disk0.0%current',
+ );
+ expect(utilization().querySelector('path[data-history-series]')).toBeNull();
+ expect(fetch).toHaveBeenCalledTimes(1);
+ });
+
it('withdraws the current stopped-VM carrier but keeps real stored History', async () => {
const fetch = vi
.spyOn(ChartsAPI, 'getMetricsHistory')
diff --git a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx
index e48866b09c..bcd8c4e085 100644
--- a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx
+++ b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx
@@ -2543,6 +2543,45 @@ describe('GuestRow', () => {
});
describe('disk usage edge cases', () => {
+ it.each(['bars', 'sparklines'] as const)(
+ 'keeps missing capacity-only reads separate from zero and byte-only reads in %s',
+ (mode) => {
+ const [value, setValue] = createSignal(makeGuest({ disk: { total: 100 }, disks: [] }));
+ const { container } = render(() => (
+ <table>
+ <tbody>
+ <GuestRow
+ guest={value()}
+ visibleColumnIds={['name', 'disk']}
+ metricDisplayMode={mode}
+ />
+ </tbody>
+ </table>
+ ));
+ const row = container.querySelector('tr');
+ const cell = () => container.querySelector('[data-workload-col="disk"]')!;
+ expect(screen.queryByTestId('disk-bar')).toBeNull();
+ expect(cell()).not.toHaveTextContent('0%');
+ setValue({ ...value(), disk: { usage: 1 } });
+ if (mode === 'bars') expect(screen.getByTestId('disk-bar')).toBeInTheDocument();
+ else
+ expect(
+ screen.getByRole('img', { name: 'test-vm disk usage history, current 1%' }),
+ ).toBeInTheDocument();
+ setValue({ ...value(), disk: { used: 50, total: 100 } });
+ if (mode === 'sparklines')
+ expect(
+ screen.getByRole('img', { name: 'test-vm disk usage history, current 50%' }),
+ ).toBeInTheDocument();
+ setValue({ ...value(), disk: { usage: 0 } });
+ if (mode === 'sparklines')
+ expect(
+ screen.getByRole('img', { name: 'test-vm disk usage history, current 0%' }),
+ ).toBeInTheDocument();
+ expect(container.querySelector('tr')).toBe(row);
+ },
+ );
+
it('shows dash when disk usage is -1 (unsupported)', () => {
renderGuestRow({
guest: makeGuest({
diff --git a/frontend-modern/src/components/Workloads/__tests__/StackedDiskBar.test.tsx b/frontend-modern/src/components/Workloads/__tests__/StackedDiskBar.test.tsx
index 46929d2fc3..b0ce5c3b73 100644
--- a/frontend-modern/src/components/Workloads/__tests__/StackedDiskBar.test.tsx
+++ b/frontend-modern/src/components/Workloads/__tests__/StackedDiskBar.test.tsx
@@ -19,11 +19,13 @@ import { StackedDiskBar } from '../StackedDiskBar';
// ── Helpers ──────────────────────────────────────────────────────────────────
function makeDisk(overrides: Partial<Disk> = {}): Disk {
+ const total = overrides.total ?? 107374182400;
+ const used = overrides.used ?? 53687091200;
return {
total: 107374182400, // 100 GiB
used: 53687091200, // ~50 GiB
free: 53687091200,
- usage: 50,
+ usage: total > 0 ? (used / total) * 100 : 0,
mountpoint: '/',
type: 'ext4',
device: '/dev/sda1',
diff --git a/frontend-modern/src/components/Workloads/__tests__/stackedDiskBarModel.branchcov0712b.test.ts b/frontend-modern/src/components/Workloads/__tests__/stackedDiskBarModel.branchcov0712b.test.ts
index 158dc85cc9..f9515e2da8 100644
--- a/frontend-modern/src/components/Workloads/__tests__/stackedDiskBarModel.branchcov0712b.test.ts
+++ b/frontend-modern/src/components/Workloads/__tests__/stackedDiskBarModel.branchcov0712b.test.ts
@@ -49,6 +49,22 @@ const makeAnomaly = (overrides: Partial<AnomalyReport> = {}): AnomalyReport => (
});
describe('stackedDiskBarModel (branch coverage 2)', () => {
+ it('does not invent aggregate usage from capacity, or bytes from a percentage', () => {
+ const capacity = buildStackedDiskBarPresentation({ aggregateDisk: { total: 100 } }, 400);
+ expect(capacity.unavailable).toBe(true);
+ expect(capacity.displayLabel).toBe('N/A');
+ expect(capacity.tooltipContent[0]).toMatchObject({ percent: '—', used: '?', total: '100 B' });
+ const percentage = buildStackedDiskBarPresentation({ aggregateDisk: { usage: 0.5 } }, 400);
+ expect(percentage.unavailable).toBe(false);
+ expect(percentage.barPercent).toBe(0.5);
+ expect(percentage.displaySublabel).toBe('');
+ expect(percentage.tooltipContent[0]).toMatchObject({ used: '?', total: '—' });
+ // DiskInfo is not an aggregate metric: its genuine zero bytes may be omitted.
+ const filesystem = buildStackedDiskBarPresentation({ disks: [{ total: 100, free: 100 }] }, 400);
+ expect(filesystem.unavailable).toBe(false);
+ expect(filesystem.displayPercentValue).toBe(0);
+ });
+
describe('getDiskUsagePercent (via miniDisks[].percent)', () => {
it('uses the used/total ratio when total > 0', () => {
// Branch: disk.total > 0 -> (used / total) * 100.
@@ -76,7 +92,7 @@ describe('stackedDiskBarModel (branch coverage 2)', () => {
);
it.each([
- { usage: 0.5, expected: 50 },
+ { usage: 0.5, expected: 0.5 },
{ usage: 75, expected: 75 },
{ usage: 0, expected: 0 },
])('preserves independently supplied aggregate-only percentages: %j', ({ usage, expected }) => {
diff --git a/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.branchcov.test.ts b/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.branchcov.test.ts
index e71d35fdd9..38b0264446 100644
--- a/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.branchcov.test.ts
+++ b/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.branchcov.test.ts
@@ -575,10 +575,10 @@ describe('workloadSelectors (branch coverage)', () => {
});
describe('getDiskUsagePercent', () => {
- it('treats usage of exactly 1 as a ratio (100) not a percentage', () => {
+ it('treats usage of exactly 1 as one percent, not a fraction', () => {
expect(
getDiskUsagePercent(makeGuest(1, { disk: { total: 100, used: 100, free: 0, usage: 1 } })),
- ).toBe(100);
+ ).toBe(1);
});
it('keeps a reported zero but treats negative usage as unavailable', () => {
@@ -590,17 +590,19 @@ describe('workloadSelectors (branch coverage)', () => {
).toBeNull();
});
- it('falls back to used/total when usage is non-finite (Infinity)', () => {
+ it('rejects an explicitly non-finite percentage, even with retained bytes', () => {
expect(
getDiskUsagePercent(
makeGuest(1, { disk: { total: 200, used: 50, free: 150, usage: Infinity } }),
),
- ).toBe(25);
+ ).toBeNull();
});
it('clamps used/total result above 100 to 100', () => {
expect(
- getDiskUsagePercent(makeGuest(1, { disk: { total: 100, used: 150, free: 0, usage: NaN } })),
+ getDiskUsagePercent(
+ makeGuest(1, { disk: { total: 100, used: 150, free: 0, usage: undefined } }),
+ ),
).toBe(100);
});
diff --git a/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.test.ts b/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.test.ts
index cf1c97a4b4..2ab01830e4 100644
--- a/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.test.ts
+++ b/frontend-modern/src/components/Workloads/__tests__/workloadSelectors.test.ts
@@ -871,12 +871,12 @@ describe('workloadSelectors', () => {
});
describe('getDiskUsagePercent', () => {
- it('handles ratio and percentage disk usage with clamping', () => {
+ it('uses percentage points, including below one, with clamping', () => {
expect(
getDiskUsagePercent(
makeGuest(1, { disk: { total: 100, used: 42, free: 58, usage: 0.42 } }),
),
- ).toBe(42);
+ ).toBe(0.42);
expect(
getDiskUsagePercent(makeGuest(2, { disk: { total: 100, used: 85, free: 15, usage: 85 } })),
).toBe(85);
@@ -888,7 +888,7 @@ describe('workloadSelectors', () => {
it('falls back to used/total and returns null for invalid inputs', () => {
expect(
getDiskUsagePercent(
- makeGuest(1, { disk: { total: 200, used: 50, free: 150, usage: NaN } }),
+ makeGuest(1, { disk: { total: 200, used: 50, free: 150, usage: undefined } }),
),
).toBe(25);
expect(
@@ -1082,6 +1082,19 @@ describe('current guest disk selection', () => {
selectedKubernetesContext: null,
});
+ it.each(['asc', 'desc'] as const)(
+ 'sorts sub-one-percent readings consistently with search in %s order',
+ (direction) => {
+ const measured = [0, 0.5, 1, 40, 95].map((usage, i) => diskGuest(i + 1, usage));
+ const unknown = diskGuest(6, 0, { disk: { total: 100 } });
+ expect([unknown, ...measured].sort(createWorkloadSortComparator('disk', direction)!)).toEqual(
+ [...(direction === 'asc' ? measured : [...measured].reverse()), unknown],
+ );
+ expect(select([...measured, unknown], 'disk>90')).toEqual([measured[4]]);
+ expect(select([...measured, unknown], 'disk<=1')).toEqual(measured.slice(0, 3));
+ },
+ );
+
it.each(['prev-vm-locked', 'prev-agent-timeout', 'permission-denied', 'agent-cooldown'])(
'excludes %s numbers from disk sorting and numeric search without hiding inventory',
(diskStatusReason) => {
diff --git a/frontend-modern/src/components/Workloads/guestDrawerModel.ts b/frontend-modern/src/components/Workloads/guestDrawerModel.ts
index e2f5632a81..4494e7b495 100644
--- a/frontend-modern/src/components/Workloads/guestDrawerModel.ts
+++ b/frontend-modern/src/components/Workloads/guestDrawerModel.ts
@@ -26,6 +26,7 @@ import {
} from '@/utils/workloadGuestPresentation';
import { getWorkloadCPUPercent, resolveWorkloadType } from '@/utils/workloads';
import { getWorkloadMetricHistoryTarget } from '@/utils/workloadMetricHistoryTarget';
+import { getWorkloadDiskUsagePercent } from '@/utils/workloadDiskUsage';
import type { NestedWorkloadContext } from './nestedWorkloadContext';
import type { WorkloadsMemoryDisplayBasis } from './workloadsFilterModel';
@@ -123,8 +124,9 @@ export const getGuestDrawerAlertAttention = (
};
const getGuestDrawerDiskUsage = (guest: Guest): number | undefined => {
- const usage = guest.telemetryAvailability?.disk === false ? undefined : guest.disk?.usage;
- return typeof usage === 'number' && Number.isFinite(usage) && usage >= 0 ? usage : undefined;
+ return guest.telemetryAvailability?.disk === false
+ ? undefined
+ : (getWorkloadDiskUsagePercent(guest.disk) ?? undefined);
};
export type GuestDrawerMemoryReading = MemoryObservationPresentation;
diff --git a/frontend-modern/src/components/Workloads/stackedDiskBarModel.ts b/frontend-modern/src/components/Workloads/stackedDiskBarModel.ts
index 85ace33d5f..de4071d2b4 100644
--- a/frontend-modern/src/components/Workloads/stackedDiskBarModel.ts
+++ b/frontend-modern/src/components/Workloads/stackedDiskBarModel.ts
@@ -1,5 +1,6 @@
import type { Disk } from '@/types/api';
import { getFilesystemByteUsagePercent } from '@/utils/filesystemByteUsage';
+import { getWorkloadDiskUsagePercent } from '@/utils/workloadDiskUsage';
import type { WorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';
import type { AnomalyReport } from '@/types/aiIntelligence';
import {
@@ -115,11 +116,7 @@ function getDiskUsagePercent(disk: Disk): number {
if (total > 0) {
return ((disk.used ?? 0) / total) * 100;
}
- const usage = disk.usage;
- if (typeof usage === 'number' && Number.isFinite(usage)) {
- return usage <= 1 ? usage * 100 : usage;
- }
- return 0;
+ return getWorkloadDiskUsagePercent(disk) ?? 0;
}
// Unknown sentinels and invalid/incomplete byte readings cannot contribute
@@ -242,17 +239,25 @@ function buildTooltipContent(
});
}
- if (options.aggregateDisk && (options.aggregateDisk.total ?? 0) > 0) {
- const percentValue = getDiskUsagePercent(options.aggregateDisk);
+ if (options.aggregateDisk) {
+ const aggregate = options.aggregateDisk;
+ const percentValue = getWorkloadDiskUsagePercent(aggregate);
+ const hasUsed =
+ typeof aggregate.used === 'number' && Number.isFinite(aggregate.used) && aggregate.used >= 0;
+ const hasTotal =
+ typeof aggregate.total === 'number' &&
+ Number.isFinite(aggregate.total) &&
+ aggregate.total > 0;
return [
{
- color: options.current
- ? getMetricColorRgba(percentValue, 'disk', options.thresholds)
- : UNKNOWN_DISK_COLOR,
+ color:
+ options.current && percentValue !== null
+ ? getMetricColorRgba(percentValue, 'disk', options.thresholds)
+ : UNKNOWN_DISK_COLOR,
label: 'Total',
- percent: options.unavailable ? '—' : formatPercent(percentValue),
- total: formatBytes(options.aggregateDisk.total ?? 0),
- used: options.unavailable ? '?' : formatBytes(options.aggregateDisk.used ?? 0),
+ percent: options.unavailable || percentValue === null ? '—' : formatPercent(percentValue),
+ total: hasTotal ? formatBytes(aggregate.total!) : '—',
+ used: options.unavailable || !hasUsed ? '?' : formatBytes(aggregate.used!),
},
];
}
@@ -289,14 +294,8 @@ export function buildStackedDiskBarPresentation(
// Independently supplied aggregate percentages keep their legacy fallback;
// they do not make an unmeasured per-filesystem byte row usable.
const aggregate = props.aggregateDisk;
- const hasAggregateUsage = Boolean(
- aggregate &&
- (getFilesystemByteUsagePercent(aggregate) !== null ||
- ((aggregate.total ?? 0) <= 0 &&
- typeof aggregate.usage === 'number' &&
- Number.isFinite(aggregate.usage) &&
- aggregate.usage >= 0)),
- );
+ const aggregatePercent = getWorkloadDiskUsagePercent(aggregate);
+ const hasAggregateUsage = aggregatePercent !== null;
// Retained numbers explain the last report, not live pressure. If every
// supplied filesystem is unmeasured, do not fall through to a fabricated 0%.
const unavailable =
@@ -329,12 +328,11 @@ export function buildStackedDiskBarPresentation(
const totalUsed = hasDisks
? disks.reduce((sum, disk) => sum + (disk.used || 0), 0)
: (aggregateDisk?.used ?? 0);
- const overallPercent =
- totalCapacity > 0
- ? (totalUsed / totalCapacity) * 100
- : aggregateDisk
- ? getDiskUsagePercent(aggregateDisk)
- : 0;
+ const overallPercent = hasDisks
+ ? (totalUsed / totalCapacity) * 100
+ : unavailable
+ ? 0
+ : (aggregatePercent ?? 0);
const anomalyRatio = formatAnomalyRatio(anomaly) ?? '';
const maxInfo = getMaxDiskInfo(disks);
const useMaxSummary =
@@ -351,7 +349,15 @@ export function buildStackedDiskBarPresentation(
: '';
const displayLabel = unavailable ? 'N/A' : formatPercent(displayPercentValue);
const displaySublabel =
- unavailable || (useMaxSummary && maxInfo)
+ unavailable ||
+ (useMaxSummary && maxInfo) ||
+ (!hasDisks &&
+ !(
+ typeof aggregateDisk?.used === 'number' &&
+ Number.isFinite(aggregateDisk.used) &&
+ aggregateDisk.used >= 0 &&
+ totalCapacity > 0
+ ))
? ''
: `${formatBytes(totalUsed)}/${formatBytes(totalCapacity)}`;
const diskCountLabel = hasMultipleDisks ? `${disks.length} disks` : '';
diff --git a/frontend-modern/src/components/Workloads/useGuestRowState.ts b/frontend-modern/src/components/Workloads/useGuestRowState.ts
index e50c4aac5b..b70bee5c1c 100644
--- a/frontend-modern/src/components/Workloads/useGuestRowState.ts
+++ b/frontend-modern/src/components/Workloads/useGuestRowState.ts
@@ -10,6 +10,7 @@ import { getGuestHealthIndicator, isGuestRunning } from '@/utils/status';
import { formatBytes } from '@/utils/format';
import { getContainerRuntimeBadgeForRuntime } from '@/utils/resourceBadgePresentation';
import { getWorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';
+import { getWorkloadDiskUsagePercent } from '@/utils/workloadDiskUsage';
import {
getCanonicalWorkloadId,
getWorkloadPlatformScopes,
@@ -215,13 +216,7 @@ export function useGuestRowState(props: GuestRowProps) {
return Math.max(0, Math.min(usage, 100));
});
- const diskPercent = createMemo(() => {
- const disk = props.guest.disk;
- const total = disk?.total ?? 0;
- if (!disk || total === 0) return 0;
- if (disk.usage === -1) return -1;
- return ((disk.used ?? 0) / total) * 100;
- });
+ const diskPercent = createMemo(() => getWorkloadDiskUsagePercent(props.guest.disk));
// The cell's filesystem bars and aggregate follow the drawer's rule: a
// linked agent's filesystems follow that agent, Proxmox's its read reason.
@@ -232,14 +227,12 @@ export function useGuestRowState(props: GuestRowProps) {
const hasDiskUsage = createMemo(() => {
const guest = props.guest;
if (!guest.disk || guest.telemetryAvailability?.disk === false) return false;
- const total = guest.disk.total ?? 0;
- if (!Number.isFinite(total) || total <= 0) return false;
// A generic canonical merge can retain the previous numeric metric while
// its source reports no usable guest reading. Only a last known reading
// may keep that number visible.
if (diskUsageRead().state === 'unavailable') return false;
const percent = diskPercent();
- return Number.isFinite(percent) && percent >= 0;
+ return percent !== null;
});
const parentOnline = createMemo(() => props.parentNodeOnline !== false);
diff --git a/frontend-modern/src/components/Workloads/workloadSelectors.ts b/frontend-modern/src/components/Workloads/workloadSelectors.ts
index ba3dc7a497..df9908b99e 100644
--- a/frontend-modern/src/components/Workloads/workloadSelectors.ts
+++ b/frontend-modern/src/components/Workloads/workloadSelectors.ts
@@ -21,7 +21,7 @@ import {
workloadMatchesViewMode,
} from '@/utils/workloads';
import { getWorkloadTypePresentation } from '@/utils/workloadTypePresentation';
-import { getWorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';
+import { getCurrentWorkloadDiskUsage } from '@/utils/workloadDiskUsage';
import { getCurrentWorkloadMemoryUsage } from '@/utils/memoryObservation';
import {
getKubernetesContextKey,
@@ -287,36 +287,9 @@ export const filterWorkloads = ({
};
export const getDiskUsagePercent = (guest: WorkloadGuest): number | null => {
- const disk = guest?.disk;
// The row may retain a clearly labelled last-known number. It must not
// compete with current readings when sorting capacity, in either direction.
- if (
- !disk ||
- guest.telemetryAvailability?.disk === false ||
- getWorkloadGuestDiskRead(guest, resolveWorkloadType(guest) === 'vm').state !== 'current' ||
- (typeof disk.usage === 'number' && disk.usage < 0)
- ) {
- return null;
- }
-
- const clamp = (value: number) => Math.min(100, Math.max(0, value));
-
- if (typeof disk.usage === 'number' && Number.isFinite(disk.usage)) {
- const usageValue = disk.usage > 1 ? disk.usage : disk.usage * 100;
- return clamp(usageValue);
- }
-
- if (
- typeof disk.used === 'number' &&
- Number.isFinite(disk.used) &&
- typeof disk.total === 'number' &&
- Number.isFinite(disk.total) &&
- disk.total > 0
- ) {
- return clamp((disk.used / disk.total) * 100);
- }
-
- return null;
+ return getCurrentWorkloadDiskUsage(guest);
};
export const createWorkloadSortComparator = (
diff --git a/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts b/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts
index af072f8a9c..2ab9d70d1b 100644
--- a/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts
+++ b/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts
@@ -83,6 +83,67 @@ describe('useWorkloads', () => {
resetWorkloadsCacheForTests();
});
+ it.each(['api', 'snapshot'] as const)(
+ 'preserves aggregate disk presence and percentage points through %s refreshes',
+ async (transport) => {
+ const [snapshot, setSnapshot] = createSignal<Resource[]>([]);
+ let dispose = () => {};
+ let result!: ReturnType<UseWorkloadsModule['useWorkloads']>;
+ createRoot((d) => {
+ dispose = d;
+ result = useWorkloads(
+ () => true,
+ transport === 'snapshot' ? { resourceSnapshot: snapshot } : {},
+ );
+ });
+ try {
+ await flushAsync();
+ for (const [metric, expected] of [
+ [{ total: 100 }, null],
+ [{ used: 0 }, null],
+ [{}, null],
+ [{ used: 0, total: 100 }, 0],
+ [{ percent: 0 }, 0],
+ [{ percent: 0.5 }, 0.5],
+ [{ percent: 1 }, 1],
+ [{ value: 0.5 }, 0.5],
+ [{ used: 50, total: 200 }, 25],
+ [{ percent: -1, used: 0, total: 100 }, null],
+ [{ percent: Infinity, used: 0, total: 100 }, null],
+ ] as const) {
+ const raw = { ...sampleResource, metrics: { ...sampleResource.metrics, disk: metric } };
+ if (transport === 'api') {
+ apiFetchJSONMock.mockResolvedValue({ data: [raw] });
+ await result.refetch();
+ } else {
+ const { percent, value, ...bytes } = metric as {
+ percent?: number;
+ value?: number;
+ total?: number;
+ used?: number;
+ };
+ setSnapshot([
+ {
+ ...raw,
+ lastSeen: Date.parse(raw.lastSeen),
+ disk: { ...bytes, current: percent ?? value } as Resource['disk'],
+ } as unknown as Resource,
+ ]);
+ }
+ await flushAsync();
+ const row = result.workloads()[0];
+ expect(row.id).toBe(sampleResource.id);
+ expect(row.telemetryAvailability?.disk).toBe(expected !== null);
+ expect(getDiskUsagePercent(row)).toBe(expected);
+ if (expected === null && !('used' in metric)) expect(row.disk.used).toBeUndefined();
+ expect(row.memory.usage).toBe(50);
+ }
+ } finally {
+ dispose();
+ }
+ },
+ );
+
it.each(
(['api', 'snapshot'] as const).flatMap((transport) =>
(['vm', 'system-container'] as const).map((type) => ({ transport, type })),
diff --git a/frontend-modern/src/hooks/useWorkloads.ts b/frontend-modern/src/hooks/useWorkloads.ts
index 84ec52bd19..00ce7ad6d0 100644
--- a/frontend-modern/src/hooks/useWorkloads.ts
+++ b/frontend-modern/src/hooks/useWorkloads.ts
@@ -10,6 +10,7 @@ import {
} from '@/utils/sourcePlatforms';
import { canonicalDiscoveryResourceType } from '@/utils/discoveryTarget';
import { normalizeDiskArray } from '@/utils/format';
+import { getWorkloadDiskUsagePercent } from '@/utils/workloadDiskUsage';
import {
getWorkloadCPUFraction,
isDockerManagedAppContainer,
@@ -331,6 +332,27 @@ const buildMetric = (metric?: APIMetricValue) => {
return { total, used, free, usage };
};
+const buildDiskMetric = (metric?: APIMetricValue): WorkloadGuest['disk'] => {
+ const disk = {
+ total: metric?.total,
+ used: metric?.used,
+ usage: metric?.percent ?? metric?.value,
+ };
+ return {
+ ...disk,
+ // Preserve missing/invalid evidence. Capacity-only metrics must not turn
+ // into current 0%, but explicitly reported zero and byte-only reads work.
+ usage: getWorkloadDiskUsagePercent(disk) ?? disk.usage,
+ free:
+ typeof disk.total === 'number' &&
+ Number.isFinite(disk.total) &&
+ typeof disk.used === 'number' &&
+ Number.isFinite(disk.used)
+ ? Math.max(0, disk.total - disk.used)
+ : undefined,
+ };
+};
+
const mapNetworkInterfaces = (interfaces?: APINetworkInterface[]) =>
interfaces?.map((iface) => ({
name: iface.name,
@@ -492,7 +514,8 @@ const mapResourceToWorkload = (resource: APIResource): WorkloadGuest | null => {
firstFiniteMetricNumber(resource.metrics?.cpu?.percent, resource.metrics?.cpu?.value) ?? 0;
const cpuAvailable = hasMetricValue(resource.metrics?.cpu);
const memoryAvailable = hasMetricValue(resource.metrics?.memory);
- const diskAvailable = hasMetricValue(resource.metrics?.disk);
+ const disk = buildDiskMetric(resource.metrics?.disk);
+ const diskAvailable = getWorkloadDiskUsagePercent(disk) !== null;
const networkIOAvailable =
hasMetricValue(resource.metrics?.netIn) || hasMetricValue(resource.metrics?.netOut);
const diskIOAvailable =
@@ -567,7 +590,7 @@ const mapResourceToWorkload = (resource: APIResource): WorkloadGuest | null => {
balloon: resource.proxmox?.balloon ?? 0,
};
})(),
- disk: buildMetric(resource.metrics?.disk),
+ disk,
disks: normalizeDiskArray(resource.proxmox?.disks ?? resource.agent?.disks),
disksFromAgent: (resource.proxmox?.disks == null && resource.agent?.disks != null) || undefined,
// Both the API and owning platform snapshot pass through this mapper.
diff --git a/frontend-modern/src/utils/__tests__/workloadDiskUsage.test.ts b/frontend-modern/src/utils/__tests__/workloadDiskUsage.test.ts
new file mode 100644
index 0000000000..4b22cfd55e
--- /dev/null
+++ b/frontend-modern/src/utils/__tests__/workloadDiskUsage.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+import type { Disk } from '@/types/api';
+import { getWorkloadDiskUsagePercent } from '../workloadDiskUsage';
+
+describe('workload aggregate disk evidence', () => {
+ it.each([0, 0.01, 0.5, 1, 1.01, 40, 95])(
+ 'keeps %s percentage points without guessing a fraction',
+ (usage) => {
+ expect(getWorkloadDiskUsagePercent({ usage })).toBe(usage);
+ expect(getWorkloadDiskUsagePercent({ usage, total: 100 })).toBe(usage);
+ },
+ );
+
+ it.each([
+ undefined,
+ null,
+ {},
+ { total: 100 },
+ { free: 100 },
+ { used: 0 },
+ { used: 0, total: 0 },
+ { used: -1, total: 100 },
+ { used: NaN, total: 100 },
+ { used: 0, total: Infinity },
+ { used: 0, total: -1 },
+ ...[-1, NaN, Infinity].map((usage) => ({ usage, total: 100, used: 0 })),
+ ] satisfies Array<Disk | undefined | null>)(
+ 'does not manufacture a healthy zero from %j',
+ (disk) => {
+ expect(getWorkloadDiskUsagePercent(disk)).toBeNull();
+ },
+ );
+
+ it('uses finite byte readings only when no percentage is supplied', () => {
+ expect(getWorkloadDiskUsagePercent({ used: 0, total: 100 })).toBe(0);
+ expect(getWorkloadDiskUsagePercent({ used: 0.5, total: 100 })).toBe(0.5);
+ expect(getWorkloadDiskUsagePercent({ used: 50, total: 200 })).toBe(25);
+ expect(getWorkloadDiskUsagePercent({ used: 50, total: 200, usage: 20 })).toBe(20);
+ expect(getWorkloadDiskUsagePercent({ used: 150, total: 100 })).toBe(100);
+ });
+});
diff --git a/frontend-modern/src/utils/searchQuery.ts b/frontend-modern/src/utils/searchQuery.ts
index f2efb42438..8bf5ffa047 100644
--- a/frontend-modern/src/utils/searchQuery.ts
+++ b/frontend-modern/src/utils/searchQuery.ts
@@ -1,6 +1,6 @@
import type { WorkloadGuest } from '@/types/workloads';
-import { getWorkloadCPUPercent, resolveWorkloadType } from '@/utils/workloads';
-import { getWorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';
+import { getWorkloadCPUPercent } from '@/utils/workloads';
+import { getCurrentWorkloadDiskUsage } from '@/utils/workloadDiskUsage';
import { getCurrentWorkloadMemoryUsage } from '@/utils/memoryObservation';
// Exclusion-aware split of a free-text search. Terms prefixed with `-` hide
@@ -166,14 +166,8 @@ function evaluateMetricCondition(guest: FilterableItem, condition: MetricConditi
case 'disk': {
// Missing and retained reads are not zero (or current capacity).
// Preserve the same provider/linked-agent freshness rule as the row.
- if (
- guest.telemetryAvailability?.disk === false ||
- getWorkloadGuestDiskRead(guest, resolveWorkloadType(guest) === 'vm').state !== 'current'
- ) {
- return false;
- }
- const usage = guest.disk?.usage;
- if (typeof usage !== 'number' || !Number.isFinite(usage) || usage < 0) return false;
+ const usage = getCurrentWorkloadDiskUsage(guest);
+ if (usage === null) return false;
value = usage;
break;
}
diff --git a/frontend-modern/src/utils/workloadDiskUsage.ts b/frontend-modern/src/utils/workloadDiskUsage.ts
new file mode 100644
index 0000000000..f4e7d16df1
--- /dev/null
+++ b/frontend-modern/src/utils/workloadDiskUsage.ts
@@ -0,0 +1,36 @@
+import type { Disk } from '@/types/api';
+import type { WorkloadGuest } from '@/types/workloads';
+import { getWorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';
+import { resolveWorkloadType } from '@/utils/workloads';
+
+// Workload aggregate metrics use percentages, including values below 1%.
+// Unlike DiskInfo filesystem entries (whose zero bytes are omitted on the
+// wire), an aggregate capacity alone is not an observed usage measurement.
+export const getWorkloadDiskUsagePercent = (disk?: Disk | null): number | null => {
+ if (!disk) return null;
+ if (disk.usage !== undefined) {
+ return typeof disk.usage === 'number' && Number.isFinite(disk.usage) && disk.usage >= 0
+ ? Math.min(100, disk.usage)
+ : null;
+ }
+ const { used, total } = disk;
+ if (
+ typeof used !== 'number' ||
+ !Number.isFinite(used) ||
+ used < 0 ||
+ typeof total !== 'number' ||
+ !Number.isFinite(total) ||
+ total <= 0
+ ) {
+ return null;
+ }
+ const percent = (used / total) * 100;
+ return Number.isFinite(percent) ? Math.min(100, percent) : null;
+};
+
+export const getCurrentWorkloadDiskUsage = (guest: WorkloadGuest): number | null =>
+ !guest ||
+ guest.telemetryAvailability?.disk === false ||
+ getWorkloadGuestDiskRead(guest, resolveWorkloadType(guest) === 'vm').state !== 'current'
+ ? null
+ : getWorkloadDiskUsagePercent(guest.disk);