temporalio 1.5.0 → 1.7.0

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

@@ -61,7 +61,7 @@ module Temporalio
                     :current_deployment_version,
                     :current_history_length, :current_history_size, :replaying, :random,
                     :signal_handlers, :query_handlers, :update_handlers, :context_frozen, :assert_valid_local_activity,
-                    :in_query_or_validator
+                    :in_query_or_validator, :random_disabled, :patch_activation_callback
         attr_accessor :io_enabled, :current_details
 
         def initialize(details)
@@ -77,6 +77,7 @@ module Temporalio
           @scheduler = Scheduler.new(self)
           @payload_converter = details.payload_converter
           @failure_converter = details.failure_converter
+          @patch_activation_callback = details.patch_activation_callback
           @disable_eager_activity_execution = details.disable_eager_activity_execution
           @pending_activities = {} # Keyed by sequence, value is fiber to resume with proto result
           @pending_timers = {} # Keyed by sequence, value is fiber to resume with proto result
@@ -99,7 +100,9 @@ module Temporalio
           @current_history_length = 0
           @current_history_size = 0
           @replaying = false
+          @context_frozen = false
           @in_query_or_validator = false
+          @random_disabled = false
           @workflow_failure_exception_types = details.workflow_failure_exception_types
           @signal_handlers = HandlerHash.new(
             details.definition.signals,
@@ -180,7 +183,9 @@ module Temporalio
           @commands = []
           @current_activation_error = nil
           @continue_as_new_suggested = activation.continue_as_new_suggested
-          @suggest_continue_as_new_reasons = activation.suggest_continue_as_new_reasons.map(&:to_i)
+          @suggest_continue_as_new_reasons = activation.suggest_continue_as_new_reasons.map do |reason|
+            ProtoUtils.enum_to_int(Api::Enums::V1::SuggestContinueAsNewReason, reason)
+          end
           @target_worker_deployment_version_changed = activation.target_worker_deployment_version_changed
           @current_deployment_version = WorkerDeploymentVersion._from_bridge(
             activation.deployment_version_for_current_task
@@ -290,7 +295,12 @@ module Temporalio
           patch_id = patch_id.to_s
           @patches_memoized ||= {}
           @patches_memoized.fetch(patch_id) do
-            patched = !replaying || @patches_notified.include?(patch_id)
+            # Only fresh, non-replay patches can consult rollout policy; replay and deprecation must follow history.
+            patched = if deprecated || replaying || @patches_notified.include?(patch_id)
+                        !replaying || @patches_notified.include?(patch_id)
+                      else
+                        patch_activated?(patch_id)
+                      end
             @patches_memoized[patch_id] = patched
             if patched
               add_command(
@@ -303,6 +313,20 @@ module Temporalio
           end
         end
 
+        def patch_activated?(patch_id)
+          return true unless patch_activation_callback
+
+          patched = with_context_frozen(in_query_or_validator: false, random_disabled: true) do
+            patch_activation_callback.call(Temporalio::Worker::PatchActivationInput.new(
+                                             workflow_info: info,
+                                             patch_id:
+                                           ))
+          end
+          return patched if patched == true || patched == false
+
+          raise TypeError, 'Patch activation callback must return true or false'
+        end
+
         def metric_meter
           @metric_meter ||= ReplaySafeMetric::Meter.new(
             @runtime_metric_meter.with_additional_attributes(
@@ -642,6 +666,7 @@ module Temporalio
                                                                  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),
+                  backoff_start_interval: ProtoUtils.seconds_to_duration(err.backoff_start_interval),
                   memo: ProtoUtils.memo_to_proto_hash(err.memo, payload_converter),
                   headers: ProtoUtils.headers_to_proto_hash(err.headers, payload_converter),
                   search_attributes: err.search_attributes&._to_proto,
@@ -683,13 +708,18 @@ module Temporalio
             @definition_options.failure_exception_types&.any? { |cls| err.is_a?(cls) }
         end
 
-        def with_context_frozen(in_query_or_validator:, &)
+        def with_context_frozen(in_query_or_validator:, random_disabled: false, &)
+          previous_context_frozen = @context_frozen
+          previous_in_query_or_validator = @in_query_or_validator
+          previous_random_disabled = @random_disabled
           @context_frozen = true
           @in_query_or_validator = in_query_or_validator
+          @random_disabled = random_disabled
           yield
         ensure
-          @context_frozen = false
-          @in_query_or_validator = false
+          @context_frozen = previous_context_frozen
+          @in_query_or_validator = previous_in_query_or_validator
+          @random_disabled = previous_random_disabled
         end
 
         def convert_handler_args(payload_array:, defn:)

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

@@ -74,6 +74,7 @@ module Temporalio
           workflow_failure_exception_types:,
           workflow_payload_codec_thread_pool:,
           unsafe_workflow_io_enabled:,
+          patch_activation_callback:,
           debug_mode:,
           assert_valid_local_activity:, on_eviction: nil
         )
@@ -118,6 +119,7 @@ module Temporalio
               t
             end.freeze,
             unsafe_workflow_io_enabled:,
+            patch_activation_callback:,
             assert_valid_local_activity:
           )
           @state.on_eviction = on_eviction if on_eviction
@@ -145,6 +147,8 @@ module Temporalio
           @state.logger.error(e)
         end
 
+        # Returns whether completion was submitted to the bridge
+        # rubocop:disable Naming/PredicateMethod
         def handle_activation_complete(runner:, activation_completion:, encoded:, completion_complete_queue:)
           if @payload_encoding_visitor && !encoded
             if Fiber.current_scheduler
@@ -154,12 +158,15 @@ module Temporalio
                 encode_activation_completion(runner, activation_completion)
               end
             end
+            false
           else
             @state.bridge_worker.async_complete_workflow_activation(
               activation_completion.run_id, activation_completion.to_proto, completion_complete_queue
             )
+            true
           end
         end
+        # rubocop:enable Naming/PredicateMethod
 
         def on_shutdown_complete
           @state.evict_all
@@ -194,7 +201,7 @@ module Temporalio
           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,
-                      :assert_valid_local_activity
+                      :patch_activation_callback, :assert_valid_local_activity
 
           attr_writer :on_eviction
 
@@ -202,7 +209,7 @@ module Temporalio
             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:,
-            assert_valid_local_activity:
+            patch_activation_callback:, assert_valid_local_activity:
           )
             @workflow_definitions = workflow_definitions
             @bridge_worker = bridge_worker
@@ -217,6 +224,7 @@ module Temporalio
             @workflow_interceptors = workflow_interceptors
             @workflow_failure_exception_types = workflow_failure_exception_types
             @unsafe_workflow_io_enabled = unsafe_workflow_io_enabled
+            @patch_activation_callback = patch_activation_callback
             @assert_valid_local_activity = assert_valid_local_activity
 
             @running_workflows = {}

data/lib/temporalio/internal/workflow_task_failure_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Temporalio
+  module Internal
+    # Marker for internal exceptions that must escape workflow fibers and fail the workflow task.
+    module WorkflowTaskFailureError
+    end
+  end
+end

data/lib/temporalio/runtime.rb

@@ -46,20 +46,32 @@ module Temporalio
     end
 
     LoggingOptions = Data.define(
-      :log_filter
+      :log_filter,
+      :log_format
       # TODO(cretz): forward_to
     )
 
+    # Formats for Core logs written to the console.
+    module ConsoleLogFormat
+      COMPACT = :compact
+      PRETTY = :pretty
+      JSON = :json
+    end
+
     # Logging options for runtime telemetry.
     #
     # @!attribute log_filter
     #   @return [LoggingFilterOptions, String] Logging filter for Core, default is new {LoggingFilterOptions} with no
     #     parameters.
+    # @!attribute log_format
+    #   @return [ConsoleLogFormat, nil] Format for Core logs written to the console. If unset, this defaults to compact
+    #     output.
     class LoggingOptions
       # Create logging options
       #
       # @param log_filter [LoggingFilterOptions, String] Logging filter for Core.
-      def initialize(log_filter: LoggingFilterOptions.new)
+      # @param log_format [ConsoleLogFormat, nil] Format for Core logs written to the console.
+      def initialize(log_filter: LoggingFilterOptions.new, log_format: nil)
         super
       end
 
@@ -73,7 +85,8 @@ module Temporalio
                         log_filter._to_bridge
                       else
                         raise 'Log filter must be string or LoggingFilterOptions'
-                      end
+                      end,
+          log_format: log_format&.to_s
         )
       end
     end
