temporalio 1.6.0 → 1.6.1.test.only.rc2

data/lib/temporalio/client/workflow_handle.rb

@@ -86,13 +86,19 @@ module Temporalio
         hist_run_id = result_run_id
         loop do
           # Get close event
-          event = fetch_history_events(
-            wait_new_event: true,
-            event_filter_type: Api::Enums::V1::HistoryEventFilterType::HISTORY_EVENT_FILTER_TYPE_CLOSE_EVENT,
-            skip_archival: true,
-            specific_run_id: hist_run_id,
-            rpc_options:
-          ).next
+          event = begin
+            fetch_history_events(
+              wait_new_event: true,
+              event_filter_type: Api::Enums::V1::HistoryEventFilterType::HISTORY_EVENT_FILTER_TYPE_CLOSE_EVENT,
+              skip_archival: true,
+              specific_run_id: hist_run_id,
+              rpc_options:
+            ).next
+          rescue StopIteration
+            # Timeskipping server can return empty events with no continuation token, this will surface as an empty
+            # iterator.
+            next
+          end
 
           # Check each close type'
           case event.event_type

data/lib/temporalio/client.rb

@@ -287,11 +287,10 @@ module Temporalio
     # @param id [String] Unique identifier for the workflow execution.
     # @param task_queue [String] Task queue to run the workflow on.
     # @param static_summary [String, nil] Fixed single-line summary for this workflow execution that may appear in
-    #   CLI/UI. This can be in single-line Temporal markdown format. This is currently experimental.
+    #   CLI/UI. This can be in single-line Temporal markdown format.
     # @param static_details [String, nil] Fixed details for this workflow execution that may appear in CLI/UI. This can
     #   be in Temporal markdown format and can be multiple lines. This is a fixed value on the workflow that cannot be
-    #   updated. For details that can be updated, use {Workflow.current_details=} within the workflow. This is currently
-    #   experimental.
+    #   updated. For details that can be updated, use {Workflow.current_details=} within the workflow.
     # @param execution_timeout [Float, nil] Total workflow execution timeout in seconds including retries and continue
     #   as new.
     # @param run_timeout [Float, nil] Timeout of a single workflow run in seconds.
@@ -380,11 +379,10 @@ module Temporalio
     # @param id [String] Unique identifier for the workflow execution.
     # @param task_queue [String] Task queue to run the workflow on.
     # @param static_summary [String, nil] Fixed single-line summary for this workflow execution that may appear in
-    #   CLI/UI. This can be in single-line Temporal markdown format. This is currently experimental.
+    #   CLI/UI. This can be in single-line Temporal markdown format.
     # @param static_details [String, nil] Fixed details for this workflow execution that may appear in CLI/UI. This can
     #   be in Temporal markdown format and can be multiple lines. This is a fixed value on the workflow that cannot be
-    #   updated. For details that can be updated, use {Workflow.current_details=} within the workflow. This is currently
-    #   experimental.
+    #   updated. For details that can be updated, use {Workflow.current_details=} within the workflow.
     # @param execution_timeout [Float, nil] Total workflow execution timeout in seconds including retries and continue
     #   as new.
     # @param run_timeout [Float, nil] Timeout of a single workflow run in seconds.

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

@@ -18,7 +18,9 @@ module Temporalio
           :keep_alive, # Optional
           :http_connect_proxy, # Optional
           :dns_load_balancing, # Optional
-          :grpc_compression
+          :grpc_compression,
+          :payloads_warn_size,
+          :memo_warn_size
         )
 
         TLSOptions = Struct.new(

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

@@ -24,11 +24,13 @@ module Temporalio
           :default_heartbeat_throttle_interval,
           :max_worker_activities_per_second,
           :max_task_queue_activities_per_second,
+          :max_eager_activity_reservations_per_workflow_task,
           :graceful_shutdown_period,
           :nondeterminism_as_workflow_fail,
           :nondeterminism_as_workflow_fail_for_types,
           :deployment_options,
-          :plugins
+          :plugins,
+          :disable_payload_error_limit
         )
 
         TunerOptions = Struct.new(

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'temporalio/internal/workflow_task_failure_error'
 require 'temporalio/worker/illegal_workflow_call_validator'
 require 'temporalio/workflow'
 
@@ -92,6 +93,11 @@ module Temporalio
                                     ))
                     nil
                   rescue Exception => e # rubocop:disable Lint/RescueException
