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.

4.3 KB
Raw Blame
import { createSignal, onCleanup } from 'solid-js';

import { AlertsAPI } from '@/api/alerts';
import { NotificationsAPI, type NotificationDeliveryLog } from '@/api/notifications';
import type { AlertEvent } from '@/types/api';
import { logger } from '@/utils/logger';
import type { APIContextOptions } from '@/utils/apiClient';

const HELD_EVENT_TYPES = ['notification_suppressed', 'notification_deferred'];
const HELD_EVENT_WINDOW_DAYS = 7;
const HELD_EVENT_LIMIT = 100;
const DELIVERY_LOG_LIMIT = 200;

// The delivery log is the positive half of delivery evidence: health warns
// when something is wrong, the log shows what actually fired and where it
// went. A log that cannot be read is reported as unavailable, never as empty,
// because "no attempts" and "cannot tell" mean opposite things to someone
// deciding whether to trust their alerting.
//
// Held events are the third half of that story: notifications that were
// deliberately not attempted, with the mechanism that held them. They come
// from the alert event log and degrade independently — a failed events read
// withdraws the held rows and reports that gap without hiding readable attempts.
export function useNotificationDeliveryLog(options?: {
  requestOptions?: APIContextOptions;
  isCurrentReader?: () => boolean;
}) {
  const [deliveryLog, setDeliveryLog] = createSignal<NotificationDeliveryLog | null>(null);
  const [deliveryLogUnavailable, setDeliveryLogUnavailable] = createSignal(false);
  const [refreshingDeliveryLog, setRefreshingDeliveryLog] = createSignal(false);
  const [heldEvents, setHeldEvents] = createSignal<AlertEvent[]>([]);
  const [heldEventsUnavailable, setHeldEventsUnavailable] = createSignal(false);
  // Before the first read, an empty array means unknown, not no held alerts.
  const [refreshingHeldEvents, setRefreshingHeldEvents] = createSignal(true);

  // Both reads belong to the same refresh, but held events never block the log.
  let latestRequest = 0;
  let disposed = false;
  onCleanup(() => {
    disposed = true;
  });
  const isCurrentReader = () => !disposed && options?.isCurrentReader?.() !== false;
  const ownsRequest = (request: number) => isCurrentReader() && request === latestRequest;

  const loadHeldEvents = async (request: number) => {
    setRefreshingHeldEvents(true);
    try {
      const since = new Date(
        Date.now() - HELD_EVENT_WINDOW_DAYS * 24 * 60 * 60 * 1000,
      ).toISOString();
      const events = await AlertsAPI.getEvents(
        {
          types: HELD_EVENT_TYPES,
          since,
          limit: HELD_EVENT_LIMIT,
        },
        options?.requestOptions,
      );
      if (!ownsRequest(request)) return;
      setHeldEvents(events);
      setHeldEventsUnavailable(false);
    } catch (error) {
      if (!ownsRequest(request)) return;
      logger.error('Failed to load held alert notification events', error);
      setHeldEvents([]);
      setHeldEventsUnavailable(true);
    } finally {
      if (ownsRequest(request)) setRefreshingHeldEvents(false);
    }
  };

  const loadDeliveryLog = async () => {
    if (!isCurrentReader()) return;
    const request = ++latestRequest;
    setRefreshingDeliveryLog(true);
    // Held events refresh independently: they must never delay or fail the
    // primary delivery-attempt log.
    void loadHeldEvents(request);
    try {
      // Request the server's bounded maximum. A degraded queue can retain more
      // than the default page of 50 failures, and the evidence view should not
      // hide them behind unrelated successful attempts when space is available.
      const log = await (options?.requestOptions
        ? NotificationsAPI.getDeliveryLog(DELIVERY_LOG_LIMIT, options.requestOptions)
        : NotificationsAPI.getDeliveryLog(DELIVERY_LOG_LIMIT));
      if (!ownsRequest(request)) return;
      setDeliveryLog(log);
      setDeliveryLogUnavailable(false);
    } catch (error) {
      if (!ownsRequest(request)) return;
      logger.error('Failed to load notification delivery log', error);
      setDeliveryLog(null);
      setDeliveryLogUnavailable(true);
    } finally {
      if (ownsRequest(request)) setRefreshingDeliveryLog(false);
    }
  };

  return {
    deliveryLog,
    deliveryLogUnavailable,
    refreshingDeliveryLog,
    heldEvents,
    heldEventsUnavailable,
    refreshingHeldEvents,
    loadDeliveryLog,
  };
}