temporalio 0.4.0-x86_64-linux-musl → 0.6.0-x86_64-linux-musl

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

@@ -42,6 +42,10 @@ module Temporalio
             @instance.current_details = (details || '')
           end
 
+          def current_deployment_version
+            @instance.current_deployment_version
+          end
+
           def current_history_length
             @instance.current_history_length
           end
@@ -58,6 +62,17 @@ module Temporalio
             @instance.patch(patch_id:, deprecated: true)
           end
 
+          def durable_scheduler_disabled(&)
+            prev = Fiber.scheduler
+            # Imply illegal call tracing disabled
+            illegal_call_tracing_disabled do
+              Fiber.set_scheduler(nil)
+              yield
+            ensure
+              Fiber.set_scheduler(prev)
+            end
+          end
+
           def execute_activity(
             activity,
             *args,
@@ -71,16 +86,22 @@ module Temporalio
             cancellation:,
             cancellation_type:,
             activity_id:,
-            disable_eager_execution:
+            disable_eager_execution:,
+            priority:,
+            arg_hints:,
+            result_hint:
           )
-            activity = case activity
-                       when Class
-                         Activity::Definition::Info.from_activity(activity).name&.to_s
-                       when Symbol, String
-                         activity.to_s
-                       else
-                         raise ArgumentError, 'Activity must be a definition class, or a symbol/string'
-                       end
+            activity, defn_arg_hints, defn_result_hint =
+              case activity
+              when Class
+                defn = Activity::Definition::Info.from_activity(activity)
+                [defn.name&.to_s, defn.arg_hints, defn.result_hint]
+              when Symbol, String
+                [activity.to_s, nil, nil]
+              else
+                raise ArgumentError,
+                      'Activity must be a definition class, or a symbol/string'
+              end
             raise 'Cannot invoke dynamic activities' unless activity
 
             @outbound.execute_activity(
@@ -98,6 +119,9 @@ module Temporalio
                 cancellation_type:,
                 activity_id:,
                 disable_eager_execution: disable_eager_execution || @instance.disable_eager_activity_execution,
+                priority:,
+                arg_hints: arg_hints || defn_arg_hints,
+                result_hint: result_hint || defn_result_hint,
                 headers: {}
               )
             )
@@ -113,16 +137,20 @@ module Temporalio
             local_retry_threshold:,
             cancellation:,
             cancellation_type:,
-            activity_id:
+            activity_id:,
+            arg_hints:,
+            result_hint:
           )
-            activity = case activity
-                       when Class
-                         Activity::Definition::Info.from_activity(activity).name&.to_s
-                       when Symbol, String
-                         activity.to_s
-                       else
-                         raise ArgumentError, 'Activity must be a definition class, or a symbol/string'
-                       end
+            activity, defn_arg_hints, defn_result_hint =
+              case activity
+              when Class
+                defn = Activity::Definition::Info.from_activity(activity)
+                [defn.name&.to_s, defn.arg_hints, defn.result_hint]
+              when Symbol, String
+                [activity.to_s, nil, nil]
+              else
+                raise ArgumentError, 'Activity must be a definition class, or a symbol/string'
+              end
             raise 'Cannot invoke dynamic activities' unless activity
 
             @outbound.execute_local_activity(
@@ -137,6 +165,8 @@ module Temporalio
                 cancellation:,
                 cancellation_type:,
                 activity_id:,
+                arg_hints: arg_hints || defn_arg_hints,
+                result_hint: result_hint || defn_result_hint,
                 headers: {}
               )
             )
@@ -245,11 +275,16 @@ module Temporalio
             retry_policy:,
             cron_schedule:,
             memo:,
-            search_attributes:
+            search_attributes:,
+            priority:,
+            arg_hints:,
+            result_hint:
           )
+            workflow, defn_arg_hints, defn_result_hint =
+              Workflow::Definition._workflow_type_and_hints_from_workflow_parameter(workflow)
             @outbound.start_child_workflow(
               Temporalio::Worker::Interceptor::Workflow::StartChildWorkflowInput.new(
-                workflow: Workflow::Definition._workflow_type_from_workflow_parameter(workflow),
+                workflow:,
                 args:,
                 id:,
                 task_queue:,
@@ -266,6 +301,9 @@ module Temporalio
                 cron_schedule:,
                 memo:,
                 search_attributes:,
+                priority:,
+                arg_hints: arg_hints || defn_arg_hints,
+                result_hint: result_hint || defn_result_hint,
                 headers: {}
               )
             )
@@ -352,26 +390,30 @@ module Temporalio
             @outbound = outbound
           end
 
