temporal-ruby 0.0.1.pre.pre1 → 0.0.1

data/lib/temporal/error_handler.rb

@@ -0,0 +1,11 @@
+module Temporal
+  module ErrorHandler
+    def self.handle(error, metadata: nil)
+      Temporal.configuration.error_handlers.each do |handler|
+        handler.call(error, metadata: metadata)
+      rescue StandardError => e
+        Temporal.logger.error("Error handler failed", { error: e.inspect })
+      end
+    end
+  end
+end

data/lib/temporal/errors.rb

@@ -5,6 +5,10 @@ module Temporal
   # Superclass for errors specific to Temporal worker itself
   class InternalError < Error; end
 
+  # Indicates a non-deterministic workflow execution, might be due to
+  # a non-deterministic workflow implementation or the gem's bug
+  class NonDeterministicWorkflowError < InternalError; end
+
   # Superclass for misconfiguration/misuse on the client (user) side
   class ClientError < Error; end
 
@@ -21,6 +25,25 @@ module Temporal
   class ApiError < Error; end
 
   class NotFoundFailure < ApiError; end
+
+  # Superclass for system errors raised when retrieving a workflow result on the
+  # client, but the workflow failed remotely.
+  class WorkflowError < Error; end
+
+  class WorkflowTimedOut < WorkflowError; end
+  class WorkflowTerminated < WorkflowError; end
+  class WorkflowCanceled < WorkflowError; end
+
+  # Errors where the workflow run didn't complete but not an error for the whole workflow.
+  class WorkflowRunError < Error; end
+  class WorkflowRunContinuedAsNew < WorkflowRunError
+    attr_reader :new_run_id
+    def initialize(new_run_id:)
+      super
+      @new_run_id = new_run_id
+    end
+  end
+
   class WorkflowExecutionAlreadyStartedFailure < ApiError
     attr_reader :run_id
 
@@ -35,4 +58,5 @@ module Temporal
   class NamespaceAlreadyExistsFailure < ApiError; end
   class CancellationAlreadyRequestedFailure < ApiError; end
   class QueryFailedFailure < ApiError; end
+
 end

data/lib/temporal/execution_options.rb

@@ -12,7 +12,7 @@ module Temporal
       @timeouts = options[:timeouts] || {}
       @headers = options[:headers] || {}
 
-      if object.singleton_class.included_modules.include?(Concerns::Executable)
+      if has_executable_concern?(object)
         @namespace ||= object.namespace
         @task_queue ||= object.task_queue
         @retry_policy ||= object.retry_policy
@@ -31,5 +31,13 @@ module Temporal
     def task_list
       @task_queue
     end
+
+    private
+
+    def has_executable_concern?(object)
+      object.singleton_class.included_modules.include?(Concerns::Executable)
+    rescue TypeError
+      false
+    end
   end
 end

data/lib/temporal/json.rb

@@ -4,7 +4,9 @@ require 'oj'
 module Temporal
   module JSON
     OJ_OPTIONS = {
-      mode: :object
+      mode: :object,
+      # use ruby's built-in serialization.  If nil, OJ seems to default to ~15 decimal places of precision
+      float_precision: 0
     }.freeze
 
     def self.serialize(value)

data/lib/temporal/logger.rb

@@ -0,0 +1,17 @@
+require 'logger'
+
+module Temporal
+  class Logger < ::Logger
+    SEVERITIES = %i[debug info warn error fatal unknown].freeze
+
+    SEVERITIES.each do |severity|
+      define_method severity do |message, data = {}|
+        super(message.to_s + ' ' + Oj.dump(data, mode: :strict))
+      end
+    end
+
+    def log(severity, message, data = {})
+      add(severity, message.to_s + ' ' + Oj.dump(data, mode: :strict))
+    end
+  end
+end

data/lib/temporal/metadata.rb

