temporalio 0.4.0-x86_64-darwin → 0.5.0-x86_64-darwin

data/lib/temporalio/internal/worker/workflow_instance.rb

@@ -24,6 +24,7 @@ require 'temporalio/internal/worker/workflow_instance/scheduler'
 require 'temporalio/retry_policy'
 require 'temporalio/scoped_logger'
 require 'temporalio/worker/interceptor'
+require 'temporalio/worker_deployment_version'
 require 'temporalio/workflow/info'
 require 'temporalio/workflow/update_info'
 require 'timeout'
@@ -54,9 +55,9 @@ module Temporalio
         attr_reader :context, :logger, :info, :scheduler, :disable_eager_activity_execution, :pending_activities,
                     :pending_timers, :pending_child_workflow_starts, :pending_child_workflows,
                     :pending_external_signals, :pending_external_cancels, :in_progress_handlers, :payload_converter,
-                    :failure_converter, :cancellation, :continue_as_new_suggested, :current_history_length,
-                    :current_history_size, :replaying, :random, :signal_handlers, :query_handlers, :update_handlers,
-                    :context_frozen
+                    :failure_converter, :cancellation, :continue_as_new_suggested, :current_deployment_version,
+                    :current_history_length, :current_history_size, :replaying, :random,
+                    :signal_handlers, :query_handlers, :update_handlers, :context_frozen, :assert_valid_local_activity
         attr_accessor :io_enabled, :current_details
 
         def initialize(details)
@@ -90,7 +91,7 @@ module Temporalio
           @current_history_length = 0
           @current_history_size = 0
           @replaying = false
-          @failure_exception_types = details.workflow_failure_exception_types + @definition.failure_exception_types
+          @workflow_failure_exception_types = details.workflow_failure_exception_types
           @signal_handlers = HandlerHash.new(
             details.definition.signals,
             Workflow::Definition::Signal
@@ -107,6 +108,12 @@ module Temporalio
           end
           @query_handlers = HandlerHash.new(details.definition.queries, Workflow::Definition::Query)
           @update_handlers = HandlerHash.new(details.definition.updates, Workflow::Definition::Update)
+          @definition_options = Workflow::DefinitionOptions.new(
+            failure_exception_types: details.definition.failure_exception_types,
+            versioning_behavior: details.definition.versioning_behavior
+          )
+
+          @assert_valid_local_activity = details.assert_valid_local_activity
 
           # Create all things needed from initial job
           @init_job = details.initial_activation.jobs.find { |j| !j.initialize_workflow.nil? }&.initialize_workflow
@@ -133,6 +140,7 @@ module Temporalio
                           workflow_id: @init_job.parent_workflow_info.workflow_id
                         )
                       end,
+              priority: Priority._from_proto(@init_job.priority),
               retry_policy: (RetryPolicy._from_proto(@init_job.retry_policy) if @init_job.retry_policy),
               root: if @init_job.root_workflow
                       Workflow::Info::RootInfo.new(
@@ -142,7 +150,7 @@ module Temporalio
                     end,
               run_id: details.initial_activation.run_id,
               run_timeout: ProtoUtils.duration_to_seconds(@init_job.workflow_run_timeout),
-              start_time: ProtoUtils.timestamp_to_time(details.initial_activation.timestamp) || raise,
+              start_time: ProtoUtils.timestamp_to_time(@init_job.start_time) || raise,
               task_queue: details.task_queue,
               task_timeout: ProtoUtils.duration_to_seconds(@init_job.workflow_task_timeout) || raise,
               workflow_id: @init_job.workflow_id,
@@ -238,6 +246,9 @@ module Temporalio
           @commands = []
           @current_activation_error = nil
           @continue_as_new_suggested = activation.continue_as_new_suggested
+          @current_deployment_version = WorkerDeploymentVersion._from_bridge(
+            activation.deployment_version_for_current_task
+          )
           @current_history_length = activation.history_length
           @current_history_size = activation.history_size_bytes
           @replaying = activation.is_replaying
@@ -287,7 +298,9 @@ module Temporalio
           else
             Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion.new(
               run_id: activation.run_id,
-              successful: Bridge::Api::WorkflowCompletion::Success.new(commands: @commands)
+              successful: Bridge::Api::WorkflowCompletion::Success.new(
+                commands: @commands, versioning_behavior: @definition_options.versioning_behavior
+              )
             )
           end
         ensure
@@ -299,7 +312,8 @@ module Temporalio
           # Convert workflow arguments
           @workflow_arguments = convert_args(payload_array: @init_job.arguments,
                                              method_name: :execute,
-                                             raw_args: @definition.raw_args)
+                                             raw_args: @definition.raw_args,
+                                             arg_hints: @definition.arg_hints)
 
           # Initialize interceptors
           @inbound = @interceptors.reverse_each.reduce(InboundImplementation.new(self)) do |acc, int|