@@ -101,8 +114,8 @@ module Temporalio
       # @!visibility private
       def _to_bridge
         # @type self: LoggingFilterOptions
-        "#{other_level},temporalio_sdk_core=#{core_level},temporalio_client=#{core_level}," \
-          "temporalio_sdk=#{core_level},temporalio_bridge=#{core_level}"
+        "#{other_level},temporalio_common=#{core_level},temporalio_sdk_core=#{core_level}," \
+          "temporalio_client=#{core_level},temporalio_sdk=#{core_level},temporalio_bridge=#{core_level}"
       end
     end
 
@@ -332,9 +345,12 @@ module Temporalio
     # @param telemetry [TelemetryOptions] Telemetry options to set.
     # @param worker_heartbeat_interval [Float, nil] Interval for worker heartbeats in seconds. Can be nil to disable
     #   heartbeating. Interval must be between 1s and 60s.
+    # @param disable_environment_info [Boolean] When true, worker heartbeats omit runtime, hosting, and platform
+    #   information. Defaults to false, which advertises this process as CRuby with `RUBY_VERSION`.
     def initialize(
       telemetry: TelemetryOptions.new,
-      worker_heartbeat_interval: 60
+      worker_heartbeat_interval: 60,
+      disable_environment_info: false
     )
       if !worker_heartbeat_interval.nil? && !worker_heartbeat_interval.positive?
         raise 'Worker heartbeat interval must be positive'
