cadence-ruby 0.0.0 → 0.1.0

data/lib/cadence/concerns/executable.rb

@@ -0,0 +1,33 @@
+require 'cadence/retry_policy'
+
+module Cadence
+  module Concerns
+    module Executable
+      def domain(*args)
+        return @domain if args.empty?
+        @domain = args.first
+      end
+
+      def task_list(*args)
+        return @task_list if args.empty?
+        @task_list = args.first
+      end
+
+      def retry_policy(*args)
+        return @retry_policy if args.empty?
+        @retry_policy = Cadence::RetryPolicy.new(args.first)
+        @retry_policy.validate!
+      end
+
+      def timeouts(*args)
+        return @timeouts if args.empty?
+        @timeouts = args.first
+      end
+
+      def headers(*args)
+        return @headers if args.empty?
+        @headers = args.first
+      end
+    end
+  end
+end

data/lib/cadence/concerns/typed.rb

@@ -0,0 +1,40 @@
+require 'dry-struct'
+require 'cadence/types'
+
+module Cadence
+  module Concerns
+    module Typed
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        attr_reader :input_class
+
+        def execute_in_context(context, input)
+          input = input_class[*input] if input_class
+
+          super(context, input)
+        end
+
+        def input(klass = nil, &block)
+          if klass
+            unless klass.is_a?(Dry::Types::Type)
+              raise 'Unsupported input class. Use one of the provided Cadence::Types'
+            end
+            @input_class = klass
+          else
+            @input_class = generate_struct
+            @input_class.instance_eval(&block)
+          end
+        end
+
+        private
+
+        def generate_struct
+          Class.new(Dry::Struct::Value) { transform_keys(&:to_sym) }
+        end
+      end
+    end
+  end
+end

data/lib/cadence/configuration.rb

@@ -0,0 +1,36 @@
+require 'logger'
+require 'cadence/metrics_adapters/null'
+
+module Cadence
+  class Configuration
+    attr_reader :timeouts
+    attr_accessor :client_type, :host, :port, :logger, :metrics_adapter, :domain, :task_list, :headers
+
+    DEFAULT_TIMEOUTS = {
+      execution: 60,          # End-to-end workflow time
+      task: 10,               # Decision task processing time
+      schedule_to_close: nil, # End-to-end activity time (default: schedule_to_start + start_to_close)
+      schedule_to_start: 10,  # Queue time for an activity
+      start_to_close: 30,     # Time spent processing an activity
+      heartbeat: nil          # Max time between heartbeats (off by default)
+    }.freeze
+
+    DEFAULT_HEADERS = {}.freeze
+    DEFAULT_DOMAIN = 'default-domain'.freeze
+    DEFAULT_TASK_LIST = 'default-task-list'.freeze
+
+    def initialize
+      @client_type = :thrift
+      @logger = Logger.new(STDOUT, progname: 'cadence_client')
+      @metrics_adapter = MetricsAdapters::Null.new
+      @timeouts = DEFAULT_TIMEOUTS
+      @domain = DEFAULT_DOMAIN
+      @task_list = DEFAULT_TASK_LIST
+      @headers = DEFAULT_HEADERS
+    end
+
+    def timeouts=(new_timeouts)
+      @timeouts = DEFAULT_TIMEOUTS.merge(new_timeouts)
+    end
+  end
+end

data/lib/cadence/errors.rb

@@ -0,0 +1,21 @@
+module Cadence
+  # Superclass for all Cadence errors
+  class Error < StandardError; end
+
+  # Superclass for errors specific to Cadence 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
+
+  # Represents any timeout
+  class TimeoutError < ClientError; end
+
+  # A superclass for activity exceptions raised explicitly
+  # with the itent to propagate to a workflow
+  class ActivityException < ClientError; end
+end

data/lib/cadence/executable_lookup.rb

@@ -0,0 +1,25 @@
+# This class is responsible for matching an executable (activity or workflow) name
+# to a class implementing it.
+#
+# TODO: This class should be responsible for handling executable versions
+#       when these are implemented
+#
+module Cadence
+  class ExecutableLookup
+    def initialize
+      @executables = {}
+    end
+
+    def add(name, executable)
+      executables[name] = executable
+    end
+
+    def find(name)
+      executables[name]
+    end
+
+    private
+
+    attr_reader :executables
+  end
+end

