temporal-ruby 0.0.1.pre.pre1 → 0.0.1

data/lib/temporal/activity/poller.rb

@@ -2,18 +2,22 @@ require 'temporal/client'
 require 'temporal/thread_pool'
 require 'temporal/middleware/chain'
 require 'temporal/activity/task_processor'
+require 'temporal/error_handler'
 
 module Temporal
   class Activity
     class Poller
-      THREAD_POOL_SIZE = 20
+      DEFAULT_OPTIONS = {
+        thread_pool_size: 20
+      }.freeze
 
-      def initialize(namespace, task_queue, activity_lookup, middleware = [])
+      def initialize(namespace, task_queue, activity_lookup, middleware = [], options = {})
         @namespace = namespace
         @task_queue = task_queue
         @activity_lookup = activity_lookup
         @middleware = middleware
         @shutting_down = false
+        @options = DEFAULT_OPTIONS.merge(options)
       end
 
       def start
@@ -21,18 +25,23 @@ module Temporal
         @thread = Thread.new(&method(:poll_loop))
       end
 
-      def stop
+      def stop_polling
         @shutting_down = true
-        Thread.new { Temporal.logger.info('Shutting down activity poller') }.join
+        Temporal.logger.info('Shutting down activity poller', { namespace: namespace, task_queue: task_queue })
+      end
+
+      def cancel_pending_requests
+        client.cancel_polling_request
       end
 
       def wait
         thread.join
+        thread_pool.shutdown
       end
 
       private
 
-      attr_reader :namespace, :task_queue, :activity_lookup, :middleware, :thread
+      attr_reader :namespace, :task_queue, :activity_lookup, :middleware, :options, :thread
 
       def client
         @client ||= Temporal::Client.generate
@@ -43,14 +52,20 @@ module Temporal
       end
 
       def poll_loop
+        last_poll_time = Time.now
+        metrics_tags = { namespace: namespace, task_queue: task_queue }.freeze
+
         loop do
           thread_pool.wait_for_available_threads
 
           return if shutting_down?
 
-          Temporal.logger.debug("Polling activity task queue (#{namespace} / #{task_queue})")
+          time_diff_ms = ((Time.now - last_poll_time) * 1000).round
+          Temporal.metrics.timing('activity_poller.time_since_last_poll', time_diff_ms, metrics_tags)
+          Temporal.logger.debug("Polling activity task queue", { namespace: namespace, task_queue: task_queue })
 
           task = poll_for_task
+          last_poll_time = Time.now
           next unless task&.activity_type
 
           thread_pool.schedule { process(task) }
@@ -60,19 +75,21 @@ module Temporal
       def poll_for_task
         client.poll_activity_task_queue(namespace: namespace, task_queue: task_queue)
       rescue StandardError => error
-        Temporal.logger.error("Unable to poll activity task queue: #{error.inspect}")
+        Temporal.logger.error("Unable to poll activity task queue", { namespace: namespace, task_queue: task_queue, error: error.inspect })
+
+        Temporal::ErrorHandler.handle(error)
+
         nil
       end
 
       def process(task)
-        client = Temporal::Client.generate
         middleware_chain = Middleware::Chain.new(middleware)
 
         TaskProcessor.new(task, namespace, activity_lookup, client, middleware_chain).process
       end
 
       def thread_pool
-        @thread_pool ||= ThreadPool.new(THREAD_POOL_SIZE)
+        @thread_pool ||= ThreadPool.new(options[:thread_pool_size])
       end
     end
   end

data/lib/temporal/activity/task_processor.rb

@@ -1,14 +1,19 @@
 require 'temporal/metadata'
+require 'temporal/error_handler'
 require 'temporal/errors'
 require 'temporal/activity/context'
-require 'temporal/json'
+require 'temporal/concerns/payloads'
+require 'temporal/client/retryer'
 
 module Temporal
   class Activity
     class TaskProcessor
+      include Concerns::Payloads
+
       def initialize(task, namespace, activity_lookup, client, middleware_chain)
         @task = task
         @namespace = namespace
+        @metadata = Metadata.generate(Metadata::ACTIVITY_TYPE, task, namespace)
         @task_token = task.task_token
         @activity_name = task.activity_type.name
         @activity_class = activity_lookup.find(activity_name)
@@ -19,33 +24,34 @@ module Temporal
       def process
         start_time = Time.now
 
