temporalio 0.3.0-x86_64-linux-musl → 0.5.0-x86_64-linux-musl

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

@@ -93,8 +93,10 @@ module Temporalio
         def handle_start_task(task_token, start)
           set_running_activity(task_token, nil)
 
-          # Find activity definition, falling back to dynamic if present
-          defn = @activities[start.activity_type] || @activities[nil]
+          # Find activity definition, falling back to dynamic if not found and not reserved name
+          defn = @activities[start.activity_type]
+          defn = @activities[nil] if !defn && !Internal::ProtoUtils.reserved_name?(start.activity_type)
+
           if defn.nil?
             raise Error::ApplicationError.new(
               "Activity #{start.activity_type} for workflow #{start.workflow_execution.workflow_id} " \
@@ -114,7 +116,7 @@ module Temporalio
             # Unset at the end
             Activity::Context._current_executor = nil
           end
-        rescue Exception => e # rubocop:disable Lint/RescueException We are intending to catch everything here
+        rescue Exception => e # rubocop:disable Lint/RescueException -- We are intending to catch everything here
           remove_running_activity(task_token)
           @scoped_logger.warn("Failed starting activity #{start.activity_type}")
           @scoped_logger.warn(e)
@@ -146,10 +148,18 @@ module Temporalio
             @scoped_logger.warn("Cannot find activity to cancel for token #{task_token}")
             return
           end
-          activity._server_requested_cancel = true
-          _, cancel_proc = activity.cancellation
           begin
-            cancel_proc.call(reason: cancel.reason.to_s)
+            activity._cancel(
+              reason: cancel.reason.to_s,
+              details: Activity::CancellationDetails.new(
+                gone_from_server: cancel.details.is_not_found,
+                cancel_requested: cancel.details.is_cancelled,
+                timed_out: cancel.details.is_timed_out,
+                worker_shutdown: cancel.details.is_worker_shutdown,
+                paused: cancel.details.is_paused,
+                reset: cancel.details.is_reset
+              )
+            )
           rescue StandardError => e
             @scoped_logger.warn("Failed cancelling activity #{activity.info.activity_type} \
               with ID #{activity.info.activity_id}")
@@ -166,12 +176,15 @@ module Temporalio
             current_attempt_scheduled_time: Internal::ProtoUtils.timestamp_to_time(
               start.current_attempt_scheduled_time
             ) || raise, # Never nil
-            heartbeat_details: ProtoUtils.convert_from_payload_array(
-              @worker.options.client.data_converter,
-              start.heartbeat_details.to_ary
-            ),
             heartbeat_timeout: Internal::ProtoUtils.duration_to_seconds(start.heartbeat_timeout),
             local?: start.is_local,
+            priority: Priority._from_proto(start.priority),
+            raw_heartbeat_details: begin
+              payloads = start.heartbeat_details.to_ary
+              codec = @worker.options.client.data_converter.payload_codec
+              payloads = codec.decode(payloads) if codec
+              payloads.map { |p| Temporalio::Converters::RawValue.new(p) }
+            end,
             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),
@@ -182,7 +195,7 @@ module Temporalio
             workflow_namespace: start.workflow_namespace,
             workflow_run_id: start.workflow_execution.run_id,
             workflow_type: start.workflow_type
