temporalio 1.1.0-aarch64-linux-musl → 1.2.0-aarch64-linux-musl

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

@@ -13,7 +13,7 @@ module Temporalio
             illegal_calls.to_h do |key, val|
               raise TypeError, 'Invalid illegal call map, top-level key must be a String' unless key.is_a?(String)
 
-              # @type var fixed_val: :all | Worker::IllegalWorkflowCallValidator | Hash[Symbol, TrueClass | Worker::IllegalWorkflowCallValidator] # rubocop:disable Layout/LineLength
+              # @type var fixed_val: :all | Temporalio::Worker::IllegalWorkflowCallValidator | Hash[Symbol, (true | Temporalio::Worker::IllegalWorkflowCallValidator)]
               fixed_val = case val
                           when Temporalio::Worker::IllegalWorkflowCallValidator
                             if val.method_name
@@ -86,21 +86,25 @@ module Temporalio
                 when Temporalio::Worker::IllegalWorkflowCallValidator
                   disable_temporarily do
                     vals.block.call(Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo.new(
-                                      class_name:, method_name: tp.callee_id, trace_point: tp
+                                      class_name:,
+                                      method_name: tp.callee_id || :__unknown__,
+                                      trace_point: tp
                                     ))
                     nil
                   rescue Exception => e # rubocop:disable Lint/RescueException
                     ", reason: #{e}"
                   end
                 else
-                  per_method = vals&.[](tp.callee_id)
+                  per_method = vals&.[](tp.callee_id || :__unknown__)
                   case per_method
                   when true
                     ''
                   when Temporalio::Worker::IllegalWorkflowCallValidator
                     disable_temporarily do
                       per_method.block.call(Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo.new(
-                                              class_name:, method_name: tp.callee_id, trace_point: tp
+                                              class_name:,
+                                              method_name: tp.callee_id || :__unknown__,
+                                              trace_point: tp
                                             ))
                       nil
                     rescue Exception => e # rubocop:disable Lint/RescueException

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

@@ -43,7 +43,12 @@ module Temporalio
             @instance.pending_external_cancels[seq] = Fiber.current
 
             # Wait
-            resolution = Fiber.yield
+            resolution = begin
+              Fiber.yield
+            ensure
+              # Remove pending
+              @instance.pending_external_cancels.delete(seq)
+            end
 
             # Raise if resolution has failure
             return unless resolution.failure
@@ -169,10 +174,13 @@ module Temporalio
             end
 
             # Wait
-            resolution = Fiber.yield
-
-            # Remove cancellation callback
-            cancellation.remove_cancel_callback(cancel_callback_key)
+            resolution = begin
+              Fiber.yield
+            ensure
+              # Remove pending and cancel callback
+              @instance.pending_activities.delete(seq)
+              cancellation.remove_cancel_callback(cancel_callback_key)
+            end
 
             case resolution.status
             when :completed
@@ -254,10 +262,13 @@ module Temporalio
             end
 
             # Wait
-            resolution = Fiber.yield
-
-            # Remove cancellation callback
-            cancellation.remove_cancel_callback(cancel_callback_key)
+            resolution = begin
+              Fiber.yield
+            ensure
+              # Remove pending and cancel callback
+              @instance.pending_external_signals.delete(seq)
+              cancellation.remove_cancel_callback(cancel_callback_key)
+            end
 
             # Raise if resolution has failure
             return unless resolution.failure
@@ -317,7 +328,12 @@ module Temporalio
             end
 
             # Wait
-            Fiber.yield
+            begin
+              Fiber.yield
+            ensure
+              # Remove pending
+              @instance.pending_timers.delete(seq)
+            end
 
             # Remove cancellation callback (only needed on success)
             input.cancellation.remove_cancel_callback(cancel_callback_key)
@@ -374,7 +390,12 @@ module Temporalio
             end
 
             # Wait for start
-            resolution = Fiber.yield
+            resolution = begin
+              Fiber.yield
+            ensure
+              # Remove pending
+              @instance.pending_child_workflow_starts.delete(seq)
+            end
 
             case resolution.status
             when :succeeded

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

@@ -23,7 +23,8 @@ module Temporalio
           end
 
           def add(...)