@@ -2,6 +2,7 @@ require 'temporal/errors'
 require 'temporal/metadata/activity'
 require 'temporal/metadata/workflow'
 require 'temporal/metadata/workflow_task'
+require 'temporal/concerns/payloads'
 
 module Temporal
   module Metadata
@@ -10,6 +11,8 @@ module Temporal
     WORKFLOW_TYPE = :workflow
 
     class << self
+      include Concerns::Payloads
+
       def generate(type, data, namespace = nil)
         case type
         when ACTIVITY_TYPE
@@ -26,7 +29,11 @@ module Temporal
       private
 
       def headers(fields)
-        fields.transform_values { |v| v[:data] }
+        result = {}
+        fields.each do |field, payload|
+          result[field] = from_payload(payload)
+        end
+        result
       end
 
       def activity_metadata_from(task, namespace)
@@ -39,7 +46,8 @@ module Temporal
           workflow_run_id: task.workflow_execution.run_id,
           workflow_id: task.workflow_execution.workflow_id,
           workflow_name: task.workflow_type.name,
-          headers: headers(task.header&.fields.to_h)
+          headers: headers(task.header&.fields),
+          heartbeat_details: from_details_payloads(task.heartbeat_details)
         )
       end
 
@@ -60,7 +68,7 @@ module Temporal
           name: event.workflow_type.name,
           run_id: event.original_execution_run_id,
           attempt: event.attempt,
-          headers: headers(event.header&.fields.to_h)
+          headers: headers(event.header&.fields)
         )
       end
     end

data/lib/temporal/metadata/activity.rb

@@ -3,9 +3,9 @@ require 'temporal/metadata/base'
 module Temporal
   module Metadata
     class Activity < Base
-      attr_reader :namespace, :id, :name, :task_token, :attempt, :workflow_run_id, :workflow_id, :workflow_name, :headers
+      attr_reader :namespace, :id, :name, :task_token, :attempt, :workflow_run_id, :workflow_id, :workflow_name, :headers, :heartbeat_details
 
-      def initialize(namespace:, id:, name:, task_token:, attempt:, workflow_run_id:, workflow_id:, workflow_name:, headers: {})
+      def initialize(namespace:, id:, name:, task_token:, attempt:, workflow_run_id:, workflow_id:, workflow_name:, headers: {}, heartbeat_details:)
         @namespace = namespace
         @id = id
         @name = name
@@ -15,6 +15,7 @@ module Temporal
         @workflow_id = workflow_id
         @workflow_name = workflow_name
         @headers = headers
+        @heartbeat_details = heartbeat_details
 
         freeze
       end
@@ -22,6 +23,18 @@ module Temporal
       def activity?
         true
       end
+
+      def to_h
+        {
+          'namespace' => namespace,
+          'workflow_id' => workflow_id,
+          'workflow_name' => workflow_name,
+          'workflow_run_id' => workflow_run_id,
+          'activity_id' => id,
+          'activity_name' => name,
+          'attempt' => attempt
+        }
+      end
     end
   end
 end

data/lib/temporal/metadata/workflow.rb

@@ -17,6 +17,14 @@ module Temporal
       def workflow?
         true
       end
+
+      def to_h
+        {
+          'workflow_name' => name,
+          'workflow_run_id' => run_id,
+          'attempt' => attempt
+        }
+      end
     end
   end
 end

data/lib/temporal/metadata/workflow_task.rb

@@ -20,6 +20,17 @@ module Temporal
       def workflow_task?
         true
       end
+
+      def to_h
+        {
+          'namespace' => namespace,
+          'workflow_task_id' => id,
+          'workflow_name' => workflow_name,
+          'workflow_id' => workflow_id,
+          'workflow_run_id' => workflow_run_id,
+          'attempt' => attempt
+        }
+      end
     end
   end
 end

data/lib/temporal/retry_policy.rb

@@ -1,25 +1,22 @@
 require 'temporal/errors'
 
 module Temporal
