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 { createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
import type { Accessor } from 'solid-js';
import { AlertsAPI } from '@/api/alerts';
import type { AlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
import type { Alert, AlertDeliveryDiagnosis } from '@/types/api';
import { useRelativeTimeNow } from '@/utils/relativeTimeClock';
import type { Override } from './types';
import { useAlertAcknowledgementState } from './useAlertAcknowledgementState';
import { useAlertSnoozeState } from './useAlertSnoozeState';
export interface AlertGroup {
key: string;
primary: Alert;
related: Alert[];
correlated: boolean;
}
export function computeAlertGroupKey(alert: Alert): string {
const correlation = alert.correlation;
if (
(correlation?.kind === 'shared-system' || correlation?.kind === 'infrastructure-incident') &&
correlation.key.trim() !== ''
) {
return `correlation:${correlation.kind}:${correlation.key.trim()}`;
}
const resourceId = alert.resourceId?.trim();
return resourceId ? `resource:${resourceId}` : `alert:${alert.id}`;
}
export interface UseAlertOverviewStateProps {
activeAlerts: Accessor<Record<string, Alert>>;
overrides: Accessor<Override[]>;
showAcknowledged: Accessor<boolean>;
updateAlert: (alertIdentifier: string, updates: Partial<Alert>) => void;
acknowledgementRequests: AlertAcknowledgementRequests;
}
export function useAlertOverviewState(props: UseAlertOverviewStateProps) {
const now = useRelativeTimeNow();
const activeAlerts = createMemo(() => Object.values(props.activeAlerts()));
const {
unacknowledgedAlerts,
processingAlerts,
bulkAckProcessing,
handleAlertAcknowledgement,
handleBulkAcknowledge,
handleGroupAcknowledge,
} = useAlertAcknowledgementState({
alerts: activeAlerts,
updateAlert: props.updateAlert,
acknowledgementRequests: props.acknowledgementRequests,
allowRestore: true,
});
const {
effectiveAlerts,
processing: snoozeProcessingAlerts,
handleSnooze,
handleUnsnooze,
} = useAlertSnoozeState({ alerts: activeAlerts, updateAlert: props.updateAlert });
// Delivery diagnoses answer "did/will this alert notify?" per card. One
// bulk request covers every active alert; a failed refresh keeps the last
// snapshot and the card simply shows no delivery line for unknown alerts.
const [deliveryDiagnoses, setDeliveryDiagnoses] = createSignal<
Record<string, AlertDeliveryDiagnosis>
>({});
let diagnosisStateDisposed = false;
let diagnosisRequestVersion = 0;
onCleanup(() => {
diagnosisStateDisposed = true;
});
const refreshDeliveryDiagnoses = async () => {
// A slower previous refresh must not replace a newer notification state.
// Increment even for an empty alert set to invalidate outstanding requests.
const requestVersion = ++diagnosisRequestVersion;
if (activeAlerts().length === 0) {
setDeliveryDiagnoses({});
return;
}
try {
const list = await AlertsAPI.getDeliveryDiagnoses();
if (diagnosisStateDisposed || requestVersion !== diagnosisRequestVersion) return;
const next: Record<string, AlertDeliveryDiagnosis> = {};
for (const diagnosis of list) {
next[diagnosis.alertIdentifier || diagnosis.alertId] = diagnosis;
}
setDeliveryDiagnoses(next);
} catch {
// Silent degrade: no diagnosis, no delivery line.
}
};
const activeAlertIdsKey = createMemo(() =>
activeAlerts()
.map((alert) => alert.id)
.sort()
.join('\n'),
);
createEffect(() => {
// Refresh when the active alert set changes.
activeAlertIdsKey();
void refreshDeliveryDiagnoses();
});
// And once a minute, so time-based holds (cooldown, quiet hours) stay
// current. This is a server read, so it keeps its own minute rather than
// following the 30-second clock the ages read.
const diagnosisInterval = setInterval(() => void refreshDeliveryDiagnoses(), 60_000);
onCleanup(() => {
clearInterval(diagnosisInterval);
});
const alertStats = createMemo(() => {
const alerts = effectiveAlerts();
const recent = alerts.filter((alert) => {
const ts = new Date(alert.startTime).getTime();
if (Number.isNaN(ts)) return true;
const age = now() - ts;
return age >= 0 && age < 86_400_000;
});
const unacknowledged = alerts.filter((alert) => !alert.acknowledged);
return {
active: unacknowledged.length,
activeCritical: unacknowledged.filter((alert) => alert.level === 'critical').length,
activeWarning: unacknowledged.filter((alert) => alert.level === 'warning').length,
acknowledged: alerts.filter((alert) => alert.acknowledged).length,
total24h: recent.length,
critical24h: recent.filter((alert) => alert.level === 'critical').length,
overrides: props.overrides().length,
};
});
const filteredAlerts = createMemo(() =>
effectiveAlerts()
.filter((alert) => props.showAcknowledged() || !alert.acknowledged)
.sort((a, b) => {
if (a.acknowledged !== b.acknowledged) {
return a.acknowledged ? 1 : -1;
}
const severityRank = (level: string) =>
level === 'critical' ? 0 : level === 'warning' ? 1 : 2;
const severityDiff = severityRank(a.level) - severityRank(b.level);
if (severityDiff !== 0) return severityDiff;
const timeDiff = new Date(b.startTime).getTime() - new Date(a.startTime).getTime();
if (timeDiff !== 0) return timeDiff;
return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
}),
);
const groupedAlerts = createMemo<AlertGroup[]>(() => {
const sorted = filteredAlerts();
const groups = new Map<string, Alert[]>();
for (const alert of sorted) {
const key = computeAlertGroupKey(alert);
const existing = groups.get(key);
if (existing) {
existing.push(alert);
} else {
groups.set(key, [alert]);
}
}
const result: AlertGroup[] = [];
for (const [key, alerts] of groups) {
const primaryIndex = alerts.findIndex((alert) => alert.correlation?.role === 'primary');
const primary = primaryIndex >= 0 ? alerts[primaryIndex] : alerts[0];
result.push({
key,
primary,
related: alerts.filter((_, index) => index !== (primaryIndex >= 0 ? primaryIndex : 0)),
correlated: key.startsWith('correlation:'),
});
}
return result;
});
return {
alertStats,
filteredAlerts,
groupedAlerts,
unacknowledgedAlerts,
processingAlerts,
snoozeProcessingAlerts,
bulkAckProcessing,
deliveryDiagnoses,
refreshDeliveryDiagnoses,
handleAlertAcknowledgement,
handleBulkAcknowledge,
handleGroupAcknowledge,
handleSnooze,
handleUnsnooze,
};
}
export type AlertOverviewState = ReturnType<typeof useAlertOverviewState>;