-          def _signal_child_workflow(id:, signal:, args:, cancellation:)
+          def _signal_child_workflow(id:, signal:, args:, cancellation:, arg_hints:)
+            signal, defn_arg_hints = Workflow::Definition::Signal._name_and_hints_from_parameter(signal)
             @outbound.signal_child_workflow(
               Temporalio::Worker::Interceptor::Workflow::SignalChildWorkflowInput.new(
                 id:,
-                signal: Workflow::Definition::Signal._name_from_parameter(signal),
+                signal:,
                 args:,
                 cancellation:,
+                arg_hints: arg_hints || defn_arg_hints,
                 headers: {}
               )
             )
           end
 
-          def _signal_external_workflow(id:, run_id:, signal:, args:, cancellation:)
+          def _signal_external_workflow(id:, run_id:, signal:, args:, cancellation:, arg_hints:)
+            signal, defn_arg_hints = Workflow::Definition::Signal._name_and_hints_from_parameter(signal)
             @outbound.signal_external_workflow(
               Temporalio::Worker::Interceptor::Workflow::SignalExternalWorkflowInput.new(
                 id:,
                 run_id:,
-                signal: Workflow::Definition::Signal._name_from_parameter(signal),
+                signal:,
                 args:,
                 cancellation:,
+                arg_hints: arg_hints || defn_arg_hints,
                 headers: {}
               )
             )

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

@@ -8,7 +8,8 @@ module Temporalio
         class Details
           attr_reader :namespace, :task_queue, :definition, :initial_activation, :logger, :metric_meter,
                       :payload_converter, :failure_converter, :interceptors, :disable_eager_activity_execution,
-                      :illegal_calls, :workflow_failure_exception_types, :unsafe_workflow_io_enabled
+                      :illegal_calls, :workflow_failure_exception_types, :unsafe_workflow_io_enabled,
+                      :assert_valid_local_activity
 
           def initialize(
             namespace:,
@@ -23,7 +24,8 @@ module Temporalio
             disable_eager_activity_execution:,
             illegal_calls:,
             workflow_failure_exception_types:,
-            unsafe_workflow_io_enabled:
+            unsafe_workflow_io_enabled:,
+            assert_valid_local_activity:
           )
             @namespace = namespace
             @task_queue = task_queue
@@ -38,6 +40,7 @@ module Temporalio
             @illegal_calls = illegal_calls
             @workflow_failure_exception_types = workflow_failure_exception_types
             @unsafe_workflow_io_enabled = unsafe_workflow_io_enabled
+            @assert_valid_local_activity = assert_valid_local_activity
           end
         end
       end

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

@@ -18,8 +18,8 @@ module Temporalio
             @instance = instance
           end
 
-          def signal(signal, *args, cancellation: Workflow.cancellation)
-            @instance.context._signal_external_workflow(id:, run_id:, signal:, args:, cancellation:)
+          def signal(signal, *args, cancellation: Workflow.cancellation, arg_hints: nil)
+            @instance.context._signal_external_workflow(id:, run_id:, signal:, args:, cancellation:, arg_hints:)
           end
 
           def cancel

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'temporalio/worker/illegal_workflow_call_validator'
 require 'temporalio/workflow'
 
 module Temporalio
@@ -12,16 +13,32 @@ module Temporalio
             illegal_calls.to_h do |key, val|
               raise TypeError, 'Invalid illegal call map, top-level key must be a String' unless key.is_a?(String)
 
-              # @type var fixed_val: :all | Hash[Symbol, bool]
+              # @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 val.method_name
+                              raise ArgumentError,
+                                    'Top level IllegalWorkflowCallValidator instances cannot have method name'
+                            end
+                            val
                           when Array
                             val.to_h do |sub_val|
-                              unless sub_val.is_a?(Symbol)
+                              case sub_val
+                              when Symbol
+                                [sub_val, true]
+                              when Temporalio::Worker::IllegalWorkflowCallValidator
+                                unless sub_val.method_name
+                                  raise ArgumentError,
+                                        'IllegalWorkflowCallValidator instances in array for ' \
+                                        "#{key} must have a method name"
+                                end
+
+                                [sub_val.method_name, sub_val]
+                              else
                                 raise TypeError,
-                                      'Invalid illegal call map, each value must be a Symbol'
+                                      'Invalid illegal call array entry for ' \
+                                      "#{key}, each value must be a Symbol or an IllegalWorkflowCallValidator"
                               end
-
-                              [sub_val, true]
                             end.freeze
                           when :all
                             :all
@@ -47,25 +64,54 @@ module Temporalio
               # class of things like `Date` does not have `attached_object` so you have to fall back in these rare cases
               # to parsing the string output. Reaching the string parsing component is rare, so this should not have
               # significant performance impact.
