Reduce noisy change events

src/Exceptionless.Core/Jobs/WorkItemHandlers/OrganizationMaintenanceWorkItemHandler.cs

@@ -56,7 +56,7 @@ public override async Task HandleItemAsync(WorkItemContext context)
             }
 
             if (wi.UpgradePlans || wi.RemoveOldUsageStats)
-                await _organizationRepository.SaveAsync(results.Documents);
+                await _organizationRepository.SaveAsync(results.Documents, o => o.Notifications(wi.UpgradePlans));
 
             // Sleep so we are not hammering the backend.
             await Task.Delay(TimeSpan.FromSeconds(2.5), _timeProvider);

src/Exceptionless.Core/Jobs/WorkItemHandlers/ProjectMaintenanceWorkItemHandler.cs

@@ -58,7 +58,7 @@ public override async Task HandleItemAsync(WorkItemContext context)
             }
 
             if (workItem.UpdateDefaultBotList || workItem.IncrementConfigurationVersion || workItem.RemoveOldUsageStats)
-                await _projectRepository.SaveAsync(results.Documents);
+                await _projectRepository.SaveAsync(results.Documents, o => o.Notifications(workItem.UpdateDefaultBotList || workItem.IncrementConfigurationVersion));
 
             // Sleep so we are not hammering the backend.
             await Task.Delay(TimeSpan.FromSeconds(2.5), _timeProvider);

src/Exceptionless.Core/Migrations/UpdateEventUsage.cs

@@ -86,7 +86,7 @@ private async Task UpdateOrganizationsUsageAsync(MigrationContext context)
                         }
                     }
 
-                    await _organizationRepository.SaveAsync(organization);
+                    await _organizationRepository.SaveAsync(organization, o => o.Notifications(false));
                     await UpdateProjectsUsageAsync(context, organization);
                     processed++;
                     await context.Lock.RenewAsync();
@@ -142,7 +142,7 @@ private async Task UpdateProjectsUsageAsync(MigrationContext context, Organizati
                             usage.Limit = organization.GetMaxEventsPerMonthWithBonus(_timeProvider);
                     }
 
-                    await _projectRepository.SaveAsync(project);
+                    await _projectRepository.SaveAsync(project, o => o.Notifications(false));
                 }
                 catch (Exception ex)
                 {

src/Exceptionless.Core/Services/UsageService.cs

@@ -117,7 +117,8 @@ await _cache.RemoveAllAsync(new[] {
                     });
 
                     await _cache.SetAsync(GetTotalCacheKey(utcNow, organizationId), usage.Total, TimeSpan.FromHours(8));
-                    await _organizationRepository.SaveAsync(organization);
+                    // Usage counters and last-event timestamps are operational updates, not user-facing entity changes.
+                    await _organizationRepository.SaveAsync(organization, o => o.Notifications(false));
                 }
             }
 
@@ -204,7 +205,8 @@ await _cache.RemoveAllAsync(new[] {
 
                     await _cache.SetAsync(GetTotalCacheKey(utcNow, project.OrganizationId, projectId), usage.Total, TimeSpan.FromHours(8));
 
-                    await _projectRepository.SaveAsync(project);
+                    // Project configuration changes have their own save path and should remain the source of ProjectChanged messages.
+                    await _projectRepository.SaveAsync(project, o => o.Notifications(false));
                 }
             }
 
@@ -257,8 +259,8 @@ public async Task HandleOrganizationChangeAsync(Organization modified, Organizat
 
         if (bucketTotal.Value >= bucketLimit)
         {
-            await _messagePublisher.PublishAsync(new PlanOverage { OrganizationId = modified.Id, IsHourly = true });
             await _cache.SetAsync(GetThrottledKey(utcNow, modified.Id), true, TimeSpan.FromMinutes(5));
+            await _messagePublisher.PublishAsync(new PlanOverage { OrganizationId = modified.Id, IsHourly = true });
         }
     }
 
