Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
import { For, Show, Suspense, createMemo, lazy } from 'solid-js';
import { useRelativeTimeNow } from '@/utils/relativeTimeClock';
import { HelpIcon } from '@/components/shared/HelpIcon';
import {
TechnicalDetailsDisclosure,
TechnicalDetailsSection,
} from '@/components/shared/TechnicalDetailsDisclosure';
import { HOST_METRICS_HISTORY_GROUPS } from '@/components/shared/hostMetricsHistoryModel';
import type { HistoryTimeRange } from '@/api/charts';
import {
DrawerAttentionSection,
DrawerNoAlertsLine,
} from '@/components/shared/DrawerAttentionSection';
import { DrawerExceptionList } from './DrawerExceptionList';
import {
compactDetailRows,
compactDetailSections,
makeDetailRow,
type DetailRow,
type DetailSection,
type DetailValueTone,
} from '@/components/shared/DetailSectionTable';
import type { Alert, Disk, HostGPUSensor, Node, Temperature } from '@/types/api';
import {
buildPowerRows,
HOST_AGENT_STOPPED_REPORTING_REASON,
} from '@/components/Infrastructure/resourceDetailMappers';
import { alertTypeDisplayLabel } from '@/features/alerts/helpers';
import { getAlertAttentionCopy } from '@/features/alerts/metricAlertPresentation';
import { formatBytes, formatRelativeTime, normalizeDiskArray } from '@/utils/format';
import type { MetricDisplayThresholds } from '@/utils/metricThresholds';
import { getMemoryObservationPresentation } from '@/utils/memoryObservation';
import { getProxmoxUpdateEvidencePresentation } from '@/utils/proxmoxUpdateEvidence';
import { formatTemperature, getTemperatureTextClass } from '@/utils/temperature';
import { buildDrawerDiskListItems } from './DrawerDiskListCard';
import {
collectDrawerExceptionRows,
getDrawerChartAlerts,
withoutDrawerExceptionRows,
} from './drawerOverviewModel';
import {
GUEST_DRAWER_HISTORY_DEFAULT_RANGE,
type GuestDrawerHistoryDeferredMetric,
type GuestDrawerHistoryGroupConfig,
type GuestDrawerHistoryTarget,
} from './guestDrawerModel';
// Loaded once a node drawer opens, so the Proxmox table chunk does not carry it.
const GuestDrawerHistory = lazy(() =>
import('./GuestDrawerHistory').then(({ GuestDrawerHistory }) => ({
default: GuestDrawerHistory,
})),
);
const finitePercent = (value: number | null | undefined): number | undefined =>
typeof value === 'number' && Number.isFinite(value) && value >= 0
? Math.min(100, value)
: undefined;
interface NodeDrawerOverviewProps {
node: Node;
disks?: Disk[];
temperatureThresholds?: MetricDisplayThresholds | null;
alerts?: Alert[];
historyTarget?: GuestDrawerHistoryTarget | null;
historyRange?: HistoryTimeRange;
onHistoryRangeChange?: (range: HistoryTimeRange) => void;
historyGroups?: GuestDrawerHistoryGroupConfig[];
/** Live readings the charts fall back to before any history is stored. */
currentMetrics?: Record<string, number | undefined>;
/** True while Overview is the visible tab; hidden charts do not poll. */
historyEnabled?: boolean;
/** The node's own alerts, without its guests', for the charts' alert lines. */
metricAlerts?: Alert[];
}
interface NodeOverviewRow {
label: string;
value: string;
valueClass?: string;
title?: string;
}
const cleanText = (value: string | null | undefined): string => {
const trimmed = (value || '').trim();
return trimmed && trimmed.toLowerCase() !== 'unknown' ? trimmed : '';
};
const stripAgentPrefix = (value: string): string =>
value.startsWith('agent:') ? value.slice('agent:'.length) : value;
const getNodeVersionLabel = (node: Node): string => {
const version = cleanText(node.pveVersion);
if (!version) return '';
return (
version.match(/pve-manager\/([^/\s]+)/i)?.[1] || version.match(/\d+(?:\.\d+)+/)?.[0] || version
);
};
const formatLoadAverage = (loadAverage: number[] | undefined): string => {
const values = (loadAverage || []).filter((value) => Number.isFinite(value));
if (values.length === 0) return '-';
return values.map((value) => value.toFixed(2)).join(' / ');
};
const hasPositiveNumber = (value: number | null | undefined): value is number =>
typeof value === 'number' && Number.isFinite(value) && value > 0;
const formatTemperatureMonitoring = (value: boolean | null | undefined): string => {
if (value === true) return 'Enabled';
if (value === false) return 'Disabled';
return 'Inherited';
};
const pushTemperature = (
rows: NodeOverviewRow[],
label: string,
value: number | null | undefined,
thresholds: MetricDisplayThresholds | null | undefined,
): void => {
if (typeof value !== 'number' || !Number.isFinite(value)) return;
rows.push({
label,
value: formatTemperature(value),
valueClass: getTemperatureTextClass(value, thresholds),
});
};
const getThermalRows = (
temperature: Temperature | undefined,
thresholds: MetricDisplayThresholds | null | undefined,
typedGPUAvailable = false,
): NodeOverviewRow[] => {
if (!temperature?.available) return [];
const rows: NodeOverviewRow[] = [];
pushTemperature(rows, 'CPU low', temperature.cpuMin, thresholds);
pushTemperature(rows, 'CPU record', temperature.cpuMaxRecord, thresholds);
if (temperature.nvme?.length) {
rows.push({
label: 'NVMe',
value: temperature.nvme
.slice(0, 2)
.map((drive) => `${drive.device} ${formatTemperature(drive.temp)}`)
.join(' / '),
title: temperature.nvme
.map((drive) => `${drive.device} ${formatTemperature(drive.temp)}`)
.join(' / '),
});
}
if (!typedGPUAvailable && temperature.gpu?.length) {
const gpuLabels = temperature.gpu
.map((gpu) => {
const value = [gpu.edge, gpu.junction, gpu.mem].find(hasPositiveNumber);
return value ? `${gpu.device} ${formatTemperature(value)}` : '';
})
.filter(Boolean);
if (gpuLabels.length > 0) {
rows.push({
label: 'GPU',
value: gpuLabels.slice(0, 2).join(' / '),
title: gpuLabels.join(' / '),
});
}
}
return rows;
};
const formatGPUValue = (gpu: HostGPUSensor): string => {
const parts: string[] = [];
const name = cleanText(gpu.name);
if (name) parts.push(name);
if (
typeof gpu.temperatureCelsius === 'number' &&
Number.isFinite(gpu.temperatureCelsius) &&
gpu.temperatureCelsius > 0
) {
parts.push(formatTemperature(gpu.temperatureCelsius));
}
if (
typeof gpu.utilizationPercent === 'number' &&
Number.isFinite(gpu.utilizationPercent) &&
gpu.utilizationPercent >= 0
) {
parts.push(`${Math.round(Math.min(100, gpu.utilizationPercent))}%`);
}
if (
typeof gpu.memoryTotalBytes === 'number' &&
Number.isFinite(gpu.memoryTotalBytes) &&
gpu.memoryTotalBytes > 0
) {
const used =
typeof gpu.memoryUsedBytes === 'number' &&
Number.isFinite(gpu.memoryUsedBytes) &&
gpu.memoryUsedBytes >= 0
? gpu.memoryUsedBytes
: 0;
parts.push(`${formatBytes(used)} / ${formatBytes(gpu.memoryTotalBytes)}`);
}
return parts.join(' · ');
};
const getGPUTelemetryRows = (node: Node): NodeOverviewRow[] =>
(node.sensors?.gpu ?? []).flatMap((gpu, index) => {
const value = formatGPUValue(gpu);
if (!value) return [];
const id = cleanText(gpu.id);
return [{ label: id ? `GPU ${id}` : `GPU ${index + 1}`, value, title: value }];
});
const getDetailTone = (valueClass: string | undefined): DetailValueTone => {
if (valueClass?.includes('red') || valueClass?.includes('rose')) return 'danger';
if (valueClass?.includes('yellow') || valueClass?.includes('amber')) return 'warning';
if (valueClass?.includes('green') || valueClass?.includes('emerald')) return 'success';
if (valueClass?.includes('blue') || valueClass?.includes('cyan')) return 'accent';
return 'default';
};
const toDetailRows = (rows: NodeOverviewRow[]): DetailRow[] =>
compactDetailRows(
rows.map((row) =>
// Details is where a reader goes for the full value; wrap rather than
// cut it off behind an ellipsis and a hover-only title.
makeDetailRow(row.label, row.value, {
title: row.title,
tone: getDetailTone(row.valueClass),
wrap: true,
}),
),
);
export function NodeDrawerOverview(props: NodeDrawerOverviewProps) {
const now = useRelativeTimeNow();
const versionLabel = () => getNodeVersionLabel(props.node);
const linkedAgentId = () => cleanText(props.node.linkedAgentId);
const clusterLabel = () =>
cleanText(props.node.clusterName) ||
(props.node.isClusterMember ? props.node.instance || 'Member' : 'Standalone');
const clockLabel = () => {
const clock = cleanText(props.node.cpuInfo?.mhz);
return clock && clock !== '0' ? clock : '';
};
const loadAverageLabel = () => formatLoadAverage(props.node.loadAverage);
const updateEvidence = () =>
getProxmoxUpdateEvidencePresentation(props.node, (value) =>
formatRelativeTime(value, { now: now() }),
);
const platformRows = (): NodeOverviewRow[] => [
...(cleanText(props.node.kernelVersion)
? [
{
label: 'Kernel',
value: cleanText(props.node.kernelVersion),
title: props.node.kernelVersion,
} satisfies NodeOverviewRow,
]
: []),
{
label: 'Cluster',
value: clusterLabel(),
},
...(props.node.instance && props.node.instance !== clusterLabel()
? [{ label: 'Instance', value: props.node.instance } satisfies NodeOverviewRow]
: []),
];
const hardwareRows = (): NodeOverviewRow[] => [
...(cleanText(props.node.cpuInfo?.model)
? [
{
label: 'CPU model',
value: cleanText(props.node.cpuInfo?.model),
title: props.node.cpuInfo?.model,
} satisfies NodeOverviewRow,
]
: []),
...(hasPositiveNumber(props.node.cpuInfo?.cores)
? [{ label: 'Cores', value: `${props.node.cpuInfo.cores}` } satisfies NodeOverviewRow]
: []),
...(hasPositiveNumber(props.node.cpuInfo?.sockets)
? [{ label: 'Sockets', value: `${props.node.cpuInfo.sockets}` } satisfies NodeOverviewRow]
: []),
...(clockLabel() ? [{ label: 'Clock', value: clockLabel() } satisfies NodeOverviewRow] : []),
...(loadAverageLabel() !== '-'
? [{ label: 'Load avg', value: loadAverageLabel() } satisfies NodeOverviewRow]
: []),
...buildPowerRows(props.node.sensors?.powerWatts).map((row) => ({
label: row.label,
value: props.node.sensorsStale ? `${row.value} (last known)` : row.value,
title: props.node.sensorsStale
? `Last known reading, not current: ${HOST_AGENT_STOPPED_REPORTING_REASON}`
: row.valueTitle,
})),
];
const memoryRows = (): NodeOverviewRow[] => [
{ label: 'Total', value: formatBytes(props.node.memory?.total || 0) },
...(props.node.memory?.cache
? [
{
label: 'Reclaimable cache',
value: formatBytes(props.node.memory.cache),
} satisfies NodeOverviewRow,
]
: []),
...(props.node.memory?.usageUnavailable === true
? []
: [{ label: 'Free', value: formatBytes(props.node.memory?.free || 0) }]),
...(props.node.memory?.swapTotal
? [
{
label: 'Swap',
value: `${formatBytes(props.node.memory.swapUsed || 0)} / ${formatBytes(
props.node.memory.swapTotal,
)}`,
} satisfies NodeOverviewRow,
]
: []),
];
const storageRows = (): NodeOverviewRow[] => [
{ label: 'Root total', value: formatBytes(props.node.disk?.total || 0) },
{ label: 'Root free', value: formatBytes(props.node.disk?.free || 0) },
];
const networkRows = (): NodeOverviewRow[] =>
(props.node.networkInterfaces || []).reduce<NodeOverviewRow[]>((rows, networkInterface) => {
const name = cleanText(networkInterface.name);
if (!name) return rows;
const addresses = (networkInterface.addresses || [])
.map((address) => cleanText(address))
.filter(Boolean);
const mac = cleanText(networkInterface.mac);
rows.push({
label: name,
value: addresses.join(' / ') || mac || 'Configured',
title: [...addresses, ...(mac ? [mac] : [])].join(' · ') || undefined,
});
return rows;
}, []);
const telemetryRows = (): NodeOverviewRow[] => [
{
label: 'Temp monitor',
value: formatTemperatureMonitoring(props.node.temperatureMonitoringEnabled),
},
];
const perDiskItems = () => {
const disks = normalizeDiskArray(props.disks) ?? [];
if (disks.length < 2) return [];
return buildDrawerDiskListItems(disks);
};
const thermalRows = () =>
getThermalRows(
props.node.temperature,
props.temperatureThresholds,
(props.node.sensors?.gpu?.length ?? 0) > 0,
);
const isSensorRow = (row: NodeOverviewRow): boolean =>
row.label === 'NVMe' || row.label === 'GPU';
const technicalSections = () =>
compactDetailSections([
{ label: 'Platform', rows: toDetailRows(platformRows()) },
{ label: 'Hardware', rows: toDetailRows(hardwareRows()) },
{ label: 'Memory', rows: toDetailRows(memoryRows()) },
{ label: 'Network', rows: toDetailRows(networkRows()) },
{
label: 'Storage',
rows:
perDiskItems().length > 0
? compactDetailRows(
perDiskItems().map((disk) =>
makeDetailRow(disk.label, disk.usageText, {
title: disk.device ? `${disk.label} · ${disk.device}` : disk.label,
tone: disk.percent === null ? 'muted' : getDetailTone(disk.textClass),
wrap: true,
}),
),
)
: toDetailRows(storageRows()),
},
{ label: 'Telemetry', rows: toDetailRows(telemetryRows()) },
{
label: 'Thermals',
rows: toDetailRows(thermalRows().filter((row) => !isSensorRow(row))),
},
]);
// GPU and NVMe readings carry no heat judgement of their own, so nothing
// would lift a hot one out of Details; they stay visible instead.
const sensorSections = () =>
compactDetailSections([
{
label: 'Sensors',
rows: toDetailRows([
...thermalRows().filter(isSensorRow),
...getGPUTelemetryRows(props.node),
]),
},
]);
const updateAccessGuidance = (
<Show when={updateEvidence()?.helpContentId}>
<div class="space-y-1 text-left text-[11px] font-normal text-muted">
<p class="whitespace-normal wrap-anywhere">
Update checks use separate Proxmox access. Other monitoring can still work.
</p>
<HelpIcon
contentId="updates.proxmox.access"
triggerLabel="Why update checks are unavailable"
size="xs"
class="-ml-2"
/>
</div>
</Show>
);
// The drawer owns the interactive help across reading and age updates.
const summarySection: DetailSection = {
label: 'Summary',
get rows() {
const primaryTemperature = props.node.cpuTemperature;
const updates = updateEvidence();
const temperatureClass =
typeof primaryTemperature === 'number'
? getTemperatureTextClass(primaryTemperature, props.temperatureThresholds)
: '';
return compactDetailRows([
makeDetailRow('Platform', versionLabel() ? `PVE ${versionLabel()}` : null),
makeDetailRow(
'Pulse coverage',
linkedAgentId() ? `Agent ${stripAgentPrefix(linkedAgentId())}` : 'PVE API only',
{ wrap: true },
),
updates
? makeDetailRow('Updates', updates.value, {
tone: updates.tone,
title: updates.title,
wrap: true,
})
: null,
typeof primaryTemperature === 'number' &&
(temperatureClass.includes('yellow') || temperatureClass.includes('red'))
? makeDetailRow('Temperature', formatTemperature(primaryTemperature), {
tone: temperatureClass.includes('red') ? 'danger' : 'warning',
})
: null,
]);
},
};
const overviewSections = () => [summarySection];
const exceptionRows = createMemo(() =>
collectDrawerExceptionRows([...overviewSections(), ...technicalSections()]),
);
// The table withholds readings from an offline or stale node; the charts do
// the same instead of presenting the last numbers as live.
const liveReadingsWithheld = (): string | null => {
const health = (props.node.connectionHealth || '').trim().toLowerCase();
if (props.node.status === 'offline') return 'Node is offline. Showing its history only.';
if (
props.node.status === 'unknown' ||
health === 'error' ||
health === 'degraded' ||
health === 'stale'
) {
return 'Proxmox readings for this node are stale. Showing its history only.';
}
return null;
};
// The adapter fills missing usage with zero; a known total is the evidence
// that a percentage was measured at all.
const memoryValue = () => {
const memory = props.node.memory;
return memory?.usageUnavailable || !((memory?.total ?? 0) > 0)
? undefined
: finitePercent(memory?.usage);
};
const diskMeasured = () => (props.node.disk?.total ?? 0) > 0;
// A retained or undated memory reading is shown as last known, the same rule
// the guest drawer follows, rather than as a live value.
const deferredMetrics = createMemo(
(): Record<string, GuestDrawerHistoryDeferredMetric | undefined> | undefined => {
if (liveReadingsWithheld()) return undefined;
const memoryReading = getMemoryObservationPresentation(
memoryValue(),
props.node.memory?.observation,
);
if (!memoryReading || memoryReading.state === 'current') return undefined;
return {
memory: {
lastKnownValue: memoryReading.state === 'unavailable' ? undefined : memoryValue(),
...(memoryReading.state === 'unknown'
? { valueLabel: 'freshness unknown' as const }
: {}),
message: memoryReading.message,
},
};
},
);
// Live readings the charts show before any history is stored. A withheld
// node offers none, and deferred memory is qualified above instead.
const liveMetrics = createMemo((): Record<string, number | undefined> | undefined => {
if (liveReadingsWithheld()) return undefined;
return {
...props.currentMetrics,
cpu: finitePercent(props.node.cpu),
memory: deferredMetrics()?.memory ? undefined : memoryValue(),
disk: diskMeasured() ? finitePercent(props.node.disk?.usage) : undefined,
};
});
const chartAlerts = createMemo(() =>
getDrawerChartAlerts(
props.metricAlerts,
(props.historyGroups ?? HOST_METRICS_HISTORY_GROUPS).flatMap((group) =>
group.series.map((series) => series.metric),
),
),
);
// The sizes the charts' percentages are of. A withheld node states only its
// capacity, not a used amount that would read as live.
const sizeFact = (total: number | undefined, used: number | undefined, label: string) => {
if (!((total ?? 0) > 0)) return '';
return !liveReadingsWithheld() && typeof used === 'number' && used >= 0
? `${formatBytes(used)} of ${formatBytes(total ?? 0)} ${label}`
: `${formatBytes(total ?? 0)} ${label}`;
};
const facts = () => {
const model = cleanText(props.node.cpuInfo?.model);
const cores = props.node.cpuInfo?.cores;
const firstAddress = (props.node.networkInterfaces || [])
.flatMap((networkInterface) => networkInterface.addresses || [])
.map((address) => cleanText(address))
.find(Boolean);
return [
versionLabel() ? `Proxmox VE ${versionLabel()}` : '',
[model, hasPositiveNumber(cores) ? `${cores} logical CPUs` : ''].filter(Boolean).join(' · '),
sizeFact(
props.node.memory?.total,
// Only a current reading states a used amount; a retained one is
// qualified in the chart and shows the size alone here.
memoryValue() !== undefined && !deferredMetrics()?.memory
? props.node.memory?.used
: undefined,
'RAM',
),
diskMeasured() ? sizeFact(props.node.disk?.total, props.node.disk?.used, 'root disk') : '',
firstAddress ?? '',
clusterLabel() && clusterLabel() !== 'Standalone' ? `Cluster ${clusterLabel()}` : '',
].filter((fact) => fact.trim().length > 0);
};
return (
<div class="space-y-3" data-testid="node-drawer-overview">
<DrawerAttentionSection
items={(props.alerts ?? []).map((alert) => ({
id: alert.id,
...getAlertAttentionCopy(alert, now),
subject:
cleanText(alert.resourceName) ||
cleanText(alert.nodeDisplayName) ||
cleanText(alert.node) ||
props.node.name,
metric: alertTypeDisplayLabel(alert.type),
severity: alert.level,
acknowledged: alert.acknowledged,
}))}
/>
<Show when={(props.alerts ?? []).length === 0}>
<DrawerNoAlertsLine />
</Show>
<DrawerExceptionList testId="node-drawer-exceptions" rows={exceptionRows()} />
<Show when={props.historyTarget}>
<Show when={liveReadingsWithheld()}>
{(message) => (
<p data-testid="node-drawer-readings-withheld" class="text-xs text-muted">
{message()}
</p>
)}
</Show>
<Suspense fallback={<div class="h-48" aria-hidden="true" />}>
<GuestDrawerHistory
target={props.historyTarget ?? null}
range={props.historyRange ?? GUEST_DRAWER_HISTORY_DEFAULT_RANGE}
onRangeChange={props.onHistoryRangeChange}
enabled={props.historyEnabled ?? true}
groups={props.historyGroups}
currentMetrics={liveMetrics()}
deferredMetrics={deferredMetrics()}
alerts={chartAlerts()}
/>
</Suspense>
</Show>
{updateAccessGuidance}
<Show when={sensorSections().length > 0}>
<TechnicalDetailsSection dataTestId="node-drawer-sensors" sections={sensorSections()} />
</Show>
<Show when={facts().length > 0}>
<div
data-testid="node-drawer-facts"
class="flex flex-wrap items-center gap-x-4 gap-y-1 text-xs text-muted"
>
<For each={facts()}>
{(fact) => <span class="max-w-full whitespace-normal wrap-anywhere">{fact}</span>}
</For>
</div>
</Show>
<TechnicalDetailsDisclosure
dataTestId="node-technical-details"
title="Details"
keepMounted
subtitle="platform, hardware, memory, network, storage and sensors"
class="border-t border-border pt-2"
contentClass="mt-2"
sections={withoutDrawerExceptionRows([...overviewSections(), ...technicalSections()])}
/>
</div>
);
}