wip: wire up telemetry throughout the application

corstian · corstian · commit d82afae5506f · 2024-12-11T10:23:51.000+01:00
diff --git a/src/Whaally.Domain/Abstractions/IEvaluationAgent.cs b/src/Whaally.Domain/Abstractions/IEvaluationAgent.cs
@@ -75,7 +75,7 @@ public async Task<IResult<IEventEnvelope[]>> Invoke(params ICommandEnvelope[] co
         
         if (eventResult.IsFailed)
             return Result.Fail<IEventEnvelope[]>(eventResult.Errors);
-
+        
         foreach (var envelope in commandResult.Value) 
             await Continue(envelope);
         
@@ -86,11 +86,11 @@ public async Task<IResult<IEventEnvelope[]>> Invoke(
         IServiceEnvelope serviceEnvelope)
     {
         var serviceResult = await Evaluate(serviceEnvelope);
-
+        
         if (serviceResult.IsFailed)
             return new Result<IEventEnvelope[]>()
                 .WithReasons(serviceResult.Reasons);
-
+        
         return await Invoke(serviceResult.Value);
     }
 }
diff --git a/src/Whaally.Domain/DefaultContextFactory.cs b/src/Whaally.Domain/DefaultContextFactory.cs
@@ -1,3 +1,4 @@
+using System.Collections.ObjectModel;
 using Microsoft.Extensions.DependencyInjection;
 using Whaally.Domain.Abstractions;
 
