temporalio 1.4.1 → 1.6.0

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

@@ -74,6 +74,7 @@ module Temporalio
           workflow_failure_exception_types:,
           workflow_payload_codec_thread_pool:,
           unsafe_workflow_io_enabled:,
+          patch_activation_callback:,
           debug_mode:,
           assert_valid_local_activity:, on_eviction: nil
         )
@@ -118,6 +119,7 @@ module Temporalio
               t
             end.freeze,
             unsafe_workflow_io_enabled:,
+            patch_activation_callback:,
             assert_valid_local_activity:
           )
           @state.on_eviction = on_eviction if on_eviction
@@ -145,6 +147,8 @@ module Temporalio
           @state.logger.error(e)
         end
 
+        # Returns whether completion was submitted to the bridge
+        # rubocop:disable Naming/PredicateMethod
         def handle_activation_complete(runner:, activation_completion:, encoded:, completion_complete_queue:)
           if @payload_encoding_visitor && !encoded
             if Fiber.current_scheduler
@@ -154,12 +158,15 @@ module Temporalio
                 encode_activation_completion(runner, activation_completion)
               end
             end
+            false
           else
             @state.bridge_worker.async_complete_workflow_activation(
               activation_completion.run_id, activation_completion.to_proto, completion_complete_queue
             )
+            true
           end
         end
+        # rubocop:enable Naming/PredicateMethod
 
         def on_shutdown_complete
           @state.evict_all
@@ -194,7 +201,7 @@ module Temporalio
           attr_reader :workflow_definitions, :bridge_worker, :logger, :metric_meter, :data_converter, :deadlock_timeout,
                       :illegal_calls, :namespace, :task_queue, :disable_eager_activity_execution,
                       :workflow_interceptors, :workflow_failure_exception_types, :unsafe_workflow_io_enabled,
-                      :assert_valid_local_activity
+                      :patch_activation_callback, :assert_valid_local_activity
 
           attr_writer :on_eviction
 
@@ -202,7 +209,7 @@ module Temporalio
             workflow_definitions:, bridge_worker:, logger:, metric_meter:, data_converter:, deadlock_timeout:,
             illegal_calls:, namespace:, task_queue:, disable_eager_activity_execution:,
             workflow_interceptors:, workflow_failure_exception_types:, unsafe_workflow_io_enabled:,
-            assert_valid_local_activity:
+            patch_activation_callback:, assert_valid_local_activity:
           )
             @workflow_definitions = workflow_definitions
             @bridge_worker = bridge_worker
@@ -217,6 +224,7 @@ module Temporalio
             @workflow_interceptors = workflow_interceptors
             @workflow_failure_exception_types = workflow_failure_exception_types
             @unsafe_workflow_io_enabled = unsafe_workflow_io_enabled
+            @patch_activation_callback = patch_activation_callback
             @assert_valid_local_activity = assert_valid_local_activity
 
             @running_workflows = {}

data/lib/temporalio/internal/workflow_task_failure_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Temporalio
+  module Internal
+    # Marker for internal exceptions that must escape workflow fibers and fail the workflow task.
+    module WorkflowTaskFailureError
+    end
+  end
+end

data/lib/temporalio/testing/activity_environment.rb

