temporalio 1.5.0 → 1.7.0

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
@@ -344,6 +344,9 @@ module Temporalio
     # same ID and workflow are memoized. Use {deprecate_patch} when all workflows are done and will never be queried
     # again. The old code path can be removed at that time too.
     #
+    # Workers can set `patch_activation_callback:` to delay activating a newly introduced patch during rolling
+    # deployments. That callback is only used when the patch marker would otherwise be created for the first time.
+    #
     # @param patch_id [Symbol, String] Patch ID.
     # @return [Boolean] True if this should take the newer patch, false if it should take the old path.
     def self.patched(patch_id)
@@ -390,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)
@@ -404,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.
@@ -477,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.
@@ -646,6 +648,7 @@ module Temporalio
     # Error that is raised by a workflow out of the primary workflow method to issue a continue-as-new.
     class ContinueAsNewError < Error
       attr_accessor :args, :workflow, :task_queue, :run_timeout, :task_timeout,
+                    :backoff_start_interval,
                     :retry_policy, :memo, :search_attributes, :arg_hints, :headers,
                     :initial_versioning_behavior
 
@@ -660,6 +663,8 @@ module Temporalio
       #   from the current workflow.
       # @param task_timeout [Float, nil] Timeout of a single workflow task in seconds. The default is _not_ carried over
       #   from the current workflow.
+      # @param backoff_start_interval [Float, nil] Delay before the first workflow task of the continued run is
+      #   scheduled.
       # @param retry_policy [RetryPolicy, nil] Retry policy for the workflow. If unset/nil, the current workflow retry
       #   policy is used.
       # @param memo [Hash{String, Symbol => Object}, nil] Memo for the workflow. If unset/nil, the current workflow memo
@@ -680,6 +685,7 @@ module Temporalio
         task_queue: nil,
         run_timeout: nil,
         task_timeout: nil,
+        backoff_start_interval: nil,
         retry_policy: nil,
         memo: nil,
         search_attributes: nil,
@@ -693,6 +699,7 @@ module Temporalio
         @task_queue = task_queue
         @run_timeout = run_timeout
         @task_timeout = task_timeout
+        @backoff_start_interval = backoff_start_interval
         @retry_policy = retry_policy
         @memo = memo
         @search_attributes = search_attributes

data/rbi/google/protobuf.rbi

@@ -0,0 +1,25 @@
+# typed: false
+# frozen_string_literal: true
+
+# Minimal shim for google-protobuf types referenced by generated proto RBI files.
+
+module Google
+  module Protobuf
+    module MessageExts
+      module ClassMethods; end
+    end
+
+    class AbstractMessage; end
+    class Descriptor; end
+    class EnumDescriptor; end
+    class RepeatedField; end
+    class Map; end
+
+    class Any; end
+    class DoubleValue; end
+    class Duration; end
+    class Empty; end
+    class FieldMask; end
+    class Timestamp; end
+  end
+end

data/rbi/temporalio/activity/cancellation_details.rbi

@@ -0,0 +1,33 @@
+# typed: true
+
+class Temporalio::Activity::CancellationDetails
+  sig do
+    params(
+      gone_from_server: T::Boolean,
+      cancel_requested: T::Boolean,
+      timed_out: T::Boolean,
+      worker_shutdown: T::Boolean,
+      paused: T::Boolean,
+      reset: T::Boolean
+    ).void
+  end
+  def initialize(gone_from_server: false, cancel_requested: false, timed_out: false, worker_shutdown: false, paused: false, reset: false); end
+
+  sig { returns(T::Boolean) }
+  def gone_from_server?; end
+
+  sig { returns(T::Boolean) }
+  def cancel_requested?; end
+
+  sig { returns(T::Boolean) }
+  def timed_out?; end
+
+  sig { returns(T::Boolean) }
+  def worker_shutdown?; end
+
+  sig { returns(T::Boolean) }
+  def paused?; end
+
+  sig { returns(T::Boolean) }
+  def reset?; end
+end