@@ -346,7 +362,9 @@ module Temporalio
       @core_runtime = Internal::Bridge::Runtime.new(
         Internal::Bridge::Runtime::Options.new(
           telemetry: telemetry._to_bridge,
-          worker_heartbeat_interval:
+          worker_heartbeat_interval:,
+          disable_environment_info:,
+          runtime_version: RUBY_VERSION
         )
       )
       @metric_meter = Internal::Metric::Meter.create_from_runtime(self) || Metric::Meter.null

data/lib/temporalio/scoped_logger.rb

@@ -42,6 +42,21 @@ module Temporalio
     end
     alias log add
 
+    # returns the logger log level as an integer.
+    def level
+      lvl = super
+
+      return lvl if lvl.is_a?(Integer)
+
+      return Logger::UNKNOWN unless lvl.respond_to?(:upcase)
+
+      if Logger::Severity.const_defined?(lvl.upcase, false)
+        Logger::Severity.const_get(lvl.upcase, false)
+      else
+        Logger::UNKNOWN
+      end
+    end
+
     # @see Logger.debug
     def debug(progname = nil, &)
       add(Logger::DEBUG, nil, progname, &)

data/lib/temporalio/version.rb

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

data/lib/temporalio/worker/activity_executor/fiber.rb

@@ -23,7 +23,7 @@ module Temporalio
         end
 
         # @see ActivityExecutor.initialize_activity
-        def execute_activity(_defn, &)
+        def execute_activity(defn, &) # rubocop:disable Lint/UnusedMethodArgument
           ::Fiber.schedule(&)
         end
 

data/lib/temporalio/worker/activity_executor/thread_pool.rb

@@ -20,7 +20,7 @@ module Temporalio
         end
 
         # @see ActivityExecutor.execute_activity
-        def execute_activity(_defn, &)
+        def execute_activity(defn, &) # rubocop:disable Lint/UnusedMethodArgument
           @thread_pool.execute(&)
         end
 

data/lib/temporalio/worker/illegal_workflow_call_validator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'temporalio/internal/google_protobuf'
+
 module Temporalio
   class Worker
     # Custom validator for validating illegal workflow calls.
@@ -44,7 +46,7 @@ module Temporalio
       def self.known_safe_mutex_validator
         @known_safe_mutex_validator ||= IllegalWorkflowCallValidator.new do
           # Only Google Protobuf use of Mutex is known to be safe, fail unless any caller location path has protobuf
-          raise 'disallowed' unless caller_locations&.any? { |loc| loc.path&.include?('google/protobuf/') }
+          raise 'disallowed' unless ::Temporalio::Internal::GoogleProtobuf.in_call_stack?(caller_locations)
         end
       end
 