-          ).freeze
+          )
 
           # Build input
           input = Temporalio::Worker::Interceptor::Activity::ExecuteInput.new(
@@ -194,13 +207,19 @@ module Temporalio
                     payloads = codec.decode(payloads) if codec
                     payloads.map { |p| Temporalio::Converters::RawValue.new(p) }
                   else
-                    ProtoUtils.convert_from_payload_array(@worker.options.client.data_converter, start.input.to_ary)
+                    ProtoUtils.convert_from_payload_array(
+                      @worker.options.client.data_converter,
+                      start.input.to_ary,
+                      hints: defn.arg_hints
+                    )
                   end,
+            result_hint: defn.result_hint,
             headers: ProtoUtils.headers_from_proto_map(start.header_fields, @worker.options.client.data_converter) || {}
           )
 
           # Run
           activity = RunningActivity.new(
+            worker: @worker,
             info:,
             cancellation: Cancellation.new,
             worker_shutdown_cancellation: @worker._worker_shutdown_cancellation,
@@ -211,7 +230,7 @@ module Temporalio
           Activity::Context._current_executor&.set_activity_context(defn, activity)
           set_running_activity(task_token, activity)
           run_activity(defn, activity, input)
-        rescue Exception => e # rubocop:disable Lint/RescueException We are intending to catch everything here
+        rescue Exception => e # rubocop:disable Lint/RescueException -- We are intending to catch everything here
           @scoped_logger.warn("Failed starting or sending completion for activity #{start.activity_type}")
           @scoped_logger.warn(e)
           # This means that the activity couldn't start or send completion (run
@@ -247,7 +266,7 @@ module Temporalio
             impl = @worker._activity_interceptors.reverse_each.reduce(impl) do |acc, int|
               int.intercept_activity(acc)
             end
-            impl.init(OutboundImplementation.new(self))
+            impl.init(OutboundImplementation.new(self, activity.info.task_token))
 
             # Execute
             result = impl.execute(input)
@@ -255,16 +274,40 @@ module Temporalio
             # Success
             Bridge::Api::ActivityResult::ActivityExecutionResult.new(
               completed: Bridge::Api::ActivityResult::Success.new(
-                result: @worker.options.client.data_converter.to_payload(result)
+                result: @worker.options.client.data_converter.to_payload(result, hint: input.result_hint)
               )
             )
-          rescue Exception => e # rubocop:disable Lint/RescueException We are intending to catch everything here
+          rescue Exception => e # rubocop:disable Lint/RescueException -- We are intending to catch everything here
             if e.is_a?(Activity::CompleteAsyncError)
               # Wanting to complete async
               @scoped_logger.debug('Completing activity asynchronously')
               Bridge::Api::ActivityResult::ActivityExecutionResult.new(
                 will_complete_async: Bridge::Api::ActivityResult::WillCompleteAsync.new
               )
+            elsif e.is_a?(Error::CanceledError) && activity.cancellation_details&.paused?
+              # Server requested pause
+              @scoped_logger.debug('Completing activity as failed due to exception caused by pause')
+              Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+                failed: Bridge::Api::ActivityResult::Failure.new(
+                  failure: @worker.options.client.data_converter.to_failure(
+                    Error._with_backtrace_and_cause(
+                      Error::ApplicationError.new('Activity paused', type: 'ActivityPause'), backtrace: nil, cause: e
+                    )
+                  )
+                )
+              )
+            elsif e.is_a?(Error::CanceledError) && activity.cancellation_details&.reset?
+              # Server requested reset
+              @scoped_logger.debug('Completing activity as failed due to exception caused by reset')
+              Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+                failed: Bridge::Api::ActivityResult::Failure.new(
+                  failure: @worker.options.client.data_converter.to_failure(
+                    Error._with_backtrace_and_cause(
+                      Error::ApplicationError.new('Activity reset', type: 'ActivityReset'), backtrace: nil, cause: e
+                    )
+                  )
+                )
+              )
             elsif e.is_a?(Error::CanceledError) && activity._server_requested_cancel
               # Server requested cancel
               @scoped_logger.debug('Completing activity as canceled')
@@ -275,8 +318,13 @@ module Temporalio
               )
             else
               # General failure
-              @scoped_logger.warn('Completing activity as failed')
-              @scoped_logger.warn(e)
+              log_level = if e.is_a?(Error::ApplicationError) && e.category == Error::ApplicationError::Category::BENIGN
+                            Logger::DEBUG
+                          else
+                            Logger::WARN
+                          end
+              @scoped_logger.add(log_level, 'Completing activity as failed')
+              @scoped_logger.add(log_level, e)
               Bridge::Api::ActivityResult::ActivityExecutionResult.new(
                 failed: Bridge::Api::ActivityResult::Failure.new(
                   failure: @worker.options.client.data_converter.to_failure(e)
@@ -294,11 +342,24 @@ module Temporalio
           )
         end
 
+        def assert_valid_activity(activity)
+          defn = @activities[activity]
+          defn = @activities[nil] if !defn && !Internal::ProtoUtils.reserved_name?(activity)
+
+          return unless defn.nil?
+
+          raise ArgumentError,
+                "Activity #{activity} " \
+                "is not registered on this worker, available activities: #{@activities.keys.sort.join(', ')}"
+        end
+
         class RunningActivity < Activity::Context
-          attr_reader :info, :cancellation, :worker_shutdown_cancellation, :payload_converter, :logger
-          attr_accessor :instance, :_outbound_impl, :_server_requested_cancel
+          attr_reader :info, :cancellation, :cancellation_details, :worker_shutdown_cancellation,
+                      :payload_converter, :logger, :_server_requested_cancel
+          attr_accessor :instance, :_outbound_impl
 
           def initialize( # rubocop:disable Lint/MissingSuper
+            worker:,
             info:,
             cancellation:,
             worker_shutdown_cancellation:,
@@ -306,8 +367,10 @@ module Temporalio
             logger:,
             runtime_metric_meter:
           )
+            @worker = worker
             @info = info
             @cancellation = cancellation
+            @cancellation_details = nil
             @worker_shutdown_cancellation = worker_shutdown_cancellation
             @payload_converter = payload_converter
             @logger = logger
@@ -316,13 +379,15 @@ module Temporalio
             @_server_requested_cancel = false
           end
 
-          def heartbeat(*details)
+          def heartbeat(*details, detail_hints: nil)
             raise 'Implementation not set yet' if _outbound_impl.nil?
 
             # No-op if local
             return if info.local?
 
-            _outbound_impl.heartbeat(Temporalio::Worker::Interceptor::Activity::HeartbeatInput.new(details:))
+            _outbound_impl.heartbeat(
+              Temporalio::Worker::Interceptor::Activity::HeartbeatInput.new(details:, detail_hints:)
+            )
           end
 
           def metric_meter
@@ -334,6 +399,21 @@ module Temporalio
               }
             )
           end