-        Temporal.logger.info("Processing activity task for #{activity_name}")
+        Temporal.logger.debug("Processing Activity task", metadata.to_h)
         Temporal.metrics.timing('activity_task.queue_time', queue_time_ms, activity: activity_name)
 
+        context = Activity::Context.new(client, metadata)
+
         if !activity_class
           raise ActivityNotRegistered, 'Activity is not registered with this worker'
         end
 
-        metadata = Metadata.generate(Metadata::ACTIVITY_TYPE, task, namespace)
-        context = Activity::Context.new(client, metadata)
-
         result = middleware_chain.invoke(metadata) do
-          activity_class.execute_in_context(context, parse_payload(task.input))
+          activity_class.execute_in_context(context, from_payloads(task.input))
         end
 
         # Do not complete asynchronous activities, these should be completed manually
         respond_completed(result) unless context.async?
       rescue StandardError, ScriptError => error
+        Temporal::ErrorHandler.handle(error, metadata: metadata)
+
         respond_failed(error)
       ensure
         time_diff_ms = ((Time.now - start_time) * 1000).round
         Temporal.metrics.timing('activity_task.latency', time_diff_ms, activity: activity_name)
-        Temporal.logger.debug("Activity task processed in #{time_diff_ms}ms")
+        Temporal.logger.debug("Activity task processed", metadata.to_h.merge(execution_time: time_diff_ms))
       end
 
       private
 
-      attr_reader :task, :namespace, :task_token, :activity_name, :activity_class, :client, :middleware_chain
+      attr_reader :task, :namespace, :task_token, :activity_name, :activity_class, :client, :middleware_chain, :metadata
 
       def queue_time_ms
         scheduled = task.current_attempt_scheduled_time.to_f
@@ -54,24 +60,31 @@ module Temporal
       end
 
       def respond_completed(result)
-        Temporal.logger.info("Activity #{activity_name} completed")
-        client.respond_activity_task_completed(task_token: task_token, result: result)
+        Temporal.logger.info("Activity task completed", metadata.to_h)
+        log_retry = proc do
+          Temporal.logger.debug("Failed to report activity task completion, retrying", metadata.to_h)
+        end
+        Temporal::Client::Retryer.with_retries(on_retry: log_retry) do
+          client.respond_activity_task_completed(task_token: task_token, result: result)
+        end
       rescue StandardError => error
-        Temporal.logger.error("Unable to complete Activity #{activity_name}: #{error.inspect}")
+        Temporal.logger.error("Unable to complete Activity", metadata.to_h.merge(error: error.inspect))
+
+        Temporal::ErrorHandler.handle(error, metadata: metadata)
       end
 
       def respond_failed(error)
-        Temporal.logger.error("Activity #{activity_name} failed with: #{error.inspect}")
-        client.respond_activity_task_failed(task_token: task_token, exception: error)
+        Temporal.logger.error("Activity task failed", metadata.to_h.merge(error: error.inspect))
+        log_retry = proc do
+          Temporal.logger.debug("Failed to report activity task failure, retrying", metadata.to_h)
+        end
+        Temporal::Client::Retryer.with_retries(on_retry: log_retry) do
+          client.respond_activity_task_failed(task_token: task_token, exception: error)
+        end
       rescue StandardError => error
-        Temporal.logger.error("Unable to fail Activity #{activity_name}: #{error.inspect}")
-      end
-
-      def parse_payload(payload)
-        return if payload.nil? || payload.payloads.empty?
+        Temporal.logger.error("Unable to fail Activity task", metadata.to_h.merge(error: error.inspect))
 
-        binary = payload.payloads.first.data
-        JSON.deserialize(binary)
+        Temporal::ErrorHandler.handle(error, metadata: metadata)
       end
     end
   end

data/lib/temporal/client/converter/base.rb

@@ -0,0 +1,35 @@
+module Temporal
+  module Client
+    module Converter
+      class Base
+        def initialize(payload_converter:)
+          @payload_converter = payload_converter
+        end
+
+        def from_payloads(payloads)
+          return nil if payloads.nil?
+          payloads.payloads.map(&method(:from_payload))
+        end
+
+        def from_payload(payload)
+          payload_converter.from_payload(payload)
+        end
+
+        def to_payloads(data)
+          return nil if data.nil?
+          Temporal::Api::Common::V1::Payloads.new(
+            payloads: data.map(&method(:to_payload))
+          )
+        end
+
+        def to_payload(data)
+          payload_converter.to_payload(data)
+        end
+
+        private
+
+        attr_reader :payload_converter
+      end
+    end
+  end
+end