-            if !@replay_safety_disabled && Temporalio::Workflow.in_workflow? && Temporalio::Workflow::Unsafe.replaying?
+            if !@replay_safety_disabled && Temporalio::Workflow.in_workflow? &&
+               Temporalio::Workflow::Unsafe.replaying_history_events?
               return true
             end
 

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

@@ -9,7 +9,8 @@ module Temporalio
         # Wrapper for a metric that does not log on replay.
         class ReplaySafeMetric < SimpleDelegator
           def record(value, additional_attributes: nil)
-            return if Temporalio::Workflow.in_workflow? && Temporalio::Workflow::Unsafe.replaying?
+            return if Temporalio::Workflow.in_workflow? &&
+                      Temporalio::Workflow::Unsafe.replaying_history_events?
 
             super
           end

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

@@ -78,7 +78,12 @@ module Temporalio
             end
 
             # This blocks until a resume is called on this fiber
-            result = Fiber.yield
+            result = begin
+              Fiber.yield
+            ensure
+              # Remove pending
+              @wait_conditions.delete(seq)
+            end
 
             # Remove cancellation callback (only needed on success)
             cancellation&.remove_cancel_callback(cancel_callback_key) if cancel_callback_key
@@ -141,6 +146,10 @@ module Temporalio
             fiber
           end
 
+          def fiber_interrupt(fiber, exception)
+            fiber.raise(exception) if fiber.alive?
+          end
+
           def io_wait(io, events, timeout)
             # Do not allow if IO disabled
             unless @instance.io_enabled

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

@@ -57,7 +57,8 @@ module Temporalio
                     :pending_external_signals, :pending_external_cancels, :in_progress_handlers, :payload_converter,
                     :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
+                    :signal_handlers, :query_handlers, :update_handlers, :context_frozen, :assert_valid_local_activity,
+                    :in_query_or_validator
         attr_accessor :io_enabled, :current_details
 
         def initialize(details)
@@ -91,6 +92,7 @@ module Temporalio
           @current_history_length = 0
           @current_history_size = 0
           @replaying = false
