Add IsReplayingHistoryEvents to allow logging in queries and validators (#594)

Related to temporalio/features#718

Author: cretz

src/Temporalio/Worker/ReplaySafeLogger.cs

@@ -30,7 +30,7 @@ public void Log<TState>(
             Exception exception,
             Func<TState, Exception, string> formatter)
         {
-            if (!Workflows.Workflow.Unsafe.IsReplaying)
+            if (!Workflows.Workflow.Unsafe.IsReplayingHistoryEvents)
             {
                 underlying.Log<TState>(logLevel, eventId, state, exception, formatter);
             }

src/Temporalio/Worker/ReplaySafeMetricMeter.cs

@@ -46,7 +46,7 @@ internal Counter(MetricCounter<T> underlying)
             public override void Add(
                 T value, IEnumerable<KeyValuePair<string, object>>? extraTags = null)
             {
-                if (!Workflows.Workflow.Unsafe.IsReplaying)
+                if (!Workflows.Workflow.Unsafe.IsReplayingHistoryEvents)
                 {
                     underlying.Add(value, extraTags);
                 }
@@ -68,7 +68,7 @@ internal Histogram(MetricHistogram<T> underlying)
             public override void Record(
                 T value, IEnumerable<KeyValuePair<string, object>>? extraTags = null)
             {
-                if (!Workflows.Workflow.Unsafe.IsReplaying)
+                if (!Workflows.Workflow.Unsafe.IsReplayingHistoryEvents)
                 {
                     underlying.Record(value, extraTags);
                 }
@@ -90,7 +90,7 @@ internal Gauge(MetricGauge<T> underlying)
             public override void Set(
                 T value, IEnumerable<KeyValuePair<string, object>>? extraTags = null)
             {
-                if (!Workflows.Workflow.Unsafe.IsReplaying)
+                if (!Workflows.Workflow.Unsafe.IsReplayingHistoryEvents)
                 {
                     underlying.Set(value, extraTags);
                 }

src/Temporalio/Worker/WorkflowInstance.cs

@@ -95,6 +95,7 @@ internal class WorkflowInstance : TaskScheduler, IWorkflowInstance, IWorkflowCon
         private bool workflowInitialized;
         private bool applyModernEventLoopLogic;
         private bool dynamicOptionsGetterInvoked;
+        private bool inQueryOrValidator;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="WorkflowInstance"/> class.
@@ -352,6 +353,9 @@ public object Instance
         /// <inheritdoc />
         public bool IsReplaying { get; private set; }
 
+        /// <inheritdoc />
+        public bool IsReplayingHistoryEvents => IsReplaying && !inQueryOrValidator;
+
         /// <inheritdoc />
         public ILogger Logger => replaySafeLogger;
 
@@ -1188,12 +1192,20 @@ private Task ApplyDoUpdateAsync(DoUpdate update)
                     {
                         // Capture command count so we can ensure it is unchanged after call
                         var origCmdCount = completion?.Successful?.Commands?.Count ?? 0;
-                        inbound.Value.ValidateUpdate(new(
-                            Id: update.Id,
-                            Update: update.Name,
-                            Definition: updateDefn,
-                            Args: DecodeUpdateArgs(),
-                            Headers: update.Headers));
+                        try
+                        {
+                            inQueryOrValidator = true;
+                            inbound.Value.ValidateUpdate(new(
+                                Id: update.Id,
+                                Update: update.Name,
+                                Definition: updateDefn,
+                                Args: DecodeUpdateArgs(),
+                                Headers: update.Headers));
+                        }
+                        finally
+                        {
+                            inQueryOrValidator = false;
+                        }
                         // If the command count changed, we need to issue a task failure
                         var newCmdCount = completion?.Successful?.Commands?.Count ?? 0;
                         if (origCmdCount != newCmdCount)
@@ -1367,6 +1379,7 @@ private void ApplyQueryWorkflow(QueryWorkflow query)
                 var origCmdCount = completion?.Successful?.Commands?.Count;
                 try
                 {
+                    inQueryOrValidator = true;
                     WorkflowQueryDefinition? queryDefn;
                     object? resultObj;
 
@@ -1437,6 +1450,10 @@ private void ApplyQueryWorkflow(QueryWorkflow query)
                     });
                     return Task.CompletedTask;
                 }
+                finally
+                {
+                    inQueryOrValidator = false;
+                }
                 // Check for commands but don't include null counts in check since Successful is
                 // unset by other completion failures
                 var newCmdCount = completion?.Successful?.Commands?.Count;

src/Temporalio/Workflows/IWorkflowContext.cs

@@ -88,6 +88,11 @@ internal interface IWorkflowContext
         /// </summary>
         bool IsReplaying { get; }
 
+        /// <summary>
+        /// Gets a value indicating whether <see cref="Workflow.Unsafe.IsReplayingHistoryEvents" /> is true.
+        /// </summary>
+        bool IsReplayingHistoryEvents { get; }
+
         /// <summary>
         /// Gets value for <see cref="Workflow.Logger" />.
         /// </summary>

src/Temporalio/Workflows/Workflow.cs

@@ -1393,11 +1393,21 @@ public static class Unsafe
             /// Gets a value indicating whether this workflow is replaying.
             /// </summary>
             /// <remarks>
-            /// This should not be used for most cases. It is only valuable for advanced cases like
-            /// preventing a log or metric from being recorded on replay.
+            /// This returns true during replay, including during queries and update validators that
+            /// are executed during a replaying workflow task. This should not be used for most cases.
             /// </remarks>
             public static bool IsReplaying => Context.IsReplaying;
 
+            /// <summary>
+            /// Gets a value indicating whether this workflow is replaying history events.
+            /// </summary>
+            /// <remarks>
+            /// This returns true during replay, but false during queries and update validators even
+            /// when they are executed during a replaying workflow task. This should not be used for
+            /// most cases.
+            /// </remarks>
+            public static bool IsReplayingHistoryEvents => Context.IsReplayingHistoryEvents;
+
             /// <summary>
             /// Disables the event listener that catches invalid calls and thread operations in
             /// workflows. This is the equivalent of

tests/Temporalio.Tests/Worker/WorkflowWorkerTests.cs

@@ -6052,6 +6052,13 @@ public async Task UpdateAsync()
             Workflow.Logger.LogInformation("In update");
             complete.SetResult();
         }
+
+        [WorkflowQuery]
+        public string QueryWithLogging()
+        {
+            Workflow.Logger.LogInformation("In query");
+            return "query-result";
+        }
     }
 
     [Fact]
@@ -6066,6 +6073,8 @@ await ExecuteWorkerAsync<UpdateLogWorkflow>(
                 var handle = await Client.StartWorkflowAsync(
                     (UpdateLogWorkflow wf) => wf.RunAsync(),
                     new(id: $"workflow-{Guid.NewGuid()}", taskQueue: worker.Options.TaskQueue!));
+                // Execute query to confirm it logs
+                Assert.Equal("query-result", await handle.QueryAsync(wf => wf.QueryWithLogging()));
                 await handle.ExecuteUpdateAsync(
                     wf => wf.UpdateAsync(), new() { Id = "my-update-id" });
                 await handle.GetResultAsync();
@@ -6084,6 +6093,10 @@ await handle.ExecuteUpdateAsync(
         Assert.Equal("UpdateLogWorkflow", updateLog.ScopeValues["WorkflowType"]);
         Assert.Equal("my-update-id", updateLog.ScopeValues["UpdateId"]);
         Assert.Equal("Update", updateLog.ScopeValues["UpdateName"]);
+        // Check query log - should be present now with IsReplayingHistoryEvents
+        var queryLog = Assert.Single(loggerFactory.Logs, l => l.Formatted == "In query");
+        Assert.Equal("UpdateLogWorkflow", queryLog.ScopeValues["WorkflowType"]);
+        Assert.False(queryLog.ScopeValues.ContainsKey("UpdateId"));
     }
 
     [Workflow]