temporalio 1.0.0-aarch64-linux-musl → 1.2.0-aarch64-linux-musl

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

@@ -7,8 +7,6 @@ module Temporalio
     module Bridge
       class Worker
         Options = Struct.new(
-          :activity,
-          :workflow,
           :namespace,
           :task_queue,
           :tuner,
@@ -17,7 +15,10 @@ module Temporalio
           :workflow_task_poller_behavior,
           :nonsticky_to_sticky_poll_ratio,
           :activity_task_poller_behavior,
-          :no_remote_activities,
+          :enable_workflows,
+          :enable_local_activities,
+          :enable_remote_activities,
+          :enable_nexus,
           :sticky_queue_schedule_to_start_timeout,
           :max_heartbeat_throttle_interval,
           :default_heartbeat_throttle_interval,
@@ -27,6 +28,7 @@ module Temporalio
           :nondeterminism_as_workflow_fail,
           :nondeterminism_as_workflow_fail_for_types,
           :deployment_options,
+          :plugins,
           keyword_init: true
         )
 

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

@@ -242,6 +242,10 @@ module Temporalio
             @instance.replaying
           end
 
+          def replaying_history_events?
+            @instance.replaying && !@instance.in_query_or_validator
+          end
+
           def search_attributes
             @instance.search_attributes
           end

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

@@ -9,7 +9,7 @@ module Temporalio
         # Delegator to a hash that does not allow external mutations. Used for memo.
         class ExternallyImmutableHash < SimpleDelegator
           def initialize(initial_hash)
-            super(initial_hash.freeze)
+            super(initial_hash.freeze) # steep:ignore ArgumentTypeMismatch
           end
 
           def _update(&)

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

@@ -7,7 +7,7 @@ module Temporalio
         # Hash for handlers that notifies when one is added. Only `[]=` and `store` can be used to mutate it.
         class HandlerHash < SimpleDelegator
           def initialize(initial_frozen_hash, definition_class, &on_new_definition)
-            super(initial_frozen_hash)
+            super(initial_frozen_hash) # steep:ignore ArgumentTypeMismatch
             @definition_class = definition_class
             @on_new_definition = on_new_definition
           end

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,
@@ -133,6 +135,7 @@ module Temporalio
               last_result: if @init_job.last_completion_result
                              @payload_converter.from_payloads(@init_job.last_completion_result).first
                            end,
+              has_last_result?: !@init_job.last_completion_result.nil?,
               namespace: details.namespace,
               parent: if @init_job.parent_workflow_info
                         Workflow::Info::ParentInfo.new(
@@ -181,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) }
@@ -344,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
@@ -355,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
@@ -438,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,
@@ -501,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,
@@ -662,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/runtime.rb

@@ -101,7 +101,8 @@ module Temporalio
       # @!visibility private
       def _to_bridge
         # @type self: LoggingFilterOptions
-        "#{other_level},temporal_sdk_core=#{core_level},temporal_client=#{core_level},temporal_sdk=#{core_level}"
+        "#{other_level},temporalio_sdk_core=#{core_level},temporalio_client=#{core_level}," \
+          "temporalio_sdk=#{core_level},temporalio_bridge=#{core_level}"
       end
     end
 
@@ -329,12 +330,24 @@ module Temporalio
     # pool, this also consumes a Ruby thread for its lifetime.
     #
     # @param telemetry [TelemetryOptions] Telemetry options to set.
-    def initialize(telemetry: TelemetryOptions.new)
+    # @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.
+    def initialize(
+      telemetry: TelemetryOptions.new,
+      worker_heartbeat_interval: 60
+    )
+      if !worker_heartbeat_interval.nil? && !worker_heartbeat_interval.positive?
+        raise 'Worker heartbeat interval must be positive'
+      end
+
       # Set runtime on the buffer which will fail if the buffer is used on another runtime
       telemetry.metrics&.buffer&._set_runtime(self)
 
       @core_runtime = Internal::Bridge::Runtime.new(
-        Internal::Bridge::Runtime::Options.new(telemetry: telemetry._to_bridge)
+        Internal::Bridge::Runtime::Options.new(
+          telemetry: telemetry._to_bridge,
+          worker_heartbeat_interval:
+        )
       )
       @metric_meter = Internal::Metric::Meter.create_from_runtime(self) || Metric::Meter.null
       # We need a thread to run the command loop

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.0.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/tuner.rb

@@ -32,8 +32,6 @@ module Temporalio
         end
 
         # A slot supplier that will dynamically adjust the number of slots based on resource usage.
-        #
-        # @note WARNING: This API is experimental.
         class ResourceBased < SlotSupplier
           attr_reader :tuner_options, :slot_options
 
@@ -66,8 +64,6 @@ module Temporalio
         #
         # Users should be cautious when implementing this and make sure it is heavily tested and the documentation for
         # every method is well understood.
-        #
-        # @note WARNING: This API is experimental.
         class Custom < SlotSupplier
           # Context provided for slot reservation on custom slot supplier.
           #