@@ -6,20 +7,32 @@ namespace Whaally.Domain;
 public class DefaultContextFactory(IServiceProvider services) : IContextFactory
 {
     public ISagaContext CreateSagaContext(IEventMetadata metadata)
-        => new SagaContext(services, metadata);
+        => new SagaContext(services, metadata)
+        {
+            Attributes = new ReadOnlyDictionary<string, object>(metadata.Attributes),
+            AggregateId = metadata.AggregateId,
+            ParentContext = metadata.ParentContext
+        };
 
     public IServiceHandlerContext CreateServiceHandlerContext(IServiceMetadata metadata)
         => new ServiceHandlerContext(
             services,
-            services.GetRequiredService<IEvaluationAgent>());
+            services.GetRequiredService<IEvaluationAgent>())
+        {
+            Attributes = new ReadOnlyDictionary<string, object>(metadata.Attributes),
+            ParentContext = metadata.ParentContext
+        };
 
     public ICommandHandlerContext<TAggregate> CreateCommandHandlerContext<TAggregate>(
         TAggregate aggregate,
         ICommandMetadata metadata)
         where TAggregate : class, IAggregate =>
         new CommandHandlerContext<TAggregate>(services, metadata.AggregateId)
         {
-            Aggregate = aggregate
+            Aggregate = aggregate,
+            Attributes = new ReadOnlyDictionary<string, object>(metadata.Attributes),
+            AggregateId = metadata.AggregateId,
+            ParentContext = metadata.ParentContext
         };
 
     public IEventHandlerContext<TAggregate> CreateEventHandlerContext<TAggregate>(
@@ -28,6 +41,9 @@ public IEventHandlerContext<TAggregate> CreateEventHandlerContext<TAggregate>(
         where TAggregate : class, IAggregate => 
         new EventHandlerContext<TAggregate>(metadata.AggregateId)
         {
-            Aggregate = aggregate
+            Aggregate = aggregate,
+            Attributes = new ReadOnlyDictionary<string, object>(metadata.Attributes),
+            AggregateId = metadata.AggregateId,
+            ParentContext = metadata.ParentContext
         };
 }
diff --git a/src/Whaally.Domain/DefaultEvaluationAgent.cs b/src/Whaally.Domain/DefaultEvaluationAgent.cs
@@ -9,16 +9,17 @@ public class DefaultEvaluationAgent : IEvaluationAgent
 {
     private readonly IServiceProvider _services;
     private readonly DomainContext _domainContext;
-    private readonly IAggregateHandlerFactory _handlerFactory;
     private readonly IContextFactory _contextFactory;
+    private readonly IAggregateHandlerFactory _handlerFactory;
+    
     private readonly Activity? _activity;
     
     public DefaultEvaluationAgent(IServiceProvider services)
     {
         _services = services;
         _domainContext = _services.GetRequiredService<DomainContext>();
-        _handlerFactory = _services.GetRequiredService<IAggregateHandlerFactory>();
         _contextFactory = _services.GetRequiredService<IContextFactory>();
+        _handlerFactory = _services.GetRequiredService<IAggregateHandlerFactory>();
         
         _activity = DomainContext.ActivitySource.StartActivity(
             ActivityKind.Internal,
@@ -36,7 +37,9 @@ public async Task<IResult<ICommandEnvelope[]>> Evaluate(IServiceEnvelope service
     {
         if (serviceEnvelope.Messages.Count() != 1)
             throw new ArgumentException($"Expected {nameof(serviceEnvelope)} to contain one message");
-
+        
+        serviceEnvelope.Metadata.ParentContext = _activity?.Context;
+        
         var serviceContext = _contextFactory.CreateServiceHandlerContext(serviceEnvelope.Metadata);
         
         var result = await _domainContext
@@ -45,13 +48,9 @@ public async Task<IResult<ICommandEnvelope[]>> Evaluate(IServiceEnvelope service
                 serviceContext,
                 serviceEnvelope.Messages.Single());
         
-        if (result.IsFailed)
-            return Result.Fail<ICommandEnvelope[]>(result.Errors);
-        
-        return Result
-            .Ok(Array.Empty<ICommandEnvelope>())
-            .WithReasons(result.Reasons)
-            .WithValue(serviceContext.Commands.ToArray());
+        return new Result<ICommandEnvelope[]>()
+            .WithValue(serviceContext.Commands.ToArray())
+            .WithReasons(result.Reasons);
     }
     
     /// <summary>
@@ -68,23 +67,20 @@ public async Task<IResult<IEventEnvelope[]>> Evaluate(params ICommandEnvelope[]
         {
             if (!envelope.Messages.Any()) continue;
             
+            envelope.Metadata.ParentContext = _activity?.Context;
+            
             var handler = _handlerFactory.Instantiate(
                 GetCommonAggregateType(envelope),
                 envelope.Metadata.AggregateId);
             
             results.Add(await handler.Evaluate(envelope));
         }
-        
-        var result = Result
-            .Ok(Array.Empty<IEventEnvelope>())
-            .WithReasons(results.SelectMany(q => q.Reasons));
-        
-        if (result.IsSuccess)
-            result.WithValue(results
+
+        return new Result<IEventEnvelope[]>()
+            .WithValue(results
                 .Select(q => q.Value)
-                .ToArray());
-        
-        return result;
+                .ToArray())
+            .WithReasons(results.SelectMany(q => q.Reasons));
     }
     
     /// <summary>
@@ -100,6 +96,8 @@ public async Task<IResultBase> Apply(params IEventEnvelope[] eventEnvelopes)
         foreach (var envelope in eventEnvelopes)
         {
             if (!envelope.Messages.Any()) continue;
+
+            envelope.Metadata.ParentContext = _activity?.Context;
             
             var handler = _handlerFactory.Instantiate(
                 GetCommonAggregateType(envelope),
@@ -108,10 +106,8 @@ public async Task<IResultBase> Apply(params IEventEnvelope[] eventEnvelopes)
             results.Add(await handler.Apply(envelope));
         }
         
-        var result = new Result()
+        return new Result()
             .WithReasons(results.SelectMany(q => q.Reasons));
-        
-        return result;
     }
     
     /// <summary>
@@ -121,6 +117,8 @@ public async Task<IResultBase> Apply(params IEventEnvelope[] eventEnvelopes)
     /// <returns></returns>
     public Task<IResultBase> Continue(IEventEnvelope eventEnvelope)
     {
+        eventEnvelope.Metadata.ParentContext = _activity?.Context;
+        
         foreach (var @event in eventEnvelope.Messages)
         {
             foreach (var saga in _domainContext.GetSaga(@event.GetType()))
@@ -142,6 +140,8 @@ public async Task<IResultBase> Invoke(ISaga saga, IEventEnvelope eventEnvelope)
     {
         if (eventEnvelope.Messages.Count() != 1)
             throw new ArgumentException($"Expected {nameof(eventEnvelope)} to contain one message");
+
+        eventEnvelope.Metadata.ParentContext = _activity?.Context;
         
         return await saga.Evaluate(
             _contextFactory.CreateSagaContext(eventEnvelope.Metadata), 
diff --git a/src/Whaally.Domain/DomainContext.cs b/src/Whaally.Domain/DomainContext.cs
@@ -12,10 +12,26 @@ namespace Whaally.Domain;
  * - Do not inject dependencies to this class (IAggregateHandlerFactory & IEvaluationAgent) as concrete instances.
  *   Doing so causes an infinite loop as this class is often injected as dependency to those.
  */
-public class DomainContext(IServiceProvider services)
+public class DomainContext
 {
     internal static ActivitySource ActivitySource = new("Whaally.Domain");
     
+    private readonly IServiceProvider _services;
+    private readonly Activity? _activity;
+
+    public DomainContext(IServiceProvider services)
+    {
+        _services = services;
+        
+        _activity = ActivitySource.StartActivity(
+            ActivityKind.Internal,
+            name: nameof(DomainContext),
+            tags: new Dictionary<string, object?>
+            {
+                
+            });
+    }
+    
     #region handler metadata
     /// <summary>
     ///     Metadata about the command handlers registered with this domain instance.
@@ -102,12 +118,12 @@ public IEnumerable<Type> SnapshotFactoryTypes
         init => SnapshotFactories = value.Select(SnapshotFactoryMeta.From).ToList().AsReadOnly();
     } 
     #endregion
-
-    private IEvaluationAgent _evaluationAgent => services.GetRequiredService<IEvaluationAgent>();
-
+    
+    private IEvaluationAgent _evaluationAgent => _services.GetRequiredService<IEvaluationAgent>();
+    
     private IAggregateHandler GetAggregate(Type type, string id)
     {
-        var aggregateHandlerFactory = services.GetRequiredService<IAggregateHandlerFactory>();
+        var aggregateHandlerFactory = _services.GetRequiredService<IAggregateHandlerFactory>();
         
         if (type.IsAssignableTo(typeof(IAggregate)))
         {
@@ -151,7 +167,8 @@ public virtual Task<IResult<IEventEnvelope[]>> Evaluate<TCommand>(
             new CommandMetadata
             {
                 AggregateId = aggregateId,
-                CreatedAt = DateTimeOffset.UtcNow
+                CreatedAt = DateTimeOffset.UtcNow,
+                ParentContext = _activity?.Context
             },
             command);
     }
@@ -164,7 +181,8 @@ public virtual Task<IResult<IEventEnvelope[]>> Evaluate(
             new CommandEnvelope(
                 new CommandMetadata
                 {
-                    AggregateId = aggregateId
+                    AggregateId = aggregateId,
+                    ParentContext = _activity?.Context
                 },
                 commands));
     }
@@ -192,7 +210,8 @@ public virtual Task<IResult<IEventEnvelope[]>> Trigger(
                 new CommandMetadata
                 {
                     AggregateId = aggregateId,
-                    CreatedAt = DateTimeOffset.UtcNow
+                    CreatedAt = DateTimeOffset.UtcNow,
+                    ParentContext = _activity?.Context
                 },
                 commands));
     }
@@ -207,30 +226,31 @@ public virtual Task<IResult<IEventEnvelope[]>> Trigger(
             new ServiceEnvelope(
                 metadata ?? new ServiceMetadata
                 {
-                    CreatedAt = DateTimeOffset.UtcNow
+                    CreatedAt = DateTimeOffset.UtcNow,
+                    ParentContext = _activity?.Context
                 }, service));
     }
     
     public IServiceHandler GetServiceHandler(Type serviceType) => 
-        (IServiceHandler)services.GetRequiredService(
+        (IServiceHandler)_services.GetRequiredService(
             ServiceHandlers
                 .Single(q => q.ServiceType == serviceType)
                 .HandlerType);
     
     public IEnumerable<ISaga> GetSaga(Type eventType) =>
         Sagas.Where(q => q.EventType == eventType)
-            .Select(q => (ISaga)services.GetRequiredService(q.HandlerType));
+            .Select(q => (ISaga)_services.GetRequiredService(q.HandlerType));
 
     public IEventHandler GetEventHandler(Type eventType) =>
-        (IEventHandler)services.GetRequiredService(
+        (IEventHandler)_services.GetRequiredService(
             EventHandlers
                 .Single(q => q.EventType == eventType)
                 .HandlerType);
 
     // TODO: See if we can also require the aggregate type as argument to validate that we're executing the correct handlers
     //       Same goes for the event handlers though.
     public ICommandHandler GetCommandHandler(Type commandType) =>
-        (ICommandHandler)services.GetRequiredService(
+        (ICommandHandler)_services.GetRequiredService(
             CommandHandlers
                 .Single(q => q.CommandType == commandType)
                 .HandlerType);
diff --git a/src/Whaally.Domain/Service/ServiceHandlerContext.cs b/src/Whaally.Domain/Service/ServiceHandlerContext.cs
@@ -11,6 +11,8 @@ public class ServiceHandlerContext : IServiceHandlerContext
     private readonly IServiceProvider _services;
     private readonly IEvaluationAgent _evaluationAgent;
 
+    // ToDo: Add an activity here to track service evaluation
+    
     public ServiceHandlerContext(
         IServiceProvider services,
         IEvaluationAgent evaluationAgent)
