temporalio 1.6.0 → 1.7.0

data/lib/temporalio/runtime.rb

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

data/lib/temporalio/scoped_logger.rb

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

data/lib/temporalio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Temporalio
-  VERSION = '1.6.0'
+  VERSION = '1.7.0'
 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

@@ -10,12 +10,14 @@ class Temporalio::Api::Activity::V1::ActivityExecutionOutcome
   sig do
     params(
       result: T.nilable(Temporalio::Api::Common::V1::Payloads),
-      failure: T.nilable(Temporalio::Api::Failure::V1::Failure)
+      failure: T.nilable(Temporalio::Api::Failure::V1::Failure),
+      retry_state: T.nilable(T.any(Symbol, String, Integer))
     ).void
   end
   def initialize(
     result: nil,
-    failure: nil
+    failure: nil,
+    retry_state: :RETRY_STATE_UNSPECIFIED
   )
   end
 
@@ -49,6 +51,24 @@ class Temporalio::Api::Activity::V1::ActivityExecutionOutcome
   def clear_failure
   end
 
+  # The retry state associated with an unsuccessful activity execution.
+# This field is only meaningful when `failure` is set.
+  sig { returns(T.any(Symbol, Integer)) }
+  def retry_state
+  end
+
+  # The retry state associated with an unsuccessful activity execution.
+# This field is only meaningful when `failure` is set.
+  sig { params(value: T.any(Symbol, String, Integer)).void }
+  def retry_state=(value)
+  end
+
+  # The retry state associated with an unsuccessful activity execution.
+# This field is only meaningful when `failure` is set.
+  sig { void }
+  def clear_retry_state
+  end
+
   sig { returns(T.nilable(Symbol)) }
   def value
   end
@@ -98,7 +118,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 +129,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 +284,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 +381,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 +422,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 +718,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 +1027,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 +1112,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 +1127,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 +1303,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