temporalio 0.5.0-aarch64-linux → 1.0.0-aarch64-linux

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

@@ -40,6 +40,7 @@ module Temporalio
         TunerSlotSupplierOptions = Struct.new(
           :fixed_size,
           :resource_based,
+          :custom,
           keyword_init: true
         )
 
@@ -103,6 +104,55 @@ module Temporalio
           # TODO(cretz): Log error on this somehow?
           async_complete_activity_task(proto.to_proto, queue)
         end
+
+        class CustomSlotSupplier
+          def initialize(slot_supplier:, thread_pool:)
+            @slot_supplier = slot_supplier
+            @thread_pool = thread_pool
+          end
+
+          def reserve_slot(context, cancellation, &block)
+            run_user_code do
+              @slot_supplier.reserve_slot(context, cancellation) { |v| block.call(v) }
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              block.call(e)
+            end
+          end
+
+          def try_reserve_slot(context, &block)
+            run_user_code do
+              block.call(@slot_supplier.try_reserve_slot(context))
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              block.call(e)
+            end
+          end
+
+          def mark_slot_used(context, &block)
+            run_user_code do
+              block.call(@slot_supplier.mark_slot_used(context))
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              block.call(e)
+            end
+          end
+
+          def release_slot(context, &block)
+            run_user_code do
+              block.call(@slot_supplier.release_slot(context))
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              block.call(e)
+            end
+          end
+
+          private
+
+          def run_user_code(&)
+            if @thread_pool
+              @thread_pool.execute(&)
+            else
+              yield
+            end
+          end
+        end
       end
     end
   end

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

@@ -2,6 +2,7 @@
 
 require 'google/protobuf/well_known_types'
 require 'securerandom'
+require 'temporalio/activity'
 require 'temporalio/api'
 require 'temporalio/client/activity_id_reference'
 require 'temporalio/client/async_activity_handle'
@@ -829,9 +830,13 @@ module Temporalio
                      rpc_options: Implementation.with_default_rpc_options(input.rpc_options)
                    )
                  end
-          raise Error::AsyncActivityCanceledError if resp.cancel_requested
+          return unless resp.cancel_requested || resp.activity_paused || resp.activity_reset
 
-          nil
+          raise Error::AsyncActivityCanceledError, Activity::CancellationDetails.new(
+            cancel_requested: resp.cancel_requested,
+            paused: resp.activity_paused,
+            reset: resp.activity_reset
+          )
         end
 
         def complete_async_activity(input)

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

@@ -185,6 +185,7 @@ module Temporalio
               payloads = codec.decode(payloads) if codec
               payloads.map { |p| Temporalio::Converters::RawValue.new(p) }
             end,
+            retry_policy: (RetryPolicy._from_proto(start.retry_policy) if start.retry_policy),
             schedule_to_close_timeout: Internal::ProtoUtils.duration_to_seconds(start.schedule_to_close_timeout),
             scheduled_time: Internal::ProtoUtils.timestamp_to_time(start.scheduled_time) || raise, # Never nil
             start_to_close_timeout: Internal::ProtoUtils.duration_to_seconds(start.start_to_close_timeout),

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

@@ -63,12 +63,13 @@ module Temporalio
           end
 
           def durable_scheduler_disabled(&)
-            prev = Fiber.current_scheduler
-            illegal_call_tracing_disabled { Fiber.set_scheduler(nil) }
-            begin
+            prev = Fiber.scheduler
+            # Imply illegal call tracing disabled
+            illegal_call_tracing_disabled do
+              Fiber.set_scheduler(nil)
               yield
             ensure
-              illegal_call_tracing_disabled { Fiber.set_scheduler(prev) }
+              Fiber.set_scheduler(prev)
             end
           end
 