@@ -449,8 +451,8 @@ public async Task IncrementTotalAsync(string organizationId, string projectId, i
         if (bucketTotal >= bucketLimit && bucketTotal - bucketLimit < eventCount)
         {
             // org will be throttled during the current bucket of time
-            await _messagePublisher.PublishAsync(new PlanOverage { OrganizationId = organizationId, IsHourly = true });
             await _cache.SetAsync(GetThrottledKey(utcNow, organizationId), true, TimeSpan.FromMinutes(5));
+            await _messagePublisher.PublishAsync(new PlanOverage { OrganizationId = organizationId, IsHourly = true });
         }
     }
 

src/Exceptionless.Web/Api/Handlers/OrganizationHandler.cs

@@ -929,6 +929,7 @@ private async Task AfterResultMapAsync<TDestination>(ICollection<TDestination> m
             currentUsage.Discarded = realTimeUsage.CurrentUsage.Discarded;
             currentUsage.TooBig = realTimeUsage.CurrentUsage.TooBig;
             currentUsage.Deleted = realTimeUsage.CurrentUsage.Deleted;
+            viewOrganization.IsOverMonthlyLimit = currentUsage.Limit >= 0 && currentUsage.Total >= currentUsage.Limit;
 
             var currentHourUsage = viewOrganization.GetCurrentHourlyUsage(timeProvider);
             currentHourUsage.Total = realTimeUsage.CurrentHourUsage.Total;

src/Exceptionless.Web/ClientApp/src/lib/features/organizations/api.svelte.ts

@@ -23,6 +23,12 @@ export async function invalidateOrganizationQueries(queryClient: QueryClient, me
     }
 }
 
+export async function invalidatePlanOverageQueries(queryClient: QueryClient, message: WebSocketMessageValue<'PlanOverage'>) {
+    await queryClient.invalidateQueries({ queryKey: queryKeys.id(message.organization_id, undefined) });
+    await queryClient.invalidateQueries({ queryKey: queryKeys.id(message.organization_id, 'stats') });
+    await queryClient.invalidateQueries({ queryKey: queryKeys.list(undefined) });
+}
+
 export const queryKeys = {
     adminSearch: (params: GetAdminSearchOrganizationsParams) => [...queryKeys.list(params.mode), 'admin', { ...params }] as const,
     changePlan: (id: string | undefined) => [...queryKeys.type, id, 'change-plan'] as const,

src/Exceptionless.Web/ClientApp/src/lib/features/organizations/api.test.ts

@@ -0,0 +1,24 @@
+import { QueryClient } from '@tanstack/svelte-query';
+import { describe, expect, it, vi } from 'vitest';
+
+import { invalidatePlanOverageQueries, queryKeys } from './api.svelte';
+
+describe('invalidatePlanOverageQueries', () => {
+    it('invalidates only the affected organization state', async () => {
+        // Arrange
+        const queryClient = new QueryClient();
+        const invalidateSpy = vi.spyOn(queryClient, 'invalidateQueries').mockImplementation(async () => {});
+
+        // Act
+        await invalidatePlanOverageQueries(queryClient, {
+            is_hourly: false,
+            organization_id: 'organization-id'
+        });
+
+        // Assert
+        expect(invalidateSpy).toHaveBeenCalledTimes(3);
+        expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.id('organization-id', undefined) });
+        expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.id('organization-id', 'stats') });
+        expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.list(undefined) });
+    });
+});

src/Exceptionless.Web/ClientApp/src/lib/features/organizations/components/organization-notifications.svelte

@@ -9,7 +9,6 @@
     import { ChangeType, type WebSocketMessageValue } from '$features/websockets/models';
     import { useEventListener } from 'runed';
     import { SvelteSet } from 'svelte/reactivity';
-    import { debounce } from 'throttle-debounce';
 
     import FreePlanNotification from './notifications/free-plan-notification.svelte';
     import HourlyOverageNotification from './notifications/hourly-overage-notification.svelte';
@@ -95,19 +94,21 @@
     );
     const requiresPremiumUpgrade = $derived(requiresPremium && !organization?.has_premium_features && !needsProjectConfiguration);
 