@@ -308,11 +322,24 @@ module Temporalio
           @inbound.init(OutboundImplementation.new(self))
 
           # Create the user instance
-          if @definition.init
-            @definition.workflow_class.new(*@workflow_arguments)
-          else
-            @definition.workflow_class.new
+          instance = if @definition.init
+                       @definition.workflow_class.new(*@workflow_arguments)
+                     else
+                       @definition.workflow_class.new
+                     end
+
+          # Run Dynamic config getter
+          if @definition.dynamic_options_method
+            dynamic_options = instance.send(@definition.dynamic_options_method)
+            if dynamic_options&.versioning_behavior
+              @definition_options.versioning_behavior = dynamic_options.versioning_behavior
+            end
+            if dynamic_options&.failure_exception_types
+              @definition_options.failure_exception_types = dynamic_options.failure_exception_types
+            end
           end
+
+          instance
         end
 
         def apply(job)
@@ -394,6 +421,7 @@ module Temporalio
         end
 
         def apply_query(job)
+          result_hint = nil
           schedule do
             # If it's a built-in, run it without interceptors, otherwise do normal behavior
             result = if job.query_type == '__stack_trace'
@@ -411,6 +439,7 @@ module Temporalio
                          raise "Query handler for #{job.query_type} expected but not found, " \
                                "known queries: [#{query_handlers.keys.compact.sort.join(', ')}]"
                        end
+                       result_hint = defn.result_hint
 
                        with_context_frozen do
                          @inbound.handle_query(
@@ -434,7 +463,7 @@ module Temporalio
                 respond_to_query: Bridge::Api::WorkflowCommands::QueryResult.new(
                   query_id: job.query_id,
                   succeeded: Bridge::Api::WorkflowCommands::QuerySuccess.new(
-                    response: @payload_converter.to_payload(result)
+                    response: @payload_converter.to_payload(result, hint: result_hint)
                   )
                 )
               )
@@ -523,7 +552,7 @@ module Temporalio
               Bridge::Api::WorkflowCommands::WorkflowCommand.new(
                 update_response: Bridge::Api::WorkflowCommands::UpdateResponse.new(
                   protocol_instance_id: job.protocol_instance_id,
-                  completed: @payload_converter.to_payload(result)
+                  completed: @payload_converter.to_payload(result, hint: defn.result_hint)
                 )
               )
             )
@@ -553,7 +582,7 @@ module Temporalio
           add_command(
             Bridge::Api::WorkflowCommands::WorkflowCommand.new(
               complete_workflow_execution: Bridge::Api::WorkflowCommands::CompleteWorkflowExecution.new(
-                result: @payload_converter.to_payload(result)
+                result: @payload_converter.to_payload(result, hint: @definition.result_hint)
               )
             )
           )
@@ -581,14 +610,19 @@ module Temporalio
         def on_top_level_exception(err)
           if err.is_a?(Workflow::ContinueAsNewError)
             @logger.debug('Workflow requested continue as new')