data/lib/temporalio/worker/workflow_executor/thread_pool.rb

@@ -4,6 +4,7 @@ require 'etc'
 require 'temporalio/internal/bridge/api'
 require 'temporalio/internal/proto_utils'
 require 'temporalio/internal/worker/workflow_instance'
+require 'temporalio/internal/workflow_task_failure_error'
 require 'temporalio/scoped_logger'
 require 'temporalio/worker/thread_pool'
 require 'temporalio/worker/workflow_executor'
@@ -215,6 +216,7 @@ module Temporalio
                 illegal_calls: worker_state.illegal_calls,
                 workflow_failure_exception_types: worker_state.workflow_failure_exception_types,
                 unsafe_workflow_io_enabled: worker_state.unsafe_workflow_io_enabled,
+                patch_activation_callback: worker_state.patch_activation_callback,
                 assert_valid_local_activity: worker_state.assert_valid_local_activity
               )
             )
@@ -229,7 +231,9 @@ module Temporalio
         private_constant :Worker
 
         # Error raised when a processing a workflow task takes more than the expected amount of time.
-        class DeadlockError < Exception; end # rubocop:disable Lint/InheritException
+        class DeadlockError < Exception # rubocop:disable Lint/InheritException
+          include Internal::WorkflowTaskFailureError
+        end
       end
     end
   end

data/lib/temporalio/worker/workflow_replayer.rb

@@ -240,10 +240,12 @@ module Temporalio
               default_heartbeat_throttle_interval: 1.0,
               max_worker_activities_per_second: nil,
               max_task_queue_activities_per_second: nil,
+              max_eager_activity_reservations_per_workflow_task: 3,
               graceful_shutdown_period: 0.0,
               nondeterminism_as_workflow_fail:,
               nondeterminism_as_workflow_fail_for_types:,
               deployment_options: Worker.default_deployment_options._to_bridge_options,
+              disable_payload_error_limit: true,
               plugins: options.plugins.map(&:name).uniq.sort
             )
           )
@@ -264,6 +266,7 @@ module Temporalio
             workflow_failure_exception_types: options.workflow_failure_exception_types,
             workflow_payload_codec_thread_pool: options.workflow_payload_codec_thread_pool,
             unsafe_workflow_io_enabled: options.unsafe_workflow_io_enabled,
+            patch_activation_callback: nil,
             debug_mode: options.debug_mode,
             on_eviction: proc { |_, remove_job| @last_workflow_remove_job = remove_job }, # steep:ignore
             assert_valid_local_activity: ->(_) {}
@@ -271,6 +274,8 @@ module Temporalio
 
           # Create the runner
           @runner = Internal::Worker::MultiRunner.new(workers: [self], shutdown_signals: [])
+          @pending_workflow_activations = 0
+          @pending_workflow_activation_completions = 0
         end
 
         # Replay a workflow history.
@@ -295,11 +300,12 @@ module Temporalio
               history.workflow_id, Api::History::V1::History.new(events: history.events).to_proto
             )
 
-            # Process events until workflow complete
-            until @last_workflow_remove_job
+            # Process events until workflow complete and all completions submitted to core have finished.
+            until @last_workflow_remove_job && workflow_activation_work_drained?
               event = @runner.next_event
               case event
               when Internal::Worker::MultiRunner::Event::PollSuccess