data/lib/cadence/execution_options.rb

@@ -0,0 +1,32 @@
+require 'cadence/concerns/executable'
+
+module Cadence
+  class ExecutionOptions
+    attr_reader :name, :domain, :task_list, :retry_policy, :timeouts, :headers
+
+    def initialize(object, options = {})
+      @name = options[:name] || object.to_s
+      @domain = options[:domain]
+      @task_list = options[:task_list]
+      @retry_policy = options[:retry_policy]
+      @cron_schedule = options[:cron_schedule]
+      @timeouts = options[:timeouts] || {}
+      @headers = options[:headers] || {}
+
+      if object.singleton_class.included_modules.include?(Concerns::Executable)
+        @domain ||= object.domain
+        @task_list ||= object.task_list
+        @retry_policy ||= object.retry_policy
+        @timeouts = object.timeouts.merge(@timeouts) if object.timeouts
+        @headers = object.headers.merge(@headers) if object.headers
+      end
+
+      @domain ||= Cadence.configuration.domain
+      @task_list ||= Cadence.configuration.task_list
+      @timeouts = Cadence.configuration.timeouts.merge(@timeouts)
+      @headers = Cadence.configuration.headers.merge(@headers)
+
+      freeze
+    end
+  end
+end

data/lib/cadence/json.rb

@@ -0,0 +1,18 @@
+# Helper class for serializing/deserializing JSON
+require 'oj'
+
+module Cadence
+  module JSON
+    OJ_OPTIONS = {
+      mode: :object
+    }.freeze
+
+    def self.serialize(value)
+      Oj.dump(value, OJ_OPTIONS)
+    end
+
+    def self.deserialize(value)
+      Oj.load(value.to_s, OJ_OPTIONS)
+    end
+  end
+end

data/lib/cadence/metadata.rb

@@ -0,0 +1,73 @@
+require 'cadence/errors'
+require 'cadence/metadata/activity'
+require 'cadence/metadata/decision'
+require 'cadence/metadata/workflow'
+
+module Cadence
+  module Metadata
+    ACTIVITY_TYPE = :activity
+    DECISION_TYPE = :decision
+    WORKFLOW_TYPE = :workflow
+
+    class << self
+      def generate(type, data, domain = nil)
+        case type
+        when ACTIVITY_TYPE
+          activity_metadata_from(data, domain)
+        when DECISION_TYPE
+          decision_metadata_from(data, domain)
+        when WORKFLOW_TYPE
+          workflow_metadata_from(data)
+        else
+          raise InternalError, 'Unsupported metadata type'
+        end
+      end
+
+      private
+
+      def activity_metadata_from(task, domain)
+        Metadata::Activity.new(
+          domain: domain,
+          id: task.activityId,
+          name: task.activityType.name,
+          task_token: task.taskToken,
+          attempt: task.attempt,
+          workflow_run_id: task.workflowExecution.runId,
+          workflow_id: task.workflowExecution.workflowId,
+          workflow_name: task.workflowType.name,
+          headers: task.header&.fields || {},
+          timeouts: {
+            start_to_close: task.startToCloseTimeoutSeconds,
+            schedule_to_close: task.scheduleToCloseTimeoutSeconds,
+            heartbeat: task.heartbeatTimeoutSeconds
+          }
+        )
+      end
+
+      def decision_metadata_from(task, domain)
+        Metadata::Decision.new(
+          domain: domain,
+          id: task.startedEventId,
+          task_token: task.taskToken,
+          attempt: task.attempt,
+          workflow_run_id: task.workflowExecution.runId,
+          workflow_id: task.workflowExecution.workflowId,
+          workflow_name: task.workflowType.name
+        )
+      end
+
+      def workflow_metadata_from(event)
+        Metadata::Workflow.new(
+          name: event.workflowType.name,
+          run_id: event.originalExecutionRunId,
+          attempt: event.attempt,
+          headers: event.header&.fields || {},
+          timeouts: {
+            execution: event.executionStartToCloseTimeoutSeconds,
+            task: event.taskStartToCloseTimeoutSeconds
+          }
+        )
+      end
+    end
+  end
+end

data/lib/cadence/metadata/activity.rb