data/rbi/temporalio/activity/complete_async_error.rbi

@@ -0,0 +1,3 @@
+# typed: true
+
+class Temporalio::Activity::CompleteAsyncError < ::Temporalio::Error; end

data/rbi/temporalio/activity/context.rbi

@@ -0,0 +1,42 @@
+# typed: true
+
+class Temporalio::Activity::Context
+  sig { returns(Temporalio::Activity::Context) }
+  def self.current; end
+
+  sig { returns(T.nilable(Temporalio::Activity::Context)) }
+  def self.current_or_nil; end
+
+  sig { returns(T::Boolean) }
+  def self.exist?; end
+
+  sig { returns(Temporalio::Activity::Info) }
+  def info; end
+
+  sig { returns(T.nilable(Temporalio::Activity::Definition)) }
+  def instance; end
+
+  sig { params(details: T.nilable(Object), detail_hints: T.nilable(T::Array[Object])).void }
+  def heartbeat(*details, detail_hints: nil); end
+
+  sig { returns(Temporalio::Cancellation) }
+  def cancellation; end
+
+  sig { returns(T.nilable(Temporalio::Activity::CancellationDetails)) }
+  def cancellation_details; end
+
+  sig { returns(Temporalio::Cancellation) }
+  def worker_shutdown_cancellation; end
+
+  sig { returns(Temporalio::Converters::PayloadConverter) }
+  def payload_converter; end
+
+  sig { returns(Temporalio::ScopedLogger) }
+  def logger; end
+
+  sig { returns(Temporalio::Metric::Meter) }
+  def metric_meter; end
+
+  sig { returns(Temporalio::Client) }
+  def client; end
+end

data/rbi/temporalio/activity/definition.rbi

@@ -0,0 +1,74 @@
+# typed: true
+
+class Temporalio::Activity::Definition
+  sig { params(args: Object).returns(Object) }
+  def execute(*args); end
+
+  class << self
+    protected
+
+    sig { params(name: T.any(String, Symbol)).void }
+    def activity_name(name); end
+
+    sig { params(executor_name: Symbol).void }
+    def activity_executor(executor_name); end
+
+    sig { params(cancel_raise: T::Boolean).void }
+    def activity_cancel_raise(cancel_raise); end
+
+    sig { params(value: T::Boolean).void }
+    def activity_dynamic(value = true); end
+
+    sig { params(value: T::Boolean).void }
+    def activity_raw_args(value = true); end
+
+    sig { params(hints: Object).void }
+    def activity_arg_hint(*hints); end
+
+    sig { params(hint: T.nilable(Object)).void }
+    def activity_result_hint(hint); end
+  end
+end
+
+class Temporalio::Activity::Definition::Info
+  sig do
+    params(
+      name: T.nilable(T.any(String, Symbol)),
+      instance: T.nilable(T.any(Object, Proc)),
+      executor: Symbol,
+      cancel_raise: T::Boolean,
+      raw_args: T::Boolean,
+      arg_hints: T.nilable(T::Array[Object]),
+      result_hint: T.nilable(Object),
+      block: T.nilable(T.proc.params(arg0: Object).returns(Object))
+    ).void
+  end
+  def initialize(name:, instance: nil, executor: :default, cancel_raise: true, raw_args: false, arg_hints: nil, result_hint: nil, &block); end
+
+  sig { params(activity: T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info)).returns(Temporalio::Activity::Definition::Info) }
+  def self.from_activity(activity); end
+
+  sig { returns(T.nilable(T.any(String, Symbol))) }
+  attr_reader :name
+
+  sig { returns(T.nilable(T.any(Object, Proc))) }
+  attr_reader :instance
+
+  sig { returns(Proc) }
+  attr_reader :proc
+
+  sig { returns(Symbol) }
+  attr_reader :executor
+
+  sig { returns(T::Boolean) }
+  attr_reader :cancel_raise
+
+  sig { returns(T::Boolean) }
+  attr_reader :raw_args
+
+  sig { returns(T.nilable(T::Array[Object])) }
+  attr_reader :arg_hints
+
+  sig { returns(T.nilable(Object)) }
+  attr_reader :result_hint
+end

