started undertaking adding support for cancellation in domain events but pretty much all storage API's aren't supporting cancellation....

ramonsmits · ramonsmits · commit 4171ba9fd5a0 · 2025-03-06T12:14:54.000+01:00
diff --git a/src/ServiceControl.AcceptanceTests.RavenDB/Recoverability/MessageFailures/When_a_message_fails_to_import.cs b/src/ServiceControl.AcceptanceTests.RavenDB/Recoverability/MessageFailures/When_a_message_fails_to_import.cs
@@ -1,6 +1,7 @@
 ﻿namespace ServiceControl.AcceptanceTests.RavenDB.Recoverability.MessageFailures
 {
     using System;
+    using System.Threading;
     using System.Threading.Tasks;
     using AcceptanceTesting;
     using AcceptanceTesting.EndpointTemplates;
@@ -75,7 +76,7 @@ public async Task It_can_be_reimported()
 
         class MessageFailedHandler(MyContext scenarioContext) : IDomainHandler<MessageFailed>
         {
-            public Task Handle(MessageFailed domainEvent)
+            public Task Handle(MessageFailed domainEvent, CancellationToken cancellationToken)
             {
                 scenarioContext.MessageFailedEventPublished = true;
                 return Task.CompletedTask;
diff --git a/src/ServiceControl.DomainEvents/DomainEvents.cs b/src/ServiceControl.DomainEvents/DomainEvents.cs
@@ -1,6 +1,7 @@
 ﻿namespace ServiceControl.Infrastructure.DomainEvents
 {
     using System;
+    using System.Threading;
     using System.Threading.Tasks;
     using Microsoft.Extensions.DependencyInjection;
     using NServiceBus.Logging;
@@ -12,14 +13,14 @@ public class DomainEvents : IDomainEvents
         readonly IServiceProvider serviceProvider;
         public DomainEvents(IServiceProvider serviceProvider) => this.serviceProvider = serviceProvider;
 
-        public async Task Raise<T>(T domainEvent) where T : IDomainEvent
+        public async Task Raise<T>(T domainEvent, CancellationToken cancellationToken) where T : IDomainEvent
         {
             var handlers = serviceProvider.GetServices<IDomainHandler<T>>();
             foreach (var handler in handlers)
             {
                 try
                 {
-                    await handler.Handle(domainEvent)
+                    await handler.Handle(domainEvent, cancellationToken)
                         .ConfigureAwait(false);
                 }
                 catch (Exception e)
@@ -34,7 +35,7 @@ await handler.Handle(domainEvent)
             {
                 try
                 {
-                    await handler.Handle(domainEvent)
+                    await handler.Handle(domainEvent, cancellationToken)
                     .ConfigureAwait(false);
                 }
                 catch (Exception e)
diff --git a/src/ServiceControl.DomainEvents/Interfaces/IDomainEvents.cs b/src/ServiceControl.DomainEvents/Interfaces/IDomainEvents.cs
@@ -1,9 +1,10 @@
 ﻿namespace ServiceControl.Infrastructure.DomainEvents
 {
+    using System.Threading;
     using System.Threading.Tasks;
 
     public interface IDomainEvents
     {
-        Task Raise<T>(T domainEvent) where T : IDomainEvent;
+        Task Raise<T>(T domainEvent, CancellationToken cancellationToken = default) where T : IDomainEvent;
     }
 }
diff --git a/src/ServiceControl.DomainEvents/Interfaces/IDomainHandler.cs b/src/ServiceControl.DomainEvents/Interfaces/IDomainHandler.cs
@@ -1,9 +1,10 @@
 namespace ServiceControl.Infrastructure.DomainEvents
 {
+    using System.Threading;
     using System.Threading.Tasks;
 
     public interface IDomainHandler<in T> where T : IDomainEvent
     {
-        Task Handle(T domainEvent);
+        Task Handle(T domainEvent, CancellationToken cancellationToken = default);
     }
 }
diff --git a/src/ServiceControl.Persistence.Tests/FakeDomainEvents.cs b/src/ServiceControl.Persistence.Tests/FakeDomainEvents.cs
@@ -3,6 +3,7 @@
     using System.Collections.Generic;
     using System.Text.Json;
     using System.Text.Json.Serialization;
+    using System.Threading;
     using System.Threading.Tasks;
     using NUnit.Framework;
     using ServiceControl.Infrastructure.DomainEvents;
@@ -12,7 +13,7 @@ class FakeDomainEvents : IDomainEvents
     {
         public List<object> RaisedEvents { get; } = [];
 
-        public Task Raise<T>(T domainEvent) where T : IDomainEvent
+        public Task Raise<T>(T domainEvent, CancellationToken cancellationToken) where T : IDomainEvent
         {
             RaisedEvents.Add(domainEvent);
             TestContext.Out.WriteLine($"Raised DomainEvent {typeof(T).Name}:");
diff --git a/src/ServiceControl.Persistence/Recoverability/Archiving/InMemoryArchive.cs b/src/ServiceControl.Persistence/Recoverability/Archiving/InMemoryArchive.cs
@@ -1,6 +1,7 @@
 ﻿namespace ServiceControl.Recoverability
 {
     using System;
+    using System.Threading;
     using System.Threading.Tasks;
     using Infrastructure.DomainEvents;
 
@@ -51,7 +52,7 @@ public Task Start()
                 ArchiveType = ArchiveType,
                 Progress = GetProgress(),
                 StartTime = Started
-            });
+            }, CancellationToken.None);
         }
 
         public Task BatchArchived(int numberOfMessagesArchivedInBatch)
@@ -68,7 +69,7 @@ public Task BatchArchived(int numberOfMessagesArchivedInBatch)
                 Progress = GetProgress(),
                 StartTime = Started,
                 Last = Last.Value
-            });
+            }, CancellationToken.None);
         }
 
         public Task FinalizeArchive()
