From 4b49b04409bd255b832c30971f368d25408d23d6 Mon Sep 17 00:00:00 2001
From: Brant DeBow <125889545+brant-livefront@users.noreply.github.com>
Date: Mon, 5 May 2025 08:05:38 -0400
Subject: [PATCH] [PM-17562] Revert event route optimization (#5766)

---
 .../Implementations/EventRouteService.cs      | 34 ++++++++++
 src/Events/Startup.cs                         |  9 +--
 .../Utilities/ServiceCollectionExtensions.cs  |  9 +--
 .../Services/EventRouteServiceTests.cs        | 65 +++++++++++++++++++
 4 files changed, 101 insertions(+), 16 deletions(-)
 create mode 100644 src/Core/AdminConsole/Services/Implementations/EventRouteService.cs
 create mode 100644 test/Core.Test/AdminConsole/Services/EventRouteServiceTests.cs

diff --git a/src/Core/AdminConsole/Services/Implementations/EventRouteService.cs b/src/Core/AdminConsole/Services/Implementations/EventRouteService.cs
new file mode 100644
index 0000000000..a542e75a7b
--- /dev/null
+++ b/src/Core/AdminConsole/Services/Implementations/EventRouteService.cs
@@ -0,0 +1,34 @@
+using Bit.Core.Models.Data;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Bit.Core.Services;
+
+public class EventRouteService(
+    [FromKeyedServices("broadcast")] IEventWriteService broadcastEventWriteService,
+    [FromKeyedServices("storage")] IEventWriteService storageEventWriteService,
+    IFeatureService _featureService) : IEventWriteService
+{
+    public async Task CreateAsync(IEvent e)
+    {
+        if (_featureService.IsEnabled(FeatureFlagKeys.EventBasedOrganizationIntegrations))
+        {
+            await broadcastEventWriteService.CreateAsync(e);
+        }
+        else
+        {
+            await storageEventWriteService.CreateAsync(e);
+        }
+    }
+
+    public async Task CreateManyAsync(IEnumerable<IEvent> e)
+    {
+        if (_featureService.IsEnabled(FeatureFlagKeys.EventBasedOrganizationIntegrations))
+        {
+            await broadcastEventWriteService.CreateManyAsync(e);
+        }
+        else
+        {
+            await storageEventWriteService.CreateManyAsync(e);
+        }
+    }
+}
diff --git a/src/Events/Startup.cs b/src/Events/Startup.cs
index bb37e240c8..366b562485 100644
--- a/src/Events/Startup.cs
+++ b/src/Events/Startup.cs
@@ -1,5 +1,4 @@
 using System.Globalization;
-using Bit.Core;
 using Bit.Core.AdminConsole.Services.Implementations;
 using Bit.Core.AdminConsole.Services.NoopImplementations;
 using Bit.Core.Context;
@@ -94,13 +93,7 @@ public class Startup
                 services.AddKeyedSingleton<IEventWriteService, NoopEventWriteService>("broadcast");
             }
         }
-        services.AddScoped<IEventWriteService>(sp =>
-        {
-            var featureService = sp.GetRequiredService<IFeatureService>();
-            var key = featureService.IsEnabled(FeatureFlagKeys.EventBasedOrganizationIntegrations)
-                ? "broadcast" : "storage";
-            return sp.GetRequiredKeyedService<IEventWriteService>(key);
-        });
+        services.AddScoped<IEventWriteService, EventRouteService>();
         services.AddScoped<IEventService, EventService>();
 
         services.AddOptionality();
diff --git a/src/SharedWeb/Utilities/ServiceCollectionExtensions.cs b/src/SharedWeb/Utilities/ServiceCollectionExtensions.cs
index 9883e6db47..26e5c7abaf 100644
--- a/src/SharedWeb/Utilities/ServiceCollectionExtensions.cs
+++ b/src/SharedWeb/Utilities/ServiceCollectionExtensions.cs
@@ -4,7 +4,6 @@ using System.Security.Claims;
 using System.Security.Cryptography.X509Certificates;
 using AspNetCoreRateLimit;
 using Azure.Storage.Queues;
-using Bit.Core;
 using Bit.Core.AdminConsole.Models.Business.Tokenables;
 using Bit.Core.AdminConsole.OrganizationFeatures.Policies;
 using Bit.Core.AdminConsole.Services;