-              cls_name = if cls.singleton_class?
-                           if cls.respond_to?(:attached_object)
-                             cls = cls.attached_object # steep:ignore
-                             next unless cls.is_a?(Module)
+              class_name = if cls.singleton_class?
+                             if cls.respond_to?(:attached_object)
+                               cls = cls.attached_object # steep:ignore
+                               next unless cls.is_a?(Module)
 
-                             cls.name.to_s
+                               cls.name.to_s
+                             else
+                               cls.to_s.delete_prefix('#<Class:').delete_suffix('>')
+                             end
                            else
-                             cls.to_s.delete_prefix('#<Class:').delete_suffix('>')
+                             cls.name.to_s
                            end
-                         else
-                           cls.name.to_s
-                         end
 
               # Check if the call is considered illegal
-              vals = illegal_calls[cls_name]
-              if vals == :all || vals&.[](tp.callee_id) # steep:ignore
+              vals = illegal_calls[class_name]
+              invalid_suffix =
+                case vals
+                when :all
+                  ''
+                when Temporalio::Worker::IllegalWorkflowCallValidator
+                  disable do
+                    vals.block.call(Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo.new(
+                                      class_name:, method_name: tp.callee_id, trace_point: tp
+                                    ))
+                    nil
+                  rescue Exception => e # rubocop:disable Lint/RescueException
+                    ", reason: #{e}"
+                  end
+                else
+                  per_method = vals&.[](tp.callee_id)
+                  case per_method
+                  when true
+                    ''
+                  when Temporalio::Worker::IllegalWorkflowCallValidator
+                    disable do
+                      per_method.block.call(Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo.new(
+                                              class_name:, method_name: tp.callee_id, trace_point: tp
+                                            ))
+                      nil
+                    rescue Exception => e # rubocop:disable Lint/RescueException
+                      ", reason: #{e}"
+                    end
+                  end
+                end
+              if invalid_suffix
                 raise Workflow::NondeterminismError,
-                      "Cannot access #{cls_name} #{tp.callee_id} from inside a " \
-                      'workflow. If this is known to be safe, the code can be run in ' \
+                      "Cannot access #{class_name} #{tp.callee_id} from inside a " \
+                      "workflow#{invalid_suffix}. If this is known to be safe, the code can be run in " \
                       'a Temporalio::Workflow::Unsafe.illegal_call_tracing_disabled block.'
               end
             end

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

@@ -56,7 +56,8 @@ module Temporalio
               raise ArgumentError, 'Activity must have schedule_to_close_timeout or start_to_close_timeout'
             end
 
-            execute_activity_with_local_backoffs(local: false, cancellation: input.cancellation) do
+            execute_activity_with_local_backoffs(local: false, cancellation: input.cancellation,
+                                                 result_hint: input.result_hint) do
               seq = (@activity_counter += 1)
               @instance.add_command(
                 Bridge::Api::WorkflowCommands::WorkflowCommand.new(
@@ -66,14 +67,17 @@ module Temporalio
                     activity_type: input.activity,
                     task_queue: input.task_queue,
                     headers: ProtoUtils.headers_to_proto_hash(input.headers, @instance.payload_converter),
-                    arguments: ProtoUtils.convert_to_payload_array(@instance.payload_converter, input.args),
+                    arguments: ProtoUtils.convert_to_payload_array(
+                      @instance.payload_converter, input.args, hints: input.arg_hints
+                    ),
                     schedule_to_close_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_close_timeout),
                     schedule_to_start_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_start_timeout),
                     start_to_close_timeout: ProtoUtils.seconds_to_duration(input.start_to_close_timeout),
                     heartbeat_timeout: ProtoUtils.seconds_to_duration(input.heartbeat_timeout),
                     retry_policy: input.retry_policy&._to_proto,
                     cancellation_type: input.cancellation_type,
-                    do_not_eagerly_execute: input.disable_eager_execution
+                    do_not_eagerly_execute: input.disable_eager_execution,
+                    priority: input.priority._to_proto
                   ),
                   user_metadata: ProtoUtils.to_user_metadata(input.summary, nil, @instance.payload_converter)
                 )
@@ -87,7 +91,10 @@ module Temporalio
               raise ArgumentError, 'Activity must have schedule_to_close_timeout or start_to_close_timeout'
             end
 