data/rbi/temporalio/activity/info.rbi

@@ -0,0 +1,112 @@
+# typed: true
+
+class Temporalio::Activity::Info < ::Data
+  sig do
+    params(
+      activity_id: String,
+      activity_run_id: T.nilable(String),
+      activity_type: String,
+      attempt: Integer,
+      current_attempt_scheduled_time: Time,
+      heartbeat_timeout: T.nilable(Float),
+      local: T::Boolean,
+      priority: T.nilable(Temporalio::Priority),
+      raw_heartbeat_details: T::Array[Temporalio::Converters::RawValue],
+      retry_policy: T.nilable(Temporalio::RetryPolicy),
+      schedule_to_close_timeout: T.nilable(Float),
+      scheduled_time: Time,
+      start_to_close_timeout: T.nilable(Float),
+      started_time: Time,
+      task_queue: String,
+      task_token: String,
+      workflow_id: T.nilable(String),
+      workflow_namespace: T.nilable(String),
+      workflow_run_id: T.nilable(String),
+      workflow_type: T.nilable(String)
+    ).void
+  end
+  def initialize(activity_id:, activity_run_id:, activity_type:, attempt:, current_attempt_scheduled_time:, heartbeat_timeout:, local:, priority:, raw_heartbeat_details:, retry_policy:, schedule_to_close_timeout:, scheduled_time:, start_to_close_timeout:, started_time:, task_queue:, task_token:, workflow_id:, workflow_namespace:, workflow_run_id:, workflow_type:); end
+
+  sig { returns(String) }
+  def activity_id; end
+
+  sig { returns(T.nilable(String)) }
+  def activity_run_id; end
+
+  sig { returns(String) }
+  def activity_type; end
+
+  sig { returns(Integer) }
+  def attempt; end
+
+  sig { returns(Time) }
+  def current_attempt_scheduled_time; end
+
+  sig { params(hints: T.nilable(T::Array[Object])).returns(T::Array[T.nilable(Object)]) }
+  def heartbeat_details(hints: nil); end
+
+  sig { returns(T.nilable(Float)) }
+  def heartbeat_timeout; end
+
+  sig { returns(T::Boolean) }
+  def local?; end
+
+  sig { returns(String) }
+  def namespace; end
+
+  sig { returns(Temporalio::Priority) }
+  def priority; end
+
+  sig { returns(T::Array[Temporalio::Converters::RawValue]) }
+  def raw_heartbeat_details; end
+
+  sig { returns(T.nilable(Temporalio::RetryPolicy)) }
+  def retry_policy; end
+
+  sig { returns(T.nilable(Float)) }
+  def schedule_to_close_timeout; end
+
+  sig { returns(Time) }
+  def scheduled_time; end
+
+  sig { returns(T.nilable(Float)) }
+  def start_to_close_timeout; end
+
+  sig { returns(Time) }
+  def started_time; end
+
+  sig { returns(String) }
+  def task_queue; end
+
+  sig { returns(String) }
+  def task_token; end
+
+  sig { returns(T.nilable(String)) }
+  def workflow_id; end
+
+  sig { returns(T.nilable(String)) }
+  def workflow_namespace; end
+
+  sig { returns(T.nilable(String)) }
+  def workflow_run_id; end
+
+  sig { returns(T.nilable(String)) }
+  def workflow_type; end
+
+  sig { params(kwargs: T.untyped).returns(Temporalio::Activity::Info) }
+  def with(**kwargs); end
+
+  sig { returns(T::Boolean) }
+  def in_workflow?; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::Activity::Info) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+
+    sig { params(args: T.untyped).returns(Temporalio::Activity::Info) }
+    def new(*args); end
+  end
+end

data/rbi/temporalio/activity.rbi

@@ -0,0 +1,3 @@
+# typed: true
+
+module Temporalio::Activity; end