Adding more tables to sql

Author: johnsimons

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

@@ -0,0 +1,10 @@
+namespace ServiceControl.Persistence.Sql.Core.Abstractions;
+
+using System.Threading;
+using System.Threading.Tasks;
+using DbContexts;
+
+public interface IUpsertHelper
+{
+    Task Upsert<TEntity>(ServiceControlDbContextBase dbContext, TEntity entity, CancellationToken cancellationToken) where TEntity : class;
+}

src/ServiceControl.Persistence.Sql.Core/DbContexts/ServiceControlDbContextBase.cs

@@ -11,12 +11,18 @@ protected ServiceControlDbContextBase(DbContextOptions options) : base(options)
     }
 
     public DbSet<TrialLicenseEntity> TrialLicenses { get; set; }
+    public DbSet<EndpointSettingsEntity> EndpointSettings { get; set; }
+    public DbSet<EventLogItemEntity> EventLogItems { get; set; }
+    public DbSet<MessageRedirectsEntity> MessageRedirects { get; set; }
 
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
         base.OnModelCreating(modelBuilder);
 
         modelBuilder.ApplyConfiguration(new TrialLicenseConfiguration());
+        modelBuilder.ApplyConfiguration(new EndpointSettingsConfiguration());
+        modelBuilder.ApplyConfiguration(new EventLogItemConfiguration());
+        modelBuilder.ApplyConfiguration(new MessageRedirectsConfiguration());
 
         OnModelCreatingProvider(modelBuilder);
     }

src/ServiceControl.Persistence.Sql.Core/Entities/EndpointSettingsEntity.cs

@@ -0,0 +1,7 @@
+namespace ServiceControl.Persistence.Sql.Core.Entities;
+
+public class EndpointSettingsEntity
+{
+    public required string Name { get; set; }
+    public bool TrackInstances { get; set; }
+}

src/ServiceControl.Persistence.Sql.Core/Entities/EventLogItemEntity.cs

@@ -0,0 +1,14 @@
+namespace ServiceControl.Persistence.Sql.Core.Entities;
+
+using System;
+
+public class EventLogItemEntity
+{
+    public required string Id { get; set; }
+    public required string Description { get; set; }
+    public int Severity { get; set; }
+    public DateTime RaisedAt { get; set; }
+    public string? RelatedTo { get; set; } // Stored as JSON array
+    public string? Category { get; set; }
+    public string? EventType { get; set; }
+}

src/ServiceControl.Persistence.Sql.Core/Entities/MessageRedirectsEntity.cs

@@ -0,0 +1,9 @@
+namespace ServiceControl.Persistence.Sql.Core.Entities;
+
+public class MessageRedirectsEntity
+{
+    public required string Id { get; set; }
+    public required string ETag { get; set; }
+    public DateTime LastModified { get; set; }
+    public required string RedirectsJson { get; set; }
+}

src/ServiceControl.Persistence.Sql.Core/EntityConfigurations/EndpointSettingsConfiguration.cs

@@ -0,0 +1,22 @@
+namespace ServiceControl.Persistence.Sql.Core.EntityConfigurations;
+
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+class EndpointSettingsConfiguration : IEntityTypeConfiguration<EndpointSettingsEntity>
+{
+    public void Configure(EntityTypeBuilder<EndpointSettingsEntity> builder)
+    {
+        builder.ToTable("EndpointSettings");
+
+        builder.HasKey(e => e.Name);
+
+        builder.Property(e => e.Name)
+            .IsRequired()
+            .HasMaxLength(500);
+
+        builder.Property(e => e.TrackInstances)
+            .IsRequired();
+    }
+}

src/ServiceControl.Persistence.Sql.Core/EntityConfigurations/EventLogItemConfiguration.cs

@@ -0,0 +1,40 @@
+namespace ServiceControl.Persistence.Sql.Core.EntityConfigurations;
+
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+class EventLogItemConfiguration : IEntityTypeConfiguration<EventLogItemEntity>
+{
+    public void Configure(EntityTypeBuilder<EventLogItemEntity> builder)
+    {
+        builder.ToTable("EventLogItems");
+
+        builder.HasKey(e => e.Id);
+
+        builder.Property(e => e.Id)
+            .IsRequired()
+            .HasMaxLength(200);
+
+        builder.Property(e => e.Description)
+            .IsRequired();
+
+        builder.Property(e => e.Severity)
+            .IsRequired();
+
+        builder.Property(e => e.RaisedAt)
+            .IsRequired();
+
+        builder.Property(e => e.Category)
+            .HasMaxLength(200);
+
+        builder.Property(e => e.EventType)
+            .HasMaxLength(200);
+
+        builder.Property(e => e.RelatedTo)
+            .HasMaxLength(4000);
+
+        // Index for querying by RaisedAt
+        builder.HasIndex(e => e.RaisedAt);
+    }
+}

src/ServiceControl.Persistence.Sql.Core/EntityConfigurations/MessageRedirectsConfiguration.cs