+  # See https://docs.temporal.io/docs/go/retries/ for go documentation of equivalent concepts.
   class RetryPolicy < Struct.new(:interval, :backoff, :max_interval, :max_attempts,
-    :expiration_interval, :non_retriable_errors, keyword_init: true)
+    :non_retriable_errors, keyword_init: true)
 
     class InvalidRetryPolicy < ClientError; end
 
     def validate!
-      unless interval && backoff
-        raise InvalidRetryPolicy, 'interval and backoff must be set'
+      unless max_attempts == 1 || (interval && backoff)
+        raise InvalidRetryPolicy, 'interval and backoff must be set if max_attempts != 1'
       end
 
-      unless max_attempts || expiration_interval
-        raise InvalidRetryPolicy, 'max_attempts or expiration_interval must be set'
-      end
-
-      unless [interval, max_interval, expiration_interval].compact.all? { |arg| arg.is_a?(Integer) }
+      unless [interval, max_interval].compact.all? { |arg| arg.is_a?(Integer) }
         raise InvalidRetryPolicy, 'All intervals must be specified in whole seconds'
       end
 
-      unless [interval, max_interval, expiration_interval].compact.all? { |arg| arg > 0 }
+      unless [interval, max_interval].compact.all? { |arg| arg > 0 }
         raise InvalidRetryPolicy, 'All intervals must be greater than 0'
       end
     end

data/lib/temporal/saga/concern.rb

@@ -11,7 +11,7 @@ module Temporal
 
         Result.new(true)
       rescue StandardError => error # TODO: is there a need for a specialized error here?
-        logger.error("Saga execution aborted: #{error.inspect}")
+        logger.error("Saga execution aborted", { error: error.inspect })
         logger.debug(error.backtrace.join("\n"))
 
         saga.compensate

data/lib/temporal/testing.rb

@@ -1,5 +1,6 @@
 require 'temporal/testing/temporal_override'
 require 'temporal/testing/workflow_override'
+require 'temporal/testing/scheduled_workflows'
 
 module Temporal
   module Testing

data/lib/temporal/testing/future_registry.rb

@@ -16,7 +16,7 @@ module Temporal
       end
 
       def fail(token, error)
-        store[token].fail(error.class.name, error.message)
+        store[token].fail(error)
       end
 
       private

data/lib/temporal/testing/local_activity_context.rb

@@ -10,7 +10,7 @@ module Temporal
       end
 
       def heartbeat(details = nil)
-        raise NotImplementedError, 'not yet available for testing'
+        # behavior is not yet testable in local mode
       end
     end
   end

data/lib/temporal/testing/local_workflow_context.rb

@@ -9,21 +9,30 @@ require 'temporal/workflow/history/event_target'
 module Temporal
   module Testing
     class LocalWorkflowContext
-      attr_reader :headers
+      attr_reader :metadata
 
-      def initialize(execution, workflow_id, run_id, disabled_releases, headers = {})
+      def initialize(execution, workflow_id, run_id, disabled_releases, metadata)
         @last_event_id = 0
         @execution = execution
         @run_id = run_id
         @workflow_id = workflow_id
         @disabled_releases = disabled_releases
-        @headers = headers
+        @metadata = metadata
+        @completed = false
+      end
+
+      def completed?
+        @completed
       end
 
       def logger
         Temporal.logger
       end
 
+      def headers
+        metadata.headers
+      end
+
       def has_release?(change_name)
         !disabled_releases.include?(change_name.to_s)
       end
@@ -48,17 +57,25 @@ module Temporal
           workflow_run_id: run_id,
           workflow_id: workflow_id,
           workflow_name: nil, # not yet used, but will be in the future
-          headers: execution_options.headers
+          headers: execution_options.headers,
+          heartbeat_details: nil
         )
         context = LocalActivityContext.new(metadata)
 