-            execute_activity_with_local_backoffs(local: true, cancellation: input.cancellation) do |do_backoff|
+            @instance.assert_valid_local_activity.call(input.activity)
+
+            execute_activity_with_local_backoffs(local: true, cancellation: input.cancellation,
+                                                 result_hint: input.result_hint) do |do_backoff|
               seq = (@activity_counter += 1)
               @instance.add_command(
                 Bridge::Api::WorkflowCommands::WorkflowCommand.new(
@@ -96,7 +103,9 @@ module Temporalio
                     activity_id: input.activity_id || seq.to_s,
                     activity_type: input.activity,
                     headers: ProtoUtils.headers_to_proto_hash(input.headers, @instance.payload_converter),
-                    arguments: ProtoUtils.convert_to_payload_array(@instance.payload_converter, input.args),
+                    arguments: ProtoUtils.convert_to_payload_array(
+                      @instance.payload_converter, input.args, hints: input.arg_hints
+                    ),
                     schedule_to_close_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_close_timeout),
                     schedule_to_start_timeout: ProtoUtils.seconds_to_duration(input.schedule_to_start_timeout),
                     start_to_close_timeout: ProtoUtils.seconds_to_duration(input.start_to_close_timeout),
@@ -112,7 +121,7 @@ module Temporalio
             end
           end
 
-          def execute_activity_with_local_backoffs(local:, cancellation:, &)
+          def execute_activity_with_local_backoffs(local:, cancellation:, result_hint:, &)
             # 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).
@@ -121,7 +130,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 = execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &)
               return result unless result.is_a?(Bridge::Api::ActivityResult::DoBackoff)
 
               # @type var result: untyped
@@ -133,7 +142,7 @@ module Temporalio
           end
 
           # If this doesn't raise, it returns success | DoBackoff
-          def execute_activity_once(local:, cancellation:, last_local_backoff:, &)
+          def execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &)
             # Add to pending activities (removed by the resolver)
             seq = yield last_local_backoff
             @instance.pending_activities[seq] = Fiber.current
@@ -166,7 +175,7 @@ module Temporalio
 
             case resolution.status
             when :completed
-              @instance.payload_converter.from_payload(resolution.completed.result)
+              @instance.payload_converter.from_payload(resolution.completed.result, hint: result_hint)
             when :failed
               raise @instance.failure_converter.from_failure(resolution.failed.failure, @instance.payload_converter)
             when :cancelled
@@ -190,6 +199,7 @@ module Temporalio
               signal: input.signal,
               args: input.args,
               cancellation: input.cancellation,
+              arg_hints: input.arg_hints,
               headers: input.headers
             )
           end
@@ -202,11 +212,12 @@ module Temporalio
               signal: input.signal,
               args: input.args,
               cancellation: input.cancellation,
+              arg_hints: input.arg_hints,
               headers: input.headers
             )
           end
 
-          def _signal_external_workflow(id:, run_id:, child:, signal:, args:, cancellation:, headers:)
+          def _signal_external_workflow(id:, run_id:, child:, signal:, args:, cancellation:, arg_hints:, headers:)
             raise Error::CanceledError, 'Signal canceled before scheduled' if cancellation.canceled?
 
             # Add command
@@ -214,7 +225,7 @@ module Temporalio
             cmd = Bridge::Api::WorkflowCommands::SignalExternalWorkflowExecution.new(
               seq:,
               signal_name: signal,
-              args: ProtoUtils.convert_to_payload_array(@instance.payload_converter, args),
+              args: ProtoUtils.convert_to_payload_array(@instance.payload_converter, args, hints: arg_hints),
               headers: ProtoUtils.headers_to_proto_hash(headers, @instance.payload_converter)
             )
             if child
@@ -324,7 +335,8 @@ module Temporalio
                   workflow_id: input.id,
                   workflow_type: input.workflow,
                   task_queue: input.task_queue,
-                  input: ProtoUtils.convert_to_payload_array(@instance.payload_converter, input.args),
+                  input: ProtoUtils.convert_to_payload_array(@instance.payload_converter, input.args,
+                                                             hints: input.arg_hints),
                   workflow_execution_timeout: ProtoUtils.seconds_to_duration(input.execution_timeout),
                   workflow_run_timeout: ProtoUtils.seconds_to_duration(input.run_timeout),
                   workflow_task_timeout: ProtoUtils.seconds_to_duration(input.task_timeout),
@@ -335,7 +347,8 @@ module Temporalio
                   headers: ProtoUtils.headers_to_proto_hash(input.headers, @instance.payload_converter),
                   memo: ProtoUtils.memo_to_proto_hash(input.memo, @instance.payload_converter),
                   search_attributes: input.search_attributes&._to_proto_hash,
-                  cancellation_type: input.cancellation_type
+                  cancellation_type: input.cancellation_type,
+                  priority: input.priority._to_proto
                 ),
                 user_metadata: ProtoUtils.to_user_metadata(
                   input.static_summary, input.static_details, @instance.payload_converter
@@ -370,7 +383,8 @@ module Temporalio
                 first_execution_run_id: resolution.succeeded.run_id,
                 instance: @instance,
                 cancellation: input.cancellation,
-                cancel_callback_key:
+                cancel_callback_key:,
+                result_hint: input.result_hint
               )
               @instance.pending_child_workflows[seq] = handle
               handle

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