+
+          def client
+            @worker.client
+          end
+
+          def _cancel(reason:, details:)
+            # Do not issue cancel if already canceled
+            return if @cancellation_details
+
+            @_server_requested_cancel = true
+            # Set the cancellation details _before_ issuing the cancel itself
+            @cancellation_details = details
+            _, cancel_proc = cancellation
+            cancel_proc.call(reason:)
+          end
         end
 
         class InboundImplementation < Temporalio::Worker::Interceptor::Activity::Inbound
@@ -355,17 +435,19 @@ module Temporalio
         end
 
         class OutboundImplementation < Temporalio::Worker::Interceptor::Activity::Outbound
-          def initialize(worker)
+          def initialize(worker, task_token)
             super(nil) # steep:ignore
             @worker = worker
+            @task_token = task_token
           end
 
           def heartbeat(input)
             @worker.bridge_worker.record_activity_heartbeat(
               Bridge::Api::CoreInterface::ActivityHeartbeat.new(
-                task_token: Activity::Context.current.info.task_token,
+                task_token: @task_token,
                 details: ProtoUtils.convert_to_payload_array(@worker.worker.options.client.data_converter,
-                                                             input.details)
+                                                             input.details,
+                                                             hints: input.detail_hints)
               ).to_proto
             )
           end

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

@@ -34,7 +34,7 @@ module Temporalio
                                rescue InjectEventForTesting => e
                                  @queue.push(e.event)
                                  @queue.push(Event::BlockSuccess.new(result: e))
-                               rescue Exception => e # rubocop:disable Lint/RescueException Intentionally catch all
+                               rescue Exception => e # rubocop:disable Lint/RescueException -- Intentionally catch all
                                  @queue.push(Event::BlockFailure.new(error: e))
                                end
                              else
@@ -43,7 +43,7 @@ module Temporalio
                                rescue InjectEventForTesting => e
                                  @queue.push(e.event)
                                  @queue.push(Event::BlockSuccess.new(result: e))
-                               rescue Exception => e # rubocop:disable Lint/RescueException Intentionally catch all
+                               rescue Exception => e # rubocop:disable Lint/RescueException -- Intentionally catch all
                                  @queue.push(Event::BlockFailure.new(error: e))
                                end
                              end

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

@@ -10,18 +10,20 @@ module Temporalio
       class WorkflowInstance
         # Implementation of the child workflow handle.
         class ChildWorkflowHandle < Workflow::ChildWorkflowHandle
-          attr_reader :id, :first_execution_run_id
+          attr_reader :id, :first_execution_run_id, :result_hint
 
-          def initialize(id:, first_execution_run_id:, instance:, cancellation:, cancel_callback_key:) # rubocop:disable Lint/MissingSuper
+          def initialize(id:, first_execution_run_id:, instance:, # rubocop:disable Lint/MissingSuper
+                         cancellation:, cancel_callback_key:, result_hint:)
             @id = id
             @first_execution_run_id = first_execution_run_id
             @instance = instance
             @cancellation = cancellation
             @cancel_callback_key = cancel_callback_key
+            @result_hint = result_hint
             @resolution = nil
           end
 
-          def result
+          def result(result_hint: nil)
             # Notice that we actually provide a detached cancellation here instead of defaulting to workflow
             # cancellation because we don't want workflow cancellation (or a user-provided cancellation to this result
             # call) to be able to interrupt waiting on a child that may be processing the cancellation.
@@ -29,7 +31,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 || @result_hint)
             when :failed
               raise @instance.failure_converter.from_failure(@resolution.failed.failure, @instance.payload_converter)
             when :cancelled
@@ -44,8 +46,8 @@ module Temporalio
             @resolution = resolution
           end
 