+          @in_query_or_validator = false
           @workflow_failure_exception_types = details.workflow_failure_exception_types
           @signal_handlers = HandlerHash.new(
             details.definition.signals,
@@ -182,7 +184,7 @@ module Temporalio
           # Apply jobs and run event loop
           begin
             # Create instance if it doesn't already exist
-            @instance ||= with_context_frozen { create_instance }
+            @instance ||= with_context_frozen(in_query_or_validator: false) { create_instance }
 
             # Apply jobs
             activation.jobs.each { |job| apply(job) }
@@ -345,7 +347,7 @@ module Temporalio
           when :initialize_workflow
             # Ignore
           when :fire_timer
-            pending_timers.delete(job.fire_timer.seq)&.resume
+            pending_timers[job.fire_timer.seq]&.resume
           when :update_random_seed
             @random = illegal_call_tracing_disabled { Random.new(job.update_random_seed.randomness_seed) }
           when :query_workflow
@@ -356,23 +358,23 @@ module Temporalio
           when :signal_workflow
             apply_signal(job.signal_workflow)
           when :resolve_activity
-            pending_activities.delete(job.resolve_activity.seq)&.resume(job.resolve_activity.result)
+            pending_activities[job.resolve_activity.seq]&.resume(job.resolve_activity.result)
           when :notify_has_patch
             @patches_notified << job.notify_has_patch.patch_id
           when :resolve_child_workflow_execution_start
-            pending_child_workflow_starts.delete(job.resolve_child_workflow_execution_start.seq)&.resume(
+            pending_child_workflow_starts[job.resolve_child_workflow_execution_start.seq]&.resume(
               job.resolve_child_workflow_execution_start
             )
           when :resolve_child_workflow_execution
-            pending_child_workflows.delete(job.resolve_child_workflow_execution.seq)&._resolve(
+            pending_child_workflows[job.resolve_child_workflow_execution.seq]&._resolve(
               job.resolve_child_workflow_execution.result
             )
           when :resolve_signal_external_workflow
-            pending_external_signals.delete(job.resolve_signal_external_workflow.seq)&.resume(
+            pending_external_signals[job.resolve_signal_external_workflow.seq]&.resume(
               job.resolve_signal_external_workflow
             )
           when :resolve_request_cancel_external_workflow
-            pending_external_cancels.delete(job.resolve_request_cancel_external_workflow.seq)&.resume(
+            pending_external_cancels[job.resolve_request_cancel_external_workflow.seq]&.resume(
               job.resolve_request_cancel_external_workflow
             )
           when :do_update
@@ -439,7 +441,7 @@ module Temporalio
                        end
                        result_hint = defn.result_hint
 
-                       with_context_frozen do
+                       with_context_frozen(in_query_or_validator: true) do
                          @inbound.handle_query(
                            Temporalio::Worker::Interceptor::Workflow::HandleQueryInput.new(
                              id: job.query_id,
@@ -502,7 +504,7 @@ module Temporalio
             # other SDKs, we are re-converting the args between validate and update to disallow user mutation in
             # validator/interceptor.
             if job.run_validator && defn.validator_to_invoke
-              with_context_frozen do
+              with_context_frozen(in_query_or_validator: true) do
                 @inbound.validate_update(
                   Temporalio::Worker::Interceptor::Workflow::HandleUpdateInput.new(
                     id: job.id,
@@ -663,11 +665,13 @@ module Temporalio
             @definition_options.failure_exception_types&.any? { |cls| err.is_a?(cls) }
         end
 
-        def with_context_frozen(&)
+        def with_context_frozen(in_query_or_validator:, &)
           @context_frozen = true
+          @in_query_or_validator = in_query_or_validator
           yield
         ensure
           @context_frozen = false
+          @in_query_or_validator = false
         end
 
         def convert_handler_args(payload_array:, defn:)

data/lib/temporalio/simple_plugin.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'temporalio/client'
+require 'temporalio/worker'
+
+module Temporalio
+  # Plugin that implements both {Client::Plugin} and {Worker::Plugin} and provides a simplified common set of settings
+  # for configuring both.
+  #
+  # WARNING: Plugins are experimental.
+  class SimplePlugin
+    include Client::Plugin
+    include Worker::Plugin
+
+    Options = Data.define(
+      :name,
+      :data_converter,
+      :client_interceptors,
+      :activities,
+      :workflows,
+      :worker_interceptors,
+      :workflow_failure_exception_types,
+      :run_context
+    )
+
+    # Options as returned from {options} representing the options passed to the constructor.
+    class Options; end # rubocop:disable Lint/EmptyClass
+
+    # @return [Options] Frozen options for this plugin which has the same attributes as {initialize}.
+    attr_reader :options
+
+    # Create a simple plugin.
+    #
+    # @param name [String] Required string name for this plugin.
+    # @param data_converter [Converters::DataConverter, Proc, nil] Data converter to apply to clients and workflow
+    #   replayers. This can be a proc that accepts the existing data converter and returns a new one.
+    # @param client_interceptors [Array<Client::Integerceptor>, Proc, nil] Client interceptors that are appended to the
+    #   existing client set (which means if they implement worker interceptors they are applied for the workers too). A
+    #   proc can be provided that accepts the existing array and returns a new one.
+    # @param activities [Array<Activity::Definition, Class<Activity::Definition>, Activity::Definition::Info>, Proc,
+    #   nil] Activities to append to each worker activity set. A proc can be provided that accepts the existing array
+    #   and returns a new one.
+    # @param workflows [Array<Class<Workflow::Definition>>, Proc, nil] Workflows to append to each worker workflow set.
+    #   A proc can be provided that accepts the existing array and returns a new one.
+    # @param worker_interceptors [Array<Interceptor::Activity, Interceptor::Workflow>, Proc, nil] Worker interceptors
+    #   that are appended to the existing worker or workflow replayer set. A proc can be provided that accepts the
+    #   existing array and returns a new one.
+    # @param workflow_failure_exception_types [Array<Class<Exception>>] Workflow failure exception types that are
+    #   appended to the existing worker or workflow replayer set. A proc can be provided that accepts the existing array
+    #   and returns a new one.
+    # @param run_context [Proc, nil] A proc that intercepts both {run_worker} or {with_workflow_replay_worker}. The proc
+    #   should accept two positional parameters: options and next_call. The options are either
+    #   {Worker::Plugin::RunWorkerOptions} or {Worker::Plugin::WithWorkflowReplayWorkerOptions}. The next_call is a proc
+    #   itself that accepts the options and returns a value. This run_context proc should return the result of the
+    #   next_call.
+    def initialize(
+      name:,
+      data_converter: nil,
+      client_interceptors: nil,
+      activities: nil,
+      workflows: nil,
+      worker_interceptors: nil,
+      workflow_failure_exception_types: nil,
+      run_context: nil
+    )
+      @options = Options.new(
+        name:,
+        data_converter:,
+        client_interceptors:,
+        activities:,
+        workflows:,
+        worker_interceptors:,
+        workflow_failure_exception_types:,
+        run_context:
+      ).freeze
+    end
+
+    # Implements {Client::Plugin#name} and {Worker::Plugin#name}.
+    def name
+      @options.name
+    end
+
+    # Implements {Client::Plugin#configure_client}.
+    def configure_client(options)
+      if (data_converter = _single_option(new: @options.data_converter, existing: options.data_converter,
+                                          type: Converters::DataConverter, name: 'data converter'))
+        options = options.with(data_converter:)
+      end
+      if (interceptors = _array_option(new: @options.client_interceptors, existing: options.interceptors,
+                                       name: 'client interceptor'))
+        options = options.with(interceptors:)
+      end
+      options
+    end
+
+    # Implements {Client::Plugin#connect_client}.
+    def connect_client(options, next_call)
+      next_call.call(options)
+    end
+
+    # Implements {Worker::Plugin#configure_worker}.
+    def configure_worker(options)
+      if (activities = _array_option(new: @options.activities, existing: options.activities, name: 'activity'))
+        options = options.with(activities:)
+      end
+      if (workflows = _array_option(new: @options.workflows, existing: options.workflows, name: 'workflow'))
+        options = options.with(workflows:)
+      end
+      if (interceptors = _array_option(new: @options.worker_interceptors, existing: options.interceptors,
+                                       name: 'worker interceptor'))
+        options = options.with(interceptors:)
+      end
+      if (workflow_failure_exception_types = _array_option(new: @options.workflow_failure_exception_types,
+                                                           existing: options.workflow_failure_exception_types,
+                                                           name: 'workflow failure exception types'))
+        options = options.with(workflow_failure_exception_types:)
+      end
+      options
+    end
+
+    # Implements {Worker::Plugin#run_worker}.
+    def run_worker(options, next_call)
+      if @options.run_context
+        @options.run_context.call(options, next_call) # steep:ignore NoMethod
+      else
+        next_call.call(options)
+      end
+    end
+
+    # Implements {Worker::Plugin#configure_workflow_replayer}.
+    def configure_workflow_replayer(options)
+      if (data_converter = _single_option(new: @options.data_converter, existing: options.data_converter,
+                                          type: Converters::DataConverter, name: 'data converter'))
+        options = options.with(data_converter:)
+      end
+      if (workflows = _array_option(new: @options.workflows, existing: options.workflows, name: 'workflow'))
+        options = options.with(workflows:)
+      end
+      if (interceptors = _array_option(new: @options.worker_interceptors, existing: options.interceptors,
+                                       name: 'worker interceptor'))
+        options = options.with(interceptors:)
+      end
+      if (workflow_failure_exception_types = _array_option(new: @options.workflow_failure_exception_types,
+                                                           existing: options.workflow_failure_exception_types,
+                                                           name: 'workflow failure exception types'))
+        options = options.with(workflow_failure_exception_types:)
+      end
+      options
+    end
+
+    # Implements {Worker::Plugin#with_workflow_replay_worker}.
+    def with_workflow_replay_worker(options, next_call)
+      if @options.run_context
+        @options.run_context.call(options, next_call) # steep:ignore NoMethod
+      else
+        next_call.call(options)
+      end
+    end
+
+    # @!visibility private
+    def _single_option(new:, existing:, type:, name:)
+      case new
+      when nil
+        nil
+      when Proc
+        new.call(existing).tap do |val| # steep:ignore NoMethod
+          raise "Instance of #{name} required" unless val.is_a?(type)
+        end
+      when type
+        new
+      else
+        raise "Unrecognized #{name} type #{new.class}"
+      end
+    end
+
+    # @!visibility private
+    def _array_option(new:, existing:, name:)
+      case new
+      when nil
+        nil
+      when Proc
+        new.call(existing).tap do |conv| # steep:ignore NoMethod
+          raise "Array for #{name} required" unless conv.is_a?(Array)
+        end
+      when Array
+        existing + new # steep:ignore NoMethod
+      else
+        raise "Unrecognized #{name} type #{new.class}"
+      end
+    end
+  end
+end

data/lib/temporalio/version.rb

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

data/lib/temporalio/worker/plugin.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Temporalio
+  class Worker
+    # Plugin mixin to include for configuring workers and workflow replayers, and intercepting the running of them.
+    #
+    # This is a low-level implementation that requires abstract methods herein to be implemented. Many implementers may
+    # prefer {SimplePlugin} which includes this.
+    #
+    # WARNING: Plugins are experimental.
+    module Plugin
+      RunWorkerOptions = Data.define(
+        :worker,
+        :cancellation,
+        :shutdown_signals,
+        :raise_in_block_on_shutdown
+      )
+
+      # Options for {run_worker}.
+      #
+      # The options contain the worker and some other options from {Worker#run}/{Worker.run_all}. Unlike other memebers
+      # in this class, mutating the worker member before invoking the next call in the chain has no effect.
+      #
+      # @note Additional required attributes of this class may be added in the future. Users should never instantiate
+      #   this class, but instead use `with` on it in {run_worker}.
+      class RunWorkerOptions; end # rubocop:disable Lint/EmptyClass
+
+      WithWorkflowReplayWorkerOptions = Data.define(
+        :worker
+      )
+
+      # Options for {with_workflow_replay_worker}.
+      #
+      # @note Additional required attributes of this class may be added in the future. Users should never instantiate
+      #   this class, but instead use `with` on it in {with_workflow_replay_worker}.
+      #
+      # @!attribute worker
+      #   @return [WorkflowReplayer::ReplayWorker] Replay worker.
+      class WithWorkflowReplayWorkerOptions; end # rubocop:disable Lint/EmptyClass
+
+      # @abstract
+      # @return [String] Name of the plugin.
+      def name
+        raise NotImplementedError
+      end
+
+      # Configure a worker.
+      #
+      # @abstract
+      # @param options [Options] Current immutable options set.
+      # @return [Options] Options to use, possibly updated from original.
+      def configure_worker(options)
+        raise NotImplementedError
+      end
+
+      # Run a worker.
+      #
+      # @abstract
+      # @param options [RunWorkerOptions] Current immutable options set.
+      # @param next_call [Proc] Proc for the next plugin in the chain to call. It accepts the options and returns an
+      #   arbitrary object that should also be returned from this method.
+      # @return [Object] Result of next_call.
+      def run_worker(options, next_call)
+        raise NotImplementedError
+      end
+
+      # Configure a workflow replayer.
+      #
+      # @abstract
+      # @param options [WorkflowReplayer::Options] Current immutable options set.
+      # @return [WorkflowReplayer::Options] Options to use, possibly updated from original.
+      def configure_workflow_replayer(options)
+        raise NotImplementedError
+      end
+
+      # Run a replay worker.
+      #
+      # @abstract
+      # @param options [WithWorkflowReplayWorkerOptions] Current immutable options set.
+      # @param next_call [Proc] Proc for the next plugin in the chain to call. It accepts the options and returns an
+      #   arbitrary object that should also be returned from this method.
+      # @return [Object] Result of next_call.
+      def with_workflow_replay_worker(options, next_call)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/temporalio/worker/workflow_replayer.rb

@@ -7,6 +7,7 @@ require 'temporalio/internal/bridge/worker'
 require 'temporalio/internal/worker/multi_runner'
 require 'temporalio/internal/worker/workflow_worker'
 require 'temporalio/worker/interceptor'
+require 'temporalio/worker/plugin'
 require 'temporalio/worker/poller_behavior'
 require 'temporalio/worker/thread_pool'
 require 'temporalio/worker/tuner'
@@ -24,6 +25,7 @@ module Temporalio
         :task_queue,
         :data_converter,
         :workflow_executor,
+        :plugins,
         :interceptors,
         :identity,
         :logger,
@@ -50,6 +52,8 @@ module Temporalio
       #   payloads.
       # @param workflow_executor [WorkflowExecutor] Workflow executor that workflow tasks run within. This must be a
       #   {WorkflowExecutor::ThreadPool} currently.
+      # @param plugins [Array<Plugin>] Plugins to use for configuring replayer and intercepting replay. WARNING: Plugins
+      #   are experimental.
       # @param interceptors [Array<Interceptor::Workflow>] Workflow interceptors.
       # @param identity [String, nil] Override the identity for this replater.
       # @param logger [Logger] Logger to use. Defaults to stdout with warn level. Callers setting this logger are
@@ -83,6 +87,7 @@ module Temporalio
         task_queue: 'ReplayTaskQueue',
         data_converter: Converters::DataConverter.default,
         workflow_executor: WorkflowExecutor::ThreadPool.default,
+        plugins: [],
         interceptors: [],
         identity: nil,
         logger: Logger.new($stdout, level: Logger::WARN),
@@ -100,6 +105,7 @@ module Temporalio
           task_queue:,
           data_converter:,
           workflow_executor:,
+          plugins:,
           interceptors:,
           identity:,
           logger:,
@@ -110,13 +116,18 @@ module Temporalio
           debug_mode:,
           runtime:
         ).freeze
+        # Apply plugins
+        Worker._validate_plugins!(plugins)
+        @options = plugins.reduce(@options) { |options, plugin| plugin.configure_workflow_replayer(options) }
+
         # Preload definitions and other settings
         @workflow_definitions = Internal::Worker::WorkflowWorker.workflow_definitions(
-          workflows, should_enforce_versioning_behavior: false
+          @options.workflows, should_enforce_versioning_behavior: false
         )
         @nondeterminism_as_workflow_fail, @nondeterminism_as_workflow_fail_for_types =
           Internal::Worker::WorkflowWorker.bridge_workflow_failure_exception_type_options(
-            workflow_failure_exception_types:, workflow_definitions: @workflow_definitions
+            workflow_failure_exception_types: @options.workflow_failure_exception_types,
+            workflow_definitions: @workflow_definitions
           )
         # If there is a block, we'll go ahead and assume it's for with_replay_worker
         with_replay_worker(&) if block_given? # steep:ignore
@@ -154,7 +165,18 @@ module Temporalio
       # @yield Block of code to run with a replay worker.
       # @yieldparam [ReplayWorker] Worker to run replays on. Note, only one workflow can replay at a time.
       # @yieldreturn [Object] Result of the block.
-      def with_replay_worker(&)
+      def with_replay_worker(&block)
+        # Apply plugins
+        run_block = proc do |options|
+          # @type var options: Plugin::WithWorkflowReplayWorkerOptions
+          block.call(options.worker)
+        end
+        run_block = options.plugins.reverse_each.reduce(run_block) do |next_call, plugin|
+          proc do |options|
+            plugin.with_workflow_replay_worker(options, next_call) # steep:ignore
+          end
+        end
+
         worker = ReplayWorker.new(
           options:,
           workflow_definitions: @workflow_definitions,
@@ -162,7 +184,7 @@ module Temporalio
           nondeterminism_as_workflow_fail_for_types: @nondeterminism_as_workflow_fail_for_types
         )
         begin
-          yield worker
+          run_block.call(Plugin::WithWorkflowReplayWorkerOptions.new(worker:))
         ensure
           worker._shutdown
         end
@@ -221,7 +243,8 @@ module Temporalio
               graceful_shutdown_period: 0.0,
               nondeterminism_as_workflow_fail:,
               nondeterminism_as_workflow_fail_for_types:,
-              deployment_options: Worker.default_deployment_options._to_bridge_options
+              deployment_options: Worker.default_deployment_options._to_bridge_options,
+              plugins: options.plugins.map(&:name).uniq.sort
             )
           )