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));
                 }
             }
 

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();
+    });
+});

tests/Exceptionless.Tests/Services/UsageServiceTests.cs

@@ -9,6 +9,8 @@
 using Foundatio.AsyncEx;
 using Foundatio.Messaging;
 using Foundatio.Repositories;
+using Foundatio.Repositories.Elasticsearch;
+using Foundatio.Repositories.Models;
 using Xunit;
 using LogLevel = Microsoft.Extensions.Logging.LogLevel;
 
@@ -273,6 +275,45 @@ await messageBus.SubscribeAsync<PlanOverage>(po =>
         Assert.Equal(0, usage.Deleted);
     }
 
+    [Fact]
+    public async Task SavePendingUsageAsync_UsageOnlyChanges_DoesNotPublishEntityChangedMessages()
+    {
+        // Arrange
+        var organization = await _organizationRepository.AddAsync(new Organization { Name = "Test", MaxEventsPerMonth = 750, PlanId = _plans.SmallPlan.Id }, o => o.ImmediateConsistency().Cache());
+        var project = await _projectRepository.AddAsync(new Project { Name = "Test", OrganizationId = organization.Id, NextSummaryEndOfDayTicks = TimeProvider.GetUtcNow().UtcDateTime.Ticks }, o => o.ImmediateConsistency().Cache());
+        var organizationRepository = Assert.IsAssignableFrom<ElasticRepositoryBase<Organization>>(_organizationRepository);
+        var projectRepository = Assert.IsAssignableFrom<ElasticRepositoryBase<Project>>(_projectRepository);
+        int notificationCount = 0;
+        Func<object, BeforePublishEntityChangedEventArgs<Organization>, Task> organizationHandler = (_, _) =>
+        {
+            Interlocked.Increment(ref notificationCount);
+            return Task.CompletedTask;
+        };
+        Func<object, BeforePublishEntityChangedEventArgs<Project>, Task> projectHandler = (_, _) =>
+        {
+            Interlocked.Increment(ref notificationCount);
+            return Task.CompletedTask;
+        };
+        organizationRepository.BeforePublishEntityChanged.AddHandler(organizationHandler);
+        projectRepository.BeforePublishEntityChanged.AddHandler(projectHandler);
+
+        try
+        {
+            // Act
+            await _usageService.IncrementTotalAsync(organization.Id, project.Id);
+            TimeProvider.Advance(TimeSpan.FromMinutes(10));
+            await _usageService.SavePendingUsageAsync();
+
+            // Assert
+            Assert.Equal(0, notificationCount);
+        }
+        finally
+        {
+            organizationRepository.BeforePublishEntityChanged.RemoveHandler(organizationHandler);
+            projectRepository.BeforePublishEntityChanged.RemoveHandler(projectHandler);
+        }
+    }
+
     [Fact]
     public async Task CanGetEventsLeft()
     {