Rule fixes.

backend/src/Squidex.Domain.Apps.Entities/Rules/IRuleEnqueuer.cs

@@ -14,6 +14,6 @@ namespace Squidex.Domain.Apps.Entities.Rules
 {
     public interface IRuleEnqueuer
     {
-        Task Enqueue(Rule rule, Guid ruleId, Envelope<IEvent> @event);
+        Task EnqueueAsync(Rule rule, Guid ruleId, Envelope<IEvent> @event);
     }
 }

backend/src/Squidex.Domain.Apps.Entities/Rules/RuleDomainObject.cs

@@ -100,7 +100,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
 
             var @event = SimpleMapper.Map(command, new RuleManuallyTriggered { RuleId = Snapshot.Id, AppId = Snapshot.AppId });
 
-            await ruleEnqueuer.Enqueue(Snapshot.RuleDef, Snapshot.Id, Envelope.Create(@event));
+            await ruleEnqueuer.EnqueueAsync(Snapshot.RuleDef, Snapshot.Id, Envelope.Create(@event));
 
             return null;
         }

backend/src/Squidex.Domain.Apps.Entities/Rules/RuleEnqueuer.cs

@@ -50,13 +50,11 @@ namespace Squidex.Domain.Apps.Entities.Rules
             this.localCache = localCache;
         }
 
-        public async Task Enqueue(Rule rule, Guid ruleId, Envelope<IEvent> @event)
+        public async Task EnqueueAsync(Rule rule, Guid ruleId, Envelope<IEvent> @event)
         {
             Guard.NotNull(rule, nameof(rule));
             Guard.NotNull(@event, nameof(@event));
 
-            using (localCache.StartContext())
-            {
             var jobs = await ruleService.CreateJobsAsync(rule, ruleId, @event);
 
             foreach (var (job, ex) in jobs)
@@ -79,9 +77,10 @@ namespace Squidex.Domain.Apps.Entities.Rules
                 }
             }
         }
-        }
 
         public async Task On(Envelope<IEvent> @event)
+        {
+            using (localCache.StartContext())
             {
                 if (@event.Payload is AppEvent appEvent)
                 {
@@ -89,7 +88,8 @@ namespace Squidex.Domain.Apps.Entities.Rules
 
                     foreach (var ruleEntity in rules)
                     {
-                    await Enqueue(ruleEntity.RuleDef, ruleEntity.Id, @event);
+                        await EnqueueAsync(ruleEntity.RuleDef, ruleEntity.Id, @event);
+                    }
                 }
             }
         }

backend/src/Squidex/Config/Orleans/OrleansServices.cs

@@ -59,10 +59,10 @@ namespace Squidex.Config.Orleans
                 options.HostSelf = false;
             });
 
+            builder.AddIncomingGrainCallFilter<LoggingFilter>();
             builder.AddIncomingGrainCallFilter<ExceptionWrapperFilter>();
             builder.AddIncomingGrainCallFilter<ActivationLimiterFilter>();
             builder.AddIncomingGrainCallFilter<LocalCacheFilter>();
-            builder.AddIncomingGrainCallFilter<LoggingFilter>();
             builder.AddIncomingGrainCallFilter<StateFilter>();
 
             var orleansPortSilo = config.GetOptionalValue("orleans:siloPort", 11111);

backend/tests/Squidex.Domain.Apps.Entities.Tests/Rules/RuleDomainObjectTests.cs

@@ -165,7 +165,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
 
             Assert.Null(result);
 
-            A.CallTo(() => ruleEnqueuer.Enqueue(sut.Snapshot.RuleDef, sut.Id,
+            A.CallTo(() => ruleEnqueuer.EnqueueAsync(sut.Snapshot.RuleDef, sut.Id,
                 A<Envelope<IEvent>>.That.Matches(x => x.Payload is RuleManuallyTriggered)))
                 .MustHaveHappened();
         }

backend/tests/Squidex.Domain.Apps.Entities.Tests/Rules/RuleEnqueuerTests.cs

@@ -86,7 +86,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
             A.CallTo(() => ruleService.CreateJobsAsync(rule.RuleDef, rule.Id, @event, true))
                 .Returns(new List<(RuleJob, Exception?)> { (job, null) });
 
-            await sut.Enqueue(rule.RuleDef, rule.Id, @event);
+            await sut.EnqueueAsync(rule.RuleDef, rule.Id, @event);
 
             A.CallTo(() => ruleEventRepository.EnqueueAsync(job, now, default))
                 .MustHaveHappened();