@@ -129,6 +130,7 @@ module Temporalio
           def execute_local_activity(
             activity,
             *args,
+            summary:,
             schedule_to_close_timeout:,
             schedule_to_start_timeout:,
             start_to_close_timeout:,
@@ -156,6 +158,7 @@ module Temporalio
               Temporalio::Worker::Interceptor::Workflow::ExecuteLocalActivityInput.new(
                 activity:,
                 args:,
+                summary:,
                 schedule_to_close_timeout:,
                 schedule_to_start_timeout:,
                 start_to_close_timeout:,

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'delegate'
+
 module Temporalio
   module Internal
     module Worker

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

@@ -16,7 +16,7 @@ module Temporalio
               # @type var fixed_val: :all | Worker::IllegalWorkflowCallValidator | Hash[Symbol, TrueClass | Worker::IllegalWorkflowCallValidator] # rubocop:disable Layout/LineLength
               fixed_val = case val
                           when Temporalio::Worker::IllegalWorkflowCallValidator
-                            if sub_val.method_name
+                            if val.method_name
                               raise ArgumentError,
                                     'Top level IllegalWorkflowCallValidator instances cannot have method name'
                             end
@@ -84,7 +84,7 @@ module Temporalio
                 when :all
                   ''
                 when Temporalio::Worker::IllegalWorkflowCallValidator
-                  disable do
+                  disable_temporarily do
                     vals.block.call(Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo.new(
                                       class_name:, method_name: tp.callee_id, trace_point: tp
                                     ))
@@ -98,7 +98,7 @@ module Temporalio
                   when true
                     ''
                   when Temporalio::Worker::IllegalWorkflowCallValidator
-                    disable do
+                    disable_temporarily do
                       per_method.block.call(Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo.new(
                                               class_name:, method_name: tp.callee_id, trace_point: tp
                                             ))
@@ -118,8 +118,11 @@ module Temporalio
           end
 
           def enable(&block)
-            # We've seen leaking issues in Ruby 3.2 where the TracePoint inadvertently remains enabled even for threads
-            # that it was not started on. So we will check the thread ourselves.
+            # This is not reentrant and not expected to be called as such. We've seen leaking issues in Ruby 3.2 where
+            # the TracePoint inadvertently remains enabled even for threads that it was not started on. So we will check
+            # the thread ourselves. We also use the "enabled thread" concept for disabling checks too, see
+            # disable_temporarily for more details.
+
             @enabled_thread = Thread.current
             @tracepoint.enable do
               block.call
@@ -128,13 +131,17 @@ module Temporalio
             end
           end
 
-          def disable(&block)
+          def disable_temporarily(&)
+            # An earlier version of this used @tracepoint.disable, but in some versions of Ruby, the observed behavior
+            # is confusingly not reentrant or at least not predictable. Therefore, instead of calling
+            # @tracepoint.disable, we are just unsetting the enabled thread. This means the tracer is still running, but
+            # no checks are performed. This is effectively a no-op if tracing was never enabled.
+
             previous_thread = @enabled_thread
-            @tracepoint.disable do
-              block.call
-            ensure
-              @enabled_thread = previous_thread
-            end
+            @enabled_thread = nil
+            yield
+          ensure
+            @enabled_thread = previous_thread
           end
         end
       end

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

@@ -114,14 +114,15 @@ module Temporalio
                     local_retry_threshold: ProtoUtils.seconds_to_duration(input.local_retry_threshold),
                     attempt: do_backoff&.attempt || 0,
                     original_schedule_time: do_backoff&.original_schedule_time
-                  )
+                  ),
+                  user_metadata: ProtoUtils.to_user_metadata(input.summary, nil, @instance.payload_converter)
                 )
               )
               seq
             end
           end
 
-          def execute_activity_with_local_backoffs(local:, cancellation:, result_hint:, &)
+          def execute_activity_with_local_backoffs(local:, cancellation:, result_hint:, &block)
             # We do not even want to schedule if the cancellation is already cancelled. We choose to use canceled
             # failure instead of wrapping in activity failure which is similar to what other SDKs do, with the accepted
             # tradeoff that it makes rescue more difficult (hence the presence of Error.canceled? helper).
@@ -130,7 +131,7 @@ module Temporalio
             # This has to be done in a loop for local activity backoff
             last_local_backoff = nil
             loop do
-              result = execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &)
+              result = execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &block)
               return result unless result.is_a?(Bridge::Api::ActivityResult::DoBackoff)
 
               # @type var result: untyped
@@ -142,9 +143,9 @@ module Temporalio
           end
 
           # If this doesn't raise, it returns success | DoBackoff
-          def execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &)
+          def execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &block)
             # Add to pending activities (removed by the resolver)
-            seq = yield last_local_backoff
+            seq = block.call(last_local_backoff)
             @instance.pending_activities[seq] = Fiber.current
 
             # Add cancellation hook

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