-        result = activity_class.execute_in_context(context, input)
-
-        if context.async?
-          execution.register_future(context.async_token, future)
+        begin
+          result = activity_class.execute_in_context(context, input)
+        rescue StandardError => e
+          # Capture any failure from running the activity into the future
+          # instead of raising immediately in order to match the behavior of
+          # running against a Temporal server.
+          future.fail(e)
         else
-          # Fulfil the future straigt away for non-async activities
-          future.set(result)
+          if context.async?
+            execution.register_future(context.async_token, future)
+          else
+            # Fulfill the future straight away for non-async activities
+            future.set(result)
+          end
         end
 
         future
@@ -66,11 +83,11 @@ module Temporal
 
       def execute_activity!(activity_class, *input, **args)
         future = execute_activity(activity_class, *input, **args)
-        result = future.get
+        result_or_exception = future.get
 
-        raise future.exception if future.failed?
+        raise result_or_exception if future.failed?
 
-        result
+        result_or_exception
       end
 
       def execute_local_activity(activity_class, *input, **args)
@@ -88,7 +105,8 @@ module Temporal
           workflow_run_id: run_id,
           workflow_id: workflow_id,
           workflow_name: nil, # not yet used, but will be in the future
-          headers: execution_options.headers
+          headers: execution_options.headers,
+          heartbeat_details: nil
         )
         context = LocalActivityContext.new(metadata)
 
@@ -131,10 +149,12 @@ module Temporal
       end
 
       def complete(result = nil)
+        completed!
         result
       end
 
       def fail(exception)
+        completed!
         raise exception
       end
 
@@ -169,6 +189,10 @@ module Temporal
 
       attr_reader :execution, :run_id, :workflow_id, :disabled_releases
 
+      def completed!
+        @completed = true
+      end
+
       def next_event_id
         @last_event_id += 1
         @last_event_id

data/lib/temporal/testing/scheduled_workflows.rb

@@ -0,0 +1,75 @@
+module Temporal
+  module Testing
+    class WorkflowIDNotScheduled < ClientError; end
+
+    # When Temporal.schedule_workflow is called in a test in local mode, we defer the execution and do
+    # not do it automatically.
+    # You can execute them or inspect their cron schedules using this module.
+    module ScheduledWorkflows
+      def self.execute(workflow_id:)
+        Private::Store.execute(workflow_id: workflow_id)
+      end
+
+      def self.execute_all
+        Private::Store.execute_all
+      end
+
+      # For someone who wants to assert that the schedule is what they expect.
+      # Populated by Temporal.schedule_workflow
+      # format: { <workflow_id>: <cron schedule string>, ... }
+      def self.cron_schedules
+        Private::Store.schedules
+      end
+
+      def self.clear_all
+        Private::Store.clear_all
+      end
+
+      module Private
+        module Store
+          class << self
+
+            def schedules
+              @schedules ||= {}.freeze
+            end
+
+            def add(workflow_id:, cron_schedule:, executor_lambda:)
+              new_schedules = schedules.dup
+              new_schedules[workflow_id] = cron_schedule
+              @schedules = new_schedules.freeze
+
+              new_scheduled_executions = scheduled_executions.dup
+              new_scheduled_executions[workflow_id] = executor_lambda
+              @scheduled_executions = new_scheduled_executions.freeze
+            end
+
+            def clear_all
+              @scheduled_executions = {}.freeze
+              @schedules = {}.freeze
+            end
+
+            def execute(workflow_id:)
+              unless scheduled_executions.key?(workflow_id)
+                raise Temporal::Testing::WorkflowIDNotScheduled,
+                "There is no workflow with id #{workflow_id} that was scheduled with Temporal.schedule_workflow.\n"\
+                "Options: #{scheduled_executions.keys}"
+              end
+
+              scheduled_executions[workflow_id].call
+            end
+
+            def execute_all
+              scheduled_executions.values.each(&:call)
+            end
+
+            private
+
+            def scheduled_executions
+              @scheduled_executions ||= {}.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end