temporalio 1.5.0 → 1.6.0

data/lib/temporalio/worker.rb

@@ -28,6 +28,17 @@ module Temporalio
   # {run_all} is used for a collection of workers. These can wait until a block is complete or a {Cancellation} is
   # canceled.
   class Worker
+    # Input for the experimental `patch_activation_callback:` worker option.
+    #
+    # @!attribute [r] workflow_info
+    #   @return [Workflow::Info] Information about the workflow execution calling {Workflow.patched}.
+    # @!attribute [r] patch_id
+    #   @return [String] Patch ID passed to {Workflow.patched}.
+    PatchActivationInput = Data.define(
+      :workflow_info,
+      :patch_id
+    )
+
     Options = Data.define(
       :client,
       :task_queue,
@@ -57,6 +68,7 @@ module Temporalio
       :workflow_payload_codec_thread_pool,
       :unsafe_workflow_io_enabled,
       :deployment_options,
+      :patch_activation_callback,
       :workflow_task_poller_behavior,
       :activity_task_poller_behavior,
       :debug_mode
@@ -81,12 +93,16 @@ module Temporalio
       # hashing all bytecode of required files. This means later/dynamic require
       # won't be accounted for because this is memoized. It also means the
       # tiniest code change will affect this, which is what we want since this
-      # is meant to be a "binary checksum". We have chosen to use MD5 for speed,
-      # similarity with other SDKs, and because security is not a factor.
+      # is meant to be a "binary checksum". We default to MD5 for speed,
+      # similarity with other SDKs, and because security is not a factor. On
+      # FIPS builds we use SHA-256 instead, since MD5 is rejected by FIPS-mode
+      # OpenSSL. This is opt-in (tied to the FIPS build) so existing,
+      # non-FIPS users keep their stable MD5-based build IDs.
       require 'digest'
 
+      initial_digest = Internal::Bridge::FIPS ? Digest::SHA256.new : Digest::MD5.new
       saw_bridge = false
-      build_id = $LOADED_FEATURES.each_with_object(Digest::MD5.new) do |file, digest|
+      build_id = $LOADED_FEATURES.each_with_object(initial_digest) do |file, digest|
         saw_bridge = true if file.include?('temporalio_bridge.')
         digest.update(File.read(file)) if File.file?(file)
       end.hexdigest
@@ -166,6 +182,7 @@ module Temporalio
       raise ArgumentError, 'Not all parameters are workers' unless workers.all?(Worker)
 
       Internal::Bridge.assert_fiber_compatibility!
+      Internal::Bridge.assert_fips_compatibility!
 
       # Start the multi runner
       runner = Internal::Worker::MultiRunner.new(workers:, shutdown_signals:)
@@ -425,6 +442,9 @@ module Temporalio
     #   scheduler will fail. Instead of setting this to true, users are encouraged to use {Workflow::Unsafe.io_enabled}
     #   with a block for narrower enabling of IO.
     # @param deployment_options [DeploymentOptions, nil] Deployment options for the worker.
+    # @param patch_activation_callback [Proc, nil] Experimental callback to decide whether the first non-replay call to
+    #   {Workflow.patched} for a patch ID should activate that patch. The callback receives a {PatchActivationInput} and
+    #   must return `true` to activate the patch or `false` to leave it inactive.
     # @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
@@ -461,6 +481,7 @@ module Temporalio
       workflow_payload_codec_thread_pool: nil,
       unsafe_workflow_io_enabled: false,
       deployment_options: Worker.default_deployment_options,
+      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)
@@ -496,6 +517,7 @@ module Temporalio
         workflow_payload_codec_thread_pool:,
         unsafe_workflow_io_enabled:,
         deployment_options:,
+        patch_activation_callback:,
         workflow_task_poller_behavior:,
         activity_task_poller_behavior:,
         debug_mode:
@@ -564,8 +586,10 @@ module Temporalio
       )
 
       # Collect interceptors from client and params
-      @activity_interceptors = (@options.client.options.interceptors + @options.interceptors).grep(Interceptor::Activity)
-      @workflow_interceptors = (@options.client.options.interceptors + @options.interceptors).grep(Interceptor::Workflow)
+      @activity_interceptors =
+        (@options.client.options.interceptors + @options.interceptors).grep(Interceptor::Activity)
+      @workflow_interceptors =
+        (@options.client.options.interceptors + @options.interceptors).grep(Interceptor::Workflow)
 
       # Cancellation for the whole worker
       @worker_shutdown_cancellation = Cancellation.new
@@ -591,6 +615,7 @@ module Temporalio
           workflow_failure_exception_types: @options.workflow_failure_exception_types,
           workflow_payload_codec_thread_pool: @options.workflow_payload_codec_thread_pool,
           unsafe_workflow_io_enabled: @options.unsafe_workflow_io_enabled,
+          patch_activation_callback: @options.patch_activation_callback,
           debug_mode: @options.debug_mode,
           assert_valid_local_activity: ->(activity) { _assert_valid_local_activity(activity) }
         )

data/lib/temporalio/workflow/future.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'temporalio/internal/workflow_task_failure_error'
 require 'temporalio/workflow'
 
 module Temporalio
@@ -81,6 +82,10 @@ module Temporalio
         @fiber = Fiber.schedule do
           @result = block.call # steep:ignore
         rescue Exception => e # rubocop:disable Lint/RescueException
+          # These errors invalidate the whole workflow task. If stored and only raised on wait, the activation may
+          # complete successfully with commands that were emitted before the error.
+          raise if e.is_a?(Internal::WorkflowTaskFailureError)
+
           @failure = e
         ensure
           @done = true

data/lib/temporalio/workflow/nexus_operation_cancellation_type.rb

@@ -9,13 +9,15 @@ module Temporalio
     # WARNING: Nexus support is experimental.
     module NexusOperationCancellationType
       # Wait for cancellation to complete (default).
-      WAIT_CANCELLATION_COMPLETED = Internal::Bridge::Api::Nexus::NexusOperationCancellationType::WAIT_CANCELLATION_COMPLETED
+      WAIT_CANCELLATION_COMPLETED =
+        Internal::Bridge::Api::Nexus::NexusOperationCancellationType::WAIT_CANCELLATION_COMPLETED
       # Abandon the operation without sending a cancellation request.
       ABANDON = Internal::Bridge::Api::Nexus::NexusOperationCancellationType::ABANDON
       # Send a cancellation request but do not wait for confirmation.
       TRY_CANCEL = Internal::Bridge::Api::Nexus::NexusOperationCancellationType::TRY_CANCEL
       # Wait for the server to confirm the cancellation request was delivered.
-      WAIT_CANCELLATION_REQUESTED = Internal::Bridge::Api::Nexus::NexusOperationCancellationType::WAIT_CANCELLATION_REQUESTED
+      WAIT_CANCELLATION_REQUESTED =
+        Internal::Bridge::Api::Nexus::NexusOperationCancellationType::WAIT_CANCELLATION_REQUESTED
     end
   end
 end

data/lib/temporalio/workflow.rb

@@ -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)
@@ -646,6 +649,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 +664,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 +686,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 +700,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