Introduce base EF Core persistence abstractions

Author: johnsimons

src/ServiceControl.Persistence.Sql.Core/Abstractions/BasePersistence.cs

@@ -0,0 +1,41 @@
+namespace ServiceControl.Persistence.Sql.Core.Abstractions;
+
+using Microsoft.Extensions.DependencyInjection;
+using ServiceControl.Persistence;
+using ServiceControl.Persistence.MessageRedirects;
+using ServiceControl.Persistence.UnitOfWork;
+using Implementation;
+using Implementation.UnitOfWork;
+
+public abstract class BasePersistence
+{
+    protected static void RegisterDataStores(IServiceCollection services, bool maintenanceMode)
+    {
+        if (maintenanceMode)
+        {
+            return;
+        }
+
+        services.AddSingleton<MinimumRequiredStorageState>();
+        services.AddSingleton<ITrialLicenseDataProvider, TrialLicenseDataProvider>();
+        services.AddSingleton<IEndpointSettingsStore, EndpointSettingsStore>();
+        services.AddSingleton<IEventLogDataStore, EventLogDataStore>();
+        services.AddSingleton<IMessageRedirectsDataStore, MessageRedirectsDataStore>();
+        services.AddSingleton<IServiceControlSubscriptionStorage, ServiceControlSubscriptionStorage>();
+        services.AddSingleton<IQueueAddressStore, QueueAddressStore>();
+        services.AddSingleton<IMonitoringDataStore, MonitoringDataStore>();
+        services.AddSingleton<ICustomChecksDataStore, CustomChecksDataStore>();
+        services.AddSingleton<Operations.BodyStorage.IBodyStorage, BodyStorage>();
+        services.AddSingleton<IRetryHistoryDataStore, RetryHistoryDataStore>();
+        services.AddSingleton<IFailedErrorImportDataStore, FailedErrorImportDataStore>();
+        services.AddSingleton<IExternalIntegrationRequestsDataStore, ExternalIntegrationRequestsDataStore>();
+        services.AddSingleton<IFailedMessageViewIndexNotifications, FailedMessageViewIndexNotifications>();
+        services.AddSingleton<Recoverability.IArchiveMessages, ArchiveMessages>();
+        services.AddSingleton<IGroupsDataStore, GroupsDataStore>();
+        services.AddSingleton<IRetryDocumentDataStore, RetryDocumentDataStore>();
+        services.AddSingleton<IRetryBatchesDataStore, RetryBatchesDataStore>();
+        services.AddSingleton<INotificationsManager, NotificationsManager>();
+        services.AddSingleton<IIngestionUnitOfWorkFactory, IngestionUnitOfWorkFactory>();
+        services.AddSingleton<IErrorMessageDataStore, ErrorMessageDataStore>();
+    }
+}

src/ServiceControl.Persistence.Sql.Core/Implementation/DataStoreBase.cs

@@ -0,0 +1,44 @@
+namespace ServiceControl.Persistence.Sql.Core.Implementation;
+
+using System;
+using System.Threading.Tasks;
+using DbContexts;
+using Microsoft.Extensions.DependencyInjection;
+
+/// <summary>
+/// Base class for data stores that provides helper methods to simplify scope and DbContext management
+/// </summary>
+public abstract class DataStoreBase
+{
+    protected readonly IServiceProvider serviceProvider;
+
+    protected DataStoreBase(IServiceProvider serviceProvider)
+    {
+        this.serviceProvider = serviceProvider;
+    }
+
+    /// <summary>
+    /// Executes an operation with a scoped DbContext, returning a result
+    /// </summary>
+    protected async Task<T> ExecuteWithDbContext<T>(Func<ServiceControlDbContextBase, Task<T>> operation)
+    {
+        using var scope = serviceProvider.CreateScope();
+        var dbContext = scope.ServiceProvider.GetRequiredService<ServiceControlDbContextBase>();
+        return await operation(dbContext);
+    }
+
+    /// <summary>
+    /// Executes an operation with a scoped DbContext, without returning a result
+    /// </summary>
+    protected async Task ExecuteWithDbContext(Func<ServiceControlDbContextBase, Task> operation)
+    {
+        using var scope = serviceProvider.CreateScope();
+        var dbContext = scope.ServiceProvider.GetRequiredService<ServiceControlDbContextBase>();
+        await operation(dbContext);
+    }
+
+    /// <summary>
+    /// Creates a scope for operations that need to manage their own scope lifecycle (e.g., managers)
+    /// </summary>
+    protected IServiceScope CreateScope() => serviceProvider.CreateScope();
+}

src/ServiceControl.Persistence.Sql.Core/Infrastructure/SequentialGuidGenerator.cs

@@ -0,0 +1,53 @@
+namespace ServiceControl.Persistence.Sql.Core.Infrastructure;
+
+using System;
+
+/// <summary>
+/// Generates sequential GUIDs for database primary keys to minimize page fragmentation
+/// and improve insert performance while maintaining security benefits of GUIDs.
+/// </summary>
+/// <remarks>
+/// This implementation creates time-ordered GUIDs similar to .NET 9's Guid.CreateVersion7()
+/// but compatible with .NET 8. The GUIDs are ordered by timestamp to reduce B-tree page splits
+/// in clustered indexes, which significantly improves insert performance compared to random GUIDs.
+///
+/// Benefits:
+/// - Database agnostic (works with SQL Server, PostgreSQL, MySQL, SQLite)
+/// - Sequential ordering reduces page fragmentation
+/// - Better insert performance than random GUIDs
+/// - Can easily migrate to Guid.CreateVersion7() when upgrading to .NET 9+
+/// - No external dependencies
+///
+/// Security:
+/// - Still cryptographically secure (uses Guid.NewGuid() as base)
+/// - Not guessable (unlike sequential integers)
+/// - Safe to expose in APIs
+/// </remarks>
+public static class SequentialGuidGenerator
+{
+    /// <summary>
+    /// Generate a sequential GUID with timestamp-based ordering for optimal database performance.
+    /// </summary>
+    /// <returns>A new GUID with sequential characteristics.</returns>
+    public static Guid NewSequentialGuid()
+    {
+        var guidBytes = Guid.NewGuid().ToByteArray();
+        var now = DateTime.UtcNow;
+
+        // Get timestamp in milliseconds since Unix epoch (similar to Version 7 GUIDs)
+        var timestamp = (long)(now - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;
+        var timestampBytes = BitConverter.GetBytes(timestamp);
+
+        // Reverse if little-endian to get big-endian byte order for proper sorting
+        if (BitConverter.IsLittleEndian)
+        {
+            Array.Reverse(timestampBytes);
+        }
+
+        // Replace last 6 bytes with timestamp for sequential ordering
+        // This placement works well with SQL Server's GUID comparison semantics
+        Array.Copy(timestampBytes, 2, guidBytes, 10, 6);
+
+        return new Guid(guidBytes);
+    }
+}