@@ -84,7 +85,7 @@ public Task FinalizeArchive()
                 Progress = GetProgress(),
                 StartTime = Started,
                 Last = Last.Value
-            });
+            }, CancellationToken.None);
         }
 
         public Task Complete()
@@ -103,7 +104,7 @@ public Task Complete()
                 Last = Last.Value,
                 CompletionTime = CompletionTime.Value,
                 GroupName = GroupName
-            });
+            }, CancellationToken.None);
         }
 
         public bool NeedsAcknowledgement()
diff --git a/src/ServiceControl.Persistence/Recoverability/Archiving/InMemoryUnarchive.cs b/src/ServiceControl.Persistence/Recoverability/Archiving/InMemoryUnarchive.cs
@@ -1,6 +1,7 @@
 ﻿namespace ServiceControl.Recoverability
 {
     using System;
+    using System.Threading;
     using System.Threading.Tasks;
     using Infrastructure.DomainEvents;
 
@@ -51,7 +52,7 @@ public Task Start()
                 ArchiveType = ArchiveType,
                 Progress = GetProgress(),
                 StartTime = Started
-            });
+            }, CancellationToken.None);
         }
 
         public Task BatchUnarchived(int numberOfMessagesUnarchivedInBatch)
@@ -68,7 +69,7 @@ public Task BatchUnarchived(int numberOfMessagesUnarchivedInBatch)
                 Progress = GetProgress(),
                 StartTime = Started,
                 Last = Last.Value
-            });
+            }, CancellationToken.None);
         }
 
         public Task FinalizeUnarchive()
@@ -84,7 +85,7 @@ public Task FinalizeUnarchive()
                 Progress = GetProgress(),
                 StartTime = Started,
                 Last = Last.Value
-            });
+            }, CancellationToken.None);
         }
 
         public Task Complete()
@@ -103,7 +104,7 @@ public Task Complete()
                 Last = Last.Value,
                 CompletionTime = CompletionTime.Value,
                 GroupName = GroupName
-            });
+            }, CancellationToken.None);
         }
 
         internal bool NeedsAcknowledgement()
