feat: Implement Filesystem and MongoDB provenance writers for PackRun execution context

- Added `FilesystemPackRunProvenanceWriter` to write provenance manifests to the filesystem.
- Introduced `MongoPackRunArtifactReader` to read artifacts from MongoDB.
- Created `MongoPackRunProvenanceWriter` to store provenance manifests in MongoDB.
- Developed unit tests for filesystem and MongoDB provenance writers.
- Established `ITimelineEventStore` and `ITimelineIngestionService` interfaces for timeline event handling.
- Implemented `TimelineIngestionService` to validate and persist timeline events with hashing.
- Created PostgreSQL schema and migration scripts for timeline indexing.
- Added dependency injection support for timeline indexer services.
- Developed tests for timeline ingestion and schema validation.

src/TimelineIndexer/StellaOps.TimelineIndexer/StellaOps.TimelineIndexer.Worker/Program.cs

@@ -1,7 +1,18 @@
-using StellaOps.TimelineIndexer.Worker;
-
-var builder = Host.CreateApplicationBuilder(args);
-builder.Services.AddHostedService<Worker>();
-
-var host = builder.Build();
-host.Run();
+using Microsoft.Extensions.Configuration;
+using StellaOps.TimelineIndexer.Core.Abstractions;
+using StellaOps.TimelineIndexer.Infrastructure.DependencyInjection;
+using StellaOps.TimelineIndexer.Infrastructure.Subscriptions;
+using StellaOps.TimelineIndexer.Worker;
+
+var builder = Host.CreateApplicationBuilder(args);
+
+builder.Configuration.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
+builder.Configuration.AddJsonFile("appsettings.Development.json", optional: true, reloadOnChange: true);
+builder.Configuration.AddEnvironmentVariables(prefix: "TIMELINE_");
+
+builder.Services.AddTimelineIndexerPostgres(builder.Configuration);
+builder.Services.AddSingleton<ITimelineEventSubscriber, NullTimelineEventSubscriber>();
+builder.Services.AddHostedService<TimelineIngestionWorker>();
+
+var host = builder.Build();
+host.Run();

src/TimelineIndexer/StellaOps.TimelineIndexer/StellaOps.TimelineIndexer.Worker/TimelineIngestionWorker.cs

@@ -0,0 +1,71 @@
+using System.Collections.Concurrent;
+using System.Diagnostics.Metrics;
+using System.Linq;
+using StellaOps.TimelineIndexer.Core.Abstractions;
+using StellaOps.TimelineIndexer.Core.Models;
+
+namespace StellaOps.TimelineIndexer.Worker;
+
+/// <summary>
+/// Background consumer that reads timeline events from configured subscribers and persists them via the ingestion service.
+/// </summary>
+public sealed class TimelineIngestionWorker(
+    IEnumerable<ITimelineEventSubscriber> subscribers,
+    ITimelineIngestionService ingestionService,
+    ILogger<TimelineIngestionWorker> logger) : BackgroundService
+{
+    private static readonly Meter Meter = new("StellaOps.TimelineIndexer", "1.0.0");
+    private static readonly Counter<long> IngestedCounter = Meter.CreateCounter<long>("timeline.ingested");
+    private static readonly Counter<long> DuplicateCounter = Meter.CreateCounter<long>("timeline.duplicates");
+    private static readonly Counter<long> FailedCounter = Meter.CreateCounter<long>("timeline.failed");
+
+    private readonly IEnumerable<ITimelineEventSubscriber> _subscribers = subscribers;
+    private readonly ITimelineIngestionService _ingestion = ingestionService;
+    private readonly ILogger<TimelineIngestionWorker> _logger = logger;
+    private readonly ConcurrentDictionary<(string tenant, string eventId), byte> _sessionSeen = new();
+
+    protected override Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        var tasks = _subscribers.Select(subscriber => ConsumeAsync(subscriber, stoppingToken)).ToArray();
+        return Task.WhenAll(tasks);
+    }
+
+    private async Task ConsumeAsync(ITimelineEventSubscriber subscriber, CancellationToken cancellationToken)
+    {
+        await foreach (var envelope in subscriber.SubscribeAsync(cancellationToken))
+        {
+            var key = (envelope.TenantId, envelope.EventId);
+            if (!_sessionSeen.TryAdd(key, 0))
+            {
+                DuplicateCounter.Add(1);
+                _logger.LogDebug("Skipped duplicate timeline event {EventId} for tenant {Tenant}", envelope.EventId, envelope.TenantId);
+                continue;
+            }
+
+            try
+            {
+                var result = await _ingestion.IngestAsync(envelope, cancellationToken).ConfigureAwait(false);
+                if (result.Inserted)
+                {
+                    IngestedCounter.Add(1);
+                    _logger.LogInformation("Ingested timeline event {EventId} from {Source} (tenant {Tenant})", envelope.EventId, envelope.Source, envelope.TenantId);
+                }
+                else
+                {
+                    DuplicateCounter.Add(1);
+                    _logger.LogDebug("Store reported duplicate for event {EventId} tenant {Tenant}", envelope.EventId, envelope.TenantId);
+                }
+            }
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+            {
+                // Respect shutdown.
+                break;
+            }
+            catch (Exception ex)
+            {
+                FailedCounter.Add(1);
+                _logger.LogError(ex, "Failed to ingest timeline event {EventId} for tenant {Tenant}", envelope.EventId, envelope.TenantId);
+            }
+        }
+    }
+}

src/TimelineIndexer/StellaOps.TimelineIndexer/StellaOps.TimelineIndexer.Worker/Worker.cs

@@ -1,16 +0,0 @@
-namespace StellaOps.TimelineIndexer.Worker;
-
-public class Worker(ILogger<Worker> logger) : BackgroundService
-{
-    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-    {
-        while (!stoppingToken.IsCancellationRequested)
-        {
-            if (logger.IsEnabled(LogLevel.Information))
-            {
-                logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
-            }
-            await Task.Delay(1000, stoppingToken);
-        }
-    }
-}