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.

6.8 KB
Raw Blame
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>;