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 Workloads memory freshness visible in every display mode

pulse-triage[bot]8df5051192a0
diff --git a/docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.md b/docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.md
index d53e286ff3..ef8be3984f 100644
--- a/docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.md
+++ b/docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.md
@@ -8,6 +8,22 @@ A gate is only `passed` when its automated proof still passes and the manual
scenario has been exercised in a staging-like environment with the expected
result.
+## Workloads memory observation presentation
+
+Automated: `GuestRow.test.tsx` (memory observation provenance),
+`MetricMiniSparkline.test.tsx`, `memoryObservation.test.ts`, and existing
+GuestDrawer/canonical History/selected-source adapter tests. The browser fixture
+`frontend-modern/browser-tests/guest-row-memory-provenance.cjs` exercises the
+production renderer with synthetic last-known, unknown, unavailable, current,
+zero and independent-memory/disk-deferral snapshots on desktop and narrow touch.
+Check source/time labels without hovering, every display mode, host-capacity
+labels, historical path preservation and same-guest updates without remount.
+
+Installed follow-through remains separate: independent thaw, writes to every
+covered filesystem, guest liveness and only-prior-active restoration belong to
+the native safety owners. These presentation checks do not set a release gate,
+prove a safe guest or authorise a diagnostic/restart.
+
## How To Use This Matrix
1. Run the automated proof first.
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
index 1f8e0a6224..ef8cb1c4df 100644
--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md
+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
@@ -33,6 +33,26 @@ Patrol manual-rule confirmation keeps its title and safe Cancel/Remove controls
All drawer History fallbacks must distinguish current observations from retained, unavailable or freshness-unknown guest readings, using original memory evidence and filesystem read reasons.
+**Workloads rows preserve memory observation provenance.**
+
+Workloads rows use the same selected-memory qualification as both drawers.
+Retained and freshness-unknown values keep a visible cue in bars, sparklines,
+the hover History lens and host-capacity mode; compact layouts shorten only the
+visible label, not the accessible original source/time explanation. Sparkline
+accessible values never call retained, unknown or unavailable memory current.
+Unavailable numeric carriers remain N/A while recorded History stays intact.
+An independent qualified memory reading is not paused by a disk deferral.
+Neither Last seen, backup completion nor running power state renews memory.
+Unannotated unrelated platforms and actual zero readings retain their meaning.
+
+`GuestRow.test.tsx`, `MetricMiniSparkline.test.tsx` and
+`memoryObservation.test.ts` pin these boundaries, with existing drawer, adapter
+and History suites. `browser-tests/guest-row-memory-provenance.cjs` checks real
+production rows and drawers, visible/accessible labels, pointer/touch/keyboard,
+light/dark and narrow/desktop layouts using synthetic observations only.
+Presentation acceptance does not establish native thaw, covered-filesystem
+writes, guest liveness, service restoration or reporter recovery.
+
### Canonical drawer History preserves guest read provenance
The shared resource drawer passes selected memory observation state/source/time
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 50344121e9..0079c57c59 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,23 @@
## Purpose
+**Memory freshness is preserved at the Workloads row boundary.**
+
+`GuestRow.tsx` qualifies selected memory once per reactive reading using the
+shared drawer policy. Non-current rows keep a visible/accessibility cue through
+bars, sparklines, the History lens and host-capacity mode. An unavailable
+numeric carrier is not a current value; retained History paths stay unchanged.
+Source-time qualification never uses Last seen or a filesystem deferral,
+and same-guest observation updates do not remount the row or request History.
+No collection, chart sampling, sorting, retention or alert threshold changes.
+
+`GuestRow.test.tsx` (memory observation provenance),
+`MetricMiniSparkline.test.tsx`, `memoryObservation.test.ts` and the existing
+drawer/History suites pin this boundary. The production browser fixture
+`browser-tests/guest-row-memory-provenance.cjs` checks touch/pointer/keyboard
+and narrow/desktop layouts with synthetic observations, not native recovery.
+
+
Drawer observation labels derive locally from the selected snapshot without renewing timestamps, adding reads, remounting charts or changing stored metric coordinates.
### Drawer provenance stays local to snapshot presentation
diff --git a/frontend-modern/browser-tests/guest-row-memory-provenance.cjs b/frontend-modern/browser-tests/guest-row-memory-provenance.cjs
new file mode 100644
index 0000000000..5dea0126ea
--- /dev/null
+++ b/frontend-modern/browser-tests/guest-row-memory-provenance.cjs
@@ -0,0 +1,355 @@
+// Production component source in the existing offline Vite preview.
+// No installation, full application build, guest operation or external service.
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const { chromium, webkit } = require('playwright');
+const root = '/workspace/frontend-modern';
+const output = '/workspace/tmp/guest-row-memory-browser';
+const origin = 'http://127.0.0.1:5332';
+const hash = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+const manifest = {
+ mode: 'source-dev-preview',
+ runtime: Object.fromEntries(
+ [
+ 'frontend-modern/src/components/Workloads/GuestRow.tsx',
+ 'frontend-modern/src/components/Workloads/MetricMiniSparkline.tsx',
+ 'frontend-modern/src/components/Workloads/guestDrawerModel.ts',
+ 'frontend-modern/src/utils/memoryObservation.ts',
+ 'frontend-modern/browser-tests/guest-row-memory-provenance.tsx',
+ ].map((file) => [file, hash('/workspace/' + file)]),
+ ),
+ graph: hash(root + '/package-lock.json'),
+};
+fs.mkdirSync(output, { recursive: true });
+const result = {
+ result: 'incomplete',
+ playwright: require('playwright/package.json').version,
+ binding: manifest,
+ cases: [],
+ captures: [],
+ cleanup: {},
+ limits:
+ 'Production GuestRow, StackedMemoryBar, MetricMiniSparkline, drawer and actual source CSS in a dev preview; synthetic selected memory/history only. This is not a production application build. No full App, native QGA, thaw, filesystem writes, reporter, installed/release or physical-device acceptance.',
+};
+assert.equal(
+ result.playwright,
+ JSON.parse(fs.readFileSync('/workspace/tests/integration/package-lock.json')).packages[
+ 'node_modules/@playwright/test'
+ ].version,
+);
+(async () => {
+ const started = Date.now();
+ const { createServer } = await import(path.join(root, 'node_modules/vite/dist/node/index.js'));
+ const server = await createServer({
+ root,
+ configFile: path.join(root, 'vite.config.ts'),
+ cacheDir: output + '/cache',
+ server: { host: '127.0.0.1', port: 5332, strictPort: true },
+ });
+ await server.listen();
+ let browser;
+ try {
+ for (const [name, engine, width, dark] of [
+ ['desktop-light', chromium, 1365, false],
+ ['desktop-dark', chromium, 1365, true],
+ ['phone-dark', webkit, 390, true],
+ ['narrow-light', webkit, 320, false],
+ ]) {
+ browser = await engine.launch(
+ engine === chromium
+ ? { headless: true, channel: 'chromium', args: ['--no-sandbox'] }
+ : { headless: true },
+ );
+ const context = await browser.newContext({
+ viewport: { width, height: width <= 768 ? 844 : 900 },
+ isMobile: width <= 768,
+ hasTouch: width <= 768,
+ locale: 'en-GB',
+ timezoneId: 'UTC',
+ reducedMotion: 'reduce',
+ });
+ const page = await context.newPage();
+ page.setDefaultTimeout(7000);
+ const record = {
+ name,
+ width,
+ dark,
+ browser: browser.version(),
+ checks: [],
+ requests: [],
+ errors: [],
+ captures: [],
+ };
+ result.cases.push(record);
+ page.on('pageerror', (e) => record.errors.push(e.message));
+ await page.route('**/*', (route) => {
+ const req = route.request(),
+ url = new URL(req.url());
+ if (url.origin !== origin) {
+ record.errors.push('Unexpected external request');
+ return route.abort();
+ }
+ if (!url.pathname.startsWith('/api/')) return route.continue();
+ record.requests.push({ path: url.pathname, method: req.method() });
+ assert.equal(req.method(), 'GET');
+ assert(!/diagnostics|\/run|guest-agent|qemu/.test(url.pathname), 'no live guest operation');
+ return route.fulfill({
+ json:
+ url.pathname === '/api/license/runtime-capabilities'
+ ? {
+ capabilities: [],
+ limits: [],
+ max_history_days: 7,
+ hosted_mode: false,
+ runtime: { build: 'community' },
+ blocked_capabilities: [],
+ }
+ : { success: true, data: [], alerts: [], anomalies: [], config: null },
+ });
+ });
+ await page.addInitScript(
+ (value) =>
+ document.addEventListener('DOMContentLoaded', () =>
+ document.documentElement.classList.toggle('dark', value),
+ ),
+ dark,
+ );
+ await page.goto(origin + '/browser-tests/guest-row-memory-provenance.html');
+ const row = page.locator('[data-guest-id="fixture-pve1-101"]');
+ const memory = row.locator('[data-workload-col="memory"]');
+ const notice = memory.locator('[data-workload-memory-read-status]');
+ const identity = await row.elementHandle();
+ const visibleLabel = () => notice.locator('[aria-hidden="true"]');
+ const capture = async (state) => {
+ const file = `${name}-${state}.png`;
+ await page.screenshot({ path: path.join(output, file), fullPage: true });
+ record.captures.push(file);
+ result.captures.push({ file, sha256: hash(path.join(output, file)) });
+ };
+ await visibleLabel()
+ .getByText(width <= 768 ? 'Prior' : 'Last known', { exact: true })
+ .waitFor();
+ assert((await notice.locator('.sr-only').textContent()).includes('2026-09-30 11:00:00 UTC'));
+ assert((await notice.textContent()).includes('Not a current measurement'));
+ assert(
+ await visibleLabel().evaluate((el) => {
+ const r = el.getBoundingClientRect(),
+ cell = el.closest('td').getBoundingClientRect();
+ return r.width > 0 && r.x >= cell.x && r.right <= cell.right;
+ }),
+ 'cue fits memory cell',
+ );
+ await capture('retained-bars');
+ record.checks.push(
+ 'retained cue is visible without hover and exposes original UTC/source to assistive technology',
+ );
+ await page.evaluate(() =>
+ window.__memoryRow.update({
+ lastSeen: '2026-10-06T10:00:00Z',
+ lock: '',
+ backupInProgress: false,
+ }),
+ );
+ assert((await notice.textContent()).includes('Last known'));
+ assert(!(await notice.textContent()).includes('2026-10-06'));
+ record.checks.push('Last seen/running/backup completion cannot renew memory');
+ await page.getByLabel('Metric display').selectOption('sparklines');
+ let svg = memory.getByRole('img', {
+ name: 'backup-guest memory history, last known 25%',
+ exact: true,
+ });
+ await svg.waitFor();
+ const plot = await svg.locator('path').getAttribute('d');
+ assert(plot.includes('M'));
+ await page.getByLabel('Memory basis').selectOption('host');
+ await memory
+ .getByRole('img', {
+ name: 'backup-guest host memory share history, last known 13%',
+ exact: true,
+ })
+ .waitFor();
+ assert((await notice.textContent()).includes('Last known'));
+ await page.getByLabel('Memory basis').selectOption('guest');
+ record.checks.push(
+ 'retained sparkline and host-capacity accessible values never become current',
+ );
+ await page.evaluate(() => {
+ const guest = window.__memoryRow.reading();
+ window.__memoryRow.update({ memory: { ...guest.memory, observation: undefined } });
+ });
+ await memory
+ .getByRole('img', {
+ name: 'backup-guest memory history, freshness unknown 25%',
+ exact: true,
+ })
+ .waitFor();
+ await visibleLabel()
+ .getByText(width <= 768 ? 'Unknown' : 'Freshness unknown', { exact: true })
+ .waitFor();
+ assert.equal(await memory.locator('svg[role="img"] path').getAttribute('d'), plot);
+ await capture('unknown-sparkline');
+ record.checks.push(
+ 'legacy unannotated Proxmox values are freshness-unknown without changing History',
+ );
+ await page.evaluate(() => {
+ const guest = window.__memoryRow.reading();
+ window.__memoryRow.update({
+ memory: {
+ ...guest.memory,
+ observation: {
+ state: 'unavailable',
+ source: 'guest-agent-meminfo',
+ observedAt: '2026-09-30T11:00:00Z',
+ },
+ },
+ });
+ });
+ await memory
+ .getByRole('img', { name: 'backup-guest memory history, unavailable N/A', exact: true })
+ .waitFor();
+ assert.equal(await memory.locator('svg[role="img"] path').getAttribute('d'), plot);
+ await capture('unavailable-sparkline');
+ await page.getByLabel('Metric display').selectOption('bars');
+ await memory.getByText('N/A', { exact: true }).first().waitFor();
+ assert.equal(
+ await memory.locator('[data-stacked-memory-segment]').count(),
+ 0,
+ 'unavailable numeric carriers have no fill',
+ );
+ record.checks.push(
+ 'unavailable carrier hides percentage/bar while retained recorded points stay intact',
+ );
+ await page.evaluate(() => {
+ const guest = window.__memoryRow.reading();
+ window.__memoryRow.update({
+ diskStatusReason: 'prev-vm-locked',
+ memory: {
+ ...guest.memory,
+ used: 0,
+ usage: 0,
+ observation: {
+ state: 'last-known',
+ source: 'status-mem',
+ observedAt: '2026-09-30T11:00:00Z',
+ },
+ },
+ });
+ });
+ await page.getByLabel('Metric display').selectOption('sparklines');
+ await memory
+ .getByRole('img', { name: 'backup-guest memory history, last known 0%', exact: true })
+ .waitFor();
+ await page.evaluate(() => {
+ const guest = window.__memoryRow.reading();
+ window.__memoryRow.update({
+ memory: {
+ ...guest.memory,
+ used: 1024 ** 3,
+ usage: 25,
+ observation: { state: 'current', source: 'agent', observedAt: '2026-10-01T11:00:00Z' },
+ },
+ });
+ });
+ await memory
+ .getByRole('img', { name: 'backup-guest memory history, current 25%', exact: true })
+ .waitFor();
+ assert.equal(await notice.count(), 0);
+ assert.equal(await memory.locator('svg[role="img"] path').getAttribute('d'), plot);
+ assert(await identity.evaluate((el) => el.isConnected), 'same row remains mounted');
+ record.checks.push(
+ 'measured zero preserved; independent current Agent memory withdraws only its cue while disk deferral persists',
+ );
+ await page.getByLabel('Metric display').selectOption('bars');
+ if (width > 768) {
+ await page.getByRole('heading', { name: 'Workloads memory freshness' }).hover();
+ await page.locator('body').click({ position: { x: 1, y: 1 } });
+ await page.keyboard.press('Tab');
+ await page.keyboard.press('Tab');
+ await page.keyboard.press('Tab');
+ assert(
+ await row
+ .getByRole('button', { name: /Expand.*details/ })
+ .evaluate((el) => document.activeElement === el),
+ );
+ await page.keyboard.press('Enter');
+ } else {
+ await row.tap();
+ }
+ const details = page.getByRole('region', { name: 'Guest details' });
+ await details.waitFor();
+ assert(
+ (await details.textContent()).includes('Current · Pulse Agent · 2026-10-01 11:00:00 UTC'),
+ );
+ assert(
+ (await details.textContent()).includes('does not prove thaw') ||
+ (await details.textContent()).includes('independent thaw'),
+ );
+ record.checks.push(
+ 'real keyboard/first-touch guest disclosure shares memory policy without clearing backup safety',
+ );
+ await details.getByRole('button', { name: 'Collapse backup-guest details' }).click();
+ await details.waitFor({ state: 'hidden' });
+ if (width > 768) {
+ await page.evaluate(() => {
+ const guest = window.__memoryRow.reading();
+ window.__memoryRow.update({
+ memory: {
+ ...guest.memory,
+ observation: {
+ state: 'last-known',
+ source: 'guest-agent-meminfo',
+ observedAt: '2026-09-30T11:00:00Z',
+ },
+ },
+ });
+ });
+ await row.hover();
+ await memory
+ .getByRole('img', { name: 'backup-guest memory history, last known 25%', exact: true })
+ .waitFor();
+ assert((await notice.textContent()).includes('Last known'));
+ await page.getByRole('heading', { name: 'Workloads memory freshness' }).hover();
+ await memory.getByText('25%', { exact: true }).waitFor();
+ record.checks.push('pointer History lens retains provenance and restores the bar');
+ }
+ assert(
+ await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth),
+ 'no horizontal overflow',
+ );
+ assert.deepEqual(record.errors, []);
+ await context.close();
+ await browser.close();
+ browser = null;
+ record.closed = true;
+ }
+ result.result = 'passed';
+ } catch (error) {
+ result.error = error.stack;
+ throw error;
+ } finally {
+ if (browser) await browser.close();
+ result.cleanup.browser_closed = true;
+ await server.close();
+ const esbuild = await import(path.join(root, 'node_modules/esbuild/lib/main.js'));
+ esbuild.stop();
+ result.cleanup.compiler_stop_requested = true;
+ result.cleanup.server_closed = true;
+ result.elapsed_ms = Date.now() - started;
+ fs.writeFileSync(path.join(output, 'result.json'), JSON.stringify(result, null, 2) + '\n');
+ console.log(
+ JSON.stringify({
+ result: result.result,
+ cases: result.cases.length,
+ captures: result.captures.length,
+ elapsed_ms: result.elapsed_ms,
+ cleanup: result.cleanup,
+ }),
+ );
+ }
+})().catch((error) => {
+ console.error(error.message);
+ process.exitCode = 1;
+});
diff --git a/frontend-modern/browser-tests/guest-row-memory-provenance.html b/frontend-modern/browser-tests/guest-row-memory-provenance.html
new file mode 100644
index 0000000000..59b5da497b
--- /dev/null
+++ b/frontend-modern/browser-tests/guest-row-memory-provenance.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" />
+ <title>Workloads memory freshness verification</title>
+ </head>
+ <body>
+ <div id="root"></div>
+ <script type="module" src="./guest-row-memory-provenance.tsx"></script>
+ </body>
+</html>
diff --git a/frontend-modern/browser-tests/guest-row-memory-provenance.tsx b/frontend-modern/browser-tests/guest-row-memory-provenance.tsx
new file mode 100644
index 0000000000..1c99ed4505
--- /dev/null
+++ b/frontend-modern/browser-tests/guest-row-memory-provenance.tsx
@@ -0,0 +1,170 @@
+// Production rows/drawer and metric History, synthetic selected observations.
+// No guest request, thaw, backup, restart or recovery operation is performed.
+import { createSignal, Show } from 'solid-js';
+import { render } from 'solid-js/web';
+import { Router, Route } from '@solidjs/router';
+import { GuestRow } from '../src/components/Workloads/GuestRow';
+import {
+ getGuestColumnStyle,
+ getWorkloadTableLayoutModeForContainer,
+} from '../src/components/Workloads/guestRowModel';
+import { GuestDrawer } from '../src/components/Workloads/GuestDrawer';
+import { DarkModeContext } from '../src/contexts/appRuntime';
+import { syncAIRuntimeSettings } from '../src/stores/aiRuntimeState';
+import type { WorkloadGuest } from '../src/types/workloads';
+import type { WorkloadMetricHistoryReader } from '../src/components/Workloads/workloadMetricHistoryModel';
+import '../src/index.css';
+
+syncAIRuntimeSettings({ discovery_enabled: false });
+const capacity = 4 * 1024 ** 3;
+const observedAt = '2026-09-30T11:00:00Z';
+const initial: WorkloadGuest = {
+ id: 'fixture-pve1-101',
+ vmid: 101,
+ name: 'backup-guest',
+ instance: 'fixture',
+ node: 'pve1',
+ type: 'qemu',
+ workloadType: 'vm',
+ platformScopes: ['proxmox-pve'],
+ platformType: 'proxmox-pve',
+ status: 'running',
+ cpu: 0.1,
+ cpus: 2,
+ memory: {
+ total: capacity,
+ used: capacity / 4,
+ free: (capacity * 3) / 4,
+ usage: 25,
+ observation: { state: 'last-known', source: 'guest-agent-meminfo', observedAt },
+ },
+ disk: { total: capacity, used: capacity / 2, usage: 50 },
+ diskStatusReason: 'prev-vm-locked',
+ lock: 'backup',
+ guestAgentStatus: 'deferred',
+ guestAgentExpected: true,
+ networkIn: 10,
+ networkOut: 20,
+ diskRead: 30,
+ diskWrite: 40,
+ uptime: 3600,
+ template: false,
+ lastBackup: 0,
+ tags: [],
+ lastSeen: '2026-10-01T12:00:00Z',
+};
+const history: WorkloadMetricHistoryReader = {
+ getGuestMetricSeries: (_guest, metric) =>
+ metric === 'memory'
+ ? [
+ {
+ id: 'memory',
+ label: 'Memory',
+ color: '#f59e0b',
+ points: [
+ { timestamp: Date.parse(observedAt) - 60_000, value: 20 },
+ { timestamp: Date.parse(observedAt), value: 25 },
+ ],
+ },
+ ]
+ : [],
+ getNodeMetricSeries: () => [],
+};
+function Fixture() {
+ const columns = ['name', 'cpu', 'memory', 'disk', 'uptime'];
+ const layout = getWorkloadTableLayoutModeForContainer(Math.min(window.innerWidth, 896) - 40);
+ const [guest, setGuest] = createSignal(initial);
+ const [mode, setMode] = createSignal<'bars' | 'sparklines'>('bars');
+ const [basis, setBasis] = createSignal<'guest' | 'host'>('guest');
+ const [expanded, setExpanded] = createSignal(false);
+ (window as any).__memoryRow = {
+ update: (next: Partial<WorkloadGuest>) => setGuest({ ...guest(), ...next }),
+ reading: () => guest(),
+ };
+ return (
+ <main class="mx-auto min-h-screen max-w-4xl space-y-3 bg-surface p-3 text-base-content">
+ <h1 class="text-base font-semibold">Workloads memory freshness</h1>
+ <p class="text-xs text-muted">
+ Synthetic observations. No guest checks or recovery commands.
+ </p>
+ <div class="flex flex-wrap gap-3 text-xs">
+ <label class="flex gap-2 items-center">
+ Display
+ <select
+ aria-label="Metric display"
+ class="rounded-sm border border-border bg-surface p-1"
+ value={mode()}
+ onChange={(e) => setMode(e.currentTarget.value as 'bars' | 'sparklines')}
+ >
+ <option value="bars">Bars</option>
+ <option value="sparklines">Sparklines</option>
+ </select>
+ </label>
+ <label class="flex gap-2 items-center">
+ Memory basis
+ <select
+ aria-label="Memory basis"
+ class="rounded-sm border border-border bg-surface p-1"
+ value={basis()}
+ onChange={(e) => setBasis(e.currentTarget.value as 'guest' | 'host')}
+ >
+ <option value="guest">Guest allocation</option>
+ <option value="host">Host capacity</option>
+ </select>
+ </label>
+ </div>
+ <section aria-label="Guest row" class="rounded-sm border border-border bg-surface-raised p-2">
+ <table class="w-full table-fixed">
+ <thead>
+ <tr>
+ {columns.map((column) => (
+ <th
+ class="text-left text-xs"
+ style={getGuestColumnStyle(column, window.innerWidth <= 768, layout, columns)}
+ >
+ {column === 'cpu' ? 'CPU' : column[0].toUpperCase() + column.slice(1)}
+ </th>
+ ))}
+ </tr>
+ </thead>
+ <tbody>
+ <GuestRow
+ guest={guest()}
+ visibleColumnIds={columns}
+ metricDisplayMode={mode()}
+ memoryDisplayBasis={basis()}
+ parentMemoryTotal={capacity * 2}
+ parentNodeName="pve1"
+ workloadTableLayoutMode={layout}
+ metricHistory={history}
+ isExpanded={expanded()}
+ onClick={() => setExpanded(!expanded())}
+ />
+ </tbody>
+ </table>
+ </section>
+ <Show when={expanded()}>
+ <section aria-label="Guest details">
+ <GuestDrawer guest={guest()} onClose={() => setExpanded(false)} />
+ </section>
+ </Show>
+ </main>
+ );
+}
+render(
+ () => (
+ <Router>
+ <Route
+ path="*"
+ component={() => (
+ <DarkModeContext.Provider
+ value={() => document.documentElement.classList.contains('dark')}
+ >
+ <Fixture />
+ </DarkModeContext.Provider>
+ )}
+ />
+ </Router>
+ ),
+ document.getElementById('root')!,
+);
diff --git a/frontend-modern/src/components/Workloads/GuestRow.tsx b/frontend-modern/src/components/Workloads/GuestRow.tsx
index adb2046f0a..18bcd14244 100644
--- a/frontend-modern/src/components/Workloads/GuestRow.tsx
+++ b/frontend-modern/src/components/Workloads/GuestRow.tsx
@@ -33,6 +33,7 @@ import { SummaryRowActionButton } from '@/components/shared/SummaryRowActionButt
import { createRowTextSelectionGuard, nativeRowClickTarget } from '@/components/shared/Table';
import { DiscoveryReadinessBadge } from '@/components/shared/DiscoveryReadinessBadge';
import { getWorkloadGuestDiskStatusMessage } from '@/utils/workloadGuestPresentation';
+import { getWorkloadMemoryObservationPresentation } from '@/utils/memoryObservation';
import { ResourceNameWithWebInterfaceLink } from '@/components/shared/WebInterfaceLink';
import type { GuestRowProps } from './guestRowModel';
import { useGuestRowState } from './useGuestRowState';
@@ -171,12 +172,45 @@ export function GuestRow(props: GuestRowProps) {
const memoryDisplayTotal = createMemo(() =>
isHostMemoryBasis() ? hostMemoryTotal() : (props.guest.memory?.total ?? 0),
);
+ const memoryReading = createMemo(() =>
+ getWorkloadMemoryObservationPresentation(props.guest, { includeCurrent: false }),
+ );
const memoryDisplayUnavailable = createMemo(
() =>
!telemetryAvailable('memory') ||
props.guest.memory?.usageUnavailable === true ||
+ memoryReading()?.state === 'unavailable' ||
(isHostMemoryBasis() && hostMemoryTotal() <= 0),
);
+ const memoryReadStatus = createMemo(() => {
+ const reading = memoryReading();
+ if (!reading || reading.state === 'current') return undefined;
+ return {
+ message: reading.message,
+ label:
+ reading.state === 'last-known'
+ ? usesCompactTableLayout()
+ ? 'Prior'
+ : 'Last known'
+ : reading.state === 'unavailable'
+ ? usesCompactTableLayout()
+ ? 'N/A'
+ : 'Unavailable'
+ : usesCompactTableLayout()
+ ? 'Unknown'
+ : 'Freshness unknown',
+ valueLabelContext:
+ reading.state === 'last-known'
+ ? ('last known' as const)
+ : reading.state === 'unavailable'
+ ? ('unavailable' as const)
+ : ('freshness unknown' as const),
+ };
+ });
+ const memoryValueLabelContext = (): MetricMiniSparklineValueLabelContext =>
+ memoryDisplayUnavailable()
+ ? 'unavailable'
+ : (memoryReadStatus()?.valueLabelContext ?? 'current');
const detailControlsId = createMemo(() => buildSummaryDisclosureControlsId(guestId()));
const nestedWorkloadCueLabel = createMemo(() => {
const context = props.nestedWorkloadContext;
@@ -503,7 +537,11 @@ export function GuestRow(props: GuestRowProps) {
{/* Memory */}
<Show when={isColVisible('memory')}>
- <td class="px-1.5 sm:px-2 py-0.5 align-middle" data-workload-col="memory">
+ <td
+ class="px-1.5 sm:px-2 py-0.5 align-middle"
+ data-workload-col="memory"
+ title={memoryReadStatus()?.message}
+ >
<Show
when={isSparklineMode()}
fallback={
@@ -566,6 +604,7 @@ export function GuestRow(props: GuestRowProps) {
memoryDisplayBasis: props.memoryDisplayBasis,
parentMemoryTotal: props.parentMemoryTotal,
},
+ memoryValueLabelContext(),
)}
</div>
</Show>
@@ -593,6 +632,19 @@ export function GuestRow(props: GuestRowProps) {
memoryDisplayBasis: props.memoryDisplayBasis,
parentMemoryTotal: props.parentMemoryTotal,
},
+ memoryValueLabelContext(),
+ )}
+ </Show>
+ <Show when={memoryReadStatus()}>
+ {(status) => (
+ <p
+ data-workload-memory-read-status
+ class="mt-0.5 text-center text-[10px] leading-none text-muted"
+ title={status().message}
+ >
+ <span aria-hidden="true">{status().label}</span>
+ <span class="sr-only">{status().message}</span>
+ </p>
)}
</Show>
</td>
diff --git a/frontend-modern/src/components/Workloads/MetricMiniSparkline.tsx b/frontend-modern/src/components/Workloads/MetricMiniSparkline.tsx
index eedc2de08f..b803ccb917 100644
--- a/frontend-modern/src/components/Workloads/MetricMiniSparkline.tsx
+++ b/frontend-modern/src/components/Workloads/MetricMiniSparkline.tsx
@@ -13,7 +13,8 @@ import {
} from './workloadMetricHistoryModel';
type MetricMiniSparklineValueLabelMode = 'inline' | 'tooltip' | 'hidden';
-export type MetricMiniSparklineValueLabelContext = 'current' | 'last known';
+export type MetricMiniSparklineValueLabelContext =
+ 'current' | 'last known' | 'freshness unknown' | 'unavailable';
interface MetricMiniSparklineProps {
series: WorkloadMetricSparklineSeries[];
diff --git a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx
index 39b59fb197..9febd0c100 100644
--- a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx
+++ b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx
@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { render, screen, fireEvent, cleanup } from '@solidjs/testing-library';
import { createSignal } from 'solid-js';
import type { WorkloadGuest } from '@/types/workloads';
@@ -922,6 +922,241 @@ describe('GuestRow', () => {
});
});
+ describe('memory observation provenance', () => {
+ const observedAt = '2026-09-30T11:00:00Z';
+ const observation = (state: string, date = observedAt, source = 'guest-agent-meminfo') =>
+ makeMemory({ observation: { state, source, observedAt: date } });
+ const noticeSelector = '[data-workload-memory-read-status]';
+ const history = {
+ getGuestMetricSeries: vi.fn(() => [
+ {
+ id: 'memory',
+ label: 'Memory',
+ color: '#f59e0b',
+ points: [
+ { timestamp: 1_000, value: 25 },
+ { timestamp: 2_000, value: 50 },
+ ],
+ },
+ ]),
+ getNodeMetricSeries: () => [],
+ };
+
+ beforeEach(() => {
+ vi.spyOn(Date, 'now').mockReturnValue(Date.parse('2026-10-01T12:00:00Z'));
+ });
+
+ for (const mode of ['bars', 'sparklines'] as const) {
+ it(`labels retained memory in ${mode} without hover or a guest check`, () => {
+ const { container } = renderGuestRow({
+ guest: makeGuest({ memory: observation('last-known'), lastSeen: '2026-10-01T12:00:00Z' }),
+ metricDisplayMode: mode,
+ visibleColumnIds: ['name', 'memory'],
+ });
+ const notice = container.querySelector(noticeSelector);
+ expect(notice?.querySelector('[aria-hidden]')).toHaveTextContent('Last known');
+ expect(notice?.querySelector('.sr-only')).toHaveTextContent(
+ 'Last known. Source: QEMU guest agent. Observed: 2026-09-30 11:00:00 UTC. Not a current measurement.',
+ );
+ expect(notice).not.toHaveTextContent('2026-10-01');
+ expect(notice).not.toHaveAttribute('tabindex');
+ if (mode === 'sparklines') {
+ expect(
+ screen.getByRole('img', { name: 'test-vm memory history, last known 50%' }),
+ ).toBeInTheDocument();
+ expect(screen.queryByRole('img', { name: /current/ })).not.toBeInTheDocument();
+ } else {
+ expect(screen.getByTestId('memory-bar')).toHaveAttribute('data-unavailable', 'false');
+ }
+ });
+
+ it.each(['qemu', 'lxc'])(
+ `labels unannotated Proxmox %s memory freshness in ${mode}`,
+ (type) => {
+ const { container } = renderGuestRow({
+ guest: makeGuest({ type, diskStatusReason: 'prev-vm-locked' }),
+ metricDisplayMode: mode,
+ visibleColumnIds: ['name', 'memory'],
+ });
+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Freshness unknown');
+ expect(container.querySelector(noticeSelector)).toHaveTextContent(
+ 'Observation time unknown',
+ );
+ if (mode === 'sparklines') {
+ expect(
+ screen.getByRole('img', { name: 'test-vm memory history, freshness unknown 50%' }),
+ ).toBeInTheDocument();
+ }
+ },
+ );
+
+ it.each(['', 'not-a-date', '9999-01-01T00:00:00Z'])(
+ `does not qualify memory using an unusable current timestamp (%s) in ${mode}`,
+ (date) => {
+ const { container } = renderGuestRow({
+ guest: makeGuest({ memory: observation('current', date) }),
+ metricDisplayMode: mode,
+ visibleColumnIds: ['name', 'memory'],
+ });
+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Freshness unknown');
+ expect(container.querySelector(noticeSelector)).toHaveTextContent(
+ 'Observation time unknown',
+ );
+ expect(container.querySelector(noticeSelector)).not.toHaveTextContent(
+ date || 'not-a-date',
+ );
+ },
+ );
+
+ it(`hides an unavailable numeric carrier without removing recorded history in ${mode}`, () => {
+ const { container } = renderGuestRow({
+ guest: makeGuest({ memory: observation('unavailable') }),
+ metricDisplayMode: mode,
+ visibleColumnIds: ['name', 'memory'],
+ metricHistory: history,
+ });
+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Unavailable');
+ if (mode === 'sparklines') {
+ expect(
+ screen.getByRole('img', { name: 'test-vm memory history, unavailable N/A' }),
+ ).toBeInTheDocument();
+ expect(container.querySelector('path')?.getAttribute('d')).toContain('M');
+ expect(screen.queryByText('50%')).not.toBeInTheDocument();
+ } else {
+ expect(screen.getByTestId('memory-bar')).toHaveAttribute('data-unavailable', 'true');
+ }
+ });
+
+ it(`withdraws the ${mode} cue only for a qualified same-guest reading`, () => {
+ const [guest, setGuest] = createSignal(makeGuest({ memory: observation('last-known') }));
+ const { container } = render(() => (
+ <table>
+ <tbody>
+ <GuestRow
+ guest={guest()}
+ metricDisplayMode={mode}
+ visibleColumnIds={['name', 'memory']}
+ />
+ </tbody>
+ </table>
+ ));
+ const row = container.querySelector('tr');
+ setGuest({
+ ...guest(),
+ lastSeen: '2026-10-01T12:00:00Z',
+ backupInProgress: false,
+ lock: '',
+ });
+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Last known');
+ setGuest({ ...guest(), memory: observation('current') });
+ expect(container.querySelector('tr')).toBe(row);
+ expect(container.querySelector(noticeSelector)).toBeNull();
+ if (mode === 'sparklines') {
+ expect(
+ screen.getByRole('img', { name: 'test-vm memory history, current 50%' }),
+ ).toBeInTheDocument();
+ }
+ });
+
+ it(`keeps a qualified independent memory reading current while disk reads defer in ${mode}`, () => {
+ const { container } = renderGuestRow({
+ guest: makeGuest({
+ memory: observation('current', observedAt, 'agent'),
+ diskStatusReason: 'prev-vm-locked',
+ }),
+ metricDisplayMode: mode,
+ visibleColumnIds: ['name', 'memory'],
+ });
+ expect(container.querySelector(noticeSelector)).toBeNull();
+ if (mode === 'sparklines')
+ expect(
+ screen.getByRole('img', { name: 'test-vm memory history, current 50%' }),
+ ).toBeInTheDocument();
+ });
+
+ it(`keeps measured zero, original source and host-share freshness in ${mode}`, () => {
+ const { container } = renderGuestRow({
+ guest: makeGuest({
+ memory: { ...observation('last-known', observedAt, 'status-mem'), used: 0, usage: 0 },
+ }),
+ metricDisplayMode: mode,
+ visibleColumnIds: ['name', 'memory'],
+ memoryDisplayBasis: 'host',
+ parentMemoryTotal: 8_589_934_592,
+ });
+ expect(container.querySelector(noticeSelector)).toHaveTextContent(
+ 'Last known. Source: Proxmox',
+ );
+ if (mode === 'sparklines')
+ expect(
+ screen.getByRole('img', { name: 'test-vm host memory share history, last known 0%' }),
+ ).toBeInTheDocument();
+ else expect(screen.getByTestId('memory-bar')).toHaveAttribute('data-unavailable', 'false');
+ });
+ }
+
+ it('keeps original freshness across the real hover lens and preserves historical points', () => {
+ const { container } = renderGuestRow({
+ guest: makeGuest({ memory: observation('last-known') }),
+ metricDisplayMode: 'bars',
+ visibleColumnIds: ['name', 'memory'],
+ metricHistory: history,
+ });
+ const row = container.querySelector('tr')!;
+ fireEvent.pointerEnter(row, { pointerType: 'mouse' });
+ expect(screen.queryByTestId('memory-bar')).not.toBeInTheDocument();
+ expect(
+ screen.getByRole('img', { name: 'test-vm memory history, last known 50%' }),
+ ).toBeInTheDocument();
+ expect(container.querySelector('path')?.getAttribute('d')).toContain('M');
+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Last known');
+ fireEvent.pointerLeave(row, { pointerType: 'mouse' });
+ expect(screen.getByTestId('memory-bar')).toBeInTheDocument();
+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Last known');
+ });
+
+ it.each([
+ ['last-known', 'Prior'],
+ ['future-state', 'Unknown'],
+ ['unavailable', 'N/A'],
+ ])('fits compact %s copy without losing the accessible source and time', (state, label) => {
+ const { container } = renderGuestRow({
+ guest: makeGuest({ memory: observation(state) }),
+ visibleColumnIds: ['name', 'memory'],
+ workloadTableLayoutMode: 'phone',
+ });
+ const notice = container.querySelector(noticeSelector);
+ expect(notice?.querySelector('[aria-hidden]')).toHaveTextContent(label);
+ expect(notice?.querySelector('.sr-only')).toHaveTextContent('QEMU guest agent');
+ expect(notice?.querySelector('.sr-only')).toHaveTextContent('2026-09-30 11:00:00 UTC');
+ expect(notice).not.toHaveTextContent('future-state');
+ });
+
+ it('does not expose unknown provider labels or borrow disk provenance', () => {
+ const { container } = renderGuestRow({
+ guest: makeGuest({ memory: observation('private-state', observedAt, 'private-source') }),
+ visibleColumnIds: ['name', 'memory'],
+ });
+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Unknown source');
+ expect(container.querySelector(noticeSelector)).not.toHaveTextContent('private-');
+ });
+
+ it.each([
+ { type: 'vm', platformScopes: ['vmware-vsphere' as const] },
+ { type: 'docker', workloadType: 'app-container' as const, vmid: 0 },
+ ])('preserves unannotated unrelated platform memory ($type)', (scope) => {
+ const { container } = renderGuestRow({
+ guest: makeGuest(scope),
+ visibleColumnIds: ['name', 'memory'],
+ metricDisplayMode: 'sparklines',
+ });
+ expect(container.querySelector(noticeSelector)).toBeNull();
+ expect(
+ screen.getByRole('img', { name: 'test-vm memory history, current 50%' }),
+ ).toBeInTheDocument();
+ });
+ });
+
describe('lock label', () => {
it.each(guestDiskDeferrals)(
'annotates retained row and disk tooltip for %s',
diff --git a/frontend-modern/src/components/Workloads/__tests__/MetricMiniSparkline.test.tsx b/frontend-modern/src/components/Workloads/__tests__/MetricMiniSparkline.test.tsx
index d145438de7..39e0befb52 100644
--- a/frontend-modern/src/components/Workloads/__tests__/MetricMiniSparkline.test.tsx
+++ b/frontend-modern/src/components/Workloads/__tests__/MetricMiniSparkline.test.tsx
@@ -66,6 +66,37 @@ describe('MetricMiniSparkline', () => {
expect(container.querySelector('path')?.getAttribute('d')).toBe(path);
});
+ it.each(['freshness unknown', 'unavailable'] as const)(
+ 'announces %s context without changing recorded History',
+ (context) => {
+ const { container } = render(() => (
+ <MetricMiniSparkline
+ title="Memory history"
+ valueLabel={context === 'unavailable' ? 'N/A' : '25%'}
+ valueLabelContext={context}
+ series={[
+ {
+ id: 'memory',
+ label: 'Memory',
+ color: '#f59e0b',
+ points: [
+ { timestamp: 1, value: 10 },
+ { timestamp: 2, value: 25 },
+ ],
+ },
+ ]}
+ />
+ ));
+ expect(
+ screen.getByRole('img', {
+ name: `Memory history, ${context} ${context === 'unavailable' ? 'N/A' : '25%'}`,
+ }),
+ ).toBeInTheDocument();
+ expect(screen.queryByRole('img', { name: /current/ })).not.toBeInTheDocument();
+ expect(container.querySelector('path')?.getAttribute('d')).toContain('M');
+ },
+ );
+
it('keeps the label visible when history has no renderable line', () => {
render(() => (
<MetricMiniSparkline
diff --git a/frontend-modern/src/components/Workloads/guestDrawerModel.ts b/frontend-modern/src/components/Workloads/guestDrawerModel.ts
index f78290928c..b955abddf8 100644
--- a/frontend-modern/src/components/Workloads/guestDrawerModel.ts
+++ b/frontend-modern/src/components/Workloads/guestDrawerModel.ts
@@ -18,7 +18,7 @@ import type { NestedWorkloadContext } from './nestedWorkloadContext';
import type { WorkloadsMemoryDisplayBasis } from './workloadsFilterModel';
import {
- getMemoryObservationPresentation,
+ getWorkloadMemoryObservationPresentation,
type MemoryObservationPresentation,
} from '@/utils/memoryObservation';
@@ -126,23 +126,7 @@ const getGuestDrawerMemoryUsage = (guest: Guest): number | undefined => {
: undefined;
};
-export const getGuestDrawerMemoryReading = (guest: Guest): GuestDrawerMemoryReading | null => {
- const observation = guest.memory?.observation;
- const nonProxmoxVMware =
- guest.platformScopes?.includes('vmware-vsphere') &&
- !guest.platformScopes.includes('proxmox-pve');
- const proxmoxGuest =
- !nonProxmoxVMware &&
- (guest.type === 'qemu' ||
- guest.type === 'lxc' ||
- guest.platformScopes?.includes('proxmox-pve') ||
- (guest.vmid > 0 && Boolean(guest.node && guest.instance)));
- return getMemoryObservationPresentation(
- getGuestDrawerMemoryUsage(guest),
- observation,
- proxmoxGuest,
- );
-};
+export const getGuestDrawerMemoryReading = getWorkloadMemoryObservationPresentation;
export const getGuestDrawerDeferredMetrics = (
guest: Guest,
diff --git a/frontend-modern/src/utils/__tests__/memoryObservation.test.ts b/frontend-modern/src/utils/__tests__/memoryObservation.test.ts
new file mode 100644
index 0000000000..26dfd44258
--- /dev/null
+++ b/frontend-modern/src/utils/__tests__/memoryObservation.test.ts
@@ -0,0 +1,92 @@
+import { describe, expect, it, vi, afterEach } from 'vitest';
+import type { WorkloadGuest } from '@/types/workloads';
+import { getWorkloadMemoryObservationPresentation } from '../memoryObservation';
+
+const guest = (changes: Partial<WorkloadGuest> = {}): WorkloadGuest =>
+ ({
+ id: 'fixture-pve1-101',
+ vmid: 101,
+ node: 'pve1',
+ instance: 'fixture',
+ type: 'qemu',
+ memory: { total: 100, used: 25, free: 75, usage: 25 },
+ ...changes,
+ }) as WorkloadGuest;
+const observedAt = '2026-09-30T11:00:00Z';
+afterEach(() => vi.restoreAllMocks());
+
+describe('selected workload memory observation', () => {
+ it.each(['qemu', 'lxc'])('requires original provenance for a legacy %s reading', (type) => {
+ expect(getWorkloadMemoryObservationPresentation(guest({ type }))?.state).toBe('unknown');
+ });
+ it('requires provenance for canonical Proxmox guests without legacy IDs', () => {
+ expect(
+ getWorkloadMemoryObservationPresentation(
+ guest({ vmid: 0, node: '', instance: '', type: 'vm', platformScopes: ['proxmox-pve'] }),
+ )?.state,
+ ).toBe('unknown');
+ });
+ it.each([
+ { type: 'vm', platformScopes: ['vmware-vsphere' as const] },
+ { type: 'docker', vmid: 0, node: '', instance: '' },
+ ])('preserves unannotated unrelated workloads ($type)', (changes) => {
+ expect(getWorkloadMemoryObservationPresentation(guest(changes))).toBeNull();
+ });
+ it.each([undefined, -1, 101, NaN, Infinity])('keeps invalid usage unavailable (%s)', (usage) => {
+ const memory = { ...guest().memory, usage } as WorkloadGuest['memory'];
+ expect(getWorkloadMemoryObservationPresentation(guest({ memory }))?.state).toBe('unavailable');
+ });
+ it.each(['last-known', 'current'])('preserves measured zero and its %s state', (state) => {
+ vi.spyOn(Date, 'now').mockReturnValue(Date.parse('2026-10-01T12:00:00Z'));
+ expect(
+ getWorkloadMemoryObservationPresentation(
+ guest({
+ memory: {
+ total: 100,
+ used: 0,
+ free: 100,
+ usage: 0,
+ observation: { state, source: 'agent', observedAt },
+ },
+ }),
+ )?.state,
+ ).toBe(state);
+ });
+ it('qualifies current row memory without allocating an unused date label', () => {
+ vi.spyOn(Date, 'now').mockReturnValue(Date.parse('2026-10-01T12:00:00Z'));
+ const iso = vi.spyOn(Date.prototype, 'toISOString');
+ const input = guest({
+ memory: { ...guest().memory, observation: { state: 'current', source: 'agent', observedAt } },
+ });
+ expect(getWorkloadMemoryObservationPresentation(input, { includeCurrent: false })).toBeNull();
+ expect(iso).not.toHaveBeenCalled();
+ input.memory.observation!.state = 'last-known';
+ expect(getWorkloadMemoryObservationPresentation(input, { includeCurrent: false })?.state).toBe(
+ 'last-known',
+ );
+ expect(iso).toHaveBeenCalledOnce();
+ });
+
+ it.each(['usageUnavailable', 'telemetryAvailability'])(
+ 'cannot revive a current numeric carrier under %s',
+ (flag) => {
+ const input = guest({
+ memory: {
+ ...guest().memory,
+ observation: { state: 'current', source: 'agent', observedAt },
+ },
+ });
+ if (flag === 'usageUnavailable') input.memory.usageUnavailable = true;
+ else
+ input.telemetryAvailability = {
+ cpu: true,
+ memory: false,
+ disk: true,
+ networkIO: true,
+ diskIO: true,
+ uptime: true,
+ };
+ expect(getWorkloadMemoryObservationPresentation(input)?.state).toBe('unavailable');
+ },
+ );
+});
diff --git a/frontend-modern/src/utils/memoryObservation.ts b/frontend-modern/src/utils/memoryObservation.ts
index e34fe41ad6..f034e58838 100644
--- a/frontend-modern/src/utils/memoryObservation.ts
+++ b/frontend-modern/src/utils/memoryObservation.ts
@@ -1,4 +1,5 @@
import type { MemoryObservation } from '@/types/api';
+import type { WorkloadGuest } from '@/types/workloads';
// Keep only the existing server-owned wire fields. Missing/future state is not
// replaced by a resource poll time or a platform facet from another metric.
@@ -37,6 +38,7 @@ export const getMemoryObservationPresentation = (
value: number | undefined,
observation: MemoryObservation | undefined,
requiresObservation = false,
+ options: { includeCurrent?: boolean } = {},
): MemoryObservationPresentation | null => {
// Unannotated unrelated platforms retain their existing behaviour. Legacy
// Proxmox readings lack authority to assert current freshness.
@@ -44,9 +46,6 @@ export const getMemoryObservationPresentation = (
const timestamp =
typeof observation?.observedAt === 'string' ? Date.parse(observation.observedAt) : NaN;
const validTime = Number.isFinite(timestamp) && timestamp > 0 && timestamp <= Date.now();
- const observed = validTime
- ? new Date(timestamp).toISOString().replace('T', ' ').replace('.000Z', 'Z').replace('Z', ' UTC')
- : null;
const state =
typeof value !== 'number' ||
!Number.isFinite(value) ||
@@ -59,6 +58,12 @@ export const getMemoryObservationPresentation = (
: observation?.state === 'current' && validTime
? 'current'
: 'unknown';
+ // Most table rows are current and need no cue. Qualify them identically,
+ // but avoid building source/date strings that will never be rendered.
+ if (state === 'current' && options.includeCurrent === false) return null;
+ const observed = validTime
+ ? new Date(timestamp).toISOString().replace('T', ' ').replace('.000Z', 'Z').replace('Z', ' UTC')
+ : null;
const label =
state === 'current'
? 'Current'
@@ -78,3 +83,26 @@ export const getMemoryObservationPresentation = (
message: `${label}. Source: ${source}. ${time}${state === 'last-known' || state === 'unknown' ? ' Not a current measurement.' : ''}`,
};
};
+
+// Rows and drawers qualify the same selected reading. Neither a disk-read
+// deferral nor a refreshed Last seen can renew the memory observation.
+export const getWorkloadMemoryObservationPresentation = (
+ guest: WorkloadGuest,
+ options: { includeCurrent?: boolean } = {},
+): MemoryObservationPresentation | null => {
+ const usage = guest.memory?.usage;
+ const value =
+ guest.telemetryAvailability?.memory !== false && !guest.memory?.usageUnavailable
+ ? usage
+ : undefined;
+ const nonProxmoxVMware =
+ guest.platformScopes?.includes('vmware-vsphere') &&
+ !guest.platformScopes.includes('proxmox-pve');
+ const proxmoxGuest =
+ !nonProxmoxVMware &&
+ (guest.type === 'qemu' ||
+ guest.type === 'lxc' ||
+ guest.platformScopes?.includes('proxmox-pve') ||
+ (guest.vmid > 0 && Boolean(guest.node && guest.instance)));
+ return getMemoryObservationPresentation(value, guest.memory?.observation, proxmoxGuest, options);
+};