+                @pending_workflow_activations += 1
                 @workflow_worker.handle_activation(
                   runner: @runner,
                   activation: Internal::Bridge::Api::WorkflowActivation::WorkflowActivation.decode(event.bytes),
@@ -308,14 +314,17 @@ module Temporalio
               when Internal::Worker::MultiRunner::Event::WorkflowActivationDecoded
                 @workflow_worker.handle_activation(runner: @runner, activation: event.activation, decoded: true)
               when Internal::Worker::MultiRunner::Event::WorkflowActivationComplete
-                @workflow_worker.handle_activation_complete(
+                if @workflow_worker.handle_activation_complete(
                   runner: @runner,
                   activation_completion: event.activation_completion,
                   encoded: event.encoded,
                   completion_complete_queue: event.completion_complete_queue
                 )
+                  @pending_workflow_activations -= 1
+                  @pending_workflow_activation_completions += 1
+                end
               when Internal::Worker::MultiRunner::Event::WorkflowActivationCompletionComplete
-              # Ignore
+                @pending_workflow_activation_completions -= 1
               else
                 raise "Unexpected event: #{event}"
               end
@@ -365,6 +374,12 @@ module Temporalio
         def _wait_all_complete
           # Do nothing
         end
+
+        private
+
+        def workflow_activation_work_drained?
+          @pending_workflow_activations.zero? && @pending_workflow_activation_completions.zero?
+        end
       end
     end
   end

data/lib/temporalio/worker.rb

@@ -28,6 +28,17 @@ module Temporalio
   # {run_all} is used for a collection of workers. These can wait until a block is complete or a {Cancellation} is
   # canceled.
   class Worker
+    # Input for the experimental `patch_activation_callback:` worker option.
+    #
+    # @!attribute [r] workflow_info
+    #   @return [Workflow::Info] Information about the workflow execution calling {Workflow.patched}.
+    # @!attribute [r] patch_id
+    #   @return [String] Patch ID passed to {Workflow.patched}.
+    PatchActivationInput = Data.define(
+      :workflow_info,
+      :patch_id
+    )
+
     Options = Data.define(
       :client,
       :task_queue,
@@ -50,6 +61,7 @@ module Temporalio
       :default_heartbeat_throttle_interval,
       :max_activities_per_second,
       :max_task_queue_activities_per_second,
+      :max_eager_activity_reservations_per_workflow_task,
       :graceful_shutdown_period,
       :disable_eager_activity_execution,
       :illegal_workflow_calls,
@@ -57,9 +69,11 @@ module Temporalio
       :workflow_payload_codec_thread_pool,
       :unsafe_workflow_io_enabled,
       :deployment_options,
+      :patch_activation_callback,
       :workflow_task_poller_behavior,
       :activity_task_poller_behavior,
-      :debug_mode
+      :debug_mode,
+      :disable_payload_error_limit
     )
 
     # Options as returned from {options} for `**to_h` splat use in {initialize}. See {initialize} for details.
@@ -81,12 +95,16 @@ module Temporalio
       # hashing all bytecode of required files. This means later/dynamic require
       # won't be accounted for because this is memoized. It also means the
       # tiniest code change will affect this, which is what we want since this
-      # is meant to be a "binary checksum". We have chosen to use MD5 for speed,
-      # similarity with other SDKs, and because security is not a factor.
+      # is meant to be a "binary checksum". We default to MD5 for speed,
+      # similarity with other SDKs, and because security is not a factor. On
+      # FIPS builds we use SHA-256 instead, since MD5 is rejected by FIPS-mode
+      # OpenSSL. This is opt-in (tied to the FIPS build) so existing,
+      # non-FIPS users keep their stable MD5-based build IDs.
       require 'digest'
 
+      initial_digest = Internal::Bridge::FIPS ? Digest::SHA256.new : Digest::MD5.new
       saw_bridge = false
-      build_id = $LOADED_FEATURES.each_with_object(Digest::MD5.new) do |file, digest|
+      build_id = $LOADED_FEATURES.each_with_object(initial_digest) do |file, digest|
         saw_bridge = true if file.include?('temporalio_bridge.')
         digest.update(File.read(file)) if File.file?(file)
       end.hexdigest
@@ -166,6 +184,7 @@ module Temporalio
       raise ArgumentError, 'Not all parameters are workers' unless workers.all?(Worker)
 
       Internal::Bridge.assert_fiber_compatibility!
+      Internal::Bridge.assert_fips_compatibility!
 
       # Start the multi runner
       runner = Internal::Worker::MultiRunner.new(workers:, shutdown_signals:)
@@ -398,6 +417,9 @@ module Temporalio
     # @param max_task_queue_activities_per_second [Float, nil] Sets the maximum number of activities per second the task
     #   queue will dispatch, controlled server-side. Note that this only takes effect upon an activity poll request. If
     #   multiple workers on the same queue have different values set, they will thrash with the last poller winning.
+    # @param max_eager_activity_reservations_per_workflow_task [Integer] Maximum number of activity slots that may be
+    #   reserved for eager execution when completing a workflow task. Defaults to 3 and must be positive. To disable
+    #   eager activity execution, set `disable_eager_activity_execution: true`.
     # @param graceful_shutdown_period [Float] Amount of time after shutdown is called that activities are given to
     #   complete before their tasks are canceled.
     # @param disable_eager_activity_execution [Boolean] If true, disables eager activity execution. Eager activity
@@ -425,6 +447,9 @@ module Temporalio
     #   scheduler will fail. Instead of setting this to true, users are encouraged to use {Workflow::Unsafe.io_enabled}
     #   with a block for narrower enabling of IO.
     # @param deployment_options [DeploymentOptions, nil] Deployment options for the worker.
+    # @param patch_activation_callback [Proc, nil] Experimental callback to decide whether the first non-replay call to
+    #   {Workflow.patched} for a patch ID should activate that patch. The callback receives a {PatchActivationInput} and
+    #   must return `true` to activate the patch or `false` to leave it inactive.
     # @param workflow_task_poller_behavior [PollerBehavior] Specify the behavior of workflow task
     #   polling. Defaults to a 5-poller maximum.
     # @param activity_task_poller_behavior [PollerBehavior] Specify the behavior of activity task
@@ -432,6 +457,9 @@ module Temporalio
     # @param debug_mode [Boolean] If true, deadlock detection is disabled. Deadlock detection will fail workflow tasks
     #   if they block the thread for too long. This defaults to true if the `TEMPORAL_DEBUG` environment variable is
     #   `true` or `1`.
+    # @param disable_payload_error_limit [Boolean] If true, the worker will not proactively fail workflow/activity
+    #   tasks whose payloads exceed the namespace error limits; oversized payloads are sent to the server, which
+    #   enforces the limit. Defaults to false (the worker fails such tasks before sending).
     def initialize(
       client:,
       task_queue:,
@@ -454,6 +482,7 @@ module Temporalio
       default_heartbeat_throttle_interval: 30,
       max_activities_per_second: nil,
       max_task_queue_activities_per_second: nil,
+      max_eager_activity_reservations_per_workflow_task: 3,
       graceful_shutdown_period: 0,
       disable_eager_activity_execution: false,
       illegal_workflow_calls: Worker.default_illegal_workflow_calls,
@@ -461,9 +490,11 @@ module Temporalio
       workflow_payload_codec_thread_pool: nil,
       unsafe_workflow_io_enabled: false,
       deployment_options: Worker.default_deployment_options,
+      patch_activation_callback: nil,
       workflow_task_poller_behavior: PollerBehavior::SimpleMaximum.new(max_concurrent_workflow_task_polls),
       activity_task_poller_behavior: PollerBehavior::SimpleMaximum.new(max_concurrent_activity_task_polls),
-      debug_mode: %w[true 1].include?(ENV['TEMPORAL_DEBUG'].to_s.downcase)
+      debug_mode: %w[true 1].include?(ENV['TEMPORAL_DEBUG'].to_s.downcase),
+      disable_payload_error_limit: false
     )
       Internal::ProtoUtils.assert_non_reserved_name(task_queue)
 
@@ -489,6 +520,7 @@ module Temporalio
         default_heartbeat_throttle_interval:,
         max_activities_per_second:,
         max_task_queue_activities_per_second:,
+        max_eager_activity_reservations_per_workflow_task:,
         graceful_shutdown_period:,
         disable_eager_activity_execution:,
         illegal_workflow_calls:,
@@ -496,9 +528,11 @@ module Temporalio
         workflow_payload_codec_thread_pool:,
         unsafe_workflow_io_enabled:,
         deployment_options:,
+        patch_activation_callback:,
         workflow_task_poller_behavior:,
         activity_task_poller_behavior:,
-        debug_mode:
+        debug_mode:,
+        disable_payload_error_limit:
       ).freeze
       # Collect applicable client plugins and worker plugins, then validate and apply to options
       @plugins = client.options.plugins.grep(Plugin) + plugins
@@ -519,6 +553,11 @@ module Temporalio
         raise ArgumentError,
               'default_versioning_behavior must be UNSPECIFIED when use_worker_versioning is false'
       end
+      unless @options.max_eager_activity_reservations_per_workflow_task.positive?
+        raise ArgumentError,
+              'max_eager_activity_reservations_per_workflow_task must be positive; ' \
+              'use disable_eager_activity_execution: true to disable eager activity execution'
+      end
 
       should_enforce_versioning_behavior =
         @options.deployment_options.use_worker_versioning &&
@@ -555,17 +594,22 @@ module Temporalio
           default_heartbeat_throttle_interval: @options.default_heartbeat_throttle_interval,
           max_worker_activities_per_second: @options.max_activities_per_second,
           max_task_queue_activities_per_second: @options.max_task_queue_activities_per_second,
+          max_eager_activity_reservations_per_workflow_task:
+            @options.max_eager_activity_reservations_per_workflow_task,
           graceful_shutdown_period: @options.graceful_shutdown_period,
           nondeterminism_as_workflow_fail:,
           nondeterminism_as_workflow_fail_for_types:,
           deployment_options: @options.deployment_options._to_bridge_options,
-          plugins: (@options.client.options.plugins + @options.plugins).map(&:name).uniq.sort
+          plugins: (@options.client.options.plugins + @options.plugins).map(&:name).uniq.sort,
+          disable_payload_error_limit: @options.disable_payload_error_limit
         )
       )
 
       # Collect interceptors from client and params