data/lib/temporal/client/converter/composite.rb

@@ -0,0 +1,49 @@
+require 'temporal/client/converter/base'
+
+module Temporal
+  module Client
+    module Converter
+      class Composite < Base
+        class ConverterNotFound < RuntimeError; end
+        class MetadataNotSet < RuntimeError; end
+
+        def initialize(payload_converters:)
+          @payload_converters = payload_converters
+          @payload_converters_by_encoding = {}
+
+          @payload_converters.each do |converter|
+            @payload_converters_by_encoding[converter.encoding] = converter
+          end
+        end
+
+        def from_payload(payload)
+          encoding = payload.metadata['encoding']
+          if encoding.nil?
+            raise MetadataNotSet
+          end
+
+          converter = payload_converters_by_encoding[encoding]
+
+          if converter.nil?
+            raise ConverterNotFound
+          end
+
+          converter.from_payload(payload)
+        end
+
+        def to_payload(data)
+          payload_converters.each do |converter|
+            payload = converter.to_payload(data)
+            return payload unless payload.nil?
+          end
+
+          raise ConverterNotFound
+        end
+
+        private
+
+        attr_reader :payload_converters, :payload_converters_by_encoding
+      end
+    end
+  end
+end

data/lib/temporal/client/converter/payload/bytes.rb