+                    # Errors that invalidate the whole workflow task (e.g. an async DeadlockError landing while the
+                    # validator runs) must propagate with their class intact so they fail the task instead of being
+                    # flattened into a NondeterminismError message that futures may store
+                    raise if e.is_a?(Internal::WorkflowTaskFailureError)
+
                     ", reason: #{e}"
                   end
                 else
@@ -108,6 +114,9 @@ module Temporalio
                                             ))
                       nil
                     rescue Exception => e # rubocop:disable Lint/RescueException
+                      # See workflow-task-failure comment on the class-level validator rescue above
+                      raise if e.is_a?(Internal::WorkflowTaskFailureError)
+
                       ", reason: #{e}"
                     end
                   end

data/lib/temporalio/runtime.rb

@@ -101,8 +101,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
 

data/lib/temporalio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Temporalio
-  VERSION = '1.6.0'
+  VERSION = '1.6.1.test.only.rc2'
 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
             )
           )

data/lib/temporalio/worker.rb

@@ -61,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,
@@ -71,7 +72,8 @@ module Temporalio
       :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.
@@ -415,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
@@ -452,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:,
@@ -474,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,
@@ -484,7 +493,8 @@ module Temporalio
       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)
 
@@ -510,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:,
@@ -520,7 +531,8 @@ module Temporalio
         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
@@ -541,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 &&
@@ -577,11 +594,14 @@ 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
         )
       )
 

data/lib/temporalio/workflow.rb

@@ -68,7 +68,7 @@ module Temporalio
 
     # Get current details for this workflow that may appear in UI/CLI. Unlike static details set at start, this value
     # can be updated throughout the life of the workflow. This can be in Temporal markdown format and can span multiple
-    # lines. This is currently experimental.
+    # lines.
     #
     # @return [String] Current details. Default is empty string.
     def self.current_details
@@ -77,7 +77,7 @@ module Temporalio
 
     # Set current details for this workflow that may appear in UI/CLI. Unlike static details set at start, this value
     # can be updated throughout the life of the workflow. This can be in Temporal markdown format and can span multiple
-    # lines. This is currently experimental.
+    # lines.
     #
     # @param details [String] Current details. Can use empty string to unset.
     def self.current_details=(details)
@@ -136,7 +136,7 @@ module Temporalio
     # @param args [Array<Object>] Arguments to the activity.
     # @param task_queue [String] Task queue to run the activity on. Defaults to the current workflow's task queue.
     # @param summary [String, nil] Single-line summary for this activity that may appear in CLI/UI. This can be in
-    #   single-line Temporal markdown format. This is currently experimental.
+    #   single-line Temporal markdown format.
     # @param schedule_to_close_timeout [Float, nil] Max amount of time the activity can take from first being scheduled
     #   to being completed before it times out. This is inclusive of all retries.
     # @param schedule_to_start_timeout [Float, nil] Max amount of time the activity can take to be started from first
@@ -235,7 +235,7 @@ module Temporalio
     # @param activity [Class<Activity::Definition>, Symbol, String] Activity definition class or name.
     # @param args [Array<Object>] Arguments to the activity.
     # @param summary [String, nil] Single-line summary for this activity that may appear in CLI/UI. This can be in
-    #   single-line Temporal markdown format. This is currently experimental.
+    #   single-line Temporal markdown format.
     # @param schedule_to_close_timeout [Float, nil] Max amount of time the activity can take from first being scheduled
     #   to being completed before it times out. This is inclusive of all retries.
     # @param schedule_to_start_timeout [Float, nil] Max amount of time the activity can take to be started from first
@@ -393,7 +393,7 @@ module Temporalio
     #   value cannot be negative. Since Temporal timers are server-side, timer resolution may not end up as precise as
     #   system timers.
     # @param summary [String, nil] A simple string identifying this timer that may be visible in UI/CLI. While it can be
-    #   normal text, it is best to treat as a timer ID. This is currently experimental.
+    #   normal text, it is best to treat as a timer ID.
     # @param cancellation [Cancellation] Cancellation for this timer.
     # @raise [Error::CanceledError] Sleep canceled.
     def self.sleep(duration, summary: nil, cancellation: Workflow.cancellation)
@@ -407,11 +407,10 @@ module Temporalio
     # @param id [String] Unique identifier for the workflow execution. Defaults to a new UUID from {random}.
     # @param task_queue [String] Task queue to run the workflow on. Defaults to the current workflow's task queue.
     # @param static_summary [String, nil] Fixed single-line summary for this workflow execution that may appear in