+            workflow_type, defn_arg_hints, =
+              if err.workflow
+                Workflow::Definition._workflow_type_and_hints_from_workflow_parameter(err.workflow)
+              else
+                [nil, @definition.arg_hints, nil]
+              end
             add_command(
               Bridge::Api::WorkflowCommands::WorkflowCommand.new(
                 continue_as_new_workflow_execution: Bridge::Api::WorkflowCommands::ContinueAsNewWorkflowExecution.new(
-                  workflow_type: if err.workflow
-                                   Workflow::Definition._workflow_type_from_workflow_parameter(err.workflow)
-                                 end,
+                  workflow_type:,
                   task_queue: err.task_queue,
-                  arguments: ProtoUtils.convert_to_payload_array(payload_converter, err.args),
+                  arguments: ProtoUtils.convert_to_payload_array(payload_converter, err.args,
+                                                                 hints: err.arg_hints || defn_arg_hints),
                   workflow_run_timeout: ProtoUtils.seconds_to_duration(err.run_timeout),
                   workflow_task_timeout: ProtoUtils.seconds_to_duration(err.task_timeout),
                   memo: ProtoUtils.memo_to_proto_hash(err.memo, payload_converter),
@@ -626,9 +660,9 @@ module Temporalio
         end
 
         def failure_exception?(err)
-          err.is_a?(Error::Failure) || err.is_a?(Timeout::Error) || @failure_exception_types.any? do |cls|
-            err.is_a?(cls)
-          end
+          err.is_a?(Error::Failure) || err.is_a?(Timeout::Error) ||
+            @workflow_failure_exception_types&.any? { |cls| err.is_a?(cls) } ||
+            @definition_options.failure_exception_types&.any? { |cls| err.is_a?(cls) }
         end
 
         def with_context_frozen(&)
@@ -643,11 +677,12 @@ module Temporalio
             payload_array:,
             method_name: defn.to_invoke.is_a?(Symbol) ? defn.to_invoke : nil,
             raw_args: defn.raw_args,
+            arg_hints: defn.arg_hints,
             ignore_first_param: defn.name.nil? # Dynamic
           )
         end
 
-        def convert_args(payload_array:, method_name:, raw_args:, ignore_first_param: false)
+        def convert_args(payload_array:, method_name:, raw_args:, arg_hints:, ignore_first_param: false)
           # Just in case it is not an array
           payload_array = payload_array.to_ary
 
@@ -687,7 +722,7 @@ module Temporalio
           if raw_args
             payload_array.map { |p| Converters::RawValue.new(p) }
           else
-            ProtoUtils.convert_from_payload_array(@payload_converter, payload_array)
+            ProtoUtils.convert_from_payload_array(@payload_converter, payload_array, hints: arg_hints)
           end
         end
 

data/lib/temporalio/internal/worker/workflow_worker.rb

@@ -13,7 +13,7 @@ module Temporalio
     module Worker
       # Worker for handling workflow activations. Most activation work is delegated to the workflow executor.
       class WorkflowWorker
-        def self.workflow_definitions(workflows)
+        def self.workflow_definitions(workflows, should_enforce_versioning_behavior:)
           workflows.each_with_object({}) do |workflow, hash|
             # Load definition
             defn = begin
@@ -29,6 +29,12 @@ module Temporalio
             # Confirm name not in use
             raise ArgumentError, "Multiple workflows named #{defn.name || '<dynamic>'}" if hash.key?(defn.name)
 
+            # Enforce versioning behavior is set when versioning is on
+            if should_enforce_versioning_behavior &&
+               defn.versioning_behavior == VersioningBehavior::UNSPECIFIED && !defn.dynamic_options_method
+              raise ArgumentError, "Workflow #{defn.name} must specify a versioning behavior"
+            end
+
             hash[defn.name] = defn
           end
         end
@@ -69,7 +75,7 @@ module Temporalio
           workflow_payload_codec_thread_pool:,
           unsafe_workflow_io_enabled:,
           debug_mode:,
-          on_eviction: nil
+          assert_valid_local_activity:, on_eviction: nil
         )
           @executor = workflow_executor
 
@@ -105,13 +111,14 @@ module Temporalio
             disable_eager_activity_execution:,
             workflow_interceptors:,
             workflow_failure_exception_types: workflow_failure_exception_types.map do |t|
-              unless t.is_a?(Class) && t < Exception
+              unless t.is_a?(Class) && t <= Exception
                 raise ArgumentError, 'All failure types must classes inheriting Exception'
               end
 
               t
             end.freeze,
-            unsafe_workflow_io_enabled:
+            unsafe_workflow_io_enabled:,
+            assert_valid_local_activity:
           )
           @state.on_eviction = on_eviction if on_eviction
 
@@ -186,14 +193,16 @@ module Temporalio
         class State
           attr_reader :workflow_definitions, :bridge_worker, :logger, :metric_meter, :data_converter, :deadlock_timeout,
                       :illegal_calls, :namespace, :task_queue, :disable_eager_activity_execution,
-                      :workflow_interceptors, :workflow_failure_exception_types, :unsafe_workflow_io_enabled
+                      :workflow_interceptors, :workflow_failure_exception_types, :unsafe_workflow_io_enabled,
+                      :assert_valid_local_activity
 
           attr_writer :on_eviction
 
           def initialize(
             workflow_definitions:, bridge_worker:, logger:, metric_meter:, data_converter:, deadlock_timeout:,
             illegal_calls:, namespace:, task_queue:, disable_eager_activity_execution:,
-            workflow_interceptors:, workflow_failure_exception_types:, unsafe_workflow_io_enabled:
+            workflow_interceptors:, workflow_failure_exception_types:, unsafe_workflow_io_enabled:,
+            assert_valid_local_activity:
           )
             @workflow_definitions = workflow_definitions
             @bridge_worker = bridge_worker