@@ -18,11 +18,13 @@ module Temporalio
       def self.default_info
         @default_info ||= Activity::Info.new(
           activity_id: 'test',
+          activity_run_id: nil,
           activity_type: 'unknown',
           attempt: 1,
           current_attempt_scheduled_time: Time.at(0),
           heartbeat_timeout: nil,
           local?: false,
+          namespace: 'default',
           priority: Temporalio::Priority.default,
           raw_heartbeat_details: [],
           retry_policy: RetryPolicy.new,

data/lib/temporalio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Temporalio
-  VERSION = '1.4.1'
+  VERSION = '1.6.0'
 end

data/lib/temporalio/worker/activity_executor/fiber.rb

@@ -23,7 +23,7 @@ module Temporalio
         end
 
         # @see ActivityExecutor.initialize_activity
-        def execute_activity(_defn, &)
+        def execute_activity(defn, &) # rubocop:disable Lint/UnusedMethodArgument
           ::Fiber.schedule(&)
         end
 

data/lib/temporalio/worker/activity_executor/thread_pool.rb

@@ -20,7 +20,7 @@ module Temporalio
         end
 
         # @see ActivityExecutor.execute_activity
-        def execute_activity(_defn, &)
+        def execute_activity(defn, &) # rubocop:disable Lint/UnusedMethodArgument
           @thread_pool.execute(&)
         end
 

data/lib/temporalio/worker/illegal_workflow_call_validator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'temporalio/internal/google_protobuf'
+
 module Temporalio
   class Worker
     # Custom validator for validating illegal workflow calls.
@@ -44,7 +46,7 @@ module Temporalio
       def self.known_safe_mutex_validator
         @known_safe_mutex_validator ||= IllegalWorkflowCallValidator.new do
           # Only Google Protobuf use of Mutex is known to be safe, fail unless any caller location path has protobuf
-          raise 'disallowed' unless caller_locations&.any? { |loc| loc.path&.include?('google/protobuf/') }
+          raise 'disallowed' unless ::Temporalio::Internal::GoogleProtobuf.in_call_stack?(caller_locations)
         end
       end
 

data/lib/temporalio/worker/workflow_executor/thread_pool.rb

@@ -4,6 +4,7 @@ require 'etc'
 require 'temporalio/internal/bridge/api'
 require 'temporalio/internal/proto_utils'
 require 'temporalio/internal/worker/workflow_instance'
+require 'temporalio/internal/workflow_task_failure_error'
 require 'temporalio/scoped_logger'
 require 'temporalio/worker/thread_pool'
 require 'temporalio/worker/workflow_executor'
@@ -215,6 +216,7 @@ module Temporalio
                 illegal_calls: worker_state.illegal_calls,
                 workflow_failure_exception_types: worker_state.workflow_failure_exception_types,
                 unsafe_workflow_io_enabled: worker_state.unsafe_workflow_io_enabled,
+                patch_activation_callback: worker_state.patch_activation_callback,
                 assert_valid_local_activity: worker_state.assert_valid_local_activity
               )
             )
@@ -229,7 +231,9 @@ module Temporalio
         private_constant :Worker
 
         # Error raised when a processing a workflow task takes more than the expected amount of time.
-        class DeadlockError < Exception; end # rubocop:disable Lint/InheritException
+        class DeadlockError < Exception # rubocop:disable Lint/InheritException
+          include Internal::WorkflowTaskFailureError
+        end
       end
     end
   end

data/lib/temporalio/worker/workflow_replayer.rb

@@ -264,6 +264,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: nil,
             debug_mode: options.debug_mode,
             on_eviction: proc { |_, remove_job| @last_workflow_remove_job = remove_job }, # steep:ignore
             assert_valid_local_activity: ->(_) {}
@@ -271,6 +272,8 @@ module Temporalio
 
           # Create the runner
           @runner = Internal::Worker::MultiRunner.new(workers: [self], shutdown_signals: [])
+          @pending_workflow_activations = 0
+          @pending_workflow_activation_completions = 0
         end
 
         # Replay a workflow history.
@@ -295,11 +298,12 @@ module Temporalio
               history.workflow_id, Api::History::V1::History.new(events: history.events).to_proto
             )
 
-            # Process events until workflow complete
-            until @last_workflow_remove_job
+            # Process events until workflow complete and all completions submitted to core have finished.
+            until @last_workflow_remove_job && workflow_activation_work_drained?
               event = @runner.next_event
               case event
               when Internal::Worker::MultiRunner::Event::PollSuccess
+                @pending_workflow_activations += 1
                 @workflow_worker.handle_activation(
                   runner: @runner,
                   activation: Internal::Bridge::Api::WorkflowActivation::WorkflowActivation.decode(event.bytes),
@@ -308,14 +312,17 @@ module Temporalio
               when Internal::Worker::MultiRunner::Event::WorkflowActivationDecoded
                 @workflow_worker.handle_activation(runner: @runner, activation: event.activation, decoded: true)
               when Internal::Worker::MultiRunner::Event::WorkflowActivationComplete
-                @workflow_worker.handle_activation_complete(
+                if @workflow_worker.handle_activation_complete(
                   runner: @runner,
                   activation_completion: event.activation_completion,
                   encoded: event.encoded,
                   completion_complete_queue: event.completion_complete_queue
                 )
+                  @pending_workflow_activations -= 1
+                  @pending_workflow_activation_completions += 1
+                end
               when Internal::Worker::MultiRunner::Event::WorkflowActivationCompletionComplete
-              # Ignore
+                @pending_workflow_activation_completions -= 1
               else
                 raise "Unexpected event: #{event}"
               end
@@ -365,6 +372,12 @@ module Temporalio
         def _wait_all_complete
           # Do nothing
         end
+
+        private
+
+        def workflow_activation_work_drained?
+          @pending_workflow_activations.zero? && @pending_workflow_activation_completions.zero?
+        end
       end
     end
   end

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