@@ -0,0 +1,30 @@
+require 'temporal/json'
+
+module Temporal
+  module Client
+    module Converter
+      module Payload
+        class Bytes
+          ENCODING = 'binary/plain'.freeze
+
+          def encoding
+            ENCODING
+          end
+
+          def from_payload(payload)
+            payload.data
+          end
+
+          def to_payload(data)
+            return nil unless data.is_a?(String) && data.encoding == Encoding::ASCII_8BIT
+
+            Temporal::Api::Common::V1::Payload.new(
+              metadata: { 'encoding' => ENCODING },
+              data: data
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporal/client/converter/payload/json.rb

@@ -0,0 +1,28 @@
+require 'temporal/json'
+
+module Temporal
+  module Client
+    module Converter
+      module Payload
+        class JSON
+          ENCODING = 'json/plain'.freeze
+
+          def encoding
+            ENCODING
+          end
+
+          def from_payload(payload)
+            Temporal::JSON.deserialize(payload.data)
+          end
+
+          def to_payload(data)
+            Temporal::Api::Common::V1::Payload.new(
+              metadata: { 'encoding' => ENCODING },
+              data: Temporal::JSON.serialize(data).b
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporal/client/converter/payload/nil.rb

@@ -0,0 +1,27 @@
+module Temporal
+  module Client
+    module Converter
+      module Payload
+        class Nil
+          ENCODING = 'binary/null'.freeze
+
+          def encoding
+            ENCODING
+          end
+
+          def from_payload(payload)
+            nil
+          end
+
+          def to_payload(data)
+            return nil unless data.nil?
+
+            Temporal::Api::Common::V1::Payload.new(
+              metadata: { 'encoding' => ENCODING }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporal/client/grpc_client.rb

@@ -1,30 +1,39 @@
 require 'grpc'
 require 'google/protobuf/well_known_types'
 require 'securerandom'
-require 'temporal/json'
 require 'temporal/client/errors'
 require 'temporal/client/serializer'
-require 'temporal/client/serializer/payload'
 require 'temporal/client/serializer/failure'
 require 'gen/temporal/api/workflowservice/v1/service_services_pb'
+require 'temporal/concerns/payloads'
 
 module Temporal
   module Client
     class GRPCClient
+      include Concerns::Payloads
+
       WORKFLOW_ID_REUSE_POLICY = {
         allow_failed: Temporal::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY,
         allow: Temporal::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE,
         reject: Temporal::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE
       }.freeze
 
+      HISTORY_EVENT_FILTER = {
+        all: Temporal::Api::Enums::V1::HistoryEventFilterType::HISTORY_EVENT_FILTER_TYPE_ALL_EVENT,
+        close: Temporal::Api::Enums::V1::HistoryEventFilterType::HISTORY_EVENT_FILTER_TYPE_CLOSE_EVENT,
+      }.freeze
+
       def initialize(host, port, identity)
         @url = "#{host}:#{port}"
         @identity = identity
+        @poll = true
+        @poll_mutex = Mutex.new
+        @poll_request = nil
       end
 
       def register_namespace(name:, description: nil, global: false, retention_period: 10)
         request = Temporal::Api::WorkflowService::V1::RegisterNamespaceRequest.new(
-          name: name,
+          namespace: name,
           description: description,
           is_global_namespace: global,
           workflow_execution_retention_period: Google::Protobuf::Duration.new(
@@ -37,7 +46,7 @@ module Temporal
       end
 
       def describe_namespace(name:)
-        request = Temporal::Api::WorkflowService::V1::DescribeNamespaceRequest.new(name: name)
+        request = Temporal::Api::WorkflowService::V1::DescribeNamespaceRequest.new(namespace: name)
         client.describe_namespace(request)
       end
 
@@ -48,7 +57,7 @@ module Temporal
 
       def update_namespace(name:, description:)
         request = Temporal::Api::WorkflowService::V1::UpdateNamespaceRequest.new(
-          name: name,
+          namespace: name,
           update_info: Temporal::Api::WorkflowService::V1::UpdateNamespaceInfo.new(
             description: description
           )
@@ -57,7 +66,7 @@ module Temporal
       end
 
       def deprecate_namespace(name:)
-        request = Temporal::Api::WorkflowService::V1::DeprecateNamespaceRequest.new(name: name)
+        request = Temporal::Api::WorkflowService::V1::DeprecateNamespaceRequest.new(namespace: name)
         client.deprecate_namespace(request)
       end
 
@@ -68,9 +77,11 @@ module Temporal
         task_queue:,
         input: nil,
         execution_timeout:,
+        run_timeout:,
         task_timeout:,
         workflow_id_reuse_policy: nil,
-        headers: nil
+        headers: nil,
+        cron_schedule: nil
       )
         request = Temporal::Api::WorkflowService::V1::StartWorkflowExecutionRequest.new(
           identity: identity,
@@ -82,14 +93,15 @@ module Temporal
           task_queue: Temporal::Api::TaskQueue::V1::TaskQueue.new(
             name: task_queue
           ),
-          input: Serializer::Payload.new(input).to_proto,
+          input: to_payloads(input),
           workflow_execution_timeout: execution_timeout,
-          workflow_run_timeout: execution_timeout,
+          workflow_run_timeout: run_timeout,
           workflow_task_timeout: task_timeout,
           request_id: SecureRandom.uuid,
           header: Temporal::Api::Common::V1::Header.new(
             fields: headers
-          )
+          ),
+          cron_schedule: cron_schedule
         )
 
         if workflow_id_reuse_policy
@@ -102,20 +114,43 @@ module Temporal
         client.start_workflow_execution(request)
       rescue GRPC::AlreadyExists => e
         # Feel like there should be cleaner way to do this...
-        run_id = e.details[/RunId: (.*)\.$/, 1]
+        run_id = e.details[/RunId: ([a-f0-9]+-[a-f0-9]+-[a-f0-9]+-[a-f0-9]+-[a-f0-9]+)/, 1]
         raise Temporal::WorkflowExecutionAlreadyStartedFailure.new(e.details, run_id)
       end
 
-      def get_workflow_execution_history(namespace:, workflow_id:, run_id:)
+      SERVER_MAX_GET_WORKFLOW_EXECUTION_HISTORY_POLL = 30
+
+      def get_workflow_execution_history(
+        namespace:,
+        workflow_id:,
+        run_id:,
+        next_page_token: nil,
+        wait_for_new_event: false,
+        event_type: :all,
+        timeout: nil
+      )
+        if wait_for_new_event 
+          if timeout.nil?
+            # This is an internal error.  Wrappers should enforce this.
+            raise "You must specify a timeout when wait_for_new_event = true."
+          elsif timeout > SERVER_MAX_GET_WORKFLOW_EXECUTION_HISTORY_POLL
+            raise ClientError.new(
+              "You may not specify a timeout of more than #{SERVER_MAX_GET_WORKFLOW_EXECUTION_HISTORY_POLL} seconds, got: #{timeout}."
+            )
+          end
+        end
         request = Temporal::Api::WorkflowService::V1::GetWorkflowExecutionHistoryRequest.new(
           namespace: namespace,
           execution: Temporal::Api::Common::V1::WorkflowExecution.new(
             workflow_id: workflow_id,
             run_id: run_id
-          )
+          ),
+          next_page_token: next_page_token,
+          wait_new_event: wait_for_new_event,
+          history_event_filter_type: HISTORY_EVENT_FILTER[event_type]
         )
-
-        client.get_workflow_execution_history(request)
+        deadline = timeout ? Time.now + timeout : nil
+        client.get_workflow_execution_history(request, deadline: deadline)
       end
 
       def poll_workflow_task_queue(namespace:, task_queue:)
@@ -126,7 +161,13 @@ module Temporal
             name: task_queue
           )
         )
-        client.poll_workflow_task_queue(request)
+
+        poll_mutex.synchronize do
+          return unless can_poll?
+          @poll_request = client.poll_workflow_task_queue(request, return_op: true)
+        end
+
+        poll_request.execute
       end
 
       def respond_workflow_task_completed(task_token:, commands:)
@@ -156,13 +197,19 @@ module Temporal
             name: task_queue
           )
         )