@@ -208,6 +217,7 @@ module Temporalio
             @workflow_interceptors = workflow_interceptors
             @workflow_failure_exception_types = workflow_failure_exception_types
             @unsafe_workflow_io_enabled = unsafe_workflow_io_enabled
+            @assert_valid_local_activity = assert_valid_local_activity
 
             @running_workflows = {}
             @running_workflows_mutex = Mutex.new

data/lib/temporalio/priority.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'temporalio/api'
+
+module Temporalio
+  Priority = Data.define(
+    :priority_key
+  )
+
+  # Priority contains metadata that controls relative ordering of task processing when tasks are
+  # backlogged in a queue. Initially, Priority will be used in activity and workflow task
+  # queues, which are typically where backlogs exist. Priority is (for now) attached to
+  # workflows and activities. Activities and child workflows inherit Priority from the workflow
+  # that created them, but may override fields when they are started or modified. For each field
+  # of a Priority on an activity/workflow, not present or equal to zero/empty string means to
+  # inherit the value from the calling workflow, or if there is no calling workflow, then use
+  # the default (documented on the field).
+  #
+  # The overall semantics of Priority are:
+  # 1. First, consider "priority_key": lower number goes first.
+  # (more will be added here later).
+  #
+  # @!attribute priority_key
+  #   @return [Integer, nil] The priority key, which is a positive integer from 1 to n, where
+  #     smaller integers correspond to higher priorities (tasks run sooner). In general, tasks in a
+  #     queue should be processed in close to priority order, although small deviations are possible.
+  #     The maximum priority value (minimum priority) is determined by server configuration, and
+  #     defaults to 5.
+  #
+  #     The default priority is (min+max)/2. With the default max of 5 and min of 1, that comes
+  #     out to 3.
+  class Priority
+    # @!visibility private
+    def self._from_proto(priority)
+      return default if priority.nil?
+
+      new(priority_key: priority.priority_key.zero? ? nil : priority.priority_key)
+    end
+
+    # The default priority instance.
+    #
+    # @return [Priority] The default priority
+    def self.default
+      @default ||= new(priority_key: nil)
+    end
+
+    # @!visibility private
+    def _to_proto
+      return nil if priority_key.nil?
+
+      Temporalio::Api::Common::V1::Priority.new(priority_key: priority_key || 0)
+    end
+
+    # @return [Boolean] True if this priority is empty/default
+    def empty?
+      priority_key.nil?
+    end
+  end
+end

data/lib/temporalio/testing/activity_environment.rb

@@ -21,9 +21,10 @@ module Temporalio
           activity_type: 'unknown',
           attempt: 1,
           current_attempt_scheduled_time: Time.at(0),
-          heartbeat_details: [],
           heartbeat_timeout: nil,
           local?: false,
+          priority: Temporalio::Priority.default,
+          raw_heartbeat_details: [],
           schedule_to_close_timeout: 1.0,
           scheduled_time: Time.at(0),
           start_to_close_timeout: 1.0,
@@ -42,8 +43,10 @@ module Temporalio
       # @param info [Activity::Info] Value for {Activity::Context#info}. Users should not try to instantiate this
       #   themselves, but rather use `with` on {default_info}.
       # @param on_heartbeat [Proc(Array), nil] Proc that is called with all heartbeat details when
-      #   {Activity::Context#heartbeat} is called.
+      #   {Activity::Context#heartbeat} is called. Should return a value
       # @param cancellation [Cancellation] Value for {Activity::Context#cancellation}.
+      # @param on_cancellation_details [Proc, nil] Proc that is called when {Activity::Context#cancellation_details} is
+      #   called. Defaults to a proc that returns an instance if canceled with `cancel_requested` as true.
       # @param worker_shutdown_cancellation [Cancellation] Value for {Activity::Context#worker_shutdown_cancellation}.
       # @param payload_converter [Converters::PayloadConverter] Value for {Activity::Context#payload_converter}.
       # @param logger [Logger] Value for {Activity::Context#logger}.
