Review comments

Author: Sushisource

temporalio/ext/src/worker.rs

@@ -620,6 +620,6 @@ fn extract_poller_behavior(poller_behavior: Struct) -> Result<PollerBehavior, Er
             initial: poller_behavior.member::<usize>(id!("initial"))?,
         }
     } else {
-        PollerBehavior::SimpleMaximum(poller_behavior.member::<usize>(id!("maximum"))?)
+        PollerBehavior::SimpleMaximum(poller_behavior.member::<usize>(id!("simple_maximum"))?)
     })
 }

temporalio/lib/temporalio/worker.rb

@@ -53,9 +53,9 @@ class Worker
       :workflow_payload_codec_thread_pool,
       :unsafe_workflow_io_enabled,
       :deployment_options,
-      :debug_mode,
       :workflow_task_poller_behavior,
-      :activity_task_poller_behavior
+      :activity_task_poller_behavior,
+      :debug_mode
     )
 
     # Options as returned from {options} for `**to_h` splat use in {initialize}. See {initialize} for details.
@@ -357,6 +357,10 @@ def self.default_illegal_workflow_calls
     #   with a block for narrower enabling of IO.
     # @param deployment_options [DeploymentOptions, nil] Deployment options for the worker.
     #   WARNING: This is an experimental feature and may change in the future.
+    # @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
+    #   polling. Defaults to a 5-poller maximum.
     # @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`.
@@ -388,8 +392,8 @@ def initialize(
       workflow_payload_codec_thread_pool: nil,
       unsafe_workflow_io_enabled: false,
       deployment_options: Worker.default_deployment_options,
-      workflow_task_poller_behavior: nil,
-      activity_task_poller_behavior: nil,
+      workflow_task_poller_behavior: SimpleMaximumPollerBehavior.new(maximum: max_concurrent_workflow_task_polls),
+      activity_task_poller_behavior: SimpleMaximumPollerBehavior.new(maximum: max_concurrent_activity_task_polls),
       debug_mode: %w[true 1].include?(ENV['TEMPORAL_DEBUG'].to_s.downcase)
     )
       raise ArgumentError, 'Must have at least one activity or workflow' if activities.empty? && workflows.empty?
@@ -424,9 +428,9 @@ def initialize(
         workflow_payload_codec_thread_pool:,
         unsafe_workflow_io_enabled:,
         deployment_options:,
-        debug_mode:,
         workflow_task_poller_behavior:,
-        activity_task_poller_behavior:
+        activity_task_poller_behavior:,
+        debug_mode:
       ).freeze
 
       should_enforce_versioning_behavior =
@@ -442,10 +446,6 @@ def initialize(
           workflow_failure_exception_types:, workflow_definitions:
         )
 