-        client.poll_activity_task_queue(request)
+
+        poll_mutex.synchronize do
+          return unless can_poll?
+          @poll_request = client.poll_activity_task_queue(request, return_op: true)
+        end
+
+        poll_request.execute
       end
 
       def record_activity_task_heartbeat(task_token:, details: nil)
         request = Temporal::Api::WorkflowService::V1::RecordActivityTaskHeartbeatRequest.new(
           task_token: task_token,
-          details: Serializer::Payload.new(details).to_proto,
+          details: to_details_payloads(details),
           identity: identity
         )
         client.record_activity_task_heartbeat(request)
@@ -176,7 +223,7 @@ module Temporal
         request = Temporal::Api::WorkflowService::V1::RespondActivityTaskCompletedRequest.new(
           identity: identity,
           task_token: task_token,
-          result: Serializer::Payload.new(result).to_proto,
+          result: to_result_payloads(result),
         )
         client.respond_activity_task_completed(request)
       end
@@ -188,7 +235,7 @@ module Temporal
           workflow_id: workflow_id,
           run_id: run_id,
           activity_id: activity_id,
-          result: Serializer::Payload.new(result).to_proto
+          result: to_result_payloads(result)
         )
         client.respond_activity_task_completed_by_id(request)
       end
@@ -217,7 +264,7 @@ module Temporal
       def respond_activity_task_canceled(task_token:, details: nil)
         request = Temporal::Api::WorkflowService::V1::RespondActivityTaskCanceledRequest.new(
           task_token: task_token,
-          details: Serializer::Payload.new(details).to_proto,
+          details: to_details_payloads(details),
           identity: identity
         )
         client.respond_activity_task_canceled(request)
@@ -239,7 +286,7 @@ module Temporal
             run_id: run_id
           ),
           signal_name: signal,
-          input: Serializer::Payload.new(input).to_proto,
+          input: to_signal_payloads(input),
           identity: identity
         )
         client.signal_workflow_execution(request)
@@ -254,7 +301,7 @@ module Temporal
           namespace: namespace,
           workflow_execution: Temporal::Api::Common::V1::WorkflowExecution.new(
             workflow_id: workflow_id,
-            run_id: run_id
+            run_id: run_id,
           ),
           reason: reason,
           workflow_task_finish_event_id: workflow_task_event_id
@@ -262,8 +309,25 @@ module Temporal
         client.reset_workflow_execution(request)
       end
 
-      def terminate_workflow_execution
-        raise NotImplementedError
+      def terminate_workflow_execution(
+        namespace:,
+        workflow_id:,
+        run_id:,
+        reason: nil,
+        details: nil
+      )
+        request = Temporal::Api::WorkflowService::V1::TerminateWorkflowExecutionRequest.new(
+          identity: identity,
+          namespace: namespace,
+          workflow_execution: Temporal::Api::Common::V1::WorkflowExecution.new(
+            workflow_id: workflow_id,
+            run_id: run_id,
+          ),
+          reason: reason,
+          details: to_details_payloads(details)
+        )
+
+        client.terminate_workflow_execution(request)
       end
 
       def list_open_workflow_executions
@@ -329,17 +393,28 @@ module Temporal
         client.describe_task_queue(request)
       end
 
+      def cancel_polling_request
+        poll_mutex.synchronize do
+          @poll = false
+          poll_request&.cancel
+        end
+      end
+
       private
 
-      attr_reader :url, :identity
+      attr_reader :url, :identity, :poll_mutex, :poll_request
 
       def client
         @client ||= Temporal::Api::WorkflowService::V1::WorkflowService::Stub.new(
           url,
           :this_channel_is_insecure,
-          timeout: 5
+          timeout: 60
         )
       end
+
+      def can_poll?
+        @poll
+      end
     end
   end
 end