-    #   CLI/UI. This can be in single-line Temporal markdown format. This is currently experimental.
+    #   CLI/UI. This can be in single-line Temporal markdown format.
     # @param static_details [String, nil] Fixed details for this workflow execution that may appear in CLI/UI. This can
     #   be in Temporal markdown format and can be multiple lines. This is a fixed value on the workflow that cannot be
-    #   updated. For details that can be updated, use {Workflow.current_details=} within the workflow. This is currently
-    #   experimental.
+    #   updated. For details that can be updated, use {Workflow.current_details=} within the workflow.
     # @param cancellation [Cancellation] Cancellation to apply to the child workflow. How cancellation is treated is
     #   based on `cancellation_type`. This defaults to the workflow's cancellation.
     # @param cancellation_type [ChildWorkflowCancellationType] How the child workflow will react to cancellation.
@@ -480,7 +479,7 @@ module Temporalio
     # @param message [String] Message to use for timeout exception. Defaults to "execution expired" like
     #   {::Timeout.timeout}.
     # @param summary [String] Timer summary for the timer created by this timeout. This is backed by {sleep} so see that
-    #   method for details. This is currently experimental.
+    #   method for details.
     #
     # @yield Block to run with a timeout.
     # @return [Object] The result of the block.

data/rbi/temporalio/api/activity/v1/message.rbi

@@ -98,7 +98,8 @@ class Temporalio::Api::Activity::V1::ActivityOptions
       start_to_close_timeout: T.nilable(Google::Protobuf::Duration),
       heartbeat_timeout: T.nilable(Google::Protobuf::Duration),
       retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy),
-      priority: T.nilable(Temporalio::Api::Common::V1::Priority)
+      priority: T.nilable(Temporalio::Api::Common::V1::Priority),
+      start_delay: T.nilable(Google::Protobuf::Duration)
     ).void
   end
   def initialize(
@@ -108,7 +109,8 @@ class Temporalio::Api::Activity::V1::ActivityOptions
     start_to_close_timeout: nil,
     heartbeat_timeout: nil,
     retry_policy: nil,
-    priority: nil
+    priority: nil,
+    start_delay: nil
   )
   end
 
@@ -262,6 +264,27 @@ class Temporalio::Api::Activity::V1::ActivityOptions
   def clear_priority
   end
 
+  # Time to wait before making the first activity task available for dispatch. This delay is not applied to retry attempts.
+# When updated, the time is added to the original `schedule_time`, not to the current time.
+# If the resulting time is in the past, the task is made available for dispatch immediately.
+  sig { returns(T.nilable(Google::Protobuf::Duration)) }
+  def start_delay
+  end
+
+  # Time to wait before making the first activity task available for dispatch. This delay is not applied to retry attempts.
+# When updated, the time is added to the original `schedule_time`, not to the current time.
+# If the resulting time is in the past, the task is made available for dispatch immediately.
+  sig { params(value: T.nilable(Google::Protobuf::Duration)).void }
+  def start_delay=(value)
+  end
+
+  # Time to wait before making the first activity task available for dispatch. This delay is not applied to retry attempts.
+# When updated, the time is added to the original `schedule_time`, not to the current time.
+# If the resulting time is in the past, the task is made available for dispatch immediately.
+  sig { void }
+  def clear_start_delay
+  end
+
   sig { params(field: String).returns(T.untyped) }
   def [](field)
   end
@@ -338,7 +361,8 @@ class Temporalio::Api::Activity::V1::ActivityExecutionInfo
       total_heartbeat_count: T.nilable(Integer),
       sdk_name: T.nilable(String),
       sdk_version: T.nilable(String),
-      start_delay: T.nilable(Google::Protobuf::Duration)
+      start_delay: T.nilable(Google::Protobuf::Duration),
+      execution_time: T.nilable(Google::Protobuf::Timestamp)
     ).void
   end
   def initialize(
@@ -378,7 +402,8 @@ class Temporalio::Api::Activity::V1::ActivityExecutionInfo
     total_heartbeat_count: 0,
     sdk_name: "",
     sdk_version: "",
-    start_delay: nil
+    start_delay: nil,
+    execution_time: nil
   )
   end
 
@@ -673,17 +698,20 @@ class Temporalio::Api::Activity::V1::ActivityExecutionInfo
   def clear_schedule_time
   end
 