@@ -27,8 +27,11 @@ module Temporalio
               return true
             end
 
-            # Disable illegal call tracing for the log call
-            @instance.illegal_call_tracing_disabled { super }
+            # Disable scheduler since logs technically have local mutexes in them that cannot be done durably or they
+            # will block workflows
+            @instance.context.durable_scheduler_disabled do
+              super
+            end
           end
         end
       end

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

@@ -40,10 +40,15 @@ module Temporalio
               cond_fiber = nil
               cond_result = nil
               @wait_conditions.each do |seq, cond|
+                # Evaluate condition or skip if not true
                 next unless (cond_result = cond.first.call)
 
-                cond_fiber = cond[1]
-                @wait_conditions.delete(seq)
+                # There have been reports of this fiber being completed already, so we make sure not to process if it
+                # has, but we still delete it
+                deleted_cond = @wait_conditions.delete(seq)
+                next unless deleted_cond&.last&.alive?
+
+                cond_fiber = deleted_cond.last
                 break
               end
               return unless cond_fiber
@@ -106,7 +111,7 @@ module Temporalio
             # We just yield because unblock will resume this. We will just wrap in timeout if needed.
             if timeout
               begin
-                Timeout.timeout(timeout) { Fiber.yield }
+                Workflow.timeout(timeout) { Fiber.yield }
                 true
               rescue Timeout::Error
                 false
@@ -141,7 +146,8 @@ module Temporalio
             unless @instance.io_enabled
               raise Workflow::NondeterminismError,
                     'Cannot perform IO from inside a workflow. If this is known to be safe, ' \
-                    'the code can be run in a Temporalio::Workflow::Unsafe.io_enabled block.'
+                    'the code can be run in a Temporalio::Workflow::Unsafe.durable_scheduler_disabled ' \
+                    'or Temporalio::Workflow::Unsafe.io_enabled block.'
             end
 
             # Use regular Ruby behavior of blocking this thread. There is no Ruby implementation of io_wait we can just

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

@@ -125,6 +125,7 @@ module Temporalio
               continued_run_id: ProtoUtils.string_or(@init_job.continued_from_execution_run_id),
               cron_schedule: ProtoUtils.string_or(@init_job.cron_schedule),
               execution_timeout: ProtoUtils.duration_to_seconds(@init_job.workflow_execution_timeout),
+              first_execution_run_id: @init_job.first_execution_run_id,
               headers: ProtoUtils.headers_from_proto_map(@init_job.headers, @payload_converter) || {},
               last_failure: if @init_job.continued_failure
                               @failure_converter.from_failure(@init_job.continued_failure, @payload_converter)
@@ -162,86 +163,9 @@ module Temporalio
         end
 
         def activate(activation)
-          # Run inside of scheduler
-          run_in_scheduler { activate_internal(activation) }
-        end
-
-        def add_command(command)
-          raise Workflow::InvalidWorkflowStateError, 'Cannot add commands in this context' if @context_frozen
-
-          @commands << command
-        end
-
-        def instance
-          @instance or raise 'Instance accessed before created'
-        end
-
-        def search_attributes
-          # Lazy on first access
-          @search_attributes ||= SearchAttributes._from_proto(
-            @init_job.search_attributes, disable_mutations: true, never_nil: true
-          ) || raise
-        end
-
-        def memo
-          # Lazy on first access
-          @memo ||= ExternallyImmutableHash.new(ProtoUtils.memo_from_proto(@init_job.memo, payload_converter) || {})
-        end
-
-        def now
-          # Create each time
-          ProtoUtils.timestamp_to_time(@now_timestamp) or raise 'Time unexpectedly not present'
-        end
-
-        def illegal_call_tracing_disabled(&)
-          @tracer.disable(&)
-        end
-
-        def patch(patch_id:, deprecated:)
-          # Use memoized result if present. If this is being deprecated, we can still use memoized result and skip the
-          # command.
-          patch_id = patch_id.to_s
-          @patches_memoized ||= {}
-          @patches_memoized.fetch(patch_id) do
-            patched = !replaying || @patches_notified.include?(patch_id)
-            @patches_memoized[patch_id] = patched
-            if patched
-              add_command(
-                Bridge::Api::WorkflowCommands::WorkflowCommand.new(
-                  set_patch_marker: Bridge::Api::WorkflowCommands::SetPatchMarker.new(patch_id:, deprecated:)
-                )
-              )
-            end
-            patched
-          end
-        end
-
-        def metric_meter
-          @metric_meter ||= ReplaySafeMetric::Meter.new(
-            @runtime_metric_meter.with_additional_attributes(
-              {
-                namespace: info.namespace,
-                task_queue: info.task_queue,
-                workflow_type: info.workflow_type
-              }
-            )
-          )
-        end
-
-        private
-
-        def run_in_scheduler(&)
+          # Run inside of scheduler (removed on ensure)
           Fiber.set_scheduler(@scheduler)