-      # Convert deprecated max concurrent polls to poller behaviors if not specified
-      workflow_task_poller_behavior ||= SimpleMaximumPollerBehavior.new(maximum: max_concurrent_workflow_task_polls)
-      activity_task_poller_behavior ||= SimpleMaximumPollerBehavior.new(maximum: max_concurrent_activity_task_polls)
-
       # Create the bridge worker
       @bridge_worker = Internal::Bridge::Worker.new(
         client.connection._core_client,

temporalio/lib/temporalio/worker/poller_behavior.rb

@@ -3,82 +3,58 @@
 module Temporalio
   class Worker
     # Base class for poller behaviors that control how polling scales.
-    #
-    # Use factory methods {.simple_maximum} or {.autoscaling} to create instances.
     class PollerBehavior
-      # Creates a simple maximum poller behavior
-      # The poller will attempt to poll as long as a slot is available, up to the
-      # provided maximum. Cannot be less than two for workflow tasks, or one for other tasks.
-      #
-      # @param maximum [Integer] Maximum number of concurrent poll requests.
-      # @return [SimpleMaximumPollerBehavior] A simple maximum poller behavior
-      def self.simple_maximum(maximum = 5)
-        SimpleMaximumPollerBehavior.new(maximum: maximum)
-      end
-
-      # Creates an autoscaling poller behavior
-      # The poller will automatically scale the number of pollers based on feedback
-      # from the server. A slot must be available before beginning polling.
-      #
-      # @param minimum [Integer] Minimum number of poll calls (assuming slots are available).
-      # @param maximum [Integer] Maximum number of poll calls that will ever be open at once.
-      # @param initial [Integer] Number of polls attempted initially before scaling kicks in.
-      # @return [AutoscalingPollerBehavior] An autoscaling poller behavior
-      def self.autoscaling(minimum: 1, maximum: 100, initial: 5)
-        AutoscalingPollerBehavior.new(minimum: minimum, maximum: maximum, initial: initial)
-      end
-
       # @!visibility private
       def _to_bridge_options
         raise NotImplementedError, 'Subclasses must implement this method'
       end
-    end
-
-    # A poller behavior that attempts to poll as long as a slot is available, up to the
-    # provided maximum. Cannot be less than two for workflow tasks, or one for other tasks.
-    class SimpleMaximumPollerBehavior < PollerBehavior
-      # @return [Integer] Maximum number of concurrent poll requests.
-      attr_reader :maximum
-
-      # @param maximum [Integer] Maximum number of concurrent poll requests.
-      def initialize(maximum: 5)
-        super()
-        @maximum = maximum
-      end
 
-      # @!visibility private
-      def _to_bridge_options
-        Internal::Bridge::Worker::PollerBehaviorSimpleMaximum.new(simple_maximum: maximum)
-      end
-    end
-
-    # A poller behavior that automatically scales the number of pollers based on feedback
-    # from the server. A slot must be available before beginning polling.
-    class AutoscalingPollerBehavior < PollerBehavior
-      # @return [Integer] Minimum number of poll calls (assuming slots are available).
-      attr_reader :minimum
-      # @return [Integer] Maximum number of poll calls that will ever be open at once.
-      attr_reader :maximum
-      # @return [Integer] Number of polls attempted initially before scaling kicks in.
-      attr_reader :initial
-
-      # @param minimum [Integer] Minimum number of poll calls (assuming slots are available).
-      # @param maximum [Integer] Maximum number of poll calls that will ever be open at once.
-      # @param initial [Integer] Number of polls attempted initially before scaling kicks in.
-      def initialize(minimum: 1, maximum: 100, initial: 5)
-        super()
-        @minimum = minimum
-        @maximum = maximum
-        @initial = initial
+      # A poller behavior that attempts to poll as long as a slot is available, up to the
+      # provided maximum. Cannot be less than two for workflow tasks, or one for other tasks.
+      class SimpleMaximum < PollerBehavior
+        # @return [Integer] Maximum number of concurrent poll requests.
+        attr_reader :maximum
+
+        # @param maximum [Integer] Maximum number of concurrent poll requests.
+        def initialize(maximum: 5)
+          super()
+          @maximum = maximum
+        end
+
+        # @!visibility private
+        def _to_bridge_options
+          Internal::Bridge::Worker::PollerBehaviorSimpleMaximum.new(simple_maximum: @maximum)
+        end
       end
 
-      # @!visibility private
-      def _to_bridge_options
-        Internal::Bridge::Worker::PollerBehaviorAutoscaling.new(
-          minimum: minimum,
-          maximum: maximum,
-          initial: initial
-        )
+      # A poller behavior that automatically scales the number of pollers based on feedback
+      # from the server. A slot must be available before beginning polling.
+      class Autoscaling < PollerBehavior
+        # @return [Integer] Minimum number of poll calls (assuming slots are available).
+        attr_reader :minimum
+        # @return [Integer] Maximum number of poll calls that will ever be open at once.
+        attr_reader :maximum
+        # @return [Integer] Number of polls attempted initially before scaling kicks in.
+        attr_reader :initial
+
+        # @param minimum [Integer] Minimum number of poll calls (assuming slots are available).
+        # @param maximum [Integer] Maximum number of poll calls that will ever be open at once.
+        # @param initial [Integer] Number of polls attempted initially before scaling kicks in.
+        def initialize(minimum: 1, maximum: 100, initial: 5)
+          super()
+          @minimum = minimum
+          @maximum = maximum
+          @initial = initial
+        end
+
+        # @!visibility private
+        def _to_bridge_options
+          Internal::Bridge::Worker::PollerBehaviorAutoscaling.new(
+            minimum: @minimum,
+            maximum: @maximum,
+            initial: @initial
+          )
+        end
       end
     end
   end

temporalio/lib/temporalio/worker/workflow_replayer.rb

@@ -206,9 +206,11 @@ def initialize(
               )._to_bridge_options,
               identity_override: options.identity,
               max_cached_workflows: 2,
-              workflow_task_poller_behavior: Temporalio::Worker::PollerBehavior.simple_maximum(2)._to_bridge_options,
+              workflow_task_poller_behavior:
+                Temporalio::Worker::PollerBehavior::SimpleMaximum.new(2)._to_bridge_options,
               nonsticky_to_sticky_poll_ratio: 1.0,
-              activity_task_poller_behavior: Temporalio::Worker::PollerBehavior.simple_maximum(1)._to_bridge_options,
+              activity_task_poller_behavior:
+                Temporalio::Worker::PollerBehavior::SimpleMaximum.new(1)._to_bridge_options,
               no_remote_activities: true,
               sticky_queue_schedule_to_start_timeout: 1.0,
               max_heartbeat_throttle_interval: 1.0,

temporalio/sig/temporalio/worker.rbs

@@ -111,8 +111,8 @@ module Temporalio
       ?workflow_failure_exception_types: Array[singleton(Exception)],
       ?workflow_payload_codec_thread_pool: ThreadPool?,
       ?unsafe_workflow_io_enabled: bool,
-      ?workflow_task_poller_behavior: SimpleMaximumPollerBehavior | AutoscalingPollerBehavior,
-      ?activity_task_poller_behavior: SimpleMaximumPollerBehavior | AutoscalingPollerBehavior,
+      ?workflow_task_poller_behavior: PollerBehavior,
+      ?activity_task_poller_behavior: PollerBehavior,
       ?deployment_options: Worker::DeploymentOptions,
       ?debug_mode: bool
     ) -> void