-  # Scheduled time + schedule to close timeout.
+  # The time at which the activity's Schedule-to-Close timeout expires.
+# Calculated as `schedule_time` + `start_delay` + `schedule_to_close_timeout`.
   sig { returns(T.nilable(Google::Protobuf::Timestamp)) }
   def expiration_time
   end
 
-  # Scheduled time + schedule to close timeout.
+  # The time at which the activity's Schedule-to-Close timeout expires.
+# Calculated as `schedule_time` + `start_delay` + `schedule_to_close_timeout`.
   sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void }
   def expiration_time=(value)
   end
 
-  # Scheduled time + schedule to close timeout.
+  # The time at which the activity's Schedule-to-Close timeout expires.
+# Calculated as `schedule_time` + `start_delay` + `schedule_to_close_timeout`.
   sig { void }
   def clear_expiration_time
   end
@@ -979,21 +1007,39 @@ class Temporalio::Api::Activity::V1::ActivityExecutionInfo
   def clear_sdk_version
   end
 
-  # Time to wait before dispatching the first activity task. This delay is not applied to retry attempts.
+  # Time to wait before making the first activity task available for dispatch. This delay is not applied to retry attempts.
   sig { returns(T.nilable(Google::Protobuf::Duration)) }
   def start_delay
   end
 
-  # Time to wait before dispatching the first activity task. This delay is not applied to retry attempts.
+  # Time to wait before making the first activity task available for dispatch. This delay is not applied to retry attempts.
   sig { params(value: T.nilable(Google::Protobuf::Duration)).void }
   def start_delay=(value)
   end
 
-  # Time to wait before dispatching the first activity task. This delay is not applied to retry attempts.
+  # Time to wait before making the first activity task available for dispatch. This delay is not applied to retry attempts.
   sig { void }
   def clear_start_delay
   end
 
+  # The time at which the first activity task is made available for dispatch, computed as
+# `schedule_time + start_delay`. Same as `schedule_time` if `start_delay` is not set.
+  sig { returns(T.nilable(Google::Protobuf::Timestamp)) }
+  def execution_time
+  end
+
+  # The time at which the first activity task is made available for dispatch, computed as
+# `schedule_time + start_delay`. Same as `schedule_time` if `start_delay` is not set.
+  sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void }
+  def execution_time=(value)
+  end
+
+  # The time at which the first activity task is made available for dispatch, computed as
+# `schedule_time + start_delay`. Same as `schedule_time` if `start_delay` is not set.
+  sig { void }
+  def clear_execution_time
+  end
+
   sig { params(field: String).returns(T.untyped) }
   def [](field)
   end
@@ -1046,7 +1092,8 @@ class Temporalio::Api::Activity::V1::ActivityExecutionListInfo
       task_queue: T.nilable(String),
       state_transition_count: T.nilable(Integer),
       state_size_bytes: T.nilable(Integer),
-      execution_duration: T.nilable(Google::Protobuf::Duration)
+      execution_duration: T.nilable(Google::Protobuf::Duration),
+      execution_time: T.nilable(Google::Protobuf::Timestamp)
     ).void
   end
   def initialize(
@@ -1060,7 +1107,8 @@ class Temporalio::Api::Activity::V1::ActivityExecutionListInfo
     task_queue: "",
     state_transition_count: 0,
     state_size_bytes: 0,
-    execution_duration: nil
+    execution_duration: nil,
+    execution_time: nil
   )
   end
 
@@ -1235,6 +1283,24 @@ class Temporalio::Api::Activity::V1::ActivityExecutionListInfo
   def clear_execution_duration
   end
 
+  # The time at which the first activity task is made available for dispatch, computed as
+# `schedule_time + start_delay`. Same as `schedule_time` if `start_delay` is not set.
+  sig { returns(T.nilable(Google::Protobuf::Timestamp)) }
+  def execution_time
+  end
+
+  # The time at which the first activity task is made available for dispatch, computed as
+# `schedule_time + start_delay`. Same as `schedule_time` if `start_delay` is not set.
+  sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void }
+  def execution_time=(value)
+  end
+
+  # The time at which the first activity task is made available for dispatch, computed as
+# `schedule_time + start_delay`. Same as `schedule_time` if `start_delay` is not set.
+  sig { void }
+  def clear_execution_time
+  end
+
   sig { params(field: String).returns(T.untyped) }
   def [](field)
   end