-      @activity_interceptors = (@options.client.options.interceptors + @options.interceptors).grep(Interceptor::Activity)
-      @workflow_interceptors = (@options.client.options.interceptors + @options.interceptors).grep(Interceptor::Workflow)
+      @activity_interceptors =
+        (@options.client.options.interceptors + @options.interceptors).grep(Interceptor::Activity)
+      @workflow_interceptors =
+        (@options.client.options.interceptors + @options.interceptors).grep(Interceptor::Workflow)
 
       # Cancellation for the whole worker
       @worker_shutdown_cancellation = Cancellation.new
@@ -591,6 +635,7 @@ module Temporalio
           workflow_failure_exception_types: @options.workflow_failure_exception_types,
           workflow_payload_codec_thread_pool: @options.workflow_payload_codec_thread_pool,
           unsafe_workflow_io_enabled: @options.unsafe_workflow_io_enabled,
+          patch_activation_callback: @options.patch_activation_callback,
           debug_mode: @options.debug_mode,
           assert_valid_local_activity: ->(activity) { _assert_valid_local_activity(activity) }
         )

data/lib/temporalio/workflow/future.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'temporalio/internal/workflow_task_failure_error'
 require 'temporalio/workflow'
 
 module Temporalio
@@ -81,6 +82,10 @@ module Temporalio
         @fiber = Fiber.schedule do
           @result = block.call # steep:ignore
         rescue Exception => e # rubocop:disable Lint/RescueException