@@ -366,13 +365,7 @@ public static class ServiceCollectionExtensions
             services.AddKeyedSingleton<IEventWriteService, NoopEventWriteService>("storage");
             services.AddKeyedSingleton<IEventWriteService, NoopEventWriteService>("broadcast");
         }
-        services.AddScoped<IEventWriteService>(sp =>
-        {
-            var featureService = sp.GetRequiredService<IFeatureService>();
-            var key = featureService.IsEnabled(FeatureFlagKeys.EventBasedOrganizationIntegrations)
-                ? "broadcast" : "storage";
-            return sp.GetRequiredKeyedService<IEventWriteService>(key);
-        });
+        services.AddScoped<IEventWriteService, EventRouteService>();
 
         if (CoreHelpers.SettingHasValue(globalSettings.Attachment.ConnectionString))
         {
diff --git a/test/Core.Test/AdminConsole/Services/EventRouteServiceTests.cs b/test/Core.Test/AdminConsole/Services/EventRouteServiceTests.cs
new file mode 100644
index 0000000000..f593a4628b
--- /dev/null
+++ b/test/Core.Test/AdminConsole/Services/EventRouteServiceTests.cs
@@ -0,0 +1,65 @@
+using Bit.Core.Models.Data;
+using Bit.Core.Services;
+using Bit.Test.Common.AutoFixture.Attributes;
+using NSubstitute;
+using Xunit;
+
+namespace Bit.Core.Test.Services;
+
+[SutProviderCustomize]
+public class EventRouteServiceTests
+{
+    private readonly IEventWriteService _broadcastEventWriteService = Substitute.For<IEventWriteService>();
+    private readonly IEventWriteService _storageEventWriteService = Substitute.For<IEventWriteService>();
+    private readonly IFeatureService _featureService = Substitute.For<IFeatureService>();
+    private readonly EventRouteService Subject;
+
+    public EventRouteServiceTests()
+    {
+        Subject = new EventRouteService(_broadcastEventWriteService, _storageEventWriteService, _featureService);
+    }
+
+    [Theory, BitAutoData]
+    public async Task CreateAsync_FlagDisabled_EventSentToStorageService(EventMessage eventMessage)
+    {
+        _featureService.IsEnabled(FeatureFlagKeys.EventBasedOrganizationIntegrations).Returns(false);
+
+        await Subject.CreateAsync(eventMessage);
+
+        _broadcastEventWriteService.DidNotReceiveWithAnyArgs().CreateAsync(Arg.Any<EventMessage>());
+        _storageEventWriteService.Received(1).CreateAsync(eventMessage);
+    }
+
+    [Theory, BitAutoData]
+    public async Task CreateAsync_FlagEnabled_EventSentToBroadcastService(EventMessage eventMessage)
+    {
+        _featureService.IsEnabled(FeatureFlagKeys.EventBasedOrganizationIntegrations).Returns(true);
+
+        await Subject.CreateAsync(eventMessage);
+
+        _broadcastEventWriteService.Received(1).CreateAsync(eventMessage);
+        _storageEventWriteService.DidNotReceiveWithAnyArgs().CreateAsync(Arg.Any<EventMessage>());
+    }
+
+    [Theory, BitAutoData]
+    public async Task CreateManyAsync_FlagDisabled_EventsSentToStorageService(IEnumerable<EventMessage> eventMessages)
+    {
+        _featureService.IsEnabled(FeatureFlagKeys.EventBasedOrganizationIntegrations).Returns(false);
+
+        await Subject.CreateManyAsync(eventMessages);
+
+        _broadcastEventWriteService.DidNotReceiveWithAnyArgs().CreateManyAsync(Arg.Any<IEnumerable<EventMessage>>());
+        _storageEventWriteService.Received(1).CreateManyAsync(eventMessages);
+    }
+
+    [Theory, BitAutoData]
+    public async Task CreateManyAsync_FlagEnabled_EventsSentToBroadcastService(IEnumerable<EventMessage> eventMessages)
+    {
+        _featureService.IsEnabled(FeatureFlagKeys.EventBasedOrganizationIntegrations).Returns(true);
+
+        await Subject.CreateManyAsync(eventMessages);
+
+        _broadcastEventWriteService.Received(1).CreateManyAsync(eventMessages);
+        _storageEventWriteService.DidNotReceiveWithAnyArgs().CreateManyAsync(Arg.Any<IEnumerable<EventMessage>>());
+    }
+}