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.

Reproduce guest memory freshness lost at frontend consumers

pulse-triage[bot]3d846f76d724
diff --git a/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.memory-provenance.test.tsx b/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.memory-provenance.test.tsx
new file mode 100644
index 0000000000..918c6cce6c
--- /dev/null
+++ b/frontend-modern/src/components/Workloads/__tests__/GuestDrawerHistory.memory-provenance.test.tsx
@@ -0,0 +1,249 @@
+import { cleanup, fireEvent, render, screen, waitFor, within } from '@solidjs/testing-library';
+import { createSignal } from 'solid-js';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { ChartsAPI, type AllMetricsHistoryResponse } from '@/api/charts';
+import { resetCreateNonSuspendingQueryCacheForTest } from '@/hooks/createNonSuspendingQuery';
+import type { WorkloadGuest } from '@/types/workloads';
+import { GuestDrawerHistory } from '../GuestDrawerHistory';
+import {
+ getGuestDrawerCurrentMetrics,
+ getGuestDrawerDeferredMetrics,
+ getGuestDrawerMemoryRows,
+} from '../guestDrawerModel';
+
+vi.mock('@/stores/license', () => ({
+ loadRuntimeCapabilities: vi.fn(async () => undefined),
+ maxHistoryDays: () => 90,
+ isRangeLocked: () => false,
+}));
+afterEach(() => {
+ cleanup();
+ resetCreateNonSuspendingQueryCacheForTest();
+ vi.restoreAllMocks();
+});
+const original = '2026-10-04T14:00:00Z';
+const later = '2026-10-04T17:00:00Z';
+const annotation = (
+ state: string,
+ observedAt: string | undefined = original,
+ source = 'guest-agent-meminfo',
+) => ({ state, source, ...(observedAt === undefined ? {} : { observedAt }) });
+const guest = (observation?: ReturnType<typeof annotation>, usage = 25): WorkloadGuest => {
+ const memory = {
+ total: 100,
+ used: usage,
+ free: 100 - usage,
+ usage,
+ ...(observation ? { observation } : {}),
+ };
+ return {
+ id: 'fixture:pve1:101',
+ vmid: 101,
+ name: 'backup-guest',
+ node: 'pve1',
+ instance: 'fixture',
+ type: 'qemu',
+ status: 'running',
+ cpu: 0.1,
+ cpus: 2,
+ memory,
+ disk: { total: 100, used: 50, usage: 50 },
+ networkIn: 100,
+ networkOut: 200,
+ diskRead: 300,
+ diskWrite: 400,
+ uptime: 3600,
+ template: false,
+ lastBackup: 0,
+ tags: [],
+ lock: '',
+ lastSeen: later,
+ };
+};
+const response = (
+ metrics: AllMetricsHistoryResponse['metrics'] = {},
+): AllMetricsHistoryResponse => ({
+ resourceType: 'vm',
+ resourceId: 'fixture:pve1:101',
+ range: '1h',
+ start: Date.parse(original),
+ end: Date.parse(later),
+ source: 'store',
+ metrics,
+});
+const mount = (value: () => WorkloadGuest) =>
+ render(() => (
+ <GuestDrawerHistory
+ target={{ resourceType: 'vm', resourceId: 'fixture:pve1:101' }}
+ range="1h"
+ currentMetrics={getGuestDrawerCurrentMetrics(value())}
+ deferredMetrics={getGuestDrawerDeferredMetrics(value())}
+ />
+ ));
+const utilization = () => screen.getAllByTestId('guest-history-group-chart')[0];
+
+describe('guest memory original-observation provenance', () => {
+ it.each(['qemu', 'lxc'] as const)(
+ 'retains %s memory as evidence without inventing current freshness',
+ (type) => {
+ const value = { ...guest(annotation('last-known')), type };
+ expect(getGuestDrawerCurrentMetrics(value).memory).toBeUndefined();
+ expect(getGuestDrawerDeferredMetrics(value).memory).toMatchObject({
+ lastKnownValue: 25,
+ message: expect.stringContaining('2026-10-04 14:00:00 UTC'),
+ });
+ expect(getGuestDrawerMemoryRows(value)).toContainEqual({
+ label: 'Reading',
+ value: expect.stringContaining('Last known'),
+ });
+ expect(getGuestDrawerCurrentMetrics(value)).toMatchObject({ cpu: 10, disk: 50, netin: 100 });
+ },
+ );
+
+ it('never borrows disk deferral or refreshed guest LastSeen for memory provenance', () => {
+ const retained = {
+ ...guest(annotation('last-known')),
+ diskStatusReason: undefined,
+ lock: '',
+ lastSeen: later,
+ };
+ expect(getGuestDrawerCurrentMetrics(retained).memory).toBeUndefined();
+ expect(getGuestDrawerDeferredMetrics(retained).memory.message).toContain('14:00:00 UTC');
+ expect(getGuestDrawerDeferredMetrics(retained).memory.message).not.toContain('17:00:00');
+ const pve = {
+ ...guest(annotation('current', original, 'status-mem')),
+ diskStatusReason: 'prev-vm-locked',
+ lock: 'backup',
+ };
+ expect(getGuestDrawerCurrentMetrics(pve).memory).toBe(25);
+ expect(getGuestDrawerDeferredMetrics(pve).memory).toBeUndefined();
+ expect(getGuestDrawerDeferredMetrics(pve).disk.lastKnownValue).toBe(50);
+ });
+
+ it('keeps unavailable numbers out of current and retained legends and usage breakdown', () => {
+ const value = guest(annotation('unavailable'), 0);
+ expect(getGuestDrawerCurrentMetrics(value).memory).toBeUndefined();
+ expect(getGuestDrawerDeferredMetrics(value).memory.lastKnownValue).toBeUndefined();
+ expect(getGuestDrawerMemoryRows(value)).toContainEqual({
+ label: 'Usage',
+ value: 'Unavailable',
+ });
+ expect(getGuestDrawerMemoryRows(value).some((row) => row.label === 'Free')).toBe(false);
+ expect(getGuestDrawerMemoryRows(value)).toContainEqual({ label: 'Total', value: '100 B' });
+ });
+
+ it.each([
+ undefined,
+ annotation('private raw state'),
+ annotation('current', 'invalid'),
+ annotation('current', '0001-01-01T00:00:00Z'),
+ annotation('current', '2999-01-01T00:00:00Z'),
+ ])('does not promote unknown legacy or unusable memory provenance %#', (observation) => {
+ const value = guest(observation);
+ expect(getGuestDrawerCurrentMetrics(value).memory).toBeUndefined();
+ expect(getGuestDrawerDeferredMetrics(value).memory).toMatchObject({
+ lastKnownValue: 25,
+ valueLabel: 'freshness unknown',
+ });
+ expect(getGuestDrawerDeferredMetrics(value).memory.message).not.toMatch(
+ /private raw state|2999|0001/,
+ );
+ });
+
+ it.each([-1, NaN, Infinity, 101])('does not expose invalid retained memory %s', (usage) => {
+ expect(
+ getGuestDrawerDeferredMetrics(guest(annotation('last-known'), usage)).memory.lastKnownValue,
+ ).toBeUndefined();
+ });
+
+ it('retains measured zero and leaves unannotated non-Proxmox data unchanged', () => {
+ expect(
+ getGuestDrawerDeferredMetrics(guest(annotation('last-known'), 0)).memory.lastKnownValue,
+ ).toBe(0);
+ const vsphere = {
+ ...guest(),
+ vmid: 0,
+ instance: '',
+ node: '',
+ platformScopes: ['vmware-vsphere'],
+ };
+ expect(getGuestDrawerCurrentMetrics(vsphere).memory).toBe(25);
+ expect(getGuestDrawerDeferredMetrics(vsphere)).toEqual({});
+ });
+
+ it('updates same-guest retained, unavailable and independent live source without remount or refetch', async () => {
+ const fetch = vi.spyOn(ChartsAPI, 'getMetricsHistory').mockResolvedValue(response());
+ const [value, setValue] = createSignal(guest(annotation('last-known')));
+ mount(value);
+ await waitFor(() =>
+ expect(screen.getAllByText('No stored history in this range')).toHaveLength(3),
+ );
+ const chart = utilization();
+ expect(chart.querySelector('[data-history-current="memory"]')).toBeNull();
+ expect(chart.querySelector('[data-history-last-known="memory"]')).toHaveTextContent(
+ 'Memory25.0%last known',
+ );
+ expect(chart.querySelector('[data-history-deferred="memory"]')).toHaveTextContent(
+ '14:00:00 UTC',
+ );
+ setValue({ ...value(), lastSeen: later, lock: 'backup', diskStatusReason: 'prev-vm-locked' });
+ expect(chart.querySelector('[data-history-deferred="memory"]')).not.toHaveTextContent(
+ '17:00:00',
+ );
+ setValue(guest(annotation('unavailable'), 0));
+ expect(chart.querySelector('[data-history-current="memory"]')).toBeNull();
+ expect(chart.querySelector('[data-history-last-known="memory"]')).toBeNull();
+ expect(chart).toHaveTextContent('Memory-');
+ setValue(guest(annotation('current', later, 'agent'), 35));
+ expect(utilization()).toBe(chart);
+ expect(chart.querySelector('[data-history-deferred="memory"]')).toBeNull();
+ expect(chart.querySelector('[data-history-current="memory"]')).toHaveTextContent(
+ 'Memory35.0%current',
+ );
+ expect(chart.querySelector('path')).toBeNull();
+ expect(fetch).toHaveBeenCalledTimes(1);
+ });
+
+ it('keeps stored points and dated inspection distinct from retained live memory', async () => {
+ const point = (timestamp: string, value: number) => ({
+ timestamp: Date.parse(timestamp),
+ value,
+ min: value,
+ max: value,
+ });
+ vi.spyOn(ChartsAPI, 'getMetricsHistory').mockResolvedValue(
+ response({ memory: [point(original, 20), point(later, 30)] }),
+ );
+ mount(() => guest(annotation('last-known'), 25));
+ await waitFor(() => expect(utilization().querySelectorAll('path')).toHaveLength(1));
+ const chart = utilization();
+ expect(chart).toHaveTextContent('Memory30.0%');
+ expect(chart.querySelector('[data-history-current="memory"]')).toBeNull();
+ expect(chart.querySelector('[data-history-last-known="memory"]')).toBeNull();
+ const slider = within(chart).getByRole('slider');
+ slider.focus();
+ fireEvent.input(slider, { target: { value: '0' } });
+ expect(chart).toHaveTextContent('Memory20.0%');
+ expect(slider).toHaveAttribute('aria-valuetext', expect.stringContaining('Memory 20.0%.'));
+ });
+
+ it('withdraws retained annotations on denied History without leaking raw errors', async () => {
+ vi.spyOn(ChartsAPI, 'getMetricsHistory')
+ .mockResolvedValueOnce(response())
+ .mockRejectedValueOnce(Object.assign(new Error('private backend refusal'), { status: 403 }));
+ mount(() => guest(annotation('last-known')));
+ await waitFor(() =>
+ expect(screen.getByRole('button', { name: 'Refresh history' })).toHaveAttribute(
+ 'aria-busy',
+ 'false',
+ ),
+ );
+ fireEvent.click(screen.getByRole('button', { name: 'Refresh history' }));
+ await waitFor(() =>
+ expect(screen.getByRole('button', { name: 'Retry history' })).toBeInTheDocument(),
+ );
+ expect(screen.queryByTestId('guest-history-group-chart')).not.toBeInTheDocument();
+ expect(document.querySelector('[data-history-deferred]')).toBeNull();
+ expect(screen.queryByText('private backend refusal')).not.toBeInTheDocument();
+ });
+});
diff --git a/frontend-modern/src/hooks/__tests__/useUnifiedResources.test.ts b/frontend-modern/src/hooks/__tests__/useUnifiedResources.test.ts
index ef2dfae357..4f87635c71 100644
--- a/frontend-modern/src/hooks/__tests__/useUnifiedResources.test.ts
+++ b/frontend-modern/src/hooks/__tests__/useUnifiedResources.test.ts
@@ -155,6 +155,36 @@ describe('useUnifiedResources', () => {
let resolveIncrementalResourcePatchIndices: UseUnifiedResourcesModule['resolveIncrementalResourcePatchIndices'];
let eventBus: (typeof import('@/stores/events'))['eventBus'];
+ it('keeps API-selected memory annotation through the canonical normalizer', async () => {
+ setWsConnected(false);
+ setWsState('resources', []);
+ const observation = {
+ state: 'last-known',
+ source: 'guest-agent-meminfo',
+ observedAt: '2026-10-04T14:00:00Z',
+ };
+ apiFetchMock.mockResolvedValue(
+ resourceResponse([
+ {
+ ...v2Resource,
+ metrics: { ...v2Resource.metrics, memory: { ...v2Resource.metrics.memory, observation } },
+ },
+ ]),
+ );
+ let dispose = () => {};
+ let result!: ReturnType<UseUnifiedResourcesModule['useUnifiedResources']>;
+ createRoot((d) => {
+ dispose = d;
+ result = useUnifiedResources();
+ });
+ try {
+ await waitForResourceCount(() => result.resources().length);
+ expect(result.resources()[0].memory).toMatchObject({ current: 50, observation });
+ } finally {
+ dispose();
+ }
+ });
+
beforeEach(async () => {
vi.useFakeTimers();
vi.resetModules();
diff --git a/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts b/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts
index 48bdb54cc2..f5c088f43f 100644
--- a/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts
+++ b/frontend-modern/src/hooks/__tests__/useWorkloads.test.ts
@@ -489,6 +489,62 @@ describe('useWorkloads', () => {
dispose();
});
+ it.each(['api', 'snapshot'])(
+ 'keeps selected memory provenance through %s without borrowing a raw facet',
+ async (transport) => {
+ const original = {
+ state: 'last-known',
+ source: 'guest-agent-meminfo',
+ observedAt: '2026-10-04T14:00:00Z',
+ };
+ const raw = { state: 'current', source: 'status-mem', observedAt: '2026-10-04T17:00:00Z' };
+ const resource = {
+ ...sampleResource,
+ proxmox: {
+ vmid: 101,
+ nodeName: 'pve1',
+ instance: 'cluster-a',
+ memory: { observation: raw },
+ },
+ metrics: {
+ ...sampleResource.metrics,
+ memory: { ...sampleResource.metrics.memory, observation: original },
+ },
+ memory: { current: 50, total: 4096, used: 2048, observation: original },
+ };
+ apiFetchJSONMock.mockResolvedValue({ data: [resource], meta: { totalPages: 1 } });
+ const [snapshot, setSnapshot] = createSignal([resource]);
+ let dispose = () => {};
+ let result!: ReturnType<UseWorkloadsModule['useWorkloads']>;
+ createRoot((d) => {
+ dispose = d;
+ result = useWorkloads(
+ () => true,
+ transport === 'snapshot' ? { resourceSnapshot: snapshot as any } : {},
+ );
+ });
+ try {
+ await waitForWorkloadCount(() => result.workloads().length);
+ expect(result.workloads()[0].memory).toMatchObject({ usage: 50, observation: original });
+ const legacy = {
+ ...resource,
+ metrics: { ...resource.metrics, memory: sampleResource.metrics.memory },
+ memory: { current: 50, total: 4096, used: 2048 },
+ };
+ if (transport === 'snapshot') setSnapshot([legacy] as any);
+ else {
+ apiFetchJSONMock.mockResolvedValue({ data: [legacy], meta: { totalPages: 1 } });
+ await result.refetch();
+ }
+ await flushAsync();
+ expect(result.workloads()[0].memory).not.toHaveProperty('observation');
+ expect(result.workloads()[0].memory.usage).toBe(50);
+ } finally {
+ dispose();
+ }
+ },
+ );
+
it('tracks canonical hybrid VM memory without substituting nested agent readings', async () => {
// #1962: synthetic snapshots exercise Web reactivity, not poller recovery.
const buildVM = (instance: string, percent?: number) =>
diff --git a/frontend-modern/src/utils/__tests__/resourceStateAdapters.test.ts b/frontend-modern/src/utils/__tests__/resourceStateAdapters.test.ts
index d38b96df74..0014cc7aaa 100644
--- a/frontend-modern/src/utils/__tests__/resourceStateAdapters.test.ts
+++ b/frontend-modern/src/utils/__tests__/resourceStateAdapters.test.ts
@@ -52,6 +52,28 @@ const createServiceResource = (
}) as Resource;
describe('resourceStateAdapters nodeFromResource', () => {
+ it('keeps selected memory provenance independent of a different raw platform reading', () => {
+ const observation = {
+ state: 'last-known',
+ source: 'guest-agent-meminfo',
+ observedAt: '2026-10-04T14:00:00Z',
+ };
+ const raw = { state: 'current', source: 'status-mem', observedAt: '2026-10-04T17:00:00Z' };
+ const resource = {
+ ...createNodeResource({}),
+ memory: { current: 25, total: 1024, used: 256, observation },
+ proxmox: { memory: { total: 1024, used: 768, usage: 75, observation: raw } },
+ } as Resource;
+ expect(nodeFromResource(resource)?.memory).toMatchObject({ usage: 25, observation });
+ expect(
+ nodeFromResource({ ...resource, memory: { current: 25, total: 1024, used: 256 } })?.memory,
+ ).not.toHaveProperty('observation');
+ expect(nodeFromResource({ ...resource, memory: undefined })?.memory).toMatchObject({
+ usage: 75,
+ observation: raw,
+ });
+ });
+
it('keeps Proxmox metric coordinates without inventing an agent from discovery routing', () => {
const resource = {
...createNodeResource({ proxmox: { nodeName: 'pve-node-1' } }),