-          if @tracer
-            @tracer.enable(&)
-          else
-            yield
-          end
-        ensure
-          Fiber.set_scheduler(nil)
-        end
 
-        def activate_internal(activation)
           # Reset some activation state
           @commands = []
           @current_activation_error = nil
@@ -266,8 +190,12 @@ module Temporalio
             # the first activation)
             @primary_fiber ||= schedule(top_level: true) { run_workflow }
 
-            # Run the event loop
-            @scheduler.run_until_all_yielded
+            # Run the event loop in the tracer if it exists
+            if @tracer
+              @tracer.enable { @scheduler.run_until_all_yielded }
+            else
+              @scheduler.run_until_all_yielded
+            end
           rescue Exception => e # rubocop:disable Lint/RescueException
             on_top_level_exception(e)
           end
@@ -306,8 +234,77 @@ module Temporalio
         ensure
           @commands = nil
           @current_activation_error = nil
+          Fiber.set_scheduler(nil)
+        end
+
+        def add_command(command)
+          raise Workflow::InvalidWorkflowStateError, 'Cannot add commands in this context' if @context_frozen
+
+          @commands << command
+        end
+
+        def instance
+          @instance or raise 'Instance accessed before created'
+        end
+
+        def search_attributes
+          # Lazy on first access
+          @search_attributes ||= SearchAttributes._from_proto(
+            @init_job.search_attributes, disable_mutations: true, never_nil: true
+          ) || raise
+        end
+
+        def memo
+          # Lazy on first access
+          @memo ||= ExternallyImmutableHash.new(ProtoUtils.memo_from_proto(@init_job.memo, payload_converter) || {})
+        end
+
+        def now
+          # Create each time
+          ProtoUtils.timestamp_to_time(@now_timestamp) or raise 'Time unexpectedly not present'
         end
 