@@ -55,6 +58,7 @@ module Temporalio
         info: ActivityEnvironment.default_info,
         on_heartbeat: nil,
         cancellation: Cancellation.new,
+        on_cancellation_details: nil,
         worker_shutdown_cancellation: Cancellation.new,
         payload_converter: Converters::PayloadConverter.default,
         logger: Logger.new(nil),
@@ -65,6 +69,9 @@ module Temporalio
         @info = info
         @on_heartbeat = on_heartbeat
         @cancellation = cancellation
+        @on_cancellation_details = on_cancellation_details || proc do
+          @_cancellation_details ||= Activity::CancellationDetails.new if @cancellation.canceled?
+        end
         @worker_shutdown_cancellation = worker_shutdown_cancellation
         @payload_converter = payload_converter
         @logger = logger
@@ -92,6 +99,7 @@ module Temporalio
                                                   defn.instance.is_a?(Proc) ? defn.instance.call : defn.instance,
                                                 on_heartbeat: @on_heartbeat,
                                                 cancellation: @cancellation,
+                                                on_cancellation_details: @on_cancellation_details,
                                                 worker_shutdown_cancellation: @worker_shutdown_cancellation,
                                                 payload_converter: @payload_converter,
                                                 logger: @logger,
@@ -121,6 +129,7 @@ module Temporalio
           instance:,
           on_heartbeat:,
           cancellation:,
+          on_cancellation_details:,
           worker_shutdown_cancellation:,
           payload_converter:,
           logger:,
@@ -131,6 +140,7 @@ module Temporalio
           @instance = instance
           @on_heartbeat = on_heartbeat
           @cancellation = cancellation
+          @on_cancellation_details = on_cancellation_details
           @worker_shutdown_cancellation = worker_shutdown_cancellation
           @payload_converter = payload_converter
           @logger = logger
@@ -152,6 +162,11 @@ module Temporalio
         def client
           @client or raise 'No client configured in this test environment'
         end
+
+        # @!visibility private
+        def cancellation_details
+          @on_cancellation_details.call
+        end
       end
 
       private_constant :Context

data/lib/temporalio/testing/workflow_environment.rb

@@ -322,7 +322,7 @@ module Temporalio
           raise 'Block required' unless block_given?
           return super unless supports_time_skipping?
 
-          already_disabled = @auto_time_skipping
+          already_disabled = !@auto_time_skipping
           @auto_time_skipping = false
           begin
             yield
@@ -394,8 +394,8 @@ module Temporalio
           end
 
           # @!visibility private
-          def result(follow_runs: true, rpc_options: nil)
-            @env.time_skipping_unlocked { super(follow_runs:, rpc_options:) }
+          def result(follow_runs: true, result_hint: nil, rpc_options: nil)
+            @env.time_skipping_unlocked { super(follow_runs:, result_hint:, rpc_options:) }
           end
         end
       end

data/lib/temporalio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Temporalio
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/lib/temporalio/versioning_override.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'temporalio/worker_deployment_version'
+
+module Temporalio
+  # Base class for version overrides that can be provided in start workflow options.
+  # Used to control the versioning behavior of workflows started with this override.
+  #
+  # WARNING: Experimental API.
+  class VersioningOverride
+    # @!visibility private
+    def _to_proto
+      raise NotImplementedError, 'Subclasses must implement this method'
+    end
+
+    # Represents a versioning override to pin a workflow to a specific version
+    class Pinned < VersioningOverride
+      # The worker deployment version to pin to
+      # @return [WorkerDeploymentVersion]
+      attr_reader :version
+
+      # Create a new pinned versioning override
+      #
+      # @param version [WorkerDeploymentVersion] The worker deployment version to pin to
+      def initialize(version)
+        @version = version
+        super()
+      end
+
+      # TODO: Remove deprecated field setting once removed from server
+
+      # @!visibility private
+      def _to_proto
+        Api::Workflow::V1::VersioningOverride.new(
+          behavior: Api::Enums::V1::VersioningBehavior::VERSIONING_BEHAVIOR_PINNED,
+          pinned_version: @version.to_canonical_string,
+          pinned: Api::Workflow::V1::VersioningOverride::PinnedOverride.new(
+            behavior: Api::Workflow::V1::VersioningOverride::PinnedOverrideBehavior::PINNED_OVERRIDE_BEHAVIOR_PINNED,
+            version: @version._to_proto
+          )
+        )
+      end
+    end
+
+    # Represents a versioning override to auto-upgrade a workflow
+    class AutoUpgrade < VersioningOverride
+      # @!visibility private
+      def _to_proto
+        Api::Workflow::V1::VersioningOverride.new(
+          behavior: Api::Enums::V1::VersioningBehavior::VERSIONING_BEHAVIOR_AUTO_UPGRADE,
+          auto_upgrade: true
+        )
+      end
+    end
+  end
+end