@@ -0,0 +1,28 @@
+require 'cadence/metadata/base'
+
+module Cadence
+  module Metadata
+    class Activity < Base
+      attr_reader :domain, :id, :name, :task_token, :attempt, :workflow_run_id, :workflow_id, :workflow_name, :headers, :timeouts
+
+      def initialize(domain:, id:, name:, task_token:, attempt:, workflow_run_id:, workflow_id:, workflow_name:, timeouts:, headers: {})
+        @domain = domain
+        @id = id
+        @name = name
+        @task_token = task_token
+        @attempt = attempt
+        @workflow_run_id = workflow_run_id
+        @workflow_id = workflow_id
+        @workflow_name = workflow_name
+        @timeouts = timeouts
+        @headers = headers
+
+        freeze
+      end
+
+      def activity?
+        true
+      end
+    end
+  end
+end

data/lib/cadence/metadata/base.rb

@@ -0,0 +1,17 @@
+module Cadence
+  module Metadata
+    class Base
+      def activity?
+        false
+      end
+
+      def decision?
+        false
+      end
+
+      def workflow?
+        false
+      end
+    end
+  end
+end

data/lib/cadence/metadata/decision.rb

@@ -0,0 +1,25 @@
+require 'cadence/metadata/base'
+
+module Cadence
+  module Metadata
+    class Decision < Base
+      attr_reader :domain, :id, :task_token, :attempt, :workflow_run_id, :workflow_id, :workflow_name, :timeouts
+
+      def initialize(domain:, id:, task_token:, attempt:, workflow_run_id:, workflow_id:, workflow_name:)
+        @domain = domain
+        @id = id
+        @task_token = task_token
+        @attempt = attempt
+        @workflow_run_id = workflow_run_id
+        @workflow_id = workflow_id
+        @workflow_name = workflow_name
+
+        freeze
+      end
+
+      def decision?
+        true
+      end
+    end
+  end
+end

data/lib/cadence/metadata/workflow.rb

@@ -0,0 +1,23 @@
+require 'cadence/metadata/base'
+
+module Cadence
+  module Metadata
+    class Workflow < Base
+      attr_reader :name, :run_id, :attempt, :headers, :timeouts
+
+      def initialize(name:, run_id:, attempt:, timeouts:, headers: {})
+        @name = name
+        @run_id = run_id
+        @attempt = attempt
+        @headers = headers
+        @timeouts = timeouts
+
+        freeze
+      end
+
+      def workflow?
+        true
+      end
+    end
+  end
+end

data/lib/cadence/metrics.rb

@@ -0,0 +1,37 @@
+module Cadence
+  class Metrics
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    def increment(key, tags = {})
+      count(key, 1, tags)
+    end
+
+    def decrement(key, tags = {})
+      count(key, -1, tags)
+    end
+
+    def count(key, count, tags = {})
+      adapter.count(key, count, tags)
+    rescue StandardError => error
+      Cadence.logger.error("Adapter failed to send count metrics for #{key}: #{error.inspect}")
+    end
+
+    def gauge(key, value, tags = {})
+      adapter.gauge(key, value, tags)
+    rescue StandardError => error
+      Cadence.logger.error("Adapter failed to send gauge metrics for #{key}: #{error.inspect}")
+    end
+
+    def timing(key, time, tags = {})
+      adapter.timing(key, time, tags)
+    rescue StandardError => error
+      Cadence.logger.error("Adapter failed to send timing metrics for #{key}: #{error.inspect}")
+    end
+
+    private
+
+    attr_reader :adapter
+  end
+end

data/lib/cadence/metrics_adapters/log.rb

@@ -0,0 +1,33 @@
+module Cadence
+  module MetricsAdapters
+    class Log
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def count(key, count, tags)
+        logger.debug(format_message(key, 'count', count, tags))
+      end
+
+      def gauge(key, value, tags)
+        logger.debug(format_message(key, 'gauge', value, tags))
+      end
+
+      def timing(key, time, tags)
+        logger.debug(format_message(key, 'timing', time, tags))
+      end
+
+      private
+
+      attr_reader :logger
+
+      def format_message(key, type, value, tags)
+        tags_str = tags.map { |k, v| "#{k}:#{v}" }.join(',')
+        parts = [key, type, value]
+        parts << tags_str if !tags_str.empty?
+
+        parts.join(' | ')
+      end
+    end
+  end
+end