+        def illegal_call_tracing_disabled(&)
+          if @tracer
+            @tracer.disable_temporarily(&)
+          else
+            yield
+          end
+        end
+
+        def patch(patch_id:, deprecated:)
+          # Use memoized result if present. If this is being deprecated, we can still use memoized result and skip the
+          # command.
+          patch_id = patch_id.to_s
+          @patches_memoized ||= {}
+          @patches_memoized.fetch(patch_id) do
+            patched = !replaying || @patches_notified.include?(patch_id)
+            @patches_memoized[patch_id] = patched
+            if patched
+              add_command(
+                Bridge::Api::WorkflowCommands::WorkflowCommand.new(
+                  set_patch_marker: Bridge::Api::WorkflowCommands::SetPatchMarker.new(patch_id:, deprecated:)
+                )
+              )
+            end
+            patched
+          end
+        end
+
+        def metric_meter
+          @metric_meter ||= ReplaySafeMetric::Meter.new(
+            @runtime_metric_meter.with_additional_attributes(
+              {
+                namespace: info.namespace,
+                task_queue: info.task_queue,
+                workflow_type: info.workflow_type
+              }
+            )
+          )
+        end
+
+        private
+
         def create_instance
           # Convert workflow arguments
           @workflow_arguments = convert_args(payload_array: @init_job.arguments,

data/lib/temporalio/priority.rb

@@ -4,7 +4,9 @@ require 'temporalio/api'
 
 module Temporalio
   Priority = Data.define(
-    :priority_key
+    :priority_key,
+    :fairness_key,
+    :fairness_weight
   )
 
   # Priority contains metadata that controls relative ordering of task processing when tasks are
@@ -29,31 +31,70 @@ module Temporalio
   #
   #     The default priority is (min+max)/2. With the default max of 5 and min of 1, that comes
   #     out to 3.
+  #
+  # @!attribute fairness_key
+  #   @return [String, nil] FairnessKey is a short string that's used as a key for a fairness
+  #     balancing mechanism. It may correspond to a tenant id, or to a fixed
+  #     string like "high" or "low". The default is the empty string.
+  #
+  #     The fairness mechanism attempts to dispatch tasks for a given key in
+  #     proportion to its weight. For example, using a thousand distinct tenant
+  #     ids, each with a weight of 1.0 (the default) will result in each tenant
+  #     getting a roughly equal share of task dispatch throughput.
+  #
+  #     Fairness keys are limited to 64 bytes.
+  #
+  # @!attribute fairness_weight
+  #   @return [Float, nil] Weight for a task can come from multiple sources for
+  #     flexibility. From highest to lowest precedence:
+  #     1. Weights for a small set of keys can be overridden in task queue
+  #        configuration with an API.
+  #     2. It can be attached to the workflow/activity in this field.
+  #     3. The default fairness_weight of 1.0 will be used.
+  #
+  #     Weight values are clamped to the range [0.001, 1000].
   class Priority
     # @!visibility private
     def self._from_proto(priority)
       return default if priority.nil?
 
-      new(priority_key: priority.priority_key.zero? ? nil : priority.priority_key)
+      new(
+        priority_key: priority.priority_key.zero? ? nil : priority.priority_key,
+        fairness_key: priority.fairness_key.empty? ? nil : priority.fairness_key,
+        fairness_weight: priority.fairness_weight.zero? ? nil : priority.fairness_weight
+      )
     end
 
     # The default priority instance.
     #
     # @return [Priority] The default priority
     def self.default
-      @default ||= new(priority_key: nil)
+      @default ||= new(priority_key: nil, fairness_key: nil, fairness_weight: nil)
+    end
+
+    # Initialize a new Priority instance.
+    #
+    # @param priority_key [Integer, nil] The priority key
+    # @param fairness_key [String, nil] The fairness key
+    # @param fairness_weight [Float, nil] The fairness weight
+    def initialize(priority_key: nil, fairness_key: nil, fairness_weight: nil)
+      super
     end
 
     # @!visibility private
     def _to_proto
-      return nil if priority_key.nil?
+      return nil if empty?
 
-      Temporalio::Api::Common::V1::Priority.new(priority_key: priority_key || 0)
+      Temporalio::Api::Common::V1::Priority.new(
+        priority_key: priority_key || 0,
+        fairness_key: fairness_key || '',
+        fairness_weight: fairness_weight || 0.0
+      )
     end
 
     # @return [Boolean] True if this priority is empty/default
     def empty?
-      priority_key.nil?
+      priority_key.nil? && fairness_key.nil? && fairness_weight.nil?
     end
   end
 end

data/lib/temporalio/scoped_logger.rb

@@ -17,7 +17,7 @@ module Temporalio
 
     # @see Logger.add
     def add(severity, message = nil, progname = nil)
-      return true if (severity || Logger::Unknown) < level
+      return true if (severity || Logger::UNKNOWN) < level
       return super if scoped_values_getter.nil? || @disable_scoped_values
 
       scoped_values = scoped_values_getter.call

data/lib/temporalio/testing/activity_environment.rb

@@ -25,6 +25,7 @@ module Temporalio
           local?: false,
           priority: Temporalio::Priority.default,
           raw_heartbeat_details: [],
+          retry_policy: RetryPolicy.new,
           schedule_to_close_timeout: 1.0,
           scheduled_time: Time.at(0),
           start_to_close_timeout: 1.0,

data/lib/temporalio/version.rb

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

data/lib/temporalio/worker/illegal_workflow_call_validator.rb

@@ -39,6 +39,15 @@ module Temporalio
         ]
       end
 
+      # @return [IllegalWorkflowCallValidator] Workflow call validator that is tailored to disallow most Mutex calls,
+      #   but let others through for certain situations.
+      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/') }
+        end
+      end
+
       # @return [String, nil] Method name if this validator is specific to a method.
       attr_reader :method_name
 

data/lib/temporalio/worker/interceptor.rb

@@ -228,6 +228,7 @@ module Temporalio
         ExecuteLocalActivityInput = Data.define(
           :activity,
           :args,
+          :summary,
           :schedule_to_close_timeout,
           :schedule_to_start_timeout,
           :start_to_close_timeout,