-    const refetchConfigurationState = debounce(1500, async () => {
-        await Promise.all([organizationQuery.refetch(), projectsQuery.refetch()]);
-    });
-
     useEventListener(document, 'PersistentEventChanged', (event) => {
         const message = (event as CustomEvent<WebSocketMessageValue<'PersistentEventChanged'>>).detail;
-
-        if (message.change_type === ChangeType.Removed || message.organization_id !== currentOrganizationId.current || !message.project_id) {
+        const projectNeedsConfiguration = projects.some((project) => project.id === message.project_id && project.is_configured === false);
+
+        if (
+            message.change_type === ChangeType.Removed ||
+            message.organization_id !== currentOrganizationId.current ||
+            !message.project_id ||
+            !projectNeedsConfiguration ||
+            configuredProjectIds.has(message.project_id)
+        ) {
             return;
         }
 
         configuredProjectIds.add(message.project_id);
-        void refetchConfigurationState();
     });
 </script>
 

src/Exceptionless.Web/ClientApp/src/lib/features/organizations/components/organization-notifications.svelte.test.ts

@@ -0,0 +1,77 @@
+import { ChangeType } from '$features/websockets/models';
+import { render } from '@testing-library/svelte';
+import { tick } from 'svelte';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import OrganizationNotifications from './organization-notifications.svelte';
+
+const organizationRefetch = vi.hoisted(() => vi.fn());
+const projectsRefetch = vi.hoisted(() => vi.fn());
+const projects = vi.hoisted(() => [{ id: 'project-id', is_configured: false, organization_id: 'organization-id' }]);
+
+vi.mock('$features/organizations/api.svelte', () => ({
+    getOrganizationQuery: () => ({ data: undefined, refetch: organizationRefetch }),
+    getOrganizationsQuery: () => ({ data: { data: [] } })
+}));
+
+vi.mock('$features/organizations/context.svelte', () => ({
+    organization: { current: 'organization-id' }
+}));
+
+vi.mock('$features/projects/api.svelte', () => ({
+    getOrganizationProjectsQuery: () => ({ data: { data: projects }, isSuccess: true, refetch: projectsRefetch })
+}));
+
+vi.mock('$features/users/api.svelte', () => ({
+    getMeQuery: () => ({ data: { organization_ids: ['organization-id'], roles: [] } })
+}));
+
+describe('OrganizationNotifications', () => {
+    beforeEach(() => {
+        organizationRefetch.mockReset();
+        projectsRefetch.mockReset();
+        projects[0]!.is_configured = false;
+    });
+
+    it('does not refetch organization or project state for persistent event changes', async () => {
+        render(OrganizationNotifications, {
+            isChatEnabled: false,
+            openChat: vi.fn()
+        });
+
+        const message = {
+            change_type: ChangeType.Added,
+            organization_id: 'organization-id',
+            project_id: 'project-id'
+        };
+
+        document.dispatchEvent(new CustomEvent('PersistentEventChanged', { detail: message }));
+        document.dispatchEvent(new CustomEvent('PersistentEventChanged', { detail: message }));
+        await tick();
+
+        expect(organizationRefetch).not.toHaveBeenCalled();
+        expect(projectsRefetch).not.toHaveBeenCalled();
+    });
+
+    it('does not refresh configuration state for an already configured project', async () => {
+        projects[0]!.is_configured = true;
+        render(OrganizationNotifications, {
+            isChatEnabled: false,
+            openChat: vi.fn()
+        });
+
+        document.dispatchEvent(
+            new CustomEvent('PersistentEventChanged', {
+                detail: {
+                    change_type: ChangeType.Added,
+                    organization_id: 'organization-id',
+                    project_id: 'project-id'
+                }
+            })
+        );
+        await tick();
+
+        expect(organizationRefetch).not.toHaveBeenCalled();
+        expect(projectsRefetch).not.toHaveBeenCalled();
+    });
+});

src/Exceptionless.Web/ClientApp/src/lib/features/websockets/models.ts

@@ -67,6 +67,10 @@ export function isEntityChangedType(message: { message: unknown; type: WebSocket
     return message.type !== 'PlanChanged' && message.type !== 'UserMembershipChanged' && message.type.endsWith('Changed');
 }
 
+export function isPlanOverageType(message: { message: unknown; type: WebSocketMessageType }): message is WebSocketMessage<'PlanOverage'> {
+    return message.type === 'PlanOverage';
+}
+
 export function isWebSocketMessageType(type: string): type is WebSocketMessageType {
     return (
         (['PlanChanged', 'PlanOverage', 'UserMembershipChanged', 'ReleaseNotification', 'SystemNotification'] as const).includes(

src/Exceptionless.Web/ClientApp/src/routes/(app)/+layout.svelte

@@ -15,7 +15,12 @@
     import { buildIntercomBootOptions, IntercomShell } from '$features/intercom';
     import { shouldLoadIntercomOrganization } from '$features/intercom/config';
     import Notifications from '$features/notifications/components/notifications.svelte';
-    import { getOrganizationQuery, getOrganizationsQuery, invalidateOrganizationQueries } from '$features/organizations/api.svelte';
+    import {
+        getOrganizationQuery,
+        getOrganizationsQuery,
+        invalidateOrganizationQueries,
+        invalidatePlanOverageQueries
+    } from '$features/organizations/api.svelte';
     import OrganizationNotifications from '$features/organizations/components/organization-notifications.svelte';
     import { organization, showOrganizationNotifications } from '$features/organizations/context.svelte';
     import { premiumPage } from '$features/organizations/premium-page.svelte';
@@ -28,7 +33,7 @@
     import { getMeQuery, invalidateUserQueries } from '$features/users/api.svelte';
     import { getGravatarFromCurrentUser } from '$features/users/gravatar.svelte';
     import { invalidateWebhookQueries } from '$features/webhooks/api.svelte';
-    import { isEntityChangedType, type WebSocketMessageType } from '$features/websockets/models';
+    import { isEntityChangedType, isPlanOverageType, type WebSocketMessageType } from '$features/websockets/models';
     import { WebSocketClient } from '$features/websockets/web-socket-client.svelte';
     import { Telemetry } from '$lib/telemetry';
     import { useMiddleware } from '@foundatiofx/fetchclient';
@@ -129,7 +134,9 @@
             })
         );
 
-        if (isEntityChangedType(data)) {
+        if (isPlanOverageType(data)) {
+            await invalidatePlanOverageQueries(queryClient, data.message);
+        } else if (isEntityChangedType(data)) {
             switch (data.type) {
                 case 'OrganizationChanged':
                     await invalidateOrganizationQueries(queryClient, data.message);

tests/Exceptionless.Tests/Api/Endpoints/OrganizationEndpointTests.cs

@@ -5,6 +5,7 @@
 using Exceptionless.Core.Models;
 using Exceptionless.Core.Models.Billing;
 using Exceptionless.Core.Repositories;
+using Exceptionless.Core.Services;
 using Exceptionless.Core.Utility;
 using Exceptionless.Tests.Extensions;
 using Exceptionless.Tests.Utility;
@@ -575,6 +576,34 @@ public async Task GetAsync_ViewOrganization_IncludesIsOverMonthlyLimit()
         Assert.False(viewOrg.IsOverMonthlyLimit);
     }
 
+    [Fact]
+    public async Task GetAsync_WithPendingUsageAtMonthlyLimit_ReturnsRealTimeOverageState()
+    {
+        // Arrange
+        var organization = await _organizationRepository.GetByIdAsync(SampleDataService.TEST_ORG_ID);
+        Assert.NotNull(organization);
+
+        organization.MaxEventsPerMonth = 1;
+        organization.Usage.Clear();
+        organization.UsageHours.Clear();
+        await _organizationRepository.SaveAsync(organization, o => o.ImmediateConsistency().Cache().Originals());
+
+        var usageService = GetService<UsageService>();
+        await usageService.IncrementTotalAsync(organization.Id, SampleDataService.TEST_PROJECT_ID);
+
+        // Act
+        var viewOrganization = await SendRequestAsAsync<ViewOrganization>(r => r
+            .AsTestOrganizationUser()
+            .AppendPaths("organizations", organization.Id)
+            .StatusCodeShouldBeOk()
+        );
+
+        // Assert
+        Assert.NotNull(viewOrganization);
+        Assert.Equal(1, viewOrganization.GetCurrentUsage(TimeProvider).Total);
+        Assert.True(viewOrganization.IsOverMonthlyLimit);
+    }
+
     [Fact]
     public async Task PostAsync_NewOrganization_SetsCreatedAndUpdatedDates()
     {