+          # These errors invalidate the whole workflow task. If stored and only raised on wait, the activation may
+          # complete successfully with commands that were emitted before the error.
+          raise if e.is_a?(Internal::WorkflowTaskFailureError)
+
           @failure = e
         ensure
           @done = true

data/lib/temporalio/workflow/nexus_operation_cancellation_type.rb

@@ -9,13 +9,15 @@ module Temporalio
     # WARNING: Nexus support is experimental.
     module NexusOperationCancellationType
       # Wait for cancellation to complete (default).
-      WAIT_CANCELLATION_COMPLETED = Internal::Bridge::Api::Nexus::NexusOperationCancellationType::WAIT_CANCELLATION_COMPLETED
+      WAIT_CANCELLATION_COMPLETED =
+        Internal::Bridge::Api::Nexus::NexusOperationCancellationType::WAIT_CANCELLATION_COMPLETED
       # Abandon the operation without sending a cancellation request.
       ABANDON = Internal::Bridge::Api::Nexus::NexusOperationCancellationType::ABANDON
       # Send a cancellation request but do not wait for confirmation.
       TRY_CANCEL = Internal::Bridge::Api::Nexus::NexusOperationCancellationType::TRY_CANCEL
       # Wait for the server to confirm the cancellation request was delivered.
-      WAIT_CANCELLATION_REQUESTED = Internal::Bridge::Api::Nexus::NexusOperationCancellationType::WAIT_CANCELLATION_REQUESTED
+      WAIT_CANCELLATION_REQUESTED =
+        Internal::Bridge::Api::Nexus::NexusOperationCancellationType::WAIT_CANCELLATION_REQUESTED
     end
   end
 end