@@ -0,0 +1,29 @@
+namespace ServiceControl.Persistence.Sql.Core.EntityConfigurations;
+
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+class MessageRedirectsConfiguration : IEntityTypeConfiguration<MessageRedirectsEntity>
+{
+    public void Configure(EntityTypeBuilder<MessageRedirectsEntity> builder)
+    {
+        builder.ToTable("MessageRedirects");
+
+        builder.HasKey(e => e.Id);
+
+        builder.Property(e => e.Id)
+            .IsRequired()
+            .HasMaxLength(200);
+
+        builder.Property(e => e.ETag)
+            .IsRequired()
+            .HasMaxLength(200);
+
+        builder.Property(e => e.LastModified)
+            .IsRequired();
+
+        builder.Property(e => e.RedirectsJson)
+            .IsRequired();
+    }
+}

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

@@ -0,0 +1,64 @@
+namespace ServiceControl.Persistence.Sql.Core.Implementation;
+
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Abstractions;
+using DbContexts;
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using ServiceControl.Persistence;
+
+public class EndpointSettingsStore : IEndpointSettingsStore
+{
+    readonly IServiceProvider serviceProvider;
+    readonly IUpsertHelper upsertHelper;
+
+    public EndpointSettingsStore(IServiceProvider serviceProvider, IUpsertHelper upsertHelper)
+    {
+        this.serviceProvider = serviceProvider;
+        this.upsertHelper = upsertHelper;
+    }
+
+    public async IAsyncEnumerable<EndpointSettings> GetAllEndpointSettings()
+    {
+        using var scope = serviceProvider.CreateScope();
+        var dbContext = scope.ServiceProvider.GetRequiredService<ServiceControlDbContextBase>();
+
+        var entities = dbContext.EndpointSettings.AsNoTracking().AsAsyncEnumerable();
+
+        await foreach (var entity in entities)
+        {
+            yield return new EndpointSettings
+            {
+                Name = entity.Name,
+                TrackInstances = entity.TrackInstances
+            };
+        }
+    }
+
+    public async Task UpdateEndpointSettings(EndpointSettings settings, CancellationToken cancellationToken)
+    {
+        using var scope = serviceProvider.CreateScope();
+        var dbContext = scope.ServiceProvider.GetRequiredService<ServiceControlDbContextBase>();
+
+        var entity = new EndpointSettingsEntity
+        {
+            Name = settings.Name,
+            TrackInstances = settings.TrackInstances
+        };
+
+        await upsertHelper.Upsert(dbContext, entity, cancellationToken);
+    }
+
+    public async Task Delete(string name, CancellationToken cancellationToken)
+    {
+        using var scope = serviceProvider.CreateScope();
+        var dbContext = scope.ServiceProvider.GetRequiredService<ServiceControlDbContextBase>();
+
+        await dbContext.EndpointSettings
+            .Where(e => e.Name == name)
+            .ExecuteDeleteAsync(cancellationToken);
+    }
+}

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

@@ -0,0 +1,77 @@
+namespace ServiceControl.Persistence.Sql.Core.Implementation;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using System.Threading.Tasks;
+using DbContexts;
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using ServiceControl.EventLog;
+using ServiceControl.Persistence;
+using ServiceControl.Persistence.Infrastructure;
+
+public class EventLogDataStore : IEventLogDataStore
+{
+    readonly IServiceProvider serviceProvider;
+
+    public EventLogDataStore(IServiceProvider serviceProvider)
+    {
+        this.serviceProvider = serviceProvider;
+    }
+
+    public async Task Add(EventLogItem logItem)
+    {
+        using var scope = serviceProvider.CreateScope();
+        var dbContext = scope.ServiceProvider.GetRequiredService<ServiceControlDbContextBase>();
+
+        var entity = new EventLogItemEntity
+        {
+            Id = logItem.Id,
+            Description = logItem.Description,
+            Severity = (int)logItem.Severity,
+            RaisedAt = logItem.RaisedAt,
+            Category = logItem.Category,
+            EventType = logItem.EventType,
+            RelatedTo = logItem.RelatedTo != null ? JsonSerializer.Serialize(logItem.RelatedTo) : null
+        };
+
+        await dbContext.EventLogItems.AddAsync(entity);
+        await dbContext.SaveChangesAsync();
+    }
+
+    public async Task<(IList<EventLogItem> items, long total, string version)> GetEventLogItems(PagingInfo pagingInfo)
+    {
+        using var scope = serviceProvider.CreateScope();
+        var dbContext = scope.ServiceProvider.GetRequiredService<ServiceControlDbContextBase>();
+
+        var query = dbContext.EventLogItems
+            .AsNoTracking()
+            .OrderByDescending(e => e.RaisedAt);
+
+        var total = await query.CountAsync();
+
+        var entities = await query
+            .Skip(pagingInfo.Offset)
+            .Take(pagingInfo.PageSize)
+            .ToListAsync();
+
+        var items = entities.Select(entity => new EventLogItem
+        {
+            Id = entity.Id,
+            Description = entity.Description,
+            Severity = (Severity)entity.Severity,
+            RaisedAt = entity.RaisedAt,
+            Category = entity.Category,
+            EventType = entity.EventType,
+            RelatedTo = entity.RelatedTo != null ? JsonSerializer.Deserialize<List<string>>(entity.RelatedTo) : null
+        }).ToList();
+
+        // Version could be based on the latest RaisedAt timestamp
+        var version = entities.Any() ? entities.Max(e => e.RaisedAt).Ticks.ToString() : "0";
+
+        return (items, total, version);
+    }
+}