diff --git a/src/ServiceControl.UnitTests/FakeDomainEvents.cs b/src/ServiceControl.UnitTests/FakeDomainEvents.cs
@@ -1,14 +1,15 @@
 ﻿namespace ServiceControl.UnitTests.Operations
 {
     using System.Collections.Generic;
+    using System.Threading;
     using System.Threading.Tasks;
     using ServiceControl.Infrastructure.DomainEvents;
 
     class FakeDomainEvents : IDomainEvents
     {
         public List<object> RaisedEvents { get; } = [];
 
-        public Task Raise<T>(T domainEvent) where T : IDomainEvent
+        public Task Raise<T>(T domainEvent, CancellationToken cancellationToken = default) where T : IDomainEvent
         {
             RaisedEvents.Add(domainEvent);
             return Task.CompletedTask;
diff --git a/src/ServiceControl.UnitTests/Monitoring/EndpointInstanceMonitoringTests.cs b/src/ServiceControl.UnitTests/Monitoring/EndpointInstanceMonitoringTests.cs
@@ -1,6 +1,7 @@
 ﻿namespace ServiceControl.UnitTests.Monitoring
 {
     using System;
+    using System.Threading;
     using System.Threading.Tasks;
     using NUnit.Framework;
     using ServiceControl.Infrastructure.DomainEvents;
@@ -33,7 +34,7 @@ public async Task When_endpoint_removed_should_stay_removed()
 
         class FakeDomainEvents : IDomainEvents
         {
-            public Task Raise<T>(T domainEvent) where T : IDomainEvent
+            public Task Raise<T>(T domainEvent, CancellationToken cancellationToken) where T : IDomainEvent
             {
                 return Task.CompletedTask;
             }
diff --git a/src/ServiceControl/EventLog/AuditEventLogWriter.cs b/src/ServiceControl/EventLog/AuditEventLogWriter.cs
@@ -1,5 +1,6 @@
 ﻿namespace ServiceControl.EventLog
 {
+    using System.Threading;
     using System.Threading.Tasks;
     using Contracts.EventLog;
     using Infrastructure.DomainEvents;
@@ -19,7 +20,7 @@ public AuditEventLogWriter(GlobalEventHandler broadcaster, IErrorMessageDataStor
             this.mappings = mappings;
         }
 
-        public async Task Handle(IDomainEvent message)
+        public async Task Handle(IDomainEvent message, CancellationToken cancellationToken)
         {
             if (!mappings.HasMapping(message))
             {
@@ -41,7 +42,7 @@ await broadcaster.Broadcast(new EventLogItemAdded
                 // The reason is because this data is not useful for end users, so for now we just empty it.
                 // At the moment too much data is being populated in this field, and this has significant down sides to the amount of data we are sending down to ServicePulse (it actually crashes it).
                 RelatedTo = []
-            });
+            }, cancellationToken);
         }
 
         readonly GlobalEventHandler broadcaster;
diff --git a/src/ServiceControl/ExternalIntegrations/IntegrationEventWriter.cs b/src/ServiceControl/ExternalIntegrations/IntegrationEventWriter.cs
@@ -2,6 +2,7 @@
 {
     using System.Collections.Generic;
     using System.Linq;
+    using System.Threading;
     using System.Threading.Tasks;
     using Infrastructure.DomainEvents;
     using NServiceBus.Logging;
@@ -15,7 +16,7 @@ public IntegrationEventWriter(IExternalIntegrationRequestsDataStore store, IEnum
             this.eventPublishers = eventPublishers;
         }
 
-        public async Task Handle(IDomainEvent message)
+        public async Task Handle(IDomainEvent message, CancellationToken cancellationToken)
         {
             var dispatchContexts = eventPublishers
                 .Where(p => p.Handles(message))
diff --git a/src/ServiceControl/Infrastructure/SignalR/GlobalEventHandler.cs b/src/ServiceControl/Infrastructure/SignalR/GlobalEventHandler.cs
@@ -1,14 +1,15 @@
 ﻿namespace ServiceControl.Infrastructure.SignalR
 {
+    using System.Threading;
     using System.Threading.Tasks;
     using Microsoft.AspNetCore.SignalR;
 
     class GlobalEventHandler(IHubContext<MessageStreamerHub> hubContext)
     {
-        public Task Broadcast(IUserInterfaceEvent @event)
+        public Task Broadcast(IUserInterfaceEvent @event, CancellationToken cancellationToken)
         {
             var typeName = @event.GetType().Name;
-            return hubContext.Clients.All.SendAsync("PushEnvelope", new Envelope { Types = [typeName], Message = @event });
+            return hubContext.Clients.All.SendAsync("PushEnvelope", new Envelope { Types = [typeName], Message = @event }, cancellationToken);
         }
     }
 }
diff --git a/src/ServiceControl/Infrastructure/SignalR/ServicePulseNotifier.cs b/src/ServiceControl/Infrastructure/SignalR/ServicePulseNotifier.cs
@@ -1,5 +1,6 @@
 namespace ServiceControl.Infrastructure.SignalR
 {
+    using System.Threading;
     using System.Threading.Tasks;
     using DomainEvents;
 
@@ -8,11 +9,11 @@ namespace ServiceControl.Infrastructure.SignalR
     /// </summary>
     class ServicePulseNotifier(GlobalEventHandler broadcaster) : IDomainHandler<IDomainEvent>
     {
-        public async Task Handle(IDomainEvent domainEvent)
+        public async Task Handle(IDomainEvent domainEvent, CancellationToken cancellationToken)
         {
             if (domainEvent is IUserInterfaceEvent userInterfaceEvent)
             {
-                await broadcaster.Broadcast(userInterfaceEvent);
+                await broadcaster.Broadcast(userInterfaceEvent, cancellationToken);
             }
         }
     }
diff --git a/src/ServiceControl/Monitoring/MonitoringDataPersister.cs b/src/ServiceControl/Monitoring/MonitoringDataPersister.cs
@@ -1,5 +1,6 @@
 ﻿namespace ServiceControl.Monitoring
 {
+    using System.Threading;
     using System.Threading.Tasks;
     using Contracts.EndpointControl;
     using Contracts.HeartbeatMonitoring;
@@ -19,22 +20,22 @@ public MonitoringDataPersister(IMonitoringDataStore monitoringDataStore, IEndpoi
             _endpointInstanceMonitoring = endpointInstanceMonitoring;
         }
 
-        public Task Handle(EndpointDetected domainEvent)
+        public Task Handle(EndpointDetected domainEvent, CancellationToken cancellationToken)
         {
             return _monitoringDataStore.CreateIfNotExists(domainEvent.Endpoint);
         }
 
-        public Task Handle(HeartbeatingEndpointDetected domainEvent)
+        public Task Handle(HeartbeatingEndpointDetected domainEvent, CancellationToken cancellationToken)
         {
             return _monitoringDataStore.CreateOrUpdate(domainEvent.Endpoint, _endpointInstanceMonitoring);
         }
 
-        public Task Handle(MonitoringEnabledForEndpoint domainEvent)
+        public Task Handle(MonitoringEnabledForEndpoint domainEvent, CancellationToken cancellationToken)
         {
             return _monitoringDataStore.UpdateEndpointMonitoring(domainEvent.Endpoint, true);
         }
 
-        public Task Handle(MonitoringDisabledForEndpoint domainEvent)
+        public Task Handle(MonitoringDisabledForEndpoint domainEvent, CancellationToken cancellationToken)
         {
             return _monitoringDataStore.UpdateEndpointMonitoring(domainEvent.Endpoint, false);
         }
diff --git a/src/ServiceControl/Notifications/Email/CustomChecksMailNotification.cs b/src/ServiceControl/Notifications/Email/CustomChecksMailNotification.cs
@@ -2,6 +2,7 @@
 {
     using System;
     using System.Linq;
+    using System.Threading;
     using System.Threading.Tasks;
     using Contracts.CustomChecks;
     using Infrastructure.DomainEvents;
@@ -42,7 +43,7 @@ public CustomChecksMailNotification(IMessageSession messageSession, Settings set
             }
         }
 
-        public Task Handle(CustomCheckFailed domainEvent)
+        public Task Handle(CustomCheckFailed domainEvent, CancellationToken cancellationToken)
         {
             if (IsHealthCheck(domainEvent.CustomCheckId))
             {
@@ -61,13 +62,13 @@ public Task Handle(CustomCheckFailed domainEvent)
 {domainEvent.CustomCheckId} failed on {domainEvent.FailedAt}. 
 
 {domainEvent.FailureReason}"
-                });
+                }, cancellationToken: cancellationToken);
             }
 
             return Task.CompletedTask;
         }
 
-        public Task Handle(CustomCheckSucceeded domainEvent)
+        public Task Handle(CustomCheckSucceeded domainEvent, CancellationToken cancellationToken)
         {
             if (IsHealthCheck(domainEvent.CustomCheckId))
             {
@@ -84,7 +85,7 @@ public Task Handle(CustomCheckSucceeded domainEvent)
                     Body = $@"{domainEvent.Category} check for ServiceControl instance {instanceName} at {instanceAddress}.
 
 {domainEvent.CustomCheckId} succeeded on {domainEvent.SucceededAt}."
-                });
+                }, cancellationToken: cancellationToken);
             }
 
             return Task.CompletedTask;
diff --git a/src/ServiceControl/Recoverability/Retrying/FailedMessageRetryCleaner.cs b/src/ServiceControl/Recoverability/Retrying/FailedMessageRetryCleaner.cs
@@ -1,5 +1,6 @@
 namespace ServiceControl.Recoverability
 {
+    using System.Threading;
     using System.Threading.Tasks;
     using Contracts.MessageFailures;
     using Infrastructure.DomainEvents;
@@ -14,7 +15,7 @@ public FailedMessageRetryCleaner(IErrorMessageDataStore dataStore)
             this.dataStore = dataStore;
         }
 
-        public Task Handle(MessageFailed message)
+        public Task Handle(MessageFailed message, CancellationToken cancellationToken)
         {
             if (message.RepeatedFailure)
             {
diff --git a/src/ServiceControl/Recoverability/Retrying/History/StoreHistoryHandler.cs b/src/ServiceControl/Recoverability/Retrying/History/StoreHistoryHandler.cs
diff --git a/src/ServiceControl/Recoverability/Retrying/Infrastructure/ReturnToSenderDequeuer.cs b/src/ServiceControl/Recoverability/Retrying/Infrastructure/ReturnToSenderDequeuer.cs

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`namespace ServiceControl.AcceptanceTests.RavenDB.Recoverability.MessageFailures`
`2`	`2`	`{`
`3`	`3`	`using System;`
	`4`	`+ using System.Threading;`
`4`	`5`	`using System.Threading.Tasks;`
`5`	`6`	`using AcceptanceTesting;`
`6`	`7`	`using AcceptanceTesting.EndpointTemplates;`
`@@ -75,7 +76,7 @@ public async Task It_can_be_reimported()`
`75`	`76`
`76`	`77`	`class MessageFailedHandler(MyContext scenarioContext) : IDomainHandler<MessageFailed>`
`77`	`78`	`{`
`78`		`- public Task Handle(MessageFailed domainEvent)`
	`79`	`+ public Task Handle(MessageFailed domainEvent, CancellationToken cancellationToken)`
`79`	`80`	`{`
`80`	`81`	`scenarioContext.MessageFailedEventPublished = true;`
`81`	`82`	`return Task.CompletedTask;`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`namespace ServiceControl.Infrastructure.DomainEvents`
`2`	`2`	`{`
`3`	`3`	`using System;`
	`4`	`+ using System.Threading;`
`4`	`5`	`using System.Threading.Tasks;`
`5`	`6`	`using Microsoft.Extensions.DependencyInjection;`
`6`	`7`	`using NServiceBus.Logging;`
`@@ -12,14 +13,14 @@ public class DomainEvents : IDomainEvents`
`12`	`13`	`readonly IServiceProvider serviceProvider;`
`13`	`14`	`public DomainEvents(IServiceProvider serviceProvider) => this.serviceProvider = serviceProvider;`
`14`	`15`
`15`		`- public async Task Raise<T>(T domainEvent) where T : IDomainEvent`
	`16`	`+ public async Task Raise<T>(T domainEvent, CancellationToken cancellationToken) where T : IDomainEvent`
`16`	`17`	`{`
`17`	`18`	`var handlers = serviceProvider.GetServices<IDomainHandler<T>>();`
`18`	`19`	`foreach (var handler in handlers)`
`19`	`20`	`{`
`20`	`21`	`try`
`21`	`22`	`{`
`22`		`- await handler.Handle(domainEvent)`
	`23`	`+ await handler.Handle(domainEvent, cancellationToken)`
`23`	`24`	`.ConfigureAwait(false);`
`24`	`25`	`}`
`25`	`26`	`catch (Exception e)`
`@@ -34,7 +35,7 @@ await handler.Handle(domainEvent)`
`34`	`35`	`{`
`35`	`36`	`try`
`36`	`37`	`{`
`37`		`- await handler.Handle(domainEvent)`
	`38`	`+ await handler.Handle(domainEvent, cancellationToken)`
`38`	`39`	`.ConfigureAwait(false);`
`39`	`40`	`}`
`40`	`41`	`catch (Exception e)`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,10 @@`
`1`	`1`	`namespace ServiceControl.Infrastructure.DomainEvents`
`2`	`2`	`{`
	`3`	`+ using System.Threading;`
`3`	`4`	`using System.Threading.Tasks;`
`4`	`5`
`5`	`6`	`public interface IDomainEvents`
`6`	`7`	`{`
`7`		`- Task Raise<T>(T domainEvent) where T : IDomainEvent;`
	`8`	`+ Task Raise<T>(T domainEvent, CancellationToken cancellationToken = default) where T : IDomainEvent;`
`8`	`9`	`}`
`9`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,14 +1,15 @@`
`1`	`1`	`namespace ServiceControl.UnitTests.Operations`
`2`	`2`	`{`
`3`	`3`	`using System.Collections.Generic;`
	`4`	`+ using System.Threading;`
`4`	`5`	`using System.Threading.Tasks;`
`5`	`6`	`using ServiceControl.Infrastructure.DomainEvents;`
`6`	`7`
`7`	`8`	`class FakeDomainEvents : IDomainEvents`
`8`	`9`	`{`
`9`	`10`	`public List<object> RaisedEvents { get; } = [];`
`10`	`11`
`11`		`- public Task Raise<T>(T domainEvent) where T : IDomainEvent`
	`12`	`+ public Task Raise<T>(T domainEvent, CancellationToken cancellationToken = default) where T : IDomainEvent`
`12`	`13`	`{`
`13`	`14`	`RaisedEvents.Add(domainEvent);`
`14`	`15`	`return Task.CompletedTask;`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`namespace ServiceControl.UnitTests.Monitoring`
`2`	`2`	`{`
`3`	`3`	`using System;`
	`4`	`+ using System.Threading;`
`4`	`5`	`using System.Threading.Tasks;`
`5`	`6`	`using NUnit.Framework;`
`6`	`7`	`using ServiceControl.Infrastructure.DomainEvents;`
`@@ -33,7 +34,7 @@ public async Task When_endpoint_removed_should_stay_removed()`
`33`	`34`
`34`	`35`	`class FakeDomainEvents : IDomainEvents`
`35`	`36`	`{`
`36`		`- public Task Raise<T>(T domainEvent) where T : IDomainEvent`
	`37`	`+ public Task Raise<T>(T domainEvent, CancellationToken cancellationToken) where T : IDomainEvent`
`37`	`38`	`{`
`38`	`39`	`return Task.CompletedTask;`
`39`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`namespace ServiceControl.EventLog`
`2`	`2`	`{`
	`3`	`+ using System.Threading;`
`3`	`4`	`using System.Threading.Tasks;`
`4`	`5`	`using Contracts.EventLog;`
`5`	`6`	`using Infrastructure.DomainEvents;`
`@@ -19,7 +20,7 @@ public AuditEventLogWriter(GlobalEventHandler broadcaster, IErrorMessageDataStor`
`19`	`20`	`this.mappings = mappings;`
`20`	`21`	`}`
`21`	`22`
`22`		`- public async Task Handle(IDomainEvent message)`
	`23`	`+ public async Task Handle(IDomainEvent message, CancellationToken cancellationToken)`
`23`	`24`	`{`
`24`	`25`	`if (!mappings.HasMapping(message))`
`25`	`26`	`{`
`@@ -41,7 +42,7 @@ await broadcaster.Broadcast(new EventLogItemAdded`
`41`	`42`	`// The reason is because this data is not useful for end users, so for now we just empty it.`
`42`	`43`	`// At the moment too much data is being populated in this field, and this has significant down sides to the amount of data we are sending down to ServicePulse (it actually crashes it).`
`43`	`44`	`RelatedTo = []`
`44`		`- });`
	`45`	`+ }, cancellationToken);`
`45`	`46`	`}`
`46`	`47`
`47`	`48`	`readonly GlobalEventHandler broadcaster;`