-          def signal(signal, *args, cancellation: Workflow.cancellation)
-            @instance.context._signal_child_workflow(id:, signal:, args:, cancellation:)
+          def signal(signal, *args, cancellation: Workflow.cancellation, arg_hints: nil)
+            @instance.context._signal_child_workflow(id:, signal:, args:, cancellation:, arg_hints:)
           end
         end
       end

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

@@ -32,6 +32,20 @@ module Temporalio
             @instance.continue_as_new_suggested
           end
 
+          def current_details
+            @instance.current_details || ''
+          end
+
+          def current_details=(details)
+            raise 'Details must be a String' unless details.nil? || details.is_a?(String)
+
+            @instance.current_details = (details || '')
+          end
+
+          def current_deployment_version
+            @instance.current_deployment_version
+          end
+
           def current_history_length
             @instance.current_history_length
           end
@@ -48,10 +62,21 @@ module Temporalio
             @instance.patch(patch_id:, deprecated: true)
           end
 
+          def durable_scheduler_disabled(&)
+            prev = Fiber.current_scheduler
+            illegal_call_tracing_disabled { Fiber.set_scheduler(nil) }
+            begin
+              yield
+            ensure
+              illegal_call_tracing_disabled { Fiber.set_scheduler(prev) }
+            end
+          end
+
           def execute_activity(
             activity,
             *args,
             task_queue:,
+            summary:,
             schedule_to_close_timeout:,
             schedule_to_start_timeout:,
             start_to_close_timeout:,
@@ -60,13 +85,30 @@ module Temporalio
             cancellation:,
             cancellation_type:,
             activity_id:,
-            disable_eager_execution:
+            disable_eager_execution:,
+            priority:,
+            arg_hints:,
+            result_hint:
           )
+            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(
               Temporalio::Worker::Interceptor::Workflow::ExecuteActivityInput.new(
                 activity:,
                 args:,
                 task_queue: task_queue || info.task_queue,
+                summary:,
                 schedule_to_close_timeout:,
                 schedule_to_start_timeout:,
                 start_to_close_timeout:,
@@ -76,6 +118,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: {}
               )
             )
@@ -91,8 +136,22 @@ module Temporalio
             local_retry_threshold:,
             cancellation:,
             cancellation_type:,
-            activity_id:
+            activity_id:,
+            arg_hints:,
+            result_hint:
           )
+            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(
               Temporalio::Worker::Interceptor::Workflow::ExecuteLocalActivityInput.new(
                 activity:,
@@ -105,6 +164,8 @@ module Temporalio
                 cancellation:,
                 cancellation_type:,
                 activity_id:,
+                arg_hints: arg_hints || defn_arg_hints,
+                result_hint: result_hint || defn_result_hint,
                 headers: {}
               )
             )
@@ -132,6 +193,16 @@ module Temporalio
             )
           end
 
+          def io_enabled(&)
+            prev = @instance.io_enabled
+            @instance.io_enabled = true
+            begin
+              yield
+            ensure
+              @instance.io_enabled = prev
+            end
+          end
+
           def logger
             @instance.logger
           end
@@ -191,6 +262,8 @@ module Temporalio
             *args,
             id:,
             task_queue:,
+            static_summary:,
+            static_details:,
             cancellation:,
             cancellation_type:,
             parent_close_policy:,
@@ -201,14 +274,21 @@ 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:,
                 args:,
                 id:,
                 task_queue:,
+                static_summary:,
+                static_details:,
                 cancellation:,
                 cancellation_type:,
                 parent_close_policy:,
@@ -220,11 +300,18 @@ module Temporalio
                 cron_schedule:,
                 memo:,
                 search_attributes:,
+                priority:,
+                arg_hints: arg_hints || defn_arg_hints,
+                result_hint: result_hint || defn_result_hint,
                 headers: {}
               )
             )
           end
 
+          def storage
+            @storage ||= {}
+          end
+
           def timeout(duration, exception_class, *exception_args, summary:, &)
             raise 'Block required for timeout' unless block_given?
 
@@ -302,19 +389,22 @@ 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:,
                 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:,
@@ -322,6 +412,7 @@ module Temporalio
                 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
+                      :illegal_calls, :workflow_failure_exception_types, :unsafe_workflow_io_enabled,
+                      :assert_valid_local_activity
 
           def initialize(
             namespace:,
@@ -22,7 +23,9 @@ module Temporalio
             interceptors:,
             disable_eager_activity_execution:,
             illegal_calls:,
-            workflow_failure_exception_types:
+            workflow_failure_exception_types:,
+            unsafe_workflow_io_enabled:,
+            assert_valid_local_activity:
           )
             @namespace = namespace
             @task_queue = task_queue
@@ -36,6 +39,8 @@ module Temporalio
             @disable_eager_activity_execution = disable_eager_activity_execution
             @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