temporalio/sig/temporalio/worker/poller_behavior.rbs

@@ -1,19 +1,17 @@
 module Temporalio
   class Worker
     class PollerBehavior
-      def self.simple_maximum: (Integer) -> SimpleMaximumPollerBehavior
-      def self.autoscaling: (?minimum: Integer, ?maximum: Integer, ?initial: Integer) -> AutoscalingPollerBehavior
       def _to_bridge_options: -> untyped
     end
 
-    class SimpleMaximumPollerBehavior < PollerBehavior
+    class SimpleMaximum < PollerBehavior
       attr_reader maximum: Integer
 
       def initialize: (?maximum: Integer) -> void
       def _to_bridge_options: -> Internal::Bridge::Worker::PollerBehaviorSimpleMaximum
     end
 
-    class AutoscalingPollerBehavior < PollerBehavior
+    class Autoscaling < PollerBehavior
       attr_reader minimum: Integer
       attr_reader maximum: Integer
       attr_reader initial: Integer

temporalio/test/worker_test.rb

@@ -199,10 +199,10 @@ def test_can_run_with_autoscaling_poller_behavior
       task_queue: "tq-#{SecureRandom.uuid}",
       workflows: [WaitOnSignalWorkflow],
       activities: [SimpleActivity],
-      workflow_task_poller_behavior: Temporalio::Worker::PollerBehavior.autoscaling(
+      workflow_task_poller_behavior: Temporalio::Worker::PollerBehavior::Autoscaling.new(
         initial: 2
       ),
-      activity_task_poller_behavior: Temporalio::Worker::PollerBehavior.autoscaling(
+      activity_task_poller_behavior: Temporalio::Worker::PollerBehavior::Autoscaling.new(
         initial: 2
       )
     )