temporalio 0.1.1 → 0.3.0

data/lib/temporalio/internal/metric.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'temporalio/internal/bridge'
+require 'temporalio/metric'
+
+module Temporalio
+  module Internal
+    class Metric < Temporalio::Metric
+      attr_reader :metric_type, :name, :description, :unit, :value_type
+
+      def initialize(metric_type:, name:, description:, unit:, value_type:, bridge:, bridge_attrs:) # rubocop:disable Lint/MissingSuper
+        @metric_type = metric_type
+        @name = name
+        @description = description
+        @unit = unit
+        @value_type = value_type
+        @bridge = bridge
+        @bridge_attrs = bridge_attrs
+      end
+
+      def record(value, additional_attributes: nil)
+        bridge_attrs = @bridge_attrs
+        bridge_attrs = @bridge_attrs.with_additional(additional_attributes) if additional_attributes
+        @bridge.record_value(value, bridge_attrs)
+      end
+
+      def with_additional_attributes(additional_attributes)
+        Metric.new(
+          metric_type:,
+          name:,
+          description:,
+          unit:,
+          value_type:,
+          bridge: @bridge,
+          bridge_attrs: @bridge_attrs.with_additional(additional_attributes)
+        )
+      end
+
+      class Meter < Temporalio::Metric::Meter
+        def self.create_from_runtime(runtime)
+          bridge = Bridge::Metric::Meter.new(runtime._core_runtime)
+          return nil unless bridge
+
+          Meter.new(bridge, bridge.default_attributes)
+        end
+
+        def initialize(bridge, bridge_attrs) # rubocop:disable Lint/MissingSuper
+          @bridge = bridge
+          @bridge_attrs = bridge_attrs
+        end
+
+        def create_metric(
+          metric_type,
+          name,
+          description: nil,
+          unit: nil,
+          value_type: :integer
+        )
+          Metric.new(
+            metric_type:,
+            name:,
+            description:,
+            unit:,
+            value_type:,
+            bridge: Bridge::Metric.new(@bridge, metric_type, name, description, unit, value_type),
+            bridge_attrs: @bridge_attrs
+          )
+        end
+
+        def with_additional_attributes(additional_attributes)
+          Meter.new(@bridge, @bridge_attrs.with_additional(additional_attributes))
+        end
+      end
+
+      class NullMeter < Temporalio::Metric::Meter
+        include Singleton
+
+        def initialize # rubocop:disable Style/RedundantInitialize,Lint/MissingSuper
+        end
+
+        def create_metric(
+          metric_type,
+          name,
+          description: nil,
+          unit: nil,
+          value_type: :integer
+        )
+          NullMetric.new(
+            metric_type:,
+            name:,
+            description:,
+            unit:,
+            value_type:
+          )
+        end
+
+        def with_additional_attributes(_additional_attributes)
+          self
+        end
+      end
+
+      class NullMetric < Temporalio::Metric
+        attr_reader :metric_type, :name, :description, :unit, :value_type
+
+        def initialize(metric_type:, name:, description:, unit:, value_type:) # rubocop:disable Lint/MissingSuper
+          @metric_type = metric_type
+          @name = name
+          @description = description
+          @unit = unit
+          @value_type = value_type
+        end
+
+        def record(value, additional_attributes: nil); end
+
+        def with_additional_attributes(_additional_attributes)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/internal/proto_utils.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'temporalio/api'
+
+module Temporalio
+  module Internal
+    module ProtoUtils
+      def self.seconds_to_duration(seconds_numeric)
+        return nil if seconds_numeric.nil?
+
+        seconds = seconds_numeric.to_i
+        nanos = ((seconds_numeric - seconds) * 1_000_000_000).round
+        Google::Protobuf::Duration.new(seconds:, nanos:)
+      end
+
+      def self.duration_to_seconds(duration)
+        return nil if duration.nil?
+
+        # This logic was corrected for timestamp at
+        # https://github.com/protocolbuffers/protobuf/pull/2482 but not for
+        # duration, so 4.56 is not properly represented in to_f, it becomes
+        # 4.5600000000000005.
+        (duration.seconds + duration.nanos.quo(1_000_000_000)).to_f
+      end
+
+      def self.time_to_timestamp(time)
+        return nil if time.nil?
+
+        Google::Protobuf::Timestamp.from_time(time)
+      end
+
+      def self.timestamp_to_time(timestamp)
+        return nil if timestamp.nil?
+
+        # The regular to_time on the timestamp converts to local timezone,
+        # and we prefer not to make a separate .utc call (converts to local
+        # then back to UTC unnecessarily)
+        Time.at(timestamp.seconds, timestamp.nanos, :nanosecond, in: 'UTC')
+      end
+
+      def self.memo_to_proto(hash, converter)
+        return nil if hash.nil? || hash.empty?
+
+        Api::Common::V1::Memo.new(fields: memo_to_proto_hash(hash, converter))
+      end
+
+      def self.memo_to_proto_hash(hash, converter)
+        return nil if hash.nil? || hash.empty?
+
+        hash.transform_keys(&:to_s).transform_values { |val| converter.to_payload(val) }
+      end
+
+      def self.memo_from_proto(memo, converter)
+        return nil if memo.nil? || memo.fields.size.zero? # rubocop:disable Style/ZeroLengthPredicate Google Maps don't have empty
+
+        memo.fields.each_with_object({}) { |(key, val), h| h[key] = converter.from_payload(val) } # rubocop:disable Style/HashTransformValues
+      end
+
+      def self.headers_to_proto(headers, converter)
+        return nil if headers.nil? || headers.empty?
+
+        Api::Common::V1::Header.new(fields: headers_to_proto_hash(headers, converter))
+      end
+
+      def self.headers_to_proto_hash(headers, converter)
+        return nil if headers.nil? || headers.empty?
+
+        headers.transform_values { |val| converter.to_payload(val) }
+      end
+
+      def self.headers_from_proto(headers, converter)
+        headers_from_proto_map(headers&.fields, converter)
+      end
+
+      def self.headers_from_proto_map(headers, converter)
+        return nil if headers.nil? || headers.size.zero? # rubocop:disable Style/ZeroLengthPredicate Google Maps don't have empty
+
+        headers.each_with_object({}) do |(key, val), h| # rubocop:disable Style/HashTransformValues
+          # @type var h: Hash[String, Object?]
+          h[key] = converter.from_payload(val)
+        end
+      end
+
+      def self.string_or(str, default = nil)
+        str && !str.empty? ? str : default
+      end
+
+      def self.enum_to_int(enum_mod, enum_val, zero_means_nil: false)
+        # Per https://protobuf.dev/reference/ruby/ruby-generated/#enum when
+        # enums are read back, they are symbols if they are known or number
+        # otherwise
+        enum_val = enum_mod.resolve(enum_val) || raise('Unexpected missing symbol') if enum_val.is_a?(Symbol)
+        enum_val = nil if zero_means_nil && enum_val.zero?
+        enum_val
+      end
+
+      def self.convert_from_payload_array(converter, payloads)
+        return [] if payloads.empty?
+
+        converter.from_payloads(Api::Common::V1::Payloads.new(payloads:))
+      end
+
+      def self.convert_to_payload_array(converter, values)
+        return [] if values.empty?
+
+        converter.to_payloads(values).payloads.to_ary
+      end
+
+      class LazyMemo
+        def initialize(raw_memo, converter)
+          @raw_memo = raw_memo
+          @converter = converter
+        end
+
+        def get
+          @memo = ProtoUtils.memo_from_proto(@raw_memo, @converter) unless defined?(@memo)
+          @memo
+        end
+      end
+
+      class LazySearchAttributes
+        def initialize(raw_search_attributes)
+          @raw_search_attributes = raw_search_attributes
+        end
+
+        def get
+          @search_attributes = SearchAttributes._from_proto(@raw_search_attributes) unless defined?(@search_attributes)
+          @search_attributes
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,373 @@
+# frozen_string_literal: true
+
+require 'temporalio/activity'
+require 'temporalio/activity/definition'
+require 'temporalio/cancellation'
+require 'temporalio/converters/raw_value'
+require 'temporalio/internal/bridge/api'
+require 'temporalio/internal/proto_utils'
+require 'temporalio/scoped_logger'
+require 'temporalio/worker/interceptor'
+
+module Temporalio
+  module Internal
+    module Worker
+      # Worker for handling activity tasks. Upon overarching worker shutdown, {wait_all_complete} should be used to wait
+      # for the activities to complete.
+      class ActivityWorker
+        LOG_TASKS = false
+
+        attr_reader :worker, :bridge_worker
+
+        def initialize(worker:, bridge_worker:)
+          @worker = worker
+          @bridge_worker = bridge_worker
+          @runtime_metric_meter = worker.options.client.connection.options.runtime.metric_meter
+
+          # Create shared logger that gives scoped activity details
+          @scoped_logger = ScopedLogger.new(@worker.options.logger)
+          @scoped_logger.scoped_values_getter = proc {
+            Activity::Context.current_or_nil&._scoped_logger_info
+          }
+
+          # Build up activity hash by name (can be nil for dynamic), failing if any fail validation
+          @activities = worker.options.activities.each_with_object({}) do |act, hash|
+            # Class means create each time, instance means just call, definition
+            # does nothing special
+            defn = Activity::Definition::Info.from_activity(act)
+            # Confirm name not in use
+            raise ArgumentError, 'Only one dynamic activity allowed' if !defn.name && hash.key?(defn.name)
+            raise ArgumentError, "Multiple activities named #{defn.name}" if hash.key?(defn.name)
+
+            # Confirm executor is a known executor and let it initialize
+            executor = worker.options.activity_executors[defn.executor]
+            raise ArgumentError, "Unknown executor '#{defn.executor}'" if executor.nil?
+
+            executor.initialize_activity(defn)
+
+            hash[defn.name] = defn
+          end
+
+          # Need mutex for the rest of these
+          @running_activities_mutex = Mutex.new
+          @running_activities = {}
+          @running_activities_empty_condvar = ConditionVariable.new
+        end
+
+        def set_running_activity(task_token, activity)
+          @running_activities_mutex.synchronize do
+            @running_activities[task_token] = activity
+          end
+        end
+
+        def get_running_activity(task_token)
+          @running_activities_mutex.synchronize do
+            @running_activities[task_token]
+          end
+        end
+
+        def remove_running_activity(task_token)
+          @running_activities_mutex.synchronize do
+            @running_activities.delete(task_token)
+            @running_activities_empty_condvar.broadcast if @running_activities.empty?
+          end
+        end
+
+        def wait_all_complete
+          @running_activities_mutex.synchronize do
+            @running_activities_empty_condvar.wait(@running_activities_mutex) until @running_activities.empty?
+          end
+        end
+
+        def handle_task(task)
+          @scoped_logger.debug("Received activity task: #{task}") if LOG_TASKS
+          if !task.start.nil?
+            handle_start_task(task.task_token, task.start)
+          elsif !task.cancel.nil?
+            handle_cancel_task(task.task_token, task.cancel)
+          else
+            raise "Unrecognized activity task: #{task}"
+          end
+        end
+
+        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]
+          if defn.nil?
+            raise Error::ApplicationError.new(
+              "Activity #{start.activity_type} for workflow #{start.workflow_execution.workflow_id} " \
+              "is not registered on this worker, available activities: #{@activities.keys.sort.join(', ')}",
+              type: 'NotFoundError'
+            )
+          end
+
+          # Run everything else in the excecutor
+          executor = @worker.options.activity_executors[defn.executor]
+          executor.execute_activity(defn) do
+            # Set current executor
+            Activity::Context._current_executor = executor
+            # Execute with error handling
+            execute_activity(task_token, defn, start)
+          ensure
+            # Unset at the end
+            Activity::Context._current_executor = nil
+          end
+        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)
+
+          # We need to complete the activity task as failed, but this is on the
+          # hot path for polling, so we want to complete it in the background
+          begin
+            @bridge_worker.complete_activity_task_in_background(
+              Bridge::Api::CoreInterface::ActivityTaskCompletion.new(
+                task_token:,
+                result: Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+                  failed: Bridge::Api::ActivityResult::Failure.new(
+                    # TODO(cretz): If failure conversion does slow failure
+                    # encoding, it can gum up the system
+                    failure: @worker.options.client.data_converter.to_failure(e)
+                  )
+                )
+              )
+            )
+          rescue StandardError => e_inner
+            @scoped_logger.error("Failed building start failure to return for #{start.activity_type}")
+            @scoped_logger.error(e_inner)
+          end
+        end
+
+        def handle_cancel_task(task_token, cancel)
+          activity = get_running_activity(task_token)
+          if activity.nil?
+            @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)
+          rescue StandardError => e
+            @scoped_logger.warn("Failed cancelling activity #{activity.info.activity_type} \
+              with ID #{activity.info.activity_id}")
+            @scoped_logger.warn(e)
+          end
+        end
+
+        def execute_activity(task_token, defn, start)
+          # Build info
+          info = Activity::Info.new(
+            activity_id: start.activity_id,
+            activity_type: start.activity_type,
+            attempt: start.attempt,
+            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,
+            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),
+            started_time: Internal::ProtoUtils.timestamp_to_time(start.started_time) || raise, # Never nil
+            task_queue: @worker.options.task_queue,
+            task_token:,
+            workflow_id: start.workflow_execution.workflow_id,
+            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(
+            proc: defn.proc,
+            # If the activity wants raw_args, we only decode we don't convert
+            args: if defn.raw_args
+                    payloads = start.input.to_ary
+                    codec = @worker.options.client.data_converter.payload_codec
+                    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)
+                  end,
+            headers: ProtoUtils.headers_from_proto_map(start.header_fields, @worker.options.client.data_converter) || {}
+          )
+
+          # Run
+          activity = RunningActivity.new(
+            info:,
+            cancellation: Cancellation.new,
+            worker_shutdown_cancellation: @worker._worker_shutdown_cancellation,
+            payload_converter: @worker.options.client.data_converter.payload_converter,
+            logger: @scoped_logger,
+            runtime_metric_meter: @runtime_metric_meter
+          )
+          Activity::Context._current_executor&.set_activity_context(defn, activity)
+          set_running_activity(task_token, activity)
+          run_activity(activity, input)
+        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
+          # handles its own errors).
+          begin
+            @bridge_worker.complete_activity_task(
+              Bridge::Api::CoreInterface::ActivityTaskCompletion.new(
+                task_token:,
+                result: Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+                  failed: Bridge::Api::ActivityResult::Failure.new(
+                    failure: @worker.options.client.data_converter.to_failure(e)
+                  )
+                )
+              )
+            )
+          rescue StandardError => e_inner
+            @scoped_logger.error("Failed sending failure for activity #{start.activity_type}")
+            @scoped_logger.error(e_inner)
+          end
+        ensure
+          Activity::Context._current_executor&.set_activity_context(defn, nil)
+          remove_running_activity(task_token)
+        end
+
+        def run_activity(activity, input)
+          result = begin
+            # Build impl with interceptors
+            # @type var impl: Temporalio::Worker::Interceptor::Activity::Inbound
+            impl = InboundImplementation.new(self)
+            impl = @worker._activity_interceptors.reverse_each.reduce(impl) do |acc, int|
+              int.intercept_activity(acc)
+            end
+            impl.init(OutboundImplementation.new(self))
+
+            # Execute
+            result = impl.execute(input)
+
+            # Success
+            Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+              completed: Bridge::Api::ActivityResult::Success.new(
+                result: @worker.options.client.data_converter.to_payload(result)
+              )
+            )
+          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._server_requested_cancel
+              # Server requested cancel
+              @scoped_logger.debug('Completing activity as canceled')
+              Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+                cancelled: Bridge::Api::ActivityResult::Cancellation.new(
+                  failure: @worker.options.client.data_converter.to_failure(e)
+                )
+              )
+            else
+              # General failure
+              @scoped_logger.warn('Completing activity as failed')
+              @scoped_logger.warn(e)
+              Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+                failed: Bridge::Api::ActivityResult::Failure.new(
+                  failure: @worker.options.client.data_converter.to_failure(e)
+                )
+              )
+            end
+          end
+
+          @scoped_logger.debug("Sending activity completion: #{result}") if LOG_TASKS
+          @bridge_worker.complete_activity_task(
+            Bridge::Api::CoreInterface::ActivityTaskCompletion.new(
+              task_token: activity.info.task_token,
+              result:
+            )
+          )
+        end
+
+        class RunningActivity < Activity::Context
+          attr_reader :info, :cancellation, :worker_shutdown_cancellation, :payload_converter, :logger
+          attr_accessor :_outbound_impl, :_server_requested_cancel
+
+          def initialize( # rubocop:disable Lint/MissingSuper
+            info:,
+            cancellation:,
+            worker_shutdown_cancellation:,
+            payload_converter:,
+            logger:,
+            runtime_metric_meter:
+          )
+            @info = info
+            @cancellation = cancellation
+            @worker_shutdown_cancellation = worker_shutdown_cancellation
+            @payload_converter = payload_converter
+            @logger = logger
+            @runtime_metric_meter = runtime_metric_meter
+            @_outbound_impl = nil
+            @_server_requested_cancel = false
+          end
+
+          def heartbeat(*details)
+            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:))
+          end
+
+          def metric_meter
+            @metric_meter ||= @runtime_metric_meter.with_additional_attributes(
+              {
+                namespace: info.workflow_namespace,
+                task_queue: info.task_queue,
+                activity_type: info.activity_type
+              }
+            )
+          end
+        end
+
+        class InboundImplementation < Temporalio::Worker::Interceptor::Activity::Inbound
+          def initialize(worker)
+            super(nil) # steep:ignore
+            @worker = worker
+          end
+
+          def init(outbound)
+            context = Activity::Context.current
+            raise 'Unexpected context type' unless context.is_a?(RunningActivity)
+
+            context._outbound_impl = outbound
+          end
+
+          def execute(input)
+            input.proc.call(*input.args)
+          end
+        end
+
+        class OutboundImplementation < Temporalio::Worker::Interceptor::Activity::Outbound
+          def initialize(worker)
+            super(nil) # steep:ignore
+            @worker = worker
+          end
+
+          def heartbeat(input)
+            @worker.bridge_worker.record_activity_heartbeat(
+              Bridge::Api::CoreInterface::ActivityHeartbeat.new(
+                task_token: Activity::Context.current.info.task_token,
+                details: ProtoUtils.convert_to_payload_array(@worker.worker.options.client.data_converter,
+                                                             input.details)
+              ).to_proto
+            )
+          end
+        end
+      end
+    end
+  end
+end