data/lib/temporalio/worker/deployment_options.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'temporalio/common_enums'
+require 'temporalio/worker_deployment_version'
+
+module Temporalio
+  class Worker
+    DeploymentOptions = Data.define(
+      :version,
+      :use_worker_versioning,
+      :default_versioning_behavior
+    )
+
+    # Options for configuring the Worker Versioning feature.
+    #
+    # WARNING: Deployment-based versioning is experimental and APIs may change.
+    #
+    # @!attribute version
+    #   @return [WorkerDeploymentVersion] The worker deployment version.
+    # @!attribute use_worker_versioning
+    #   @return [Boolean] Whether worker versioning is enabled.
+    # @!attribute default_versioning_behavior
+    #   @return [VersioningBehavior] The default versioning behavior.
+    class DeploymentOptions
+      def initialize(
+        version:,
+        use_worker_versioning: false,
+        default_versioning_behavior: VersioningBehavior::UNSPECIFIED
+      )
+        super
+      end
+
+      # @!visibility private
+      def _to_bridge_options
+        Internal::Bridge::Worker::DeploymentOptions.new(
+          version: Internal::Bridge::Worker::WorkerDeploymentVersion.new(
+            deployment_name: version.deployment_name, build_id: version.build_id
+          ),
+          use_worker_versioning: use_worker_versioning,
+          default_versioning_behavior: default_versioning_behavior
+        )
+      end
+    end
+  end
+end

data/lib/temporalio/worker/illegal_workflow_call_validator.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Temporalio
+  class Worker
+    # Custom validator for validating illegal workflow calls.
+    class IllegalWorkflowCallValidator
+      CallInfo = Data.define(
+        :class_name,
+        :method_name,
+        :trace_point
+      )
+
+      # Call info passed to the validation block for each validation.
+      #
+      # @!attribute class_name
+      #   @return [String] Class name the method is on.
+      # @!attribute method_name
+      #   @return [String] Method name being called.
+      # @!attribute trace_point
+      #   @return [TracePoint] TracePoint instance for the call.
+      class CallInfo; end # rubocop:disable Lint/EmptyClass
+
+      # @return [Array<IllegalWorkflowCallValidator>] Set of advanced validators for Time calls.
+      def self.default_time_validators
+        @default_time_validators ||= [
+          # Do not consider initialize as invalid if year is present and not "true"
+          IllegalWorkflowCallValidator.new(method_name: :initialize) do |info|
+            year_val = info.trace_point.binding&.local_variable_get(:year)
+            raise 'can only use if passing string or explicit time info' unless year_val && year_val != true
+          end,
+          IllegalWorkflowCallValidator.new(method_name: :now) do
+            # When the xmlschema (aliased as iso8601) call is made, zone_offset is called which has a default parameter
+            # of Time.now.year. We want to prevent failing in that specific case. It is expensive to access the caller
+            # stack, but this is only done in the rare case they are calling this safely.
+            next if caller_locations&.any? { |loc| loc.label == 'zone_offset' || loc.label == 'Time.zone_offset' }
+
+            raise 'Invalid Time.now call'
+          end
+        ]
+      end
+
+      # @return [String, nil] Method name if this validator is specific to a method.
+      attr_reader :method_name
+
+      # @return [Proc] Block provided in constructor to invoke. See constructor for more details.
+      attr_reader :block
+
+      # Create a call validator.
+      #
+      # @param method_name [String, nil] Method name to check. This must be provided if the validator is in an illegal
+      #   call array, this cannot be provided if it is a top-level class validator.
+      # @yield Required block that is called each time validation is needed. If the call raises, the exception message
+      #   is used as the reason why the call is considered invalid. Return value is ignored.
+      # @yieldparam info [CallInfo] Information about the current call.
+      def initialize(method_name: nil, &block)
+        raise 'Block required' unless block_given?
+        raise TypeError, 'Method name must be Symbol' unless method_name.nil? || method_name.is_a?(Symbol)
+
+        @method_name = method_name
+        @block = block
+      end
+    end
+  end
+end