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.

fix(alerts): share acknowledgement request ownership

rcourtmanf2696232714d
diff --git a/docs/release-control/v6/internal/subsystems/alerts.md b/docs/release-control/v6/internal/subsystems/alerts.md
index 9d72b6a04c..9bded06e06 100644
--- a/docs/release-control/v6/internal/subsystems/alerts.md
+++ b/docs/release-control/v6/internal/subsystems/alerts.md
@@ -1142,6 +1142,8 @@ default construction path still restores.
82. `internal/alerts/active_state_bootstrap.go`
83. `internal/alerts/eventlog/active_state.go`
84. `frontend-modern/src/features/alerts/AlertDeadManDestinationSection.tsx`
+85. `frontend-modern/src/stores/alertAcknowledgementRequests.ts`
+86. `frontend-modern/src/stores/websocket-global.ts`
## Shared Boundaries
@@ -1202,7 +1204,8 @@ Regression proof lives in `internal/alerts/telemetry_quality_test.go` and the
HTTP-to-manager lifecycle in `internal/monitoring/monitor_pbs_coverage_test.go`.
-1. `frontend-modern/src/stores/websocket.ts` shared with `performance-and-scalability`: the connection-owned realtime store is both the canonical alert truth boundary and the fleet-scale resource reconciliation hot path.
+1. `frontend-modern/src/stores/websocket-global.ts` shared with `performance-and-scalability`, `unified-resources`: the process-wide realtime store owns alert acknowledgement request lifetime, unified-resource state and fleet-scale connection and reconciliation.
+2. `frontend-modern/src/stores/websocket.ts` shared with `performance-and-scalability`: the connection-owned realtime store is both the canonical alert truth boundary and the fleet-scale resource reconciliation hot path.
That shared store normalizes slimmed broadcast resources at ingestion —
expanding `capabilitiesRef` through the state `capabilityCatalog` and
synthesizing the default policy posture for resources published without one
@@ -1210,8 +1213,8 @@ HTTP-to-manager lifecycle in `internal/monitoring/monitor_pbs_coverage_test.go`.
display. Alert override and threshold identity matching must consult
`canonicalIdentity.supersededIds` alongside aliases, because broadcast
aliases no longer duplicate superseded canonical ids.
-2. `internal/operationaltrust/contracts.go` shared with `notifications`: the operational trust contract is jointly consumed by canonical alert lifecycle ownership and notification delivery linkage without making delivery state operational truth.
-3. `internal/proxmoxidentity/backup_identity.go` shared with `monitoring`, `storage-recovery`: Proxmox PBS backup subject identity is a shared runtime boundary for monitoring backup freshness, backup-age alert attribution, and recovery-point guest mapping.
+3. `internal/operationaltrust/contracts.go` shared with `notifications`: the operational trust contract is jointly consumed by canonical alert lifecycle ownership and notification delivery linkage without making delivery state operational truth.
+4. `internal/proxmoxidentity/backup_identity.go` shared with `monitoring`, `storage-recovery`: Proxmox PBS backup subject identity is a shared runtime boundary for monitoring backup freshness, backup-age alert attribution, and recovery-point guest mapping.
Alert multiline field presentation is shared with frontend-primitives:
notification, timeline, threshold ignored-prefix, and resource threshold note
editors must compose the shared `FormTextarea` primitive for label/id/help
@@ -3706,6 +3709,35 @@ derived alert read-model and Last 24 Hours stat refresh for
shared acknowledgement owner instead of keeping its own alert mutation fork.
Future overview action behavior should extend that shared acknowledgement hook
instead of putting acknowledge mutations back into render shells.
+Global and group acknowledgement read the bulk endpoint's per-alert results
+through one path, so a group action reports the alerts it could not
+acknowledge with the same count notice as the global action, beside the
+success count of a partial result. Request ownership is app-wide: the alert
+store creates `frontend-modern/src/stores/alertAcknowledgementRequests.ts`,
+which gives each alert to at most one unsettled card, restore, group or
+global request. Later card, group and global actions leave an owned alert to
+that request, which reports its outcome. A card shows every alert an
+unsettled request carries as processing, a global request's included, and
+keeps the 1.5-second hold only after a card or group request settles, so a
+failed group or global request can be retried at once. The cards' processing
+state and the global button's progress derive from the owner: a remounted
+overview shows a request its predecessor sent, and an older request's hold
+cannot mark an alert idle while a newer request carries it. The owner resets
+with the store's alert scope (the organization switch through `switchUrl`,
+shutdown and store cleanup). Its pending acknowledgement confirmation guards
+and their 15-second timers end at that same boundary, so a settled local change
+cannot suppress another scope's alert with a reused identifier or emit a stale
+resync notice there. A same-scope reconnect retains both the request owner and
+confirmation guards. A response from an ended scope writes nothing
+to the store and shows nothing, since both belong to the next scope, whose
+alerts can share its identifiers; a rejection is still logged. Within one
+scope a response still reports once after the overview unmounts. The jsdom
+no-op store keeps its own owner, reset by its `shutdown`, and
+`shutdownGlobalWebSocketStore` ends that shared app for a test as page unload
+ends it for the app. `alertAcknowledgementRequests.test.ts`,
+`websocket.alertAcknowledgementRequests.test.ts`,
+`websocket-global.noopLifetime.test.ts`, `useAlertAcknowledgementState.test.tsx`
+and `OverviewTab.acknowledgementbusy.test.tsx` pin these paths.
Overview ages and bands read the shared clock. `AlertOverviewAlertCard.tsx`
passes its own `useRelativeTimeNow` reading as `now` to
`formatAlertOverviewStartedAgo` and `getMetricAlertPresentation`, and the Last
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
index 8d83acd992..576ea2896d 100644
--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md
+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
@@ -8422,6 +8422,13 @@ shell stays in `frontend-modern/src/features/alerts/OverviewTab.tsx`, while
alert stats, filtered ordering, and single/bulk acknowledge runtime behavior.
Future overview control flow should extend that hook rather than restoring
action timers or acknowledge mutations to the tab shell.
+Card, group and global acknowledgement requests use the owner passed from the
+shared realtime store through the Alerts page and overview hook. Busy controls
+therefore survive an overview remount. Partial group results expose both the
+success and failure counts, and each in-flight alert stays with its original
+request. The scope-lifetime and rendered-control proofs are
+`frontend-modern/src/stores/__tests__/websocket.alertAcknowledgementRequests.test.ts`
+and `frontend-modern/src/features/alerts/__tests__/OverviewTab.acknowledgementbusy.test.tsx`.
The overview follows the shared-clock rule for relative ages: the alert card
reads `useRelativeTimeNow` for its started age and the live reading's stale
cut-off, and the hook reads it for the Last 24 Hours count. A hook-local
diff --git a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md b/docs/release-control/v6/internal/subsystems/performance-and-scalability.md
index 67605e1536..4df69320e7 100644
--- a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md
+++ b/docs/release-control/v6/internal/subsystems/performance-and-scalability.md
@@ -861,7 +861,7 @@ or a measured fleet performance improvement.
13. `frontend-modern/src/features/platformPage/PlatformWindowedRows.tsx` shared with `frontend-primitives`: the shared bounded table-row renderer is both a canonical platform-page primitive and a fleet-scale mounted-DOM performance boundary.
14. `frontend-modern/src/features/platformPage/usePlatformWindowedItems.ts` shared with `frontend-primitives`: the platform windowing controller is both a canonical frontend scroll primitive and a directional-runway performance hot path.
15. `frontend-modern/src/routing/routePreload.ts` shared with `frontend-primitives`, `unified-resources`: the app-shell route preload registry is a canonical frontend shell boundary, an authenticated hot-path performance boundary, and the entry point for the unified-resource Actions workspace.
-18. `frontend-modern/src/stores/websocket-global.ts` shared with `unified-resources`: the process-wide realtime store owner is both a unified-resource state boundary and a fleet-scale connection and reconciliation hot path.
+18. `frontend-modern/src/stores/websocket-global.ts` shared with `alerts`, `unified-resources`: the process-wide realtime store owns alert acknowledgement request lifetime, unified-resource state and fleet-scale connection and reconciliation.
19. `frontend-modern/src/stores/websocket.ts` shared with `alerts`: the connection-owned realtime store is both the canonical alert truth boundary and the fleet-scale resource reconciliation hot path.
16. `frontend-modern/src/useAppRuntimeState.ts` shared with `cloud-paid`: the authenticated app runtime bootstrap is both a hosted commercial org-context boundary and a protected app-shell performance boundary.
Security-status SSO display labels are part of the existing authenticated
@@ -996,7 +996,11 @@ acknowledgement write that overlaps a recovery discards its response and
fetches once more. These projection baselines are
socket-owned: an oversized
frame invalidates resources, connected infrastructure, and active alerts
-together, while REST recovery hydrates display state only. A later keyed delta
+together, while REST recovery hydrates display state only. The store also
+owns acknowledgement request lifetimes across overview remounts. Scope changes
+end both request ownership and optimistic confirmation guards; a same-scope
+reconnect retains them. `websocket.alertAcknowledgementRequests.test.ts` and
+`websocket-global.noopLifetime.test.ts` pin that boundary. A later keyed delta
without a socket baseline requests the throttled recovery path instead of
patching an independently built REST array or silently retaining a stale
projection. Workload table rows derived from canonical
diff --git a/docs/release-control/v6/internal/subsystems/registry.json b/docs/release-control/v6/internal/subsystems/registry.json
index 62243dbd5f..009688e4c9 100644
--- a/docs/release-control/v6/internal/subsystems/registry.json
+++ b/docs/release-control/v6/internal/subsystems/registry.json
@@ -429,8 +429,9 @@
},
{
"path": "frontend-modern/src/stores/websocket-global.ts",
- "rationale": "the process-wide realtime store owner is both a unified-resource state boundary and a fleet-scale connection and reconciliation hot path",
+ "rationale": "the process-wide realtime store owns alert acknowledgement request lifetime, unified-resource state and fleet-scale connection and reconciliation",
"subsystems": [
+ "alerts",
"performance-and-scalability",
"unified-resources"
]
@@ -2387,7 +2388,9 @@
],
"owned_files": [
"frontend-modern/src/pages/Alerts.tsx",
+ "frontend-modern/src/stores/alertAcknowledgementRequests.ts",
"frontend-modern/src/stores/alertsActivation.ts",
+ "frontend-modern/src/stores/websocket-global.ts",
"frontend-modern/src/stores/websocket.ts",
"frontend-modern/src/types/alerts.ts",
"frontend-modern/src/utils/alertActivationPresentation.ts",
@@ -2426,6 +2429,8 @@
"label": "alert detection and notification state proof",
"match_prefixes": [],
"match_files": [
+ "frontend-modern/src/stores/alertAcknowledgementRequests.ts",
+ "frontend-modern/src/stores/websocket-global.ts",
"frontend-modern/src/stores/websocket.ts",
"frontend-modern/src/utils/alerts.ts",
"frontend-modern/src/utils/alertsActivation.ts"
@@ -2433,8 +2438,11 @@
"allow_same_subsystem_tests": false,
"test_prefixes": [],
"exact_files": [
+ "frontend-modern/src/stores/__tests__/alertAcknowledgementRequests.test.ts",
+ "frontend-modern/src/stores/__tests__/websocket-global.noopLifetime.test.ts",
"frontend-modern/src/stores/__tests__/websocket-resilience.test.ts",
"frontend-modern/src/stores/__tests__/websocket-unified.test.ts",
+ "frontend-modern/src/stores/__tests__/websocket.alertAcknowledgementRequests.test.ts",
"frontend-modern/src/utils/__tests__/alerts.test.ts",
"frontend-modern/src/utils/__tests__/alertsActivation.branchcov0712c.test.ts",
"frontend-modern/src/utils/__tests__/alertsActivation.test.ts"
@@ -2531,10 +2539,12 @@
"frontend-modern/src/features/alerts/__tests__/AlertOverviewAlertCard.system-scope.test.tsx",
"frontend-modern/src/features/alerts/__tests__/alertsConfigurationModel.test.ts",
"frontend-modern/src/features/alerts/__tests__/helpers.test.ts",
+ "frontend-modern/src/features/alerts/__tests__/OverviewTab.acknowledgementbusy.test.tsx",
"frontend-modern/src/features/alerts/__tests__/OverviewTab.emptystate.test.tsx",
"frontend-modern/src/features/alerts/__tests__/OverviewTab.timelineerror.test.tsx",
"frontend-modern/src/features/alerts/__tests__/OverviewTab.total24h.test.tsx",
"frontend-modern/src/features/alerts/__tests__/ThresholdsTab.test.tsx",
+ "frontend-modern/src/features/alerts/__tests__/useAlertAcknowledgementState.test.tsx",
"frontend-modern/src/features/alerts/__tests__/useAlertDestinationsState.test.tsx",
"frontend-modern/src/features/alerts/__tests__/useAlertDestinationsTabState.test.tsx",
"frontend-modern/src/features/alerts/__tests__/useAlertOverridesState.test.tsx",
@@ -7759,7 +7769,9 @@
"allow_same_subsystem_tests": false,
"test_prefixes": [],
"exact_files": [
+ "frontend-modern/src/stores/__tests__/websocket-global.noopLifetime.test.ts",
"frontend-modern/src/stores/__tests__/websocket-unified.test.ts",
+ "frontend-modern/src/stores/__tests__/websocket.alertAcknowledgementRequests.test.ts",
"frontend-modern/src/utils/__tests__/resourceStateAdapters.test.ts",
"internal/mock/alert_incidents_test.go",
"internal/mock/generator_test.go",
@@ -8859,7 +8871,9 @@
"allow_same_subsystem_tests": false,
"test_prefixes": [],
"exact_files": [
+ "frontend-modern/src/stores/__tests__/websocket-global.noopLifetime.test.ts",
"frontend-modern/src/stores/__tests__/websocket-unified.test.ts",
+ "frontend-modern/src/stores/__tests__/websocket.alertAcknowledgementRequests.test.ts",
"internal/ai/tools/filesystem_evidence_test.go",
"internal/monitoring/docker_filesystem_evidence_test.go",
"internal/monitoring/issue1595_collection_trust_test.go",
diff --git a/docs/release-control/v6/internal/subsystems/unified-resources.md b/docs/release-control/v6/internal/subsystems/unified-resources.md
index b37e75bb1d..c3ca9191f5 100644
--- a/docs/release-control/v6/internal/subsystems/unified-resources.md
+++ b/docs/release-control/v6/internal/subsystems/unified-resources.md
@@ -2562,7 +2562,13 @@ the expansion's Network details.
13. `frontend-modern/src/features/proxmox/ProxmoxCoverageTable.tsx` shared with `storage-recovery`: Proxmox workload coverage rows are both a storage/recovery protection-posture surface and a unified-resource identity consumer boundary.
14. `frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx` shared with `storage-recovery`: Proxmox recoverable workload table rows are both a storage/recovery coverage surface and a unified-resource platform-table consumer boundary.
15. `frontend-modern/src/routing/routePreload.ts` shared with `frontend-primitives`, `performance-and-scalability`: the app-shell route preload registry is a canonical frontend shell boundary, an authenticated hot-path performance boundary, and the entry point for the unified-resource Actions workspace.
-16. `frontend-modern/src/stores/websocket-global.ts` shared with `performance-and-scalability`: the process-wide realtime store owner is both a unified-resource state boundary and a fleet-scale connection and reconciliation hot path.
+16. `frontend-modern/src/stores/websocket-global.ts` shared with `alerts`, `performance-and-scalability`: the process-wide realtime store owns alert acknowledgement request lifetime, unified-resource state and fleet-scale connection and reconciliation.
+ Alert request ownership follows this store's scope across route remounts.
+ A scope switch ends request ownership and confirmation guards before
+ accepting that scope's alerts. Same-scope reconnects retain them. The real
+ store and global no-op lifetime tests pin this shared boundary through
+ `websocket.alertAcknowledgementRequests.test.ts` and
+ `websocket-global.noopLifetime.test.ts`.
17. `frontend-modern/src/utils/platformSupportManifest.generated.ts` shared with `frontend-primitives`: the generated platform support projection is both a canonical unified-resource platform union boundary and a shared frontend source/platform vocabulary boundary.
It must carry the manifest `surface_kind` distinction so `docker` remains
machine-readable as a `runtime-lens` while owning infrastructure sources
diff --git a/frontend-modern/browser-verification/ef19f599dcfea639.json b/frontend-modern/browser-verification/ef19f599dcfea639.json
new file mode 100644
index 0000000000..c45716e4d6
--- /dev/null
+++ b/frontend-modern/browser-verification/ef19f599dcfea639.json
@@ -0,0 +1,81 @@
+{
+ "version": 1,
+ "base_sha": "fa3a83c4f3fbe8d184dd8c7403e3174daa49d586",
+ "verified_at": "2026-10-31T20:58:18Z",
+ "result": "passed",
+ "changed_paths": [
+ "frontend-modern/src/features/alerts/OverviewTab.tsx",
+ "frontend-modern/src/features/alerts/useAlertAcknowledgementState.ts",
+ "frontend-modern/src/features/alerts/useAlertOverviewState.ts",
+ "frontend-modern/src/pages/Alerts.tsx",
+ "frontend-modern/src/stores/alertAcknowledgementRequests.ts",
+ "frontend-modern/src/stores/websocket-global.ts",
+ "frontend-modern/src/stores/websocket.ts"
+ ],
+ "content_sha256": {
+ "frontend-modern/src/features/alerts/OverviewTab.tsx": "8dec020fea359130f646a85abe35c734656242daa420f31d8dcaf7c370a54237",
+ "frontend-modern/src/features/alerts/useAlertAcknowledgementState.ts": "a2300cbec94cba1b0ca719d508e0788e9609c6a52ac9a8d8a39a93507b2f3dac",
+ "frontend-modern/src/features/alerts/useAlertOverviewState.ts": "f618429aa4e69e2f357e59c5c35fbd42a96e19ff3166f43a37de21fd8dea1198",
+ "frontend-modern/src/pages/Alerts.tsx": "a2c66936d9f881b23bd133abe7affdee9a62d638fa68eb1a8cca5bac6c20e43c",
+ "frontend-modern/src/stores/alertAcknowledgementRequests.ts": "62eec58b08aa7cac9465896b80c1011fdc01fab0e04c3fefea1fb6fc21193b39",
+ "frontend-modern/src/stores/websocket-global.ts": "4950e4d28999adbd3c0ec1f5274c390af123fe4d3f4c4f3455be08b374b2b179",
+ "frontend-modern/src/stores/websocket.ts": "42564e6855b4eb431c89f5a933ec2a9d40754bd9ddf04c8bd7480ff851ca64a7"
+ },
+ "routes": [
+ "/alerts/overview"
+ ],
+ "viewports": [
+ {
+ "width": 1440,
+ "height": 1000
+ },
+ {
+ "width": 768,
+ "height": 1000
+ },
+ {
+ "width": 390,
+ "height": 844
+ }
+ ],
+ "states": [
+ "default",
+ "card hover",
+ "card keyboard focus",
+ "global pending",
+ "pending remount",
+ "completed after unmount",
+ "acknowledged hidden",
+ "group partial feedback",
+ "overlapping ownership",
+ "group rejected",
+ "group retried",
+ "global rejected",
+ "global retried",
+ "old scope outcomes silent",
+ "new scope completed",
+ "settled ack scope switch",
+ "settled restore scope switch",
+ "same scope reconnect",
+ "group expanded",
+ "timeline loading",
+ "timeline error",
+ "timeline terminal",
+ "snooze dialog",
+ "monitoring menu"
+ ],
+ "interactions": [
+ "Built production OverviewTab, hooks, ToastContainer and real WebSocket store with private controlled API/socket fixtures. Completion observation delegates unchanged to the actual request owner.",
+ "Hover and keyboard-focus card action; Enter starts global acknowledgement; included cards and global action stay disabled, and repeated activation sends no duplicate request.",
+ "Unmount and remount the overview while pending; finish after unmount, show the result once and retain shared busy state.",
+ "Partial group success reports both counts; retry sends only failed unowned alerts; an older settled hold cannot release a newer group request; an unrelated card remains usable.",
+ "Overlapping card, group and global actions exclude alerts already owned by another request; group/global rejection preserves alerts and allows retry.",
+ "Actual store.switchUrl with reused identifiers: old card success, group partial failure and global rejection neither mutate nor notify the new scope or release its new bulk request.",
+ "Settled acknowledge and restore guards end on scope switch; wait beyond the old 15-second confirmation deadline without a stale error.",
+ "Actual same-scope reconnect receives a uniquely marked stale socket frame and retains both confirmation guards and outstanding request ownership.",
+ "Toggle acknowledged visibility to the empty state and back; reload from confirmed synthetic server truth.",
+ "Enter expands related alerts; More/Less opens and closes adjacent actions; timeline loading, error, Retry and exact terminal unavailable state are visible.",
+ "Snooze dialog fully animates, fits the viewport and dismisses by Escape/Cancel with focus return. Monitoring menu opens by ArrowDown, fits the viewport and dismisses by Escape/outside click with focus return.",
+ "Pixel review of all 72 captures using contact sheets plus full-size controls, feedback, timeline and overlays; horizontal overflow assertions pass at all three widths."
+ ]
+}
diff --git a/frontend-modern/src/features/alerts/OverviewTab.tsx b/frontend-modern/src/features/alerts/OverviewTab.tsx
index e7572d3e7b..2d466842ef 100644
--- a/frontend-modern/src/features/alerts/OverviewTab.tsx
+++ b/frontend-modern/src/features/alerts/OverviewTab.tsx
@@ -2,6 +2,7 @@ import { AlertQueueActionFeedback } from './AlertQueueActionFeedback';
import { createSignal, onCleanup, createEffect, onMount, Show } from 'solid-js';
import { useLocation } from '@solidjs/router';
+import type { AlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
import type { Alert } from '@/types/api';
import { AlertDeliveryHealthCard } from './AlertDeliveryHealthCard';
@@ -17,6 +18,7 @@ export function OverviewTab(props: {
overrides: Override[];
activeAlerts: Record<string, Alert>;
updateAlert: (alertIdentifier: string, updates: Partial<Alert>) => void;
+ acknowledgementRequests: AlertAcknowledgementRequests;
showQuickTip: () => boolean;
dismissQuickTip: () => void;
showAcknowledged: () => boolean;
@@ -31,6 +33,7 @@ export function OverviewTab(props: {
overrides: () => props.overrides,
showAcknowledged: props.showAcknowledged,
updateAlert: props.updateAlert,
+ acknowledgementRequests: props.acknowledgementRequests,
});
const timelineState = useAlertIncidentTimelineState();
// A destination that stopped delivering is invisible by nature: the failure
diff --git a/frontend-modern/src/features/alerts/__tests__/AlertOverviewAlertCard.clock.test.tsx b/frontend-modern/src/features/alerts/__tests__/AlertOverviewAlertCard.clock.test.tsx
index 3461952248..922347f18f 100644
--- a/frontend-modern/src/features/alerts/__tests__/AlertOverviewAlertCard.clock.test.tsx
+++ b/frontend-modern/src/features/alerts/__tests__/AlertOverviewAlertCard.clock.test.tsx
@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { cleanup, render, screen } from '@solidjs/testing-library';
import { createSignal } from 'solid-js';
import { DEFAULT_LOCALE, setActiveLocale } from '@/i18n';
+import { createAlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
import type { Alert, AlertDeliveryDiagnosis } from '@/types/api';
import { RELATIVE_TIME_TICK_MS } from '@/utils/relativeTimeClock';
import { METRIC_ALERT_STATUS_STALE_MS } from '../metricAlertPresentation';
@@ -72,6 +73,7 @@ function renderOverview() {
overrides={[]}
activeAlerts={activeAlerts()}
updateAlert={vi.fn()}
+ acknowledgementRequests={createAlertAcknowledgementRequests()}
showQuickTip={() => false}
dismissQuickTip={vi.fn()}
showAcknowledged={() => true}
diff --git a/frontend-modern/src/features/alerts/__tests__/OverviewTab.acknowledgementbusy.test.tsx b/frontend-modern/src/features/alerts/__tests__/OverviewTab.acknowledgementbusy.test.tsx
new file mode 100644
index 0000000000..1080521f03
--- /dev/null
+++ b/frontend-modern/src/features/alerts/__tests__/OverviewTab.acknowledgementbusy.test.tsx
@@ -0,0 +1,163 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, fireEvent, render, screen, waitFor } from '@solidjs/testing-library';
+import { DEFAULT_LOCALE, setActiveLocale } from '@/i18n';
+import { createAlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
+import type { Alert, AlertDeliveryDiagnosis } from '@/types/api';
+import {
+ getAlertOverviewBulkAcknowledgeLabel,
+ getAlertOverviewPrimaryActionLabel,
+} from '@/utils/alertOverviewPresentation';
+
+vi.mock('@solidjs/router', () => ({
+ useLocation: () => ({ hash: '', pathname: '/alerts', search: '', query: {} }),
+ A: (props: Record<string, unknown>) => props.children,
+}));
+
+type BulkAcknowledgeResult = {
+ results: Array<{ alertIdentifier: string; success: boolean; error?: string }>;
+};
+
+const getDeliveryDiagnoses = vi.fn<() => Promise<AlertDeliveryDiagnosis[]>>();
+const bulkAcknowledge = vi.fn<(alertIdentifiers: string[]) => Promise<BulkAcknowledgeResult>>();
+
+vi.mock('@/api/alerts', () => ({
+ AlertsAPI: {
+ get getDeliveryDiagnoses() {
+ return getDeliveryDiagnoses;
+ },
+ get bulkAcknowledge() {
+ return bulkAcknowledge;
+ },
+ },
+}));
+
+vi.mock('@/stores/notifications', () => ({
+ notificationStore: { success: vi.fn(), error: vi.fn() },
+}));
+
+vi.mock('@/utils/logger', () => ({
+ logger: { error: vi.fn() },
+}));
+
+vi.mock('@/components/Alerts/InvestigateAlertButton', () => ({
+ InvestigateAlertButton: () => null,
+}));
+
+import { OverviewTab } from '../OverviewTab';
+
+function makeAlert(id: string): Alert {
+ return {
+ id,
+ resourceId: `vm-${id}`,
+ resourceName: `VM ${id}`,
+ type: 'cpu',
+ level: 'warning',
+ message: `High CPU on VM ${id}`,
+ startTime: new Date().toISOString(),
+ acknowledged: false,
+ node: 'node1',
+ } as Alert;
+}
+
+function deferred<T>() {
+ let resolve!: (value: T) => void;
+ const promise = new Promise<T>((settle) => {
+ resolve = settle;
+ });
+ return { promise, resolve };
+}
+
+function defaultProps(overrides: Record<string, unknown> = {}) {
+ return {
+ overrides: [] as never[],
+ activeAlerts: {} as Record<string, Alert>,
+ updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
+ showQuickTip: () => false,
+ dismissQuickTip: vi.fn(),
+ showAcknowledged: () => true,
+ setShowAcknowledged: vi.fn(),
+ alertsDisabled: () => false,
+ ...overrides,
+ };
+}
+
+const acknowledgeLabel = () =>
+ getAlertOverviewPrimaryActionLabel({ acknowledged: false, processing: false });
+const processingLabel = () =>
+ getAlertOverviewPrimaryActionLabel({ acknowledged: false, processing: true });
+
+describe('OverviewTab cards during a global acknowledgement', () => {
+ beforeEach(() => {
+ setActiveLocale(DEFAULT_LOCALE);
+ getDeliveryDiagnoses.mockReset();
+ getDeliveryDiagnoses.mockResolvedValue([]);
+ bulkAcknowledge.mockReset();
+ });
+
+ afterEach(() => {
+ cleanup();
+ setActiveLocale(DEFAULT_LOCALE);
+ });
+
+ it('shows the cards it carries as processing until it settles', async () => {
+ const response = deferred<BulkAcknowledgeResult>();
+ bulkAcknowledge.mockReturnValueOnce(response.promise);
+ const activeAlerts = { a1: makeAlert('a1'), a2: makeAlert('a2') };
+
+ render(() => <OverviewTab {...defaultProps({ activeAlerts })} />);
+ expect(screen.getAllByRole('button', { name: acknowledgeLabel() })).toHaveLength(2);
+
+ fireEvent.click(
+ screen.getByRole('button', { name: getAlertOverviewBulkAcknowledgeLabel(2, false) }),
+ );
+ expect(bulkAcknowledge).toHaveBeenCalledWith(['a1', 'a2']);
+ const busyCards = screen.getAllByRole('button', { name: processingLabel() });
+ expect(busyCards).toHaveLength(2);
+ busyCards.forEach((button) => expect((button as HTMLButtonElement).disabled).toBe(true));
+ expect(
+ screen.getByRole('button', { name: getAlertOverviewBulkAcknowledgeLabel(2, true) }),
+ ).toBeTruthy();
+
+ // Both fail, so both cards stay; a settled global request holds neither.
+ response.resolve({
+ results: [
+ { alertIdentifier: 'a1', success: false },
+ { alertIdentifier: 'a2', success: false },
+ ],
+ });
+ await waitFor(
+ () => expect(screen.getAllByRole('button', { name: acknowledgeLabel() })).toHaveLength(2),
+ { timeout: 500 },
+ );
+ expect(screen.queryAllByRole('button', { name: processingLabel() })).toHaveLength(0);
+ });
+
+ it('shows a global acknowledgement from before a remount as still in progress', async () => {
+ const response = deferred<BulkAcknowledgeResult>();
+ bulkAcknowledge.mockReturnValueOnce(response.promise);
+ const props = defaultProps({ activeAlerts: { a1: makeAlert('a1') } });
+
+ render(() => <OverviewTab {...props} />);
+ fireEvent.click(
+ screen.getByRole('button', { name: getAlertOverviewBulkAcknowledgeLabel(1, false) }),
+ );
+ cleanup();
+
+ // The overview mounts again over the same app-wide request owner.
+ render(() => <OverviewTab {...props} />);
+ const busyCard = screen.getByRole('button', { name: processingLabel() });
+ expect((busyCard as HTMLButtonElement).disabled).toBe(true);
+ const globalButton = screen.getByRole('button', {
+ name: getAlertOverviewBulkAcknowledgeLabel(1, true),
+ }) as HTMLButtonElement;
+ expect(globalButton.disabled).toBe(true);
+
+ response.resolve({ results: [{ alertIdentifier: 'a1', success: false }] });
+ await waitFor(
+ () => expect(screen.getByRole('button', { name: acknowledgeLabel() })).toBeTruthy(),
+ { timeout: 500 },
+ );
+ expect(bulkAcknowledge).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/frontend-modern/src/features/alerts/__tests__/OverviewTab.deliveryactions.test.tsx b/frontend-modern/src/features/alerts/__tests__/OverviewTab.deliveryactions.test.tsx
index f7724875b2..b0420fd15c 100644
--- a/frontend-modern/src/features/alerts/__tests__/OverviewTab.deliveryactions.test.tsx
+++ b/frontend-modern/src/features/alerts/__tests__/OverviewTab.deliveryactions.test.tsx
@@ -1,6 +1,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { cleanup, fireEvent, render, screen, waitFor } from '@solidjs/testing-library';
import { DEFAULT_LOCALE, setActiveLocale } from '@/i18n';
+import { createAlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
import type { Alert } from '@/types/api';
import type { NotificationHealth } from '@/api/notifications';
@@ -92,6 +93,7 @@ function defaultProps() {
overrides: [] as never[],
activeAlerts: {} as Record<string, Alert>,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
showQuickTip: () => false,
dismissQuickTip: vi.fn(),
showAcknowledged: () => true,
diff --git a/frontend-modern/src/features/alerts/__tests__/OverviewTab.deliverystatus.test.tsx b/frontend-modern/src/features/alerts/__tests__/OverviewTab.deliverystatus.test.tsx
index 8e1886af95..513a9080e5 100644
--- a/frontend-modern/src/features/alerts/__tests__/OverviewTab.deliverystatus.test.tsx
+++ b/frontend-modern/src/features/alerts/__tests__/OverviewTab.deliverystatus.test.tsx
@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { createSignal } from 'solid-js';
import { cleanup, render, screen, waitFor } from '@solidjs/testing-library';
import { DEFAULT_LOCALE, setActiveLocale } from '@/i18n';
+import { createAlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
import type { Alert, AlertDeliveryDiagnosis } from '@/types/api';
vi.mock('@solidjs/router', () => ({
@@ -78,6 +79,7 @@ function defaultProps(overrides: Record<string, unknown> = {}) {
overrides: [] as never[],
activeAlerts: {} as Record<string, Alert>,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
showQuickTip: () => false,
dismissQuickTip: vi.fn(),
showAcknowledged: () => true,
diff --git a/frontend-modern/src/features/alerts/__tests__/OverviewTab.emptystate.test.tsx b/frontend-modern/src/features/alerts/__tests__/OverviewTab.emptystate.test.tsx
index 5c9b70513f..f4d9ebf2c3 100644
--- a/frontend-modern/src/features/alerts/__tests__/OverviewTab.emptystate.test.tsx
+++ b/frontend-modern/src/features/alerts/__tests__/OverviewTab.emptystate.test.tsx
@@ -26,6 +26,7 @@ vi.mock('@/components/Alerts/InvestigateAlertButton', () => ({
}));
import { OverviewTab } from '../OverviewTab';
+import { createAlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
import { useAlertsActivation } from '@/stores/alertsActivation';
function defaultProps(overrides: Record<string, unknown> = {}) {
@@ -33,6 +34,7 @@ function defaultProps(overrides: Record<string, unknown> = {}) {
overrides: [] as never[],
activeAlerts: {} as Record<string, never>,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
showQuickTip: () => false,
dismissQuickTip: vi.fn(),
showAcknowledged: () => false,
diff --git a/frontend-modern/src/features/alerts/__tests__/OverviewTab.systemalert.test.tsx b/frontend-modern/src/features/alerts/__tests__/OverviewTab.systemalert.test.tsx
index 9d326df11a..53b822e9a7 100644
--- a/frontend-modern/src/features/alerts/__tests__/OverviewTab.systemalert.test.tsx
+++ b/frontend-modern/src/features/alerts/__tests__/OverviewTab.systemalert.test.tsx
@@ -1,6 +1,8 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { cleanup, render, screen } from '@solidjs/testing-library';
+import type { ComponentProps } from 'solid-js';
import { DEFAULT_LOCALE, setActiveLocale } from '@/i18n';
+import { createAlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
import type { Alert } from '@/types/api';
vi.mock('@solidjs/router', () => ({
@@ -52,11 +54,14 @@ function systemAlert(): Alert {
} as unknown as Alert;
}
-function defaultProps(overrides: Record<string, unknown> = {}) {
+function defaultProps(
+ overrides: Partial<ComponentProps<typeof OverviewTab>> = {},
+): ComponentProps<typeof OverviewTab> {
return {
overrides: [] as never[],
activeAlerts: {} as Record<string, Alert>,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
showQuickTip: () => false,
dismissQuickTip: vi.fn(),
showAcknowledged: () => true,
@@ -78,9 +83,7 @@ describe('OverviewTab system-scoped alerts', () => {
it('renders a resource-less system alert without inventing a resource', () => {
const alert = systemAlert();
- render(
- () => OverviewTab(defaultProps({ activeAlerts: { [alert.id]: alert } }) as never) as never,
- );
+ render(() => <OverviewTab {...defaultProps({ activeAlerts: { [alert.id]: alert } })} />);
// Named as Pulse itself rather than a monitored resource.
expect(screen.getByText('Pulse')).toBeTruthy();
@@ -94,9 +97,9 @@ describe('OverviewTab system-scoped alerts', () => {
it('does not render a node line for an alert with no node', () => {
const alert = systemAlert();
- const { container } = render(
- () => OverviewTab(defaultProps({ activeAlerts: { [alert.id]: alert } }) as never) as never,
- );
+ const { container } = render(() => (
+ <OverviewTab {...defaultProps({ activeAlerts: { [alert.id]: alert } })} />
+ ));
// Resource alerts render an "on <node>" line. A system alert has no node,
// so that affordance must be skipped rather than rendered empty.
diff --git a/frontend-modern/src/features/alerts/__tests__/OverviewTab.timelineerror.test.tsx b/frontend-modern/src/features/alerts/__tests__/OverviewTab.timelineerror.test.tsx
index 87a8e5f1d3..009707dfc6 100644
--- a/frontend-modern/src/features/alerts/__tests__/OverviewTab.timelineerror.test.tsx
+++ b/frontend-modern/src/features/alerts/__tests__/OverviewTab.timelineerror.test.tsx
@@ -1,6 +1,7 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { cleanup, render, screen, fireEvent, waitFor } from '@solidjs/testing-library';
import { DEFAULT_LOCALE, setActiveLocale } from '@/i18n';
+import { createAlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
import type { Alert } from '@/types/api';
const mockGetIncidentTimeline = vi.fn();
@@ -50,6 +51,7 @@ function defaultProps(overrides: Record<string, unknown> = {}) {
},
} as Record<string, Alert>,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
showQuickTip: () => false,
dismissQuickTip: vi.fn(),
showAcknowledged: () => false,
diff --git a/frontend-modern/src/features/alerts/__tests__/OverviewTab.total24h.test.tsx b/frontend-modern/src/features/alerts/__tests__/OverviewTab.total24h.test.tsx
index 359d15bb3c..411a50fab1 100644
--- a/frontend-modern/src/features/alerts/__tests__/OverviewTab.total24h.test.tsx
+++ b/frontend-modern/src/features/alerts/__tests__/OverviewTab.total24h.test.tsx
@@ -1,6 +1,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { cleanup, fireEvent, render, screen, waitFor } from '@solidjs/testing-library';
import { DEFAULT_LOCALE, setActiveLocale } from '@/i18n';
+import { createAlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
import type { Alert, AlertDeliveryDiagnosis } from '@/types/api';
vi.mock('@solidjs/router', () => ({
@@ -51,6 +52,7 @@ function defaultProps(overrides: Record<string, unknown> = {}) {
overrides: [] as never[],
activeAlerts: {} as Record<string, Alert>,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
showQuickTip: () => false,
dismissQuickTip: vi.fn(),
showAcknowledged: () => true,
diff --git a/frontend-modern/src/features/alerts/__tests__/useAlertAcknowledgementState.test.tsx b/frontend-modern/src/features/alerts/__tests__/useAlertAcknowledgementState.test.tsx
index 09331ea4ac..186db62f45 100644
--- a/frontend-modern/src/features/alerts/__tests__/useAlertAcknowledgementState.test.tsx
+++ b/frontend-modern/src/features/alerts/__tests__/useAlertAcknowledgementState.test.tsx
@@ -1,11 +1,21 @@
import { renderHook } from '@solidjs/testing-library';
import { createMemo } from 'solid-js';
-import { createStore, reconcile } from 'solid-js/store';
+import { createStore, produce, reconcile } from 'solid-js/store';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { AlertsAPI } from '@/api/alerts';
+import {
+ createAlertAcknowledgementRequests,
+ type AlertAcknowledgementRequests,
+} from '@/stores/alertAcknowledgementRequests';
import { notificationStore } from '@/stores/notifications';
import type { Alert } from '@/types/api';
+import { logger } from '@/utils/logger';
+import {
+ getAlertOverviewBulkAcknowledgedNotification,
+ getAlertOverviewBulkAcknowledgeFailureNotification,
+ getAlertOverviewBulkAcknowledgeGenericFailureNotification,
+} from '@/utils/alertOverviewPresentation';
import { useAlertAcknowledgementState } from '../useAlertAcknowledgementState';
@@ -48,33 +58,79 @@ function acknowledgedBy(id: string, ackUser: string): Alert {
return { ...makeAlert(id, true), ackTime: '2026-03-22T11:30:00Z', ackUser };
}
+type BulkAcknowledgeResult = Awaited<ReturnType<typeof AlertsAPI.bulkAcknowledge>>;
+
+// A request the test answers later, so it can act while the request is out.
+function deferred<T>() {
+ let resolve!: (value: T) => void;
+ let reject!: (reason: unknown) => void;
+ const promise = new Promise<T>((settle, fail) => {
+ resolve = settle;
+ reject = fail;
+ });
+ return { promise, resolve, reject };
+}
+
// The keyed alert store the way the websocket store keeps it: updateAlert
// merges a local change into the stored alert, and every server payload
-// replaces the stored alert in place through reconcile. The page reads the
-// alerts through a memo over the keyed store, as useAlertOverviewState does.
-function renderWithAlertStore(initial: Alert[]) {
- return renderHook(() => {
- const [alertsById, setAlertsById] = createStore<Record<string, Alert>>(
- Object.fromEntries(initial.map((alert) => [alert.id, alert])),
+// replaces the stored alert in place through reconcile. This mocks the
+// store's contract; the request owner each test passes is the real module the
+// store creates. The store lives outside any view, as the app's does.
+function createAlertStore(initial: Alert[]) {
+ const [alertsById, setAlertsById] = createStore<Record<string, Alert>>(
+ Object.fromEntries(initial.map((alert) => [alert.id, alert])),
+ );
+ const updateAlert = vi.fn((alertIdentifier: string, updates: Partial<Alert>) => {
+ const existing = alertsById[alertIdentifier];
+ if (existing) {
+ setAlertsById(alertIdentifier, { ...existing, ...updates });
+ }
+ });
+ const serverSends = (alert: Alert) => setAlertsById(alert.id, reconcile(alert));
+ // A resolved alert leaves the store, as the websocket store removes it.
+ const serverResolves = (alertIdentifier: string) =>
+ setAlertsById(
+ produce((draft) => {
+ delete draft[alertIdentifier];
+ }),
);
- const alerts = createMemo(() => Object.values(alertsById));
- const updateAlert = vi.fn((alertIdentifier: string, updates: Partial<Alert>) => {
- const existing = alertsById[alertIdentifier];
- if (existing) {
- setAlertsById(alertIdentifier, { ...existing, ...updates });
- }
- });
- const serverSends = (alert: Alert) => setAlertsById(alert.id, reconcile(alert));
+ return { alertsById, updateAlert, serverSends, serverResolves };
+}
+type AlertStoreHarness = ReturnType<typeof createAlertStore>;
+
+// One overview view over the store and the app's request owner. A second view
+// over the same pair after the first is cleaned up is a remount. The page
+// reads the alerts through a memo over the keyed store, as
+// useAlertOverviewState does.
+function renderOverview(
+ store: AlertStoreHarness,
+ acknowledgementRequests: AlertAcknowledgementRequests,
+) {
+ return renderHook(() => {
+ const alerts = createMemo(() => Object.values(store.alertsById));
return {
- ...useAlertAcknowledgementState({ alerts, updateAlert, allowRestore: true }),
+ ...useAlertAcknowledgementState({
+ alerts,
+ updateAlert: store.updateAlert,
+ acknowledgementRequests,
+ allowRestore: true,
+ }),
alerts,
- updateAlert,
- serverSends,
+ updateAlert: store.updateAlert,
+ serverSends: store.serverSends,
+ serverResolves: store.serverResolves,
};
});
}
+// Each test gets its own store and its own request owner.
+function renderWithAlertStore(initial: Alert[]) {
+ const store = createAlertStore(initial);
+ const acknowledgementRequests = createAlertAcknowledgementRequests();
+ return { ...renderOverview(store, acknowledgementRequests), store, acknowledgementRequests };
+}
+
describe('useAlertAcknowledgementState', () => {
beforeEach(() => {
vi.useFakeTimers();
@@ -179,4 +235,588 @@ describe('useAlertAcknowledgementState', () => {
expect(notificationStore.error).toHaveBeenCalledWith('Failed to acknowledge 1 alert.');
expect(unacknowledgedIds(result)).toEqual(['alert-3']);
});
+
+ describe('group acknowledgement', () => {
+ it('reports the alerts a group acknowledgement could not acknowledge', async () => {
+ const { result } = renderWithAlertStore([
+ makeAlert('alert-1'),
+ makeAlert('alert-2'),
+ makeAlert('alert-3'),
+ ]);
+ const response = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge).mockReturnValueOnce(response.promise);
+
+ const settled = result.handleGroupAcknowledge(result.alerts());
+ expect(AlertsAPI.bulkAcknowledge).toHaveBeenCalledWith(['alert-1', 'alert-2', 'alert-3']);
+ expect([...result.processingAlerts()]).toEqual(['alert-1', 'alert-2', 'alert-3']);
+ expect(notificationStore.success).not.toHaveBeenCalled();
+
+ response.resolve({
+ results: [
+ { alertIdentifier: 'alert-1', success: true },
+ { alertIdentifier: 'alert-2', success: false },
+ { alertIdentifier: 'alert-3', success: false },
+ ],
+ });
+ await settled;
+
+ // The partial success keeps its count, and the failures are said beside it.
+ expect(notificationStore.success).toHaveBeenCalledWith('Acknowledged 1 alert.');
+ expect(notificationStore.error).toHaveBeenCalledWith(
+ getAlertOverviewBulkAcknowledgeFailureNotification(2),
+ );
+ expect(result.updateAlert).toHaveBeenCalledTimes(1);
+ expect(unacknowledgedIds(result)).toEqual(['alert-2', 'alert-3']);
+
+ vi.advanceTimersByTime(1500);
+ expect(result.processingAlerts().size).toBe(0);
+ });
+
+ it('says so when a group acknowledgement acknowledges none of its alerts', async () => {
+ const { result } = renderWithAlertStore([makeAlert('alert-1'), makeAlert('alert-2')]);
+ const response = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge).mockReturnValueOnce(response.promise);
+
+ const settled = result.handleGroupAcknowledge(result.alerts());
+ response.resolve({
+ results: [
+ { alertIdentifier: 'alert-1', success: false },
+ { alertIdentifier: 'alert-2', success: false },
+ ],
+ });
+ await settled;
+
+ expect(notificationStore.success).not.toHaveBeenCalled();
+ expect(notificationStore.error).toHaveBeenCalledTimes(1);
+ expect(notificationStore.error).toHaveBeenCalledWith(
+ getAlertOverviewBulkAcknowledgeFailureNotification(2),
+ );
+ expect(result.updateAlert).not.toHaveBeenCalled();
+ expect(unacknowledgedIds(result)).toEqual(['alert-1', 'alert-2']);
+ });
+
+ it('sends a failed alert again on retry while its card still shows processing', async () => {
+ const { result } = renderWithAlertStore([makeAlert('alert-1'), makeAlert('alert-2')]);
+ vi.mocked(AlertsAPI.bulkAcknowledge)
+ .mockResolvedValueOnce({
+ results: [
+ { alertIdentifier: 'alert-1', success: false },
+ { alertIdentifier: 'alert-2', success: true },
+ ],
+ })
+ .mockResolvedValueOnce({ results: [{ alertIdentifier: 'alert-1', success: true }] });
+
+ await result.handleGroupAcknowledge(result.alerts());
+ expect(result.processingAlerts().has('alert-1')).toBe(true);
+
+ await result.handleGroupAcknowledge(result.alerts());
+ expect(AlertsAPI.bulkAcknowledge).toHaveBeenNthCalledWith(2, ['alert-1']);
+ expect(unacknowledgedIds(result)).toEqual([]);
+ });
+
+ it('does not send a group again while its acknowledgement is in flight', async () => {
+ const { result } = renderWithAlertStore([makeAlert('alert-1'), makeAlert('alert-2')]);
+ const response = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge).mockReturnValueOnce(response.promise);
+
+ const first = result.handleGroupAcknowledge(result.alerts());
+ const second = result.handleGroupAcknowledge(result.alerts());
+ // A card in the group waits for the same request.
+ await result.handleAlertAcknowledgement(result.alerts()[0]);
+ expect(AlertsAPI.bulkAcknowledge).toHaveBeenCalledTimes(1);
+ expect(AlertsAPI.acknowledge).not.toHaveBeenCalled();
+
+ response.resolve({
+ results: [
+ { alertIdentifier: 'alert-1', success: true },
+ { alertIdentifier: 'alert-2', success: true },
+ ],
+ });
+ await Promise.all([first, second]);
+
+ expect(vi.mocked(notificationStore.success).mock.calls).toEqual([
+ [getAlertOverviewBulkAcknowledgedNotification(2)],
+ ]);
+ expect(notificationStore.error).not.toHaveBeenCalled();
+ expect(unacknowledgedIds(result)).toEqual([]);
+ });
+
+ it('leaves an alert to its own request when its group is acknowledged meanwhile', async () => {
+ const { result } = renderWithAlertStore([makeAlert('alert-1'), makeAlert('alert-2')]);
+ const single = deferred<{ success: boolean }>();
+ const bulk = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.acknowledge).mockReturnValueOnce(single.promise);
+ vi.mocked(AlertsAPI.bulkAcknowledge).mockReturnValueOnce(bulk.promise);
+
+ const card = result.handleAlertAcknowledgement(result.alerts()[0]);
+ const group = result.handleGroupAcknowledge(result.alerts());
+ expect(AlertsAPI.bulkAcknowledge).toHaveBeenCalledWith(['alert-2']);
+
+ single.resolve({ success: true });
+ await card;
+ bulk.resolve({ results: [{ alertIdentifier: 'alert-2', success: true }] });
+ await group;
+
+ expect(vi.mocked(notificationStore.success).mock.calls).toEqual([
+ ['Alert acknowledged'],
+ ['Acknowledged 1 alert.'],
+ ]);
+ expect(notificationStore.error).not.toHaveBeenCalled();
+ expect(unacknowledgedIds(result)).toEqual([]);
+ });
+
+ it('sends only the rest of a group while a global acknowledgement is out', async () => {
+ const { result } = renderWithAlertStore([
+ makeAlert('alert-1'),
+ makeAlert('alert-2'),
+ acknowledgedBy('alert-3', 'admin'),
+ ]);
+ const globalResponse = deferred<BulkAcknowledgeResult>();
+ const groupResponse = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge)
+ .mockReturnValueOnce(globalResponse.promise)
+ .mockReturnValueOnce(groupResponse.promise);
+
+ const globalAck = result.handleBulkAcknowledge();
+ expect(AlertsAPI.bulkAcknowledge).toHaveBeenLastCalledWith(['alert-1', 'alert-2']);
+
+ // Another session unacknowledges alert-3 while the global request is out.
+ result.serverSends(makeAlert('alert-3'));
+ const groupAck = result.handleGroupAcknowledge([result.alerts()[1], result.alerts()[2]]);
+ expect(AlertsAPI.bulkAcknowledge).toHaveBeenLastCalledWith(['alert-3']);
+
+ globalResponse.resolve({
+ results: [
+ { alertIdentifier: 'alert-1', success: true },
+ { alertIdentifier: 'alert-2', success: true },
+ ],
+ });
+ groupResponse.resolve({ results: [{ alertIdentifier: 'alert-3', success: true }] });
+ await Promise.all([globalAck, groupAck]);
+
+ expect(vi.mocked(notificationStore.success).mock.calls).toEqual([
+ [getAlertOverviewBulkAcknowledgedNotification(2)],
+ ['Acknowledged 1 alert.'],
+ ]);
+ expect(notificationStore.error).not.toHaveBeenCalled();
+ expect(unacknowledgedIds(result)).toEqual([]);
+ });
+
+ it('leaves a group its alerts when the global action runs meanwhile', async () => {
+ const { result } = renderWithAlertStore([
+ makeAlert('alert-1'),
+ makeAlert('alert-2'),
+ makeAlert('alert-3'),
+ ]);
+ const groupResponse = deferred<BulkAcknowledgeResult>();
+ const globalResponse = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge)
+ .mockReturnValueOnce(groupResponse.promise)
+ .mockReturnValueOnce(globalResponse.promise);
+
+ const groupAck = result.handleGroupAcknowledge([result.alerts()[0], result.alerts()[1]]);
+ const globalAck = result.handleBulkAcknowledge();
+ expect(AlertsAPI.bulkAcknowledge).toHaveBeenNthCalledWith(1, ['alert-1', 'alert-2']);
+ expect(AlertsAPI.bulkAcknowledge).toHaveBeenNthCalledWith(2, ['alert-3']);
+
+ globalResponse.resolve({ results: [{ alertIdentifier: 'alert-3', success: true }] });
+ await globalAck;
+ groupResponse.resolve({
+ results: [
+ { alertIdentifier: 'alert-1', success: true },
+ { alertIdentifier: 'alert-2', success: false },
+ ],
+ });
+ await groupAck;
+
+ expect(vi.mocked(notificationStore.success).mock.calls).toEqual([
+ ['Acknowledged 1 alert.'],
+ ['Acknowledged 1 alert.'],
+ ]);
+ expect(vi.mocked(notificationStore.error).mock.calls).toEqual([
+ ['Failed to acknowledge 1 alert.'],
+ ]);
+ expect(unacknowledgedIds(result)).toEqual(['alert-2']);
+ });
+
+ it('reports results for alerts resolved while the group request was out', async () => {
+ const { result } = renderWithAlertStore([
+ makeAlert('alert-1'),
+ makeAlert('alert-2'),
+ makeAlert('alert-3'),
+ ]);
+ const response = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge).mockReturnValueOnce(response.promise);
+
+ const settled = result.handleGroupAcknowledge(result.alerts());
+ result.serverResolves('alert-1');
+ result.serverResolves('alert-3');
+ response.resolve({
+ results: [
+ { alertIdentifier: 'alert-1', success: true },
+ { alertIdentifier: 'alert-2', success: true },
+ { alertIdentifier: 'alert-3', success: false },
+ ],
+ });
+ await settled;
+
+ // The store ignores a write for an alert it no longer holds, so a
+ // resolved alert does not come back as an acknowledged card.
+ expect(result.alerts().map((alert) => alert.id)).toEqual(['alert-2']);
+ expect(result.alerts()[0].acknowledged).toBe(true);
+ expect(notificationStore.success).toHaveBeenCalledWith(
+ getAlertOverviewBulkAcknowledgedNotification(2),
+ );
+ expect(notificationStore.error).toHaveBeenCalledWith('Failed to acknowledge 1 alert.');
+ });
+
+ it('reports a rejected group request once and releases its cards', async () => {
+ const { result } = renderWithAlertStore([makeAlert('alert-1'), makeAlert('alert-2')]);
+ const response = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge).mockReturnValueOnce(response.promise);
+
+ const settled = result.handleGroupAcknowledge(result.alerts());
+ response.reject(new Error('Service Unavailable'));
+ await settled;
+
+ expect(vi.mocked(notificationStore.error).mock.calls).toEqual([
+ [getAlertOverviewBulkAcknowledgeGenericFailureNotification()],
+ ]);
+ expect(notificationStore.success).not.toHaveBeenCalled();
+ expect(result.updateAlert).not.toHaveBeenCalled();
+ expect(result.processingAlerts().size).toBe(2);
+ vi.advanceTimersByTime(1500);
+ expect(result.processingAlerts().size).toBe(0);
+ });
+
+ it('still reports a group outcome that settles after the overview unmounts', async () => {
+ const { result, cleanup } = renderWithAlertStore([
+ makeAlert('alert-1'),
+ makeAlert('alert-2'),
+ ]);
+ const response = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge).mockReturnValueOnce(response.promise);
+
+ const settled = result.handleGroupAcknowledge(result.alerts());
+ cleanup();
+ response.resolve({
+ results: [
+ { alertIdentifier: 'alert-1', success: true },
+ { alertIdentifier: 'alert-2', success: true },
+ ],
+ });
+ await settled;
+
+ // The alert store and the notifications outlive the overview, so the
+ // request's outcome still lands after it closes.
+ expect(result.updateAlert).toHaveBeenCalledTimes(2);
+ expect(notificationStore.success).toHaveBeenCalledWith(
+ getAlertOverviewBulkAcknowledgedNotification(2),
+ );
+ expect(() => vi.advanceTimersByTime(1500)).not.toThrow();
+ });
+ });
+
+ describe('request ownership', () => {
+ it('shows the cards a global request carries as processing until it settles', async () => {
+ const { result } = renderWithAlertStore([makeAlert('alert-1'), makeAlert('alert-2')]);
+ const response = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge).mockReturnValueOnce(response.promise);
+
+ const globalAck = result.handleBulkAcknowledge();
+ expect(result.bulkAckProcessing()).toBe(true);
+ expect([...result.processingAlerts()]).toEqual(['alert-1', 'alert-2']);
+ await result.handleAlertAcknowledgement(result.alerts()[0]);
+ expect(AlertsAPI.acknowledge).not.toHaveBeenCalled();
+
+ response.resolve({
+ results: [
+ { alertIdentifier: 'alert-1', success: true },
+ { alertIdentifier: 'alert-2', success: false },
+ ],
+ });
+ await globalAck;
+
+ expect(vi.mocked(notificationStore.success).mock.calls).toEqual([['Acknowledged 1 alert.']]);
+ expect(vi.mocked(notificationStore.error).mock.calls).toEqual([
+ ['Failed to acknowledge 1 alert.'],
+ ]);
+ expect(result.bulkAckProcessing()).toBe(false);
+ // A settled global request holds nothing, so the failed alert is ready at once.
+ expect(result.processingAlerts().size).toBe(0);
+ expect(unacknowledgedIds(result)).toEqual(['alert-2']);
+ });
+
+ it('retries a failed global request at once', async () => {
+ const { result } = renderWithAlertStore([makeAlert('alert-1')]);
+ const retry = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge)
+ .mockRejectedValueOnce(new Error('Service Unavailable'))
+ .mockReturnValueOnce(retry.promise);
+
+ await result.handleBulkAcknowledge();
+ expect(vi.mocked(notificationStore.error).mock.calls).toEqual([
+ [getAlertOverviewBulkAcknowledgeGenericFailureNotification()],
+ ]);
+ expect(result.processingAlerts().size).toBe(0);
+
+ const retried = result.handleBulkAcknowledge();
+ expect(vi.mocked(AlertsAPI.bulkAcknowledge).mock.calls).toEqual([
+ [['alert-1']],
+ [['alert-1']],
+ ]);
+ retry.resolve({ results: [{ alertIdentifier: 'alert-1', success: true }] });
+ await retried;
+ expect(unacknowledgedIds(result)).toEqual([]);
+ });
+
+ it('keeps a retried alert busy when the earlier hold ends', async () => {
+ const { result } = renderWithAlertStore([makeAlert('alert-1')]);
+ const retry = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge)
+ .mockResolvedValueOnce({ results: [{ alertIdentifier: 'alert-1', success: false }] })
+ .mockReturnValueOnce(retry.promise);
+
+ await result.handleGroupAcknowledge(result.alerts());
+ expect(notificationStore.error).toHaveBeenCalledWith('Failed to acknowledge 1 alert.');
+
+ vi.advanceTimersByTime(500);
+ const retried = result.handleGroupAcknowledge(result.alerts());
+ expect(AlertsAPI.bulkAcknowledge).toHaveBeenCalledTimes(2);
+
+ // The first request's hold ends here while the retry is still out.
+ vi.advanceTimersByTime(1000);
+ expect(result.processingAlerts().has('alert-1')).toBe(true);
+ await result.handleAlertAcknowledgement(result.alerts()[0]);
+ expect(AlertsAPI.acknowledge).not.toHaveBeenCalled();
+
+ retry.resolve({ results: [{ alertIdentifier: 'alert-1', success: true }] });
+ await retried;
+ expect(unacknowledgedIds(result)).toEqual([]);
+ expect(result.processingAlerts().has('alert-1')).toBe(true);
+ vi.advanceTimersByTime(1500);
+ expect(result.processingAlerts().has('alert-1')).toBe(false);
+ });
+
+ it('leaves a restore its alert when its broadcast arrives before its response', async () => {
+ const { result } = renderWithAlertStore([
+ acknowledgedBy('alert-1', 'admin'),
+ makeAlert('alert-2'),
+ ]);
+ const restore = deferred<{ success: boolean }>();
+ const bulk = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.unacknowledge).mockReturnValueOnce(restore.promise);
+ vi.mocked(AlertsAPI.bulkAcknowledge).mockReturnValueOnce(bulk.promise);
+
+ const restoring = result.handleAlertAcknowledgement(result.alerts()[0]);
+ // The restore's own broadcast reaches the store before its HTTP response.
+ result.serverSends(makeAlert('alert-1'));
+ const globalAck = result.handleBulkAcknowledge();
+ expect(AlertsAPI.bulkAcknowledge).toHaveBeenCalledWith(['alert-2']);
+
+ restore.resolve({ success: true });
+ await restoring;
+ bulk.resolve({ results: [{ alertIdentifier: 'alert-2', success: true }] });
+ await globalAck;
+
+ expect(vi.mocked(notificationStore.success).mock.calls).toEqual([
+ ['Alert restored'],
+ ['Acknowledged 1 alert.'],
+ ]);
+ expect(unacknowledgedIds(result)).toEqual(['alert-1']);
+ });
+
+ it('keeps a pending group with the app when the overview remounts', async () => {
+ const store = createAlertStore([
+ makeAlert('alert-1'),
+ makeAlert('alert-2'),
+ makeAlert('alert-3'),
+ ]);
+ const acknowledgementRequests = createAlertAcknowledgementRequests();
+ const groupResponse = deferred<BulkAcknowledgeResult>();
+ const globalResponse = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge)
+ .mockReturnValueOnce(groupResponse.promise)
+ .mockReturnValueOnce(globalResponse.promise);
+
+ const first = renderOverview(store, acknowledgementRequests);
+ const groupAck = first.result.handleGroupAcknowledge([
+ first.result.alerts()[0],
+ first.result.alerts()[1],
+ ]);
+ first.cleanup();
+
+ const second = renderOverview(store, acknowledgementRequests);
+ expect([...second.result.processingAlerts()]).toEqual(['alert-1', 'alert-2']);
+ await second.result.handleAlertAcknowledgement(second.result.alerts()[0]);
+ await second.result.handleGroupAcknowledge([
+ second.result.alerts()[0],
+ second.result.alerts()[1],
+ ]);
+ const globalAck = second.result.handleBulkAcknowledge();
+ expect(AlertsAPI.acknowledge).not.toHaveBeenCalled();
+ expect(vi.mocked(AlertsAPI.bulkAcknowledge).mock.calls).toEqual([
+ [['alert-1', 'alert-2']],
+ [['alert-3']],
+ ]);
+
+ // The first view's request answers after the second view mounted.
+ groupResponse.resolve({
+ results: [
+ { alertIdentifier: 'alert-1', success: true },
+ { alertIdentifier: 'alert-2', success: false },
+ ],
+ });
+ await groupAck;
+ globalResponse.resolve({ results: [{ alertIdentifier: 'alert-3', success: true }] });
+ await globalAck;
+
+ expect(store.updateAlert).toHaveBeenCalledWith(
+ 'alert-1',
+ expect.objectContaining({ acknowledged: true }),
+ );
+ expect(vi.mocked(notificationStore.success).mock.calls).toEqual([
+ ['Acknowledged 1 alert.'],
+ ['Acknowledged 1 alert.'],
+ ]);
+ expect(vi.mocked(notificationStore.error).mock.calls).toEqual([
+ ['Failed to acknowledge 1 alert.'],
+ ]);
+ expect(unacknowledgedIds(second.result)).toEqual(['alert-2']);
+ expect(second.result.processingAlerts().has('alert-2')).toBe(true);
+ vi.advanceTimersByTime(1500);
+ expect(second.result.processingAlerts().size).toBe(0);
+ });
+
+ it('shows a global request from an earlier view as in progress', async () => {
+ const store = createAlertStore([makeAlert('alert-1'), makeAlert('alert-2')]);
+ const acknowledgementRequests = createAlertAcknowledgementRequests();
+ const response = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge).mockReturnValueOnce(response.promise);
+
+ const first = renderOverview(store, acknowledgementRequests);
+ const globalAck = first.result.handleBulkAcknowledge();
+ first.cleanup();
+
+ const second = renderOverview(store, acknowledgementRequests);
+ expect(second.result.bulkAckProcessing()).toBe(true);
+ expect([...second.result.processingAlerts()]).toEqual(['alert-1', 'alert-2']);
+ await second.result.handleBulkAcknowledge();
+ await second.result.handleAlertAcknowledgement(second.result.alerts()[0]);
+ expect(AlertsAPI.bulkAcknowledge).toHaveBeenCalledTimes(1);
+ expect(AlertsAPI.acknowledge).not.toHaveBeenCalled();
+
+ response.resolve({
+ results: [
+ { alertIdentifier: 'alert-1', success: true },
+ { alertIdentifier: 'alert-2', success: true },
+ ],
+ });
+ await globalAck;
+
+ expect(second.result.bulkAckProcessing()).toBe(false);
+ expect(unacknowledgedIds(second.result)).toEqual([]);
+ expect(notificationStore.success).toHaveBeenCalledWith(
+ getAlertOverviewBulkAcknowledgedNotification(2),
+ );
+ });
+
+ it('keeps a request to the app that owns it', async () => {
+ const appRequests = createAlertAcknowledgementRequests();
+ const appResponse = deferred<BulkAcknowledgeResult>();
+ const otherResponse = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.bulkAcknowledge)
+ .mockReturnValueOnce(appResponse.promise)
+ .mockReturnValueOnce(otherResponse.promise);
+
+ const app = renderOverview(createAlertStore([makeAlert('alert-1')]), appRequests);
+ const other = renderOverview(
+ createAlertStore([makeAlert('alert-1')]),
+ createAlertAcknowledgementRequests(),
+ );
+ const appAck = app.result.handleGroupAcknowledge(app.result.alerts());
+ // Another app (or test) with its own owner is not held by this request.
+ const otherAck = other.result.handleGroupAcknowledge(other.result.alerts());
+ expect(AlertsAPI.bulkAcknowledge).toHaveBeenCalledTimes(2);
+
+ appRequests.reset();
+ expect(app.result.processingAlerts().size).toBe(0);
+ expect(other.result.processingAlerts().has('alert-1')).toBe(true);
+
+ appResponse.resolve({ results: [{ alertIdentifier: 'alert-1', success: true }] });
+ otherResponse.resolve({ results: [{ alertIdentifier: 'alert-1', success: true }] });
+ await Promise.all([appAck, otherAck]);
+ expect(unacknowledgedIds(app.result)).toEqual(['alert-1']);
+ expect(unacknowledgedIds(other.result)).toEqual([]);
+ expect(vi.mocked(notificationStore.success).mock.calls).toEqual([['Acknowledged 1 alert.']]);
+ });
+
+ it('drops responses from an ended alert scope without touching the next one', async () => {
+ const ids = ['alert-1', 'alert-2', 'alert-3', 'alert-4'];
+ const { result, store, acknowledgementRequests } = renderWithAlertStore(
+ ids.map((id) => makeAlert(id)),
+ );
+ vi.mocked(logger.error).mockClear();
+ const oldCard = deferred<{ success: boolean }>();
+ const oldGroup = deferred<BulkAcknowledgeResult>();
+ const oldGlobal = deferred<BulkAcknowledgeResult>();
+ const newGlobal = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.acknowledge).mockReturnValueOnce(oldCard.promise);
+ vi.mocked(AlertsAPI.bulkAcknowledge)
+ .mockReturnValueOnce(oldGroup.promise)
+ .mockReturnValueOnce(oldGlobal.promise)
+ .mockReturnValueOnce(newGlobal.promise);
+
+ const cardAck = result.handleAlertAcknowledgement(result.alerts()[0]);
+ const groupAck = result.handleGroupAcknowledge([result.alerts()[1], result.alerts()[2]]);
+ const globalAck = result.handleBulkAcknowledge();
+ expect(vi.mocked(AlertsAPI.bulkAcknowledge).mock.calls).toEqual([
+ [['alert-2', 'alert-3']],
+ [['alert-4']],
+ ]);
+
+ // An organization switch: the scope ends and the next one holds alerts
+ // with the same identifiers.
+ acknowledgementRequests.reset();
+ ids.forEach((id) => store.serverSends({ ...makeAlert(id), message: `next scope ${id}` }));
+ expect(result.processingAlerts().size).toBe(0);
+ expect(result.bulkAckProcessing()).toBe(false);
+ const nextAck = result.handleBulkAcknowledge();
+ expect(vi.mocked(AlertsAPI.bulkAcknowledge).mock.calls.at(-1)).toEqual([ids]);
+
+ // The old scope answers: a success, a partial failure and a rejection.
+ oldCard.resolve({ success: true });
+ oldGroup.resolve({
+ results: [
+ { alertIdentifier: 'alert-2', success: true },
+ { alertIdentifier: 'alert-3', success: false },
+ ],
+ });
+ oldGlobal.reject(new Error('Service Unavailable'));
+ await Promise.all([cardAck, groupAck, globalAck]);
+
+ expect(store.updateAlert).not.toHaveBeenCalled();
+ expect(notificationStore.success).not.toHaveBeenCalled();
+ expect(notificationStore.error).not.toHaveBeenCalled();
+ // The rejection is still logged; it reaches no one's screen.
+ expect(logger.error).toHaveBeenCalledWith('Bulk acknowledge failed', expect.any(Error));
+ expect(unacknowledgedIds(result)).toEqual(ids);
+ // Nothing the next scope's request carries was released.
+ expect([...result.processingAlerts()]).toEqual(ids);
+ expect(result.bulkAckProcessing()).toBe(true);
+
+ newGlobal.resolve({
+ results: ids.map((alertIdentifier) => ({ alertIdentifier, success: true })),
+ });
+ await nextAck;
+ expect(store.updateAlert).toHaveBeenCalledTimes(4);
+ expect(vi.mocked(notificationStore.success).mock.calls).toEqual([
+ [getAlertOverviewBulkAcknowledgedNotification(4)],
+ ]);
+ expect(unacknowledgedIds(result)).toEqual([]);
+ expect(result.alerts().map((alert) => alert.message)).toEqual(
+ ids.map((id) => `next scope ${id}`),
+ );
+ });
+ });
});
diff --git a/frontend-modern/src/features/alerts/__tests__/useAlertOverviewState.test.tsx b/frontend-modern/src/features/alerts/__tests__/useAlertOverviewState.test.tsx
index a037ebe31e..0043e40355 100644
--- a/frontend-modern/src/features/alerts/__tests__/useAlertOverviewState.test.tsx
+++ b/frontend-modern/src/features/alerts/__tests__/useAlertOverviewState.test.tsx
@@ -4,6 +4,7 @@ import { createStore, reconcile } from 'solid-js/store';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { AlertsAPI } from '@/api/alerts';
+import { createAlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
import { notificationStore } from '@/stores/notifications';
import type { Alert, AlertDeliveryDiagnosis } from '@/types/api';
import { RELATIVE_TIME_TICK_MS } from '@/utils/relativeTimeClock';
@@ -78,6 +79,7 @@ describe('useAlertOverviewState', () => {
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledOnce();
@@ -107,6 +109,7 @@ describe('useAlertOverviewState', () => {
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
await Promise.resolve();
@@ -126,6 +129,7 @@ describe('useAlertOverviewState', () => {
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledOnce();
@@ -148,6 +152,7 @@ describe('useAlertOverviewState', () => {
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
cleanup();
@@ -189,6 +194,7 @@ describe('useAlertOverviewState', () => {
overrides: () => [],
showAcknowledged,
updateAlert,
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
@@ -257,6 +263,7 @@ describe('useAlertOverviewState', () => {
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
@@ -278,6 +285,7 @@ describe('useAlertOverviewState', () => {
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
@@ -318,6 +326,7 @@ describe('useAlertOverviewState', () => {
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
@@ -365,6 +374,7 @@ describe('useAlertOverviewState', () => {
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
@@ -390,6 +400,7 @@ describe('useAlertOverviewState', () => {
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
@@ -409,6 +420,7 @@ describe('useAlertOverviewState', () => {
overrides: () => [],
showAcknowledged: () => true,
updateAlert: vi.fn(),
+ acknowledgementRequests: createAlertAcknowledgementRequests(),
}),
);
diff --git a/frontend-modern/src/features/alerts/useAlertAcknowledgementState.ts b/frontend-modern/src/features/alerts/useAlertAcknowledgementState.ts
index 88c7d3e225..a224f57c3d 100644
--- a/frontend-modern/src/features/alerts/useAlertAcknowledgementState.ts
+++ b/frontend-modern/src/features/alerts/useAlertAcknowledgementState.ts
@@ -1,7 +1,11 @@
-import { createMemo, createSignal, onCleanup } from 'solid-js';
+import { createMemo } from 'solid-js';
import type { Accessor } from 'solid-js';
import { AlertsAPI } from '@/api/alerts';
+import type {
+ AlertAcknowledgementRequest,
+ AlertAcknowledgementRequests,
+} from '@/stores/alertAcknowledgementRequests';
import { notificationStore } from '@/stores/notifications';
import type { Alert } from '@/types/api';
import {
@@ -16,6 +20,8 @@ import { logger } from '@/utils/logger';
import { getCanonicalAlertId } from './identity';
+type BulkAcknowledgeResult = Awaited<ReturnType<typeof AlertsAPI.bulkAcknowledge>>;
+
export interface UseAlertAcknowledgementStateProps {
alerts: Accessor<Alert[]>;
// The shared alert store owns the optimistic acknowledgement: it holds back
@@ -23,43 +29,56 @@ export interface UseAlertAcknowledgementStateProps {
// (an unacknowledge from another session) through. Keep no second copy
// here; one would outlive that confirmation and hide those changes.
updateAlert: (alertIdentifier: string, updates: Partial<Alert>) => void;
+ // The alert store's record of which request carries each alert. It outlives
+ // this view, so a remounted overview neither resends an alert in flight nor
+ // shows it idle, and the request that carries an alert reports its outcome.
+ acknowledgementRequests: AlertAcknowledgementRequests;
allowRestore?: boolean;
}
export function useAlertAcknowledgementState(props: UseAlertAcknowledgementStateProps) {
- const [processingAlerts, setProcessingAlerts] = createSignal<Set<string>>(new Set());
- const [bulkAckProcessing, setBulkAckProcessing] = createSignal(false);
- const processingReleaseTimers = new Map<string, ReturnType<typeof setTimeout>>();
-
- const clearProcessingReleaseTimer = (alertIdentifier: string) => {
- const timer = processingReleaseTimers.get(alertIdentifier);
- if (timer === undefined) {
- return;
- }
- clearTimeout(timer);
- processingReleaseTimers.delete(alertIdentifier);
- };
-
- onCleanup(() => {
- processingReleaseTimers.forEach((timer) => clearTimeout(timer));
- processingReleaseTimers.clear();
- });
+ const requests = props.acknowledgementRequests;
+ // Busy state follows the requests themselves, so an older request's hold
+ // cannot mark an alert idle while a newer request still carries it.
+ const processingAlerts = createMemo(() => requests.processingAlerts());
+ const bulkAckProcessing = createMemo(() => requests.bulkInFlight());
const unacknowledgedAlerts = createMemo(() =>
props.alerts().filter((alert) => !alert.acknowledged),
);
- const releaseAlertProcessing = (alertIdentifier: string) => {
- clearProcessingReleaseTimer(alertIdentifier);
- const timer = setTimeout(() => {
- processingReleaseTimers.delete(alertIdentifier);
- setProcessingAlerts((previous) => {
- const next = new Set(previous);
- next.delete(alertIdentifier);
- return next;
+ // Global and group actions share the bulk endpoint, so they read its
+ // per-alert results one way: a partial result reports both counts. A
+ // response from an ended alert scope (an organization switch or shutdown)
+ // neither writes nor reports: the store and the notifications now belong
+ // to another scope, whose alerts can share these identifiers.
+ const applyBulkAcknowledgeResult = (
+ request: AlertAcknowledgementRequest,
+ result: BulkAcknowledgeResult,
+ ) => {
+ if (!requests.isCurrent(request)) {
+ return;
+ }
+
+ const acknowledgedAt = new Date().toISOString();
+ const successes = result.results.filter((entry) => entry.success);
+ const failures = result.results.filter((entry) => !entry.success);
+
+ successes.forEach((entry) => {
+ props.updateAlert(entry.alertIdentifier, {
+ acknowledged: true,
+ ackTime: acknowledgedAt,
+ ackUser: undefined,
});
- }, 1500);
- processingReleaseTimers.set(alertIdentifier, timer);
+ });
+
+ if (successes.length > 0) {
+ notificationStore.success(getAlertOverviewBulkAcknowledgedNotification(successes.length));
+ }
+
+ if (failures.length > 0) {
+ notificationStore.error(getAlertOverviewBulkAcknowledgeFailureNotification(failures.length));
+ }
};
const handleAlertAcknowledgement = async (alert: Alert) => {
@@ -75,31 +94,44 @@ export function useAlertAcknowledgementState(props: UseAlertAcknowledgementState
return;
}
- setProcessingAlerts((previous) => new Set(previous).add(alertIdentifier));
+ // Another request that carries this alert reports its outcome.
+ const request = requests.claim('alert', [alertIdentifier]);
+ if (!request) {
+ return;
+ }
try {
if (wasAcknowledged) {
await AlertsAPI.unacknowledge(alertIdentifier);
- props.updateAlert(alertIdentifier, {
- acknowledged: false,
- ackTime: undefined,
- ackUser: undefined,
- });
- notificationStore.success(getAlertOverviewRestoredNotification());
+ // A response from an ended alert scope neither writes nor reports.
+ if (requests.isCurrent(request)) {
+ props.updateAlert(alertIdentifier, {
+ acknowledged: false,
+ ackTime: undefined,
+ ackUser: undefined,
+ });
+ notificationStore.success(getAlertOverviewRestoredNotification());
+ }
} else {
await AlertsAPI.acknowledge(alertIdentifier);
- props.updateAlert(alertIdentifier, {
- acknowledged: true,
- ackTime: new Date().toISOString(),
- ackUser: undefined,
- });
- notificationStore.success(getAlertOverviewAcknowledgedNotification());
+ if (requests.isCurrent(request)) {
+ props.updateAlert(alertIdentifier, {
+ acknowledged: true,
+ ackTime: new Date().toISOString(),
+ ackUser: undefined,
+ });
+ notificationStore.success(getAlertOverviewAcknowledgedNotification());
+ }
}
} catch (error) {
logger.error(`Failed to ${wasAcknowledged ? 'unacknowledge' : 'acknowledge'} alert:`, error);
- notificationStore.error(getAlertOverviewAcknowledgementFailureNotification(wasAcknowledged));
+ if (requests.isCurrent(request)) {
+ notificationStore.error(
+ getAlertOverviewAcknowledgementFailureNotification(wasAcknowledged),
+ );
+ }
} finally {
- releaseAlertProcessing(alertIdentifier);
+ requests.release(request);
}
};
@@ -108,42 +140,25 @@ export function useAlertAcknowledgementState(props: UseAlertAcknowledgementState
return;
}
- const pendingAlerts = unacknowledgedAlerts();
- if (pendingAlerts.length === 0) {
+ // Alerts a card or group request carries stay with it.
+ const request = requests.claim(
+ 'bulk',
+ unacknowledgedAlerts().map((alert) => getCanonicalAlertId(alert)),
+ );
+ if (!request) {
return;
}
- setBulkAckProcessing(true);
try {
- const result = await AlertsAPI.bulkAcknowledge(
- pendingAlerts.map((alert) => getCanonicalAlertId(alert)),
- );
- const acknowledgedAt = new Date().toISOString();
- const successes = result.results.filter((entry) => entry.success);
- const failures = result.results.filter((entry) => !entry.success);
-
- successes.forEach((entry) => {
- props.updateAlert(entry.alertIdentifier, {
- acknowledged: true,
- ackTime: acknowledgedAt,
- ackUser: undefined,
- });
- });
-
- if (successes.length > 0) {
- notificationStore.success(getAlertOverviewBulkAcknowledgedNotification(successes.length));
- }
-
- if (failures.length > 0) {
- notificationStore.error(
- getAlertOverviewBulkAcknowledgeFailureNotification(failures.length),
- );
- }
+ const result = await AlertsAPI.bulkAcknowledge([...request.alertIdentifiers]);
+ applyBulkAcknowledgeResult(request, result);
} catch (error) {
logger.error('Bulk acknowledge failed', error);
- notificationStore.error(getAlertOverviewBulkAcknowledgeGenericFailureNotification());
+ if (requests.isCurrent(request)) {
+ notificationStore.error(getAlertOverviewBulkAcknowledgeGenericFailureNotification());
+ }
} finally {
- setBulkAckProcessing(false);
+ requests.release(request);
}
};
@@ -152,33 +167,23 @@ export function useAlertAcknowledgementState(props: UseAlertAcknowledgementState
const id = getCanonicalAlertId(alert);
return !props.alerts().find((e) => getCanonicalAlertId(e) === id)?.acknowledged;
});
- if (pending.length === 0) return;
-
- const identifiers = pending.map((alert) => getCanonicalAlertId(alert));
- const groupProcessing = new Set(identifiers);
- setProcessingAlerts((previous) => new Set([...previous, ...groupProcessing]));
+ // Alerts another request carries stay with it.
+ const request = requests.claim(
+ 'group',
+ pending.map((alert) => getCanonicalAlertId(alert)),
+ );
+ if (!request) return;
try {
- const result = await AlertsAPI.bulkAcknowledge(identifiers);
- const acknowledgedAt = new Date().toISOString();
- const successes = result.results.filter((entry) => entry.success);
-
- successes.forEach((entry) => {
- props.updateAlert(entry.alertIdentifier, {
- acknowledged: true,
- ackTime: acknowledgedAt,
- ackUser: undefined,
- });
- });
-
- if (successes.length > 0) {
- notificationStore.success(getAlertOverviewBulkAcknowledgedNotification(successes.length));
- }
+ const result = await AlertsAPI.bulkAcknowledge([...request.alertIdentifiers]);
+ applyBulkAcknowledgeResult(request, result);
} catch (error) {
logger.error('Group acknowledge failed', error);
- notificationStore.error(getAlertOverviewBulkAcknowledgeGenericFailureNotification());
+ if (requests.isCurrent(request)) {
+ notificationStore.error(getAlertOverviewBulkAcknowledgeGenericFailureNotification());
+ }
} finally {
- groupProcessing.forEach((id) => releaseAlertProcessing(id));
+ requests.release(request);
}
};
diff --git a/frontend-modern/src/features/alerts/useAlertOverviewState.ts b/frontend-modern/src/features/alerts/useAlertOverviewState.ts
index 0424aba4da..a472970bbf 100644
--- a/frontend-modern/src/features/alerts/useAlertOverviewState.ts
+++ b/frontend-modern/src/features/alerts/useAlertOverviewState.ts
@@ -2,6 +2,7 @@ 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';
@@ -32,6 +33,7 @@ export interface UseAlertOverviewStateProps {
overrides: Accessor<Override[]>;
showAcknowledged: Accessor<boolean>;
updateAlert: (alertIdentifier: string, updates: Partial<Alert>) => void;
+ acknowledgementRequests: AlertAcknowledgementRequests;
}
export function useAlertOverviewState(props: UseAlertOverviewStateProps) {
@@ -47,6 +49,7 @@ export function useAlertOverviewState(props: UseAlertOverviewStateProps) {
} = useAlertAcknowledgementState({
alerts: activeAlerts,
updateAlert: props.updateAlert,
+ acknowledgementRequests: props.acknowledgementRequests,
allowRestore: true,
});
const {
diff --git a/frontend-modern/src/pages/Alerts.tsx b/frontend-modern/src/pages/Alerts.tsx
index 90c5733959..1becee87d5 100644
--- a/frontend-modern/src/pages/Alerts.tsx
+++ b/frontend-modern/src/pages/Alerts.tsx
@@ -55,6 +55,7 @@ export function Alerts() {
refreshActiveAlerts,
updateAlert,
removeAlerts,
+ alertAcknowledgementRequests,
} = useWebSocket();
const { get: getResource, resources: allResources, byType, children } = useResources();
const navigate = useNavigate();
@@ -425,6 +426,7 @@ export function Alerts() {
overrides={overviewOverrides()}
activeAlerts={activeAlerts}
updateAlert={updateAlert}
+ acknowledgementRequests={alertAcknowledgementRequests}
showQuickTip={showQuickTip}
dismissQuickTip={dismissQuickTip}
showAcknowledged={showAcknowledged}
diff --git a/frontend-modern/src/pages/__tests__/Alerts.readOnly.test.tsx b/frontend-modern/src/pages/__tests__/Alerts.readOnly.test.tsx
index 5b63554d60..5068020dfe 100644
--- a/frontend-modern/src/pages/__tests__/Alerts.readOnly.test.tsx
+++ b/frontend-modern/src/pages/__tests__/Alerts.readOnly.test.tsx
@@ -2,6 +2,7 @@ import { cleanup, render, screen, waitFor } from '@solidjs/testing-library';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { Alerts } from '@/pages/Alerts';
+import { createAlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
import alertsPageSource from '@/pages/Alerts.tsx?raw';
import alertHistoryFiltersCardSource from '@/features/alerts/AlertHistoryFiltersCard.tsx?raw';
@@ -14,8 +15,10 @@ const locationState = vi.hoisted(() => ({
search: '',
query: {},
}));
+// The store's request owner, one per test, as the app keeps one per store.
+const storeFixture = vi.hoisted(() => ({ alertAcknowledgementRequests: undefined as unknown }));
const overviewTabSpy = vi.hoisted(() =>
- vi.fn((props: { alertsDisabled: () => boolean }) => (
+ vi.fn((props: { alertsDisabled: () => boolean; acknowledgementRequests?: unknown }) => (
<div data-testid="overview-tab">{props.alertsDisabled() ? 'disabled' : 'enabled'}</div>
)),
);
@@ -41,6 +44,7 @@ vi.mock('@/contexts/appRuntime', () => ({
refreshActiveAlerts: vi.fn(async () => undefined),
updateAlert: vi.fn(),
removeAlerts: vi.fn(),
+ alertAcknowledgementRequests: storeFixture.alertAcknowledgementRequests,
}),
}));
@@ -118,10 +122,20 @@ describe('Alerts read-only presentation', () => {
locationState.pathname = '/alerts';
locationState.hash = '';
locationState.search = '';
+ storeFixture.alertAcknowledgementRequests = createAlertAcknowledgementRequests();
});
afterEach(() => cleanup());
+ it('hands the store acknowledgement requests to the overview', async () => {
+ render(() => <Alerts />);
+
+ expect(await screen.findByTestId('overview-tab')).toBeInTheDocument();
+ expect(overviewTabSpy.mock.calls.at(-1)?.[0].acknowledgementRequests).toBe(
+ storeFixture.alertAcknowledgementRequests,
+ );
+ });
+
it('keeps alert history narrowing URL-owned with no saved-views affordance', () => {
// Saved views stored the page's URL query string in localStorage. Bookmarks
// already do that, and better, so the control was removed; history filters
diff --git a/frontend-modern/src/stores/__tests__/alertAcknowledgementRequests.test.ts b/frontend-modern/src/stores/__tests__/alertAcknowledgementRequests.test.ts
new file mode 100644
index 0000000000..3375dd84ae
--- /dev/null
+++ b/frontend-modern/src/stores/__tests__/alertAcknowledgementRequests.test.ts
@@ -0,0 +1,99 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { createAlertAcknowledgementRequests } from '../alertAcknowledgementRequests';
+
+describe('createAlertAcknowledgementRequests', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it('gives each alert to one unsettled request', () => {
+ const requests = createAlertAcknowledgementRequests();
+
+ const group = requests.claim('group', ['a', 'b', 'a']);
+ expect(group?.alertIdentifiers).toEqual(['a', 'b']);
+ const bulk = requests.claim('bulk', ['b', 'c']);
+ expect(bulk?.alertIdentifiers).toEqual(['c']);
+ expect(requests.claim('alert', ['a'])).toBeNull();
+ expect(requests.isOwned('c')).toBe(true);
+ expect(requests.isOwned('d')).toBe(false);
+
+ // A card shows every unsettled request's alerts as processing.
+ expect([...requests.processingAlerts()]).toEqual(['a', 'b', 'c']);
+ expect(requests.bulkInFlight()).toBe(true);
+ });
+
+ it('releases exactly one request and holds its card or group alerts briefly', () => {
+ const requests = createAlertAcknowledgementRequests();
+ const group = requests.claim('group', ['a'])!;
+ const bulk = requests.claim('bulk', ['b'])!;
+ expect(requests.processingAlerts().has('b')).toBe(true);
+
+ // A global request frees its alerts at once; only card and group requests hold.
+ requests.release(bulk);
+ expect(requests.bulkInFlight()).toBe(false);
+ expect(requests.isOwned('b')).toBe(false);
+ expect(requests.isOwned('a')).toBe(true);
+ expect(requests.processingAlerts().has('b')).toBe(false);
+
+ requests.release(group);
+ expect(requests.isCurrent(group)).toBe(false);
+ expect(requests.isOwned('a')).toBe(false);
+ expect(requests.processingAlerts().has('a')).toBe(true);
+ // Releasing again changes nothing, the hold included.
+ vi.advanceTimersByTime(1000);
+ requests.release(group);
+ vi.advanceTimersByTime(500);
+ expect(requests.processingAlerts().size).toBe(0);
+ });
+
+ it('keeps an alert busy while a newer request carries it after an older hold ends', () => {
+ const requests = createAlertAcknowledgementRequests();
+ const failed = requests.claim('group', ['a'])!;
+ requests.release(failed);
+
+ vi.advanceTimersByTime(500);
+ const retry = requests.claim('group', ['a'])!;
+ vi.advanceTimersByTime(1000);
+ expect(requests.processingAlerts().has('a')).toBe(true);
+
+ requests.release(retry);
+ vi.advanceTimersByTime(1499);
+ expect(requests.processingAlerts().has('a')).toBe(true);
+ vi.advanceTimersByTime(1);
+ expect(requests.processingAlerts().has('a')).toBe(false);
+ });
+
+ it('drops every claim and hold when its alert scope ends', () => {
+ const requests = createAlertAcknowledgementRequests();
+ const held = requests.claim('alert', ['a'])!;
+ requests.release(held);
+ const pending = requests.claim('group', ['b'])!;
+
+ requests.reset();
+ expect(requests.processingAlerts().size).toBe(0);
+ expect(requests.isOwned('b')).toBe(false);
+ expect(requests.isCurrent(pending)).toBe(false);
+
+ // The next scope claims the same alert; the old request's release frees nothing.
+ const next = requests.claim('group', ['b'])!;
+ requests.release(pending);
+ expect(requests.isCurrent(next)).toBe(true);
+ expect(requests.isOwned('b')).toBe(true);
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
+ it('shares nothing between separate owners', () => {
+ const app = createAlertAcknowledgementRequests();
+ const other = createAlertAcknowledgementRequests();
+
+ expect(app.claim('bulk', ['a'])).not.toBeNull();
+ expect(other.claim('bulk', ['a'])).not.toBeNull();
+ app.reset();
+ expect(other.bulkInFlight()).toBe(true);
+ });
+});
diff --git a/frontend-modern/src/stores/__tests__/websocket-global.noopLifetime.test.ts b/frontend-modern/src/stores/__tests__/websocket-global.noopLifetime.test.ts
new file mode 100644
index 0000000000..674036f35c
--- /dev/null
+++ b/frontend-modern/src/stores/__tests__/websocket-global.noopLifetime.test.ts
@@ -0,0 +1,76 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { getGlobalWebSocketStore, shutdownGlobalWebSocketStore } from '@/stores/websocket-global';
+
+// In a jsdom test window the shared app store is the no-op store. An inert
+// WebSocket stand-in keeps any other runtime from reaching the network, and
+// the first test says which store this is. Each test ends the shared app it
+// used, so nothing it left behind reaches the next one.
+const InertWebSocket = vi.fn().mockImplementation(function () {
+ return { readyState: 0, send: vi.fn(), close: vi.fn() };
+});
+
+describe('the shared no-op app store', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ vi.stubGlobal('WebSocket', InertWebSocket);
+ shutdownGlobalWebSocketStore();
+ });
+
+ afterEach(() => {
+ shutdownGlobalWebSocketStore();
+ vi.useRealTimers();
+ vi.unstubAllGlobals();
+ });
+
+ it('is the no-op store in the test window', () => {
+ expect(window.navigator.userAgent).toMatch(/jsdom/i);
+ const store = getGlobalWebSocketStore();
+ expect(store.initialDataReceived()).toBe(true);
+ expect(store.connected()).toBe(false);
+ expect(InertWebSocket).not.toHaveBeenCalled();
+ });
+
+ it('keeps one request owner for the app', () => {
+ const store = getGlobalWebSocketStore();
+ expect(getGlobalWebSocketStore()).toBe(store);
+ expect(getGlobalWebSocketStore().alertAcknowledgementRequests).toBe(
+ store.alertAcknowledgementRequests,
+ );
+ });
+
+ it('drops the request owner when the app shuts down, as the real store does', () => {
+ const store = getGlobalWebSocketStore();
+ const requests = store.alertAcknowledgementRequests;
+ requests.claim('group', ['a']);
+
+ store.shutdown();
+ expect(requests.isOwned('a')).toBe(false);
+ expect(requests.processingAlerts().size).toBe(0);
+ });
+
+ it('ends a discarded hold and a pending claim with the app that held them', () => {
+ const first = getGlobalWebSocketStore();
+ const firstRequests = first.alertAcknowledgementRequests;
+ const pending = firstRequests.claim('group', ['a'])!;
+ firstRequests.release(firstRequests.claim('alert', ['b'])!);
+ expect([...firstRequests.processingAlerts()].sort()).toEqual(['a', 'b']);
+
+ // A test that ends here leaves the pending claim and the hold behind; its
+ // fake timer for the hold never runs.
+ vi.useRealTimers();
+ shutdownGlobalWebSocketStore();
+ expect(firstRequests.processingAlerts().size).toBe(0);
+
+ const next = getGlobalWebSocketStore();
+ expect(next).not.toBe(first);
+ const nextRequests = next.alertAcknowledgementRequests;
+ expect(nextRequests).not.toBe(firstRequests);
+ expect(nextRequests.processingAlerts().size).toBe(0);
+ expect(nextRequests.claim('group', ['a', 'b'])?.alertIdentifiers).toEqual(['a', 'b']);
+
+ // The old app's request settling late frees nothing in the next one.
+ firstRequests.release(pending);
+ expect(nextRequests.isOwned('a')).toBe(true);
+ });
+});
diff --git a/frontend-modern/src/stores/__tests__/websocket.alertAcknowledgementRequests.test.ts b/frontend-modern/src/stores/__tests__/websocket.alertAcknowledgementRequests.test.ts
new file mode 100644
index 0000000000..c665082be9
--- /dev/null
+++ b/frontend-modern/src/stores/__tests__/websocket.alertAcknowledgementRequests.test.ts
@@ -0,0 +1,361 @@
+import { renderHook } from '@solidjs/testing-library';
+import { createMemo, createRoot } from 'solid-js';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { AlertsAPI } from '@/api/alerts';
+import { useAlertAcknowledgementState } from '@/features/alerts/useAlertAcknowledgementState';
+import { notificationStore } from '@/stores/notifications';
+import type { Alert } from '@/types/api';
+import { getAlertOverviewBulkAcknowledgedNotification } from '@/utils/alertOverviewPresentation';
+import { logger } from '@/utils/logger';
+
+// The real alert store owns the acknowledgement request record. These tests
+// build it over the same inert WebSocket stand-in as websocket-unified.test.ts:
+// no socket opens and no request leaves the test.
+const apiFetchJSONMock = vi.fn();
+vi.mock('@/utils/apiClient', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('@/utils/apiClient')>();
+ return {
+ ...actual,
+ apiFetchJSON: (...args: unknown[]) => apiFetchJSONMock(...args),
+ };
+});
+
+vi.mock('@/api/alerts', () => ({
+ AlertsAPI: {
+ acknowledge: vi.fn(),
+ bulkAcknowledge: vi.fn(),
+ unacknowledge: vi.fn(),
+ },
+}));
+
+vi.mock('@/stores/notifications', () => ({
+ notificationStore: {
+ error: vi.fn(),
+ success: vi.fn(),
+ info: vi.fn(),
+ warning: vi.fn(),
+ },
+}));
+
+interface MockWebSocketInstance {
+ url: string;
+ readyState: number;
+ send: ReturnType<typeof vi.fn>;
+ close: ReturnType<typeof vi.fn>;
+ onopen: ((event: Event) => void) | null;
+ onmessage: ((event: MessageEvent) => void) | null;
+ onclose: ((event: CloseEvent) => void) | null;
+ onerror: ((event: Event) => void) | null;
+}
+
+let mockWsInstance: MockWebSocketInstance | null = null;
+
+const MockWebSocket = vi.fn().mockImplementation(function (url: string): MockWebSocketInstance {
+ const instance: MockWebSocketInstance = {
+ url,
+ readyState: 1,
+ send: vi.fn(),
+ close: vi.fn(),
+ onopen: null,
+ onmessage: null,
+ onclose: null,
+ onerror: null,
+ };
+ mockWsInstance = instance;
+ setTimeout(() => {
+ instance.onopen?.({} as Event);
+ }, 0);
+ return instance;
+});
+
+const installWebSocketMock = () => {
+ vi.stubGlobal(
+ 'WebSocket',
+ Object.assign(MockWebSocket, { CONNECTING: 0, OPEN: 1, CLOSING: 2, CLOSED: 3 }),
+ );
+};
+
+const waitForOpenTick = async () => {
+ vi.advanceTimersByTime(1);
+ await Promise.resolve();
+};
+
+const emitInitialAlerts = (lastUpdate: number, activeAlerts: unknown[]) => {
+ if (!mockWsInstance?.onmessage) {
+ throw new Error('WebSocket onmessage handler is not initialized');
+ }
+ mockWsInstance.onmessage({
+ data: JSON.stringify({
+ type: 'initialState',
+ data: { resources: [], lastUpdate, activeAlerts, recentlyResolved: [] },
+ }),
+ } as MessageEvent);
+};
+
+const createStoreHarness = async () => {
+ const { createWebSocketStore } = await import('@/stores/websocket');
+ let dispose = () => {};
+ const store = createRoot((d) => {
+ dispose = d;
+ return createWebSocketStore('ws://localhost/ws');
+ });
+ return { store, dispose };
+};
+
+const alertPayload = (id: string, message: string) => ({
+ id,
+ type: 'cpu',
+ level: 'warning',
+ resourceId: `vm-${id}`,
+ resourceName: `VM ${id}`,
+ node: 'node-1',
+ message,
+ startTime: '2026-10-30T10:00:00Z',
+ acknowledged: false,
+});
+
+type BulkAcknowledgeResult = Awaited<ReturnType<typeof AlertsAPI.bulkAcknowledge>>;
+
+function deferred<T>() {
+ let resolve!: (value: T) => void;
+ let reject!: (reason: unknown) => void;
+ const promise = new Promise<T>((settle, fail) => {
+ resolve = settle;
+ reject = fail;
+ });
+ return { promise, resolve, reject };
+}
+
+describe('alert store acknowledgement request lifetime', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ vi.resetModules();
+ mockWsInstance = null;
+ MockWebSocket.mockClear();
+ apiFetchJSONMock.mockReset();
+ vi.mocked(AlertsAPI.acknowledge).mockReset();
+ vi.mocked(AlertsAPI.bulkAcknowledge).mockReset();
+ vi.mocked(notificationStore.success).mockReset();
+ vi.mocked(notificationStore.error).mockReset();
+ installWebSocketMock();
+ });
+
+ afterEach(() => {
+ vi.clearAllTimers();
+ vi.useRealTimers();
+ vi.unstubAllGlobals();
+ });
+
+ it('keeps one request owner for the store and drops it on an organization switch', async () => {
+ const { store, dispose } = await createStoreHarness();
+ try {
+ await waitForOpenTick();
+ const requests = store.alertAcknowledgementRequests;
+ expect(store.alertAcknowledgementRequests).toBe(requests);
+
+ const settled = requests.claim('group', ['a'])!;
+ requests.release(settled);
+ const pending = requests.claim('bulk', ['b'])!;
+ expect([...requests.processingAlerts()]).toEqual(['a', 'b']);
+
+ store.switchUrl('ws://localhost/ws?org=another');
+ expect(store.alertAcknowledgementRequests).toBe(requests);
+ expect(requests.processingAlerts().size).toBe(0);
+ expect(requests.bulkInFlight()).toBe(false);
+ expect(requests.isCurrent(pending)).toBe(false);
+
+ // The next organization's request is not released by the old one.
+ const next = requests.claim('bulk', ['b'])!;
+ requests.release(pending);
+ expect(requests.isCurrent(next)).toBe(true);
+ } finally {
+ dispose();
+ }
+ });
+
+ it.each([true, false])(
+ 'drops settled acknowledgement guards when switching alert scopes (ack=%s)',
+ async (acknowledged) => {
+ const { store, dispose } = await createStoreHarness();
+ try {
+ await waitForOpenTick();
+ emitInitialAlerts(100, [
+ { ...alertPayload('same-id', 'first scope'), acknowledged: !acknowledged },
+ ]);
+ store.updateAlert('same-id', { acknowledged });
+ expect(store.activeAlerts['same-id']?.acknowledged).toBe(acknowledged);
+
+ store.switchUrl('ws://localhost/ws?org=next');
+ await waitForOpenTick();
+ emitInitialAlerts(200, [
+ { ...alertPayload('same-id', 'next scope'), acknowledged: !acknowledged },
+ ]);
+ // The first scope's confirmation guard must not suppress an unrelated
+ // alert with the same identifier in this scope.
+ expect(store.activeAlerts['same-id']).toMatchObject({
+ message: 'next scope',
+ acknowledged: !acknowledged,
+ });
+ vi.advanceTimersByTime(15001);
+ await Promise.resolve();
+ expect(notificationStore.error).not.toHaveBeenCalled();
+ } finally {
+ dispose();
+ }
+ },
+ );
+
+ it('retains request ownership and confirmation guards during same-scope reconnect', async () => {
+ const { store, dispose } = await createStoreHarness();
+ try {
+ await waitForOpenTick();
+ emitInitialAlerts(100, [alertPayload('same-id', 'current scope')]);
+ store.updateAlert('same-id', { acknowledged: true });
+ const requests = store.alertAcknowledgementRequests;
+ const request = requests.claim('bulk', ['another-alert'])!;
+
+ store.reconnect();
+ await waitForOpenTick();
+ emitInitialAlerts(200, [alertPayload('same-id', 'stale server view')]);
+ expect(store.activeAlerts['same-id']?.acknowledged).toBe(true);
+ expect(requests.isCurrent(request)).toBe(true);
+ expect(requests.processingAlerts().has('another-alert')).toBe(true);
+
+ emitInitialAlerts(300, [
+ { ...alertPayload('same-id', 'server confirmed'), acknowledged: true },
+ ]);
+ emitInitialAlerts(400, [alertPayload('same-id', 'restored by another session')]);
+ expect(store.activeAlerts['same-id']).toMatchObject({
+ acknowledged: false,
+ message: 'restored by another session',
+ });
+ } finally {
+ dispose();
+ }
+ });
+
+ it('drops the request owner on shutdown', async () => {
+ const { store, dispose } = await createStoreHarness();
+ try {
+ await waitForOpenTick();
+ const requests = store.alertAcknowledgementRequests;
+ requests.release(requests.claim('alert', ['a'])!);
+ requests.claim('group', ['b']);
+
+ store.shutdown();
+ expect(requests.processingAlerts().size).toBe(0);
+ expect(requests.isOwned('b')).toBe(false);
+ } finally {
+ dispose();
+ }
+ });
+
+ it('drops the request owner when the store root is disposed', async () => {
+ const { store, dispose } = await createStoreHarness();
+ await waitForOpenTick();
+ const requests = store.alertAcknowledgementRequests;
+ requests.claim('group', ['a']);
+
+ dispose();
+ expect(requests.isOwned('a')).toBe(false);
+ expect(requests.processingAlerts().size).toBe(0);
+ });
+
+ it('keeps responses from before an organization switch out of the next one', async () => {
+ const { store, dispose } = await createStoreHarness();
+ const errorLog = vi.spyOn(logger, 'error').mockImplementation(() => {});
+ try {
+ await waitForOpenTick();
+ const ids = ['cpu-1', 'cpu-2', 'cpu-3', 'cpu-4'];
+ emitInitialAlerts(
+ 100,
+ ids.map((id) => alertPayload(id, `first ${id}`)),
+ );
+ expect(Object.keys(store.activeAlerts).sort()).toEqual(ids);
+
+ const updateAlert = vi.fn((id: string, updates: Partial<Alert>) =>
+ store.updateAlert(id, updates),
+ );
+ const { result } = renderHook(() => {
+ const alerts = createMemo(() => Object.values(store.activeAlerts));
+ return {
+ ...useAlertAcknowledgementState({
+ alerts,
+ updateAlert,
+ acknowledgementRequests: store.alertAcknowledgementRequests,
+ allowRestore: true,
+ }),
+ alerts,
+ };
+ });
+ const byId = (id: string) => result.alerts().find((alert) => alert.id === id)!;
+
+ const oldCard = deferred<{ success: boolean }>();
+ const oldGroup = deferred<BulkAcknowledgeResult>();
+ const oldGlobal = deferred<BulkAcknowledgeResult>();
+ const nextGlobal = deferred<BulkAcknowledgeResult>();
+ vi.mocked(AlertsAPI.acknowledge).mockReturnValueOnce(oldCard.promise);
+ vi.mocked(AlertsAPI.bulkAcknowledge)
+ .mockReturnValueOnce(oldGroup.promise)
+ .mockReturnValueOnce(oldGlobal.promise)
+ .mockReturnValueOnce(nextGlobal.promise);
+
+ const cardAck = result.handleAlertAcknowledgement(byId('cpu-1'));
+ const groupAck = result.handleGroupAcknowledge([byId('cpu-2'), byId('cpu-3')]);
+ const globalAck = result.handleBulkAcknowledge();
+ expect(vi.mocked(AlertsAPI.bulkAcknowledge).mock.calls).toEqual([
+ [['cpu-2', 'cpu-3']],
+ [['cpu-4']],
+ ]);
+
+ // The organization switch reuses the store; the next organization has
+ // alerts with the same identifiers.
+ store.switchUrl('ws://localhost/ws?org=next');
+ await waitForOpenTick();
+ emitInitialAlerts(
+ 200,
+ ids.map((id) => alertPayload(id, `next ${id}`)),
+ );
+ expect(result.processingAlerts().size).toBe(0);
+ const nextAck = result.handleBulkAcknowledge();
+ expect([...vi.mocked(AlertsAPI.bulkAcknowledge).mock.calls.at(-1)![0]].sort()).toEqual(ids);
+
+ // The old organization answers: a success, a partial failure, a rejection.
+ oldCard.resolve({ success: true });
+ oldGroup.resolve({
+ results: [
+ { alertIdentifier: 'cpu-2', success: true },
+ { alertIdentifier: 'cpu-3', success: false },
+ ],
+ });
+ oldGlobal.reject(new Error('Service Unavailable'));
+ await Promise.all([cardAck, groupAck, globalAck]);
+
+ expect(updateAlert).not.toHaveBeenCalled();
+ expect(notificationStore.success).not.toHaveBeenCalled();
+ expect(notificationStore.error).not.toHaveBeenCalled();
+ expect(errorLog).toHaveBeenCalledWith('Bulk acknowledge failed', expect.any(Error));
+ ids.forEach((id) => {
+ expect(store.activeAlerts[id]).toMatchObject({
+ acknowledged: false,
+ message: `next ${id}`,
+ });
+ });
+ expect([...result.processingAlerts()].sort()).toEqual(ids);
+
+ nextGlobal.resolve({
+ results: ids.map((alertIdentifier) => ({ alertIdentifier, success: true })),
+ });
+ await nextAck;
+ expect(updateAlert).toHaveBeenCalledTimes(4);
+ ids.forEach((id) => expect(store.activeAlerts[id]?.acknowledged).toBe(true));
+ expect(vi.mocked(notificationStore.success).mock.calls).toEqual([
+ [getAlertOverviewBulkAcknowledgedNotification(4)],
+ ]);
+ } finally {
+ errorLog.mockRestore();
+ dispose();
+ }
+ });
+});
diff --git a/frontend-modern/src/stores/alertAcknowledgementRequests.ts b/frontend-modern/src/stores/alertAcknowledgementRequests.ts
new file mode 100644
index 0000000000..5263c1bd0b
--- /dev/null
+++ b/frontend-modern/src/stores/alertAcknowledgementRequests.ts
@@ -0,0 +1,129 @@
+import { batch, createSignal } from 'solid-js';
+
+// Card and group requests keep their alerts busy for this long after they
+// settle, as the overview cards always have. A global request does not.
+const SETTLED_HOLD_MS = 1500;
+
+export type AlertAcknowledgementRequestKind = 'alert' | 'group' | 'bulk';
+
+export interface AlertAcknowledgementRequest {
+ readonly kind: AlertAcknowledgementRequestKind;
+ readonly alertIdentifiers: readonly string[];
+}
+
+// The acknowledgement and restore requests the app has in flight, by the
+// alerts each one carries. An alert belongs to at most one unsettled request,
+// and that request reports its outcome, so card, group and global actions
+// leave an owned alert out instead of sending it again. The owner outlives any
+// one view, so a remounted overview still sees a request its predecessor sent.
+// It ends with the alert scope that holds it: reset() on an organization
+// switch or shutdown drops every claim, and a request from the old scope then
+// releases nothing and is no longer current.
+export function createAlertAcknowledgementRequests() {
+ const [requests, setRequests] = createSignal<ReadonlySet<AlertAcknowledgementRequest>>(new Set());
+ const ownerByAlert = new Map<string, AlertAcknowledgementRequest>();
+ // Alerts just settled by a card or group request, by that request. A later
+ // settle replaces the entry, so an older timer cannot end a newer hold, and
+ // an alert a newer request carries stays busy whatever the old timer does.
+ const [settledHolds, setSettledHolds] = createSignal<
+ ReadonlyMap<string, AlertAcknowledgementRequest>
+ >(new Map());
+ const holdTimers = new Set<ReturnType<typeof setTimeout>>();
+
+ const isOwned = (alertIdentifier: string) => ownerByAlert.has(alertIdentifier);
+
+ // Claims the given alerts that no unsettled request carries, in order.
+ // Returns null when every one is already carried.
+ const claim = (
+ kind: AlertAcknowledgementRequestKind,
+ alertIdentifiers: readonly string[],
+ ): AlertAcknowledgementRequest | null => {
+ const unowned = [...new Set(alertIdentifiers)].filter((id) => !ownerByAlert.has(id));
+ if (unowned.length === 0) {
+ return null;
+ }
+ const request: AlertAcknowledgementRequest = { kind, alertIdentifiers: unowned };
+ unowned.forEach((id) => ownerByAlert.set(id, request));
+ setRequests((previous) => new Set(previous).add(request));
+ return request;
+ };
+
+ // False once the request has settled or its alert scope has ended.
+ const isCurrent = (request: AlertAcknowledgementRequest) => requests().has(request);
+
+ // Releases exactly this request's alerts. A card or group request holds
+ // them briefly; a global request frees them at once.
+ const release = (request: AlertAcknowledgementRequest) => {
+ if (!requests().has(request)) {
+ return;
+ }
+ request.alertIdentifiers.forEach((id) => {
+ if (ownerByAlert.get(id) === request) {
+ ownerByAlert.delete(id);
+ }
+ });
+ batch(() => {
+ setRequests((previous) => {
+ const next = new Set(previous);
+ next.delete(request);
+ return next;
+ });
+ if (request.kind !== 'bulk') {
+ setSettledHolds((previous) => {
+ const next = new Map(previous);
+ request.alertIdentifiers.forEach((id) => next.set(id, request));
+ return next;
+ });
+ }
+ });
+ if (request.kind === 'bulk') {
+ return;
+ }
+ const timer = setTimeout(() => {
+ holdTimers.delete(timer);
+ setSettledHolds((previous) => {
+ const next = new Map(previous);
+ request.alertIdentifiers.forEach((id) => {
+ if (next.get(id) === request) {
+ next.delete(id);
+ }
+ });
+ return next;
+ });
+ }, SETTLED_HOLD_MS);
+ holdTimers.add(timer);
+ };
+
+ // Alerts a card shows as processing: carried by any unsettled request, or
+ // just settled by a card or group request.
+ const processingAlerts = () => {
+ const processing = new Set(settledHolds().keys());
+ requests().forEach((request) => {
+ request.alertIdentifiers.forEach((id) => processing.add(id));
+ });
+ return processing;
+ };
+
+ const bulkInFlight = () => {
+ for (const request of requests()) {
+ if (request.kind === 'bulk') {
+ return true;
+ }
+ }
+ return false;
+ };
+
+ const reset = () => {
+ holdTimers.forEach((timer) => clearTimeout(timer));
+ holdTimers.clear();
+ ownerByAlert.clear();
+ batch(() => {
+ setRequests(new Set<AlertAcknowledgementRequest>());
+ setSettledHolds(new Map<string, AlertAcknowledgementRequest>());
+ });
+ };
+
+ return { claim, isCurrent, isOwned, release, processingAlerts, bulkInFlight, reset };
+}
+
+export type AlertAcknowledgementRequests = ReturnType<typeof createAlertAcknowledgementRequests>;
diff --git a/frontend-modern/src/stores/websocket-global.ts b/frontend-modern/src/stores/websocket-global.ts
index 08400ca3b7..d07f4673d7 100644
--- a/frontend-modern/src/stores/websocket-global.ts
+++ b/frontend-modern/src/stores/websocket-global.ts
@@ -1,3 +1,4 @@
+import { createAlertAcknowledgementRequests } from './alertAcknowledgementRequests';
import { createWebSocketStore, type ActiveAlertsHydrationStatus } from './websocket';
import { createSignal, createRoot } from 'solid-js';
import { createStore } from 'solid-js/store';
@@ -28,6 +29,9 @@ const createNoopWebSocketStore = (): ReturnType<typeof createWebSocketStore> =>
changedIds: ReadonlySet<string> | null;
changedKeys: import('@/utils/resourceStateAdapters').ResourceChangedKeys | null;
}>({ version: 0, changedIds: null, changedKeys: null });
+ // The no-op app's request owner lives as long as this store; shutdown ends
+ // it, as the real store's shutdown does.
+ const alertAcknowledgementRequests = createAlertAcknowledgementRequests();
const [state] = createStore<State>({
connectedInfrastructure: [],
metrics: [],
@@ -69,28 +73,30 @@ const createNoopWebSocketStore = (): ReturnType<typeof createWebSocketStore> =>
resourceChange,
changedResourceIdsSince: () => null,
changedResourceMetaSince: () => null,
- shutdown: () => {},
+ shutdown: () => alertAcknowledgementRequests.reset(),
refreshActiveAlerts: async () => false,
reconnect: () => {},
switchUrl: () => {},
markDockerRuntimesTokenRevoked: () => {},
markAgentsTokenRevoked: () => {},
+ alertAcknowledgementRequests,
removeAlerts: () => {},
updateAlert: () => {},
};
};
+// Ends this window's app store: it shuts down, and the next caller gets a new
+// one. The page does this on unload; a test that used the shared store does it
+// when it finishes, so nothing it left pending reaches the next test.
+export function shutdownGlobalWebSocketStore() {
+ window.__pulseWsStore?.shutdown();
+ delete window.__pulseWsStore;
+}
+
const bindGlobalShutdownHandler = () => {
if (window.__pulseWsShutdownBound) return;
- window.addEventListener(
- 'beforeunload',
- () => {
- window.__pulseWsStore?.shutdown();
- delete window.__pulseWsStore;
- },
- { once: true },
- );
+ window.addEventListener('beforeunload', shutdownGlobalWebSocketStore, { once: true });
window.__pulseWsShutdownBound = true;
};
diff --git a/frontend-modern/src/stores/websocket.ts b/frontend-modern/src/stores/websocket.ts
index 4c2f2865b7..dacec573a8 100644
--- a/frontend-modern/src/stores/websocket.ts
+++ b/frontend-modern/src/stores/websocket.ts
@@ -11,6 +11,7 @@ import type { Resource, ResourceCapability } from '@/types/resource';
import { createDefaultResourcePolicy } from '@/types/resource';
import { logger } from '@/utils/logger';
import { POLLING_INTERVALS, WEBSOCKET } from '@/constants';
+import { createAlertAcknowledgementRequests } from './alertAcknowledgementRequests';
import { notificationStore } from './notifications';
import { eventBus } from './events';
import { ALERTS_DETECTION_EVENT, isAlertsDetectionEnabled } from '@/utils/alertsActivation';
@@ -364,6 +365,10 @@ export function createWebSocketStore(url: string) {
// Track alerts with pending acknowledgment changes to prevent race conditions
const pendingAckChanges = new Map<string, { ack: boolean; previousAckTime?: string }>();
const pendingAckTimeouts = new Map<string, number>();
+ // Which acknowledgement request carries each alert. It lives and ends with
+ // this store's alert scope, so a remounted overview keeps it and an
+ // organization switch or shutdown drops it.
+ const alertAcknowledgementRequests = createAlertAcknowledgementRequests();
let alertsEnabled = isAlertsDetectionEnabled();
let lastActiveAlertsPayload: Record<string, Alert> = {};
@@ -383,6 +388,15 @@ export function createWebSocketStore(url: string) {
clearPendingAckTimeout(alertIdentifier);
};
+ // Request ownership and server-confirmation guards belong to the same alert
+ // scope. Reused identifiers in the next scope must not inherit either one.
+ const resetAlertAcknowledgements = () => {
+ pendingAckTimeouts.forEach((timeout) => window.clearTimeout(timeout));
+ pendingAckTimeouts.clear();
+ pendingAckChanges.clear();
+ alertAcknowledgementRequests.reset();
+ };
+
const applyActiveAlerts = (alertsMap: Record<string, Alert>) => {
// Remove alerts that no longer exist
const currentAlertIds = Object.keys(activeAlerts);
@@ -1049,9 +1063,7 @@ export function createWebSocketStore(url: string) {
clearReconnectTimeout();
clearReconnectDelayTimeout();
clearHeartbeatInterval();
- pendingAckTimeouts.forEach((timeout) => window.clearTimeout(timeout));
- pendingAckTimeouts.clear();
- pendingAckChanges.clear();
+ resetAlertAcknowledgements();
activeAlertsRecoveryRequestId += 1;
activeAlertsRecoveryInFlight = null;
if (activeAlertsColdHydrationTimeout) {
@@ -1787,8 +1799,7 @@ export function createWebSocketStore(url: string) {
window.clearTimeout(reconnectDelayTimeout);
window.clearTimeout(reconnectTimeout);
window.clearInterval(heartbeatInterval);
- pendingAckTimeouts.forEach((t) => window.clearTimeout(t));
- pendingAckTimeouts.clear();
+ resetAlertAcknowledgements();
activeAlertsRecoveryRequestId += 1;
activeAlertsRecoveryInFlight = null;
if (activeAlertsColdHydrationTimeout) {
@@ -1935,6 +1946,7 @@ export function createWebSocketStore(url: string) {
setState(reconcile(createInitialState()));
setActiveAlerts(reconcile({}));
setRecentlyResolved(reconcile({}));
+ resetAlertAcknowledgements();
});
clearReconnectTimeout();
@@ -1948,6 +1960,7 @@ export function createWebSocketStore(url: string) {
markTokenRevoked('dockerRuntimes', tokenId, agentIds),
markAgentsTokenRevoked: (tokenId: string, agentIds: string[]) =>
markTokenRevoked('agents', tokenId, agentIds),
+ alertAcknowledgementRequests,
removeAlerts: (predicate: (alert: Alert) => boolean) => {
const keysToRemove: string[] = [];
Object.entries(activeAlerts).forEach(([alertIdentifier, alert]) => {
diff --git a/scripts/release_control/canonical_completion_guard_test.py b/scripts/release_control/canonical_completion_guard_test.py
index 2fb9ed6c11..3c50ad6629 100644
--- a/scripts/release_control/canonical_completion_guard_test.py
+++ b/scripts/release_control/canonical_completion_guard_test.py
@@ -2548,6 +2548,7 @@ None yet.
"frontend-modern/src/features/alerts/__tests__/AlertIncidentSynthesisSummary.test.tsx",
"frontend-modern/src/features/alerts/__tests__/AlertIntentPolicyPanel.test.tsx",
"frontend-modern/src/features/alerts/__tests__/AlertOverviewAlertCard.system-scope.test.tsx",
+ "frontend-modern/src/features/alerts/__tests__/OverviewTab.acknowledgementbusy.test.tsx",
"frontend-modern/src/features/alerts/__tests__/OverviewTab.emptystate.test.tsx",
"frontend-modern/src/features/alerts/__tests__/OverviewTab.timelineerror.test.tsx",
"frontend-modern/src/features/alerts/__tests__/OverviewTab.total24h.test.tsx",
@@ -2555,6 +2556,7 @@ None yet.
"frontend-modern/src/features/alerts/__tests__/alertHistoryModel.test.ts",
"frontend-modern/src/features/alerts/__tests__/alertsConfigurationModel.test.ts",
"frontend-modern/src/features/alerts/__tests__/helpers.test.ts",
+ "frontend-modern/src/features/alerts/__tests__/useAlertAcknowledgementState.test.tsx",
"frontend-modern/src/features/alerts/__tests__/useAlertDestinationsState.test.tsx",
"frontend-modern/src/features/alerts/__tests__/useAlertDestinationsTabState.test.tsx",
"frontend-modern/src/features/alerts/__tests__/useAlertOverridesState.test.tsx",