ruby_reactor 0.1.0 → 0.2.0

data/lib/ruby_reactor/async_router.rb

@@ -4,12 +4,16 @@ module RubyReactor
   class AsyncRouter
     def self.perform_async(serialized_context, reactor_class_name = nil, intermediate_results: {})
       job_id = SidekiqWorkers::Worker.perform_async(serialized_context, reactor_class_name)
-      RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: intermediate_results)
+      context = ContextSerializer.deserialize(serialized_context)
+      RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: intermediate_results,
+                                   execution_id: context.context_id)
     end
 
     def self.perform_in(delay, serialized_context, reactor_class_name = nil, intermediate_results: {})
       job_id = SidekiqWorkers::Worker.perform_in(delay, serialized_context, reactor_class_name)
-      RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: intermediate_results)
+      context = ContextSerializer.deserialize(serialized_context)
+      RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: intermediate_results,
+                                   execution_id: context.context_id)
     end
 
     # rubocop:disable Metrics/ParameterLists

data/lib/ruby_reactor/context.rb

@@ -4,7 +4,8 @@ module RubyReactor
   class Context
     attr_accessor :inputs, :intermediate_results, :private_data, :current_step, :retry_count, :concurrency_key,
                   :retry_context, :reactor_class, :execution_trace, :inline_async_execution, :undo_stack, :test_mode,
-                  :parent_context, :root_context, :composed_contexts, :context_id, :map_operations, :map_metadata
+                  :parent_context, :root_context, :composed_contexts, :context_id, :map_operations, :map_metadata,
+                  :cancelled, :cancellation_reason, :parent_context_id, :status, :failure_reason
 
     def initialize(inputs = {}, reactor_class = nil)
       @context_id = SecureRandom.uuid
@@ -23,7 +24,12 @@ module RubyReactor
       @inline_async_execution = false # Flag to prevent nested async calls
       @undo_stack = [] # Initialize the undo stack
       @test_mode = false
+      @cancelled = false
+      @cancellation_reason = nil
+      @status = "pending"
+      @failure_reason = nil
       @parent_context = nil
+      @parent_context_id = nil
       @root_context = nil
     end
 
@@ -37,6 +43,7 @@ module RubyReactor
         value
       end
     end
+    alias input get_input
 
     def get_result(step_name, path = nil)
       value = @intermediate_results[step_name.to_sym] || @intermediate_results[step_name.to_s]
@@ -48,6 +55,7 @@ module RubyReactor
         value
       end
     end
+    alias result get_result
 
     def set_result(step_name, value)
       @intermediate_results[step_name.to_sym] = value
@@ -73,7 +81,9 @@ module RubyReactor
         retry_context: @retry_context,
         reactor_class: @reactor_class,
         execution_trace: @execution_trace,
-        test_mode: @test_mode
+        test_mode: @test_mode,
+        status: @status,
+        failure_reason: @failure_reason
       }
     end
 
@@ -95,14 +105,19 @@ module RubyReactor
         retry_context: @retry_context.serialize_for_retry,
         execution_trace: ContextSerializer.serialize_value(@execution_trace),
         undo_stack: serialize_undo_stack,
-        test_mode: @test_mode
+        test_mode: @test_mode,
+        cancelled: @cancelled,
+        cancellation_reason: @cancellation_reason,
+        status: @status,
+        failure_reason: ContextSerializer.serialize_value(@failure_reason),
+        parent_context_id: @parent_context&.context_id || @parent_context_id
       }
     end
 
     def self.deserialize_from_retry(data)
       context = new
       context.context_id = data["context_id"] if data["context_id"]
-      context.reactor_class = data["reactor_class"] ? Object.const_get(data["reactor_class"]) : nil
+      context.reactor_class = resolve_reactor_class(data["reactor_class"])
       context.inputs = ContextSerializer.deserialize_value(data["inputs"]) || {}
       context.intermediate_results = ContextSerializer.deserialize_value(data["intermediate_results"]) || {}
       context.private_data = ContextSerializer.deserialize_value(data["private_data"]) || {}
@@ -116,15 +131,26 @@ module RubyReactor
       context.execution_trace = ContextSerializer.deserialize_value(data["execution_trace"]) || []
       context.undo_stack = deserialize_undo_stack(data["undo_stack"] || [], context.reactor_class)
       context.test_mode = data["test_mode"] || false
-
-      # Reconstruct parent/root relationships if nested contexts exist in private_data
-      # This is tricky because private_data is just a hash.
-      # We rely on the fact that nested contexts are stored in private_data by ComposeStep
-      # But here we just deserialize the values.
+      context.cancelled = data["cancelled"] || false
+      context.cancellation_reason = data["cancellation_reason"]
+      context.status = data["status"] || "pending"
+      context.failure_reason = ContextSerializer.deserialize_value(data["failure_reason"])
+      context.parent_context_id = data["parent_context_id"]
 
       context
     end
 
+    def self.resolve_reactor_class(name)
+      return nil unless name
+
+      begin
+        Object.const_get(name)
+      rescue NameError
+        # Try finding in registry for anonymous classes
+        RubyReactor::Registry.find(name)
+      end
+    end
+
     private
 
     def extract_path(value, path)

data/lib/ruby_reactor/dependency_graph.rb

@@ -2,6 +2,8 @@
 
 module RubyReactor
   class DependencyGraph
+    attr_reader :dependencies, :completed
+
     def initialize
       @nodes = {}
       @edges = {}

data/lib/ruby_reactor/dsl/compose_builder.rb

@@ -10,6 +10,14 @@ module RubyReactor
       def initialize(name, composed_reactor_class = nil, reactor = nil, &block)
         @name = name
         @composed_reactor_class = composed_reactor_class || (block ? Class.new(RubyReactor::Reactor) : nil)
+        if @composed_reactor_class && @composed_reactor_class.name.nil? && reactor
+          step_name_camel = name.to_s.split("_").map(&:capitalize).join
+          parent_name = reactor.name
+
+          full_name = "#{parent_name}::#{step_name_camel}"
+          @composed_reactor_class.define_singleton_method(:name) { full_name }
+          RubyReactor::Registry.register(full_name, @composed_reactor_class)
+        end
         @reactor = reactor
         @argument_mappings = {}
         @async = false

data/lib/ruby_reactor/dsl/interrupt_builder.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Dsl
+    class InterruptBuilder < StepBuilder
+      def initialize(name, reactor = nil)
+        super(name, nil, reactor)
+        @correlation_id_block = nil
+        @timeout_config = nil
+        @validation_schema = nil
+        @max_attempts = 1
+      end
+
+      def max_attempts(count)
+        @max_attempts = count
+      end
+
+      def correlation_id(&block)
+        @correlation_id_block = block
+      end
+
+      def timeout(seconds, strategy: :lazy)
+        @timeout_config = { duration: seconds, strategy: strategy }
+      end
+
+      def validate(&block)
+        check_dry_validation_available!
+        @validation_schema = build_validation_schema(&block)
+      end
+
+      def build
+        step_config = {
+          name: @name,
+          correlation_id_block: @correlation_id_block,
+          timeout_config: @timeout_config,
+          validation_schema: @validation_schema,
+          max_attempts: @max_attempts,
+          dependencies: @dependencies,
+          async: false, # Interrupts are effectively boundaries, not async jobs themselves (until resumed)
+          conditions: @conditions,
+          guards: @guards
+        }
+
+        RubyReactor::Dsl::InterruptStepConfig.new(step_config)
+      end
+    end
+  end
+end

data/lib/ruby_reactor/dsl/interrupt_step_config.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Dsl
+    class InterruptStepConfig < StepConfig
+      attr_reader :correlation_id_block, :timeout_config, :validation_schema, :strategy, :max_attempts
+
+      def initialize(config)
+        super
+        @correlation_id_block = config[:correlation_id_block]
+        @timeout_config = config[:timeout_config]
+        @validation_schema = config[:validation_schema]
+        @max_attempts = config[:max_attempts] || 1
+      end
+
+      def interrupt?
+        true
+      end
+    end
+  end
+end

data/lib/ruby_reactor/dsl/map_builder.rb

@@ -10,6 +10,14 @@ module RubyReactor
       def initialize(name, mapped_reactor_class = nil, reactor = nil, &block)
         @name = name
         @mapped_reactor_class = mapped_reactor_class || (block ? Class.new(RubyReactor::Reactor) : nil)
+        if @mapped_reactor_class && @mapped_reactor_class.name.nil? && reactor
+          map_name_camel = name.to_s.split("_").map(&:capitalize).join
+          parent_name = reactor.name # Assuming reactor has a name method or is a class with a name.
+
+          full_name = "#{parent_name}::#{map_name_camel}"
+          @mapped_reactor_class.define_singleton_method(:name) { full_name }
+          RubyReactor::Registry.register(full_name, @mapped_reactor_class)
+        end
         @reactor = reactor
         @argument_mappings = {}
         @async = false

data/lib/ruby_reactor/dsl/reactor.rb

@@ -18,6 +18,9 @@ module RubyReactor
         include RubyReactor::Dsl::TemplateHelpers
         include RubyReactor::Dsl::ValidationHelpers
 
+        require_relative "interrupt_builder"
+        require_relative "interrupt_step_config"
+
         def inputs
           @inputs ||= {}
         end
@@ -106,6 +109,15 @@ module RubyReactor
           step_config
         end
 
+        def interrupt(name, &block)
+          builder = RubyReactor::Dsl::InterruptBuilder.new(name, self)
+          builder.instance_eval(&block) if block_given?
+
+          step_config = builder.build
+          steps[name] = step_config
+          step_config
+        end
+
         def returns(step_name)
           @return_step = step_name
         end

data/lib/ruby_reactor/dsl/step_builder.rb

@@ -172,6 +172,10 @@ module RubyReactor
         @conditions.all? { |condition| condition.call(context) } &&
           @guards.all? { |guard| guard.call(context) }
       end
+
+      def interrupt?
+        false
+      end
     end
   end
 end

data/lib/ruby_reactor/executor/compensation_manager.rb

@@ -5,14 +5,17 @@ module RubyReactor
     class CompensationManager
       def initialize(context)
         @context = context
-        @undo_stack = []
         @undo_trace = []
       end
 
-      attr_reader :undo_stack, :undo_trace
+      def undo_stack
+        @context.undo_stack
+      end
+
+      attr_reader :undo_trace
 
       def add_to_undo_stack(step_info)
-        @undo_stack << step_info
+        @context.undo_stack << step_info
       end
 
       def handle_step_failure(step_config, error, arguments)
@@ -36,43 +39,73 @@ module RubyReactor
       end
 
       def rollback_completed_steps
-        @undo_stack.reverse_each do |step_info|
-          result = undo_step(step_info[:step], step_info[:result], step_info[:arguments])
+        undo_stack.reverse_each do |step_info|
+          result = @context.with_step(step_info[:step].name) do
+            undo_step(step_info[:step], step_info[:result], step_info[:arguments])
+          end
           @undo_trace << { type: :undo, step: step_info[:step].name, result: result,
                            arguments: step_info[:arguments] }
         end
-        @undo_stack.clear
+        undo_stack.clear
       end
 
       private
 
       def compensate_step(step_config, error, arguments)
-        if step_config.compensate_block
-          @context.execution_trace << { type: :compensate, step: step_config.name, timestamp: Time.now, error: error,
-                                        arguments: arguments }
-          @undo_trace << { type: :compensation, step: step_config.name, error: error, arguments: arguments }
-          step_config.compensate_block.call(error, arguments, @context)
-        elsif step_config.has_impl?
-          @context.execution_trace << { type: :compensate, step: step_config.name, timestamp: Time.now, error: error,
-                                        arguments: arguments }
-          @undo_trace << { type: :compensation, step: step_config.name, error: error, arguments: arguments }
-          step_config.impl.compensate(error, arguments, @context)
-        else
-          RubyReactor.Success() # Default compensation
-        end
+        compensate_result = if step_config.compensate_block
+                              step_config.compensate_block.call(error, arguments, @context)
+                            elsif step_config.has_impl?
+                              step_config.impl.compensate(error, arguments, @context)
+                            else
+                              RubyReactor.Success() # Default compensation
+                            end
+
+        # Ensure we have a value to log
+        logged_result = if compensate_result.respond_to?(:value)
+                          compensate_result.value
+                        elsif compensate_result.respond_to?(:error)
+                          compensate_result.error
+                        else
+                          compensate_result
+                        end
+
+        @context.execution_trace << {
+          type: :compensate,
+          step: step_config.name,
+          timestamp: Time.now,
+          result: logged_result,
+          arguments: arguments
+        }
+        @undo_trace << { type: :compensation, step: step_config.name, error: error, arguments: arguments }
+        compensate_result
       end
 
       def undo_step(step_config, result, arguments)
-        @context.execution_trace << { type: :undo, step: step_config.name, timestamp: Time.now, result: result.value,
+        undo_result = if step_config.undo_block
+                        step_config.undo_block.call(result.value, arguments, @context)
+                      elsif step_config.has_impl?
+                        step_config.impl.undo(result.value, arguments, @context)
+                      else
+                        RubyReactor.Success()
+                      end
+
+        # Ensure we have a value to log (if it's a Success/Failure object, get the value or error)
+        logged_result = if undo_result.respond_to?(:value)
+                          undo_result.value
+                        elsif undo_result.respond_to?(:error)
+                          undo_result.error
+                        else
+                          undo_result
+                        end
+
+        @context.execution_trace << { type: :undo, step: step_config.name, timestamp: Time.now, result: logged_result,
                                       arguments: arguments }
-        if step_config.undo_block
-          step_config.undo_block.call(result.value, arguments, @context)
-        elsif step_config.has_impl?
-          step_config.impl.undo(result.value, arguments, @context)
-        end
-      rescue StandardError
+        undo_result
+      rescue StandardError => e
         # Log undo failure but don't halt the rollback process
-        # In a real implementation, this would use a logger
+        @context.execution_trace << { type: :undo_failure, step: step_config.name, timestamp: Time.now,
+                                      error: e.message }
+        RubyReactor.Failure(e)
       end
     end
   end

data/lib/ruby_reactor/executor/graph_manager.rb

@@ -3,6 +3,8 @@
 module RubyReactor
   class Executor
     class GraphManager
+      attr_reader :dependency_graph
+
       def initialize(reactor_class, dependency_graph, context)
         @reactor_class = reactor_class
         @dependency_graph = dependency_graph

data/lib/ruby_reactor/executor/result_handler.rb

@@ -15,62 +15,30 @@ module RubyReactor
       def handle_step_result(step_config, result, resolved_arguments)
         case result
         when RubyReactor::Success
-          validate_step_output(step_config, result.value, resolved_arguments)
-          @step_results[step_config.name] = result
-          @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments, result: result })
-          @context.set_result(step_config.name, result.value)
-          @dependency_graph.complete_step(step_config.name)
+          handle_success(step_config, result, resolved_arguments)
         when RubyReactor::MaxRetriesExhaustedFailure
-          # For MaxRetriesExhaustedFailure, use the original error to avoid double-wrapping the message
-          # The error message from MaxRetriesExhaustedFailure already includes "failed after N attempts"
-          @compensation_manager.handle_step_failure(step_config, result.original_error, resolved_arguments)
-          # Use the MaxRetriesExhaustedFailure error message for the final error
-          raise Error::StepFailureError.new(result.error, step: step_config.name, context: @context,
-                                                          step_arguments: resolved_arguments)
+          handle_retries_exhausted(step_config, result, resolved_arguments)
         when RubyReactor::Failure
-          failure_result = @compensation_manager.handle_step_failure(step_config, result.error, resolved_arguments)
-          raise Error::StepFailureError.new(failure_result.error, step: step_config.name, context: @context,
-                                                                  step_arguments: resolved_arguments)
+          handle_failure(step_config, result, resolved_arguments)
         else
-          # Treat non-Success/Failure results as success with that value
-          validate_step_output(step_config, result, resolved_arguments)
-          success_result = RubyReactor.Success(result)
-          @step_results[step_config.name] = success_result
-          @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments,
-                                                    result: success_result })
-          @context.set_result(step_config.name, result)
-          @dependency_graph.complete_step(step_config.name)
+          handle_unknown_result(step_config, result, resolved_arguments)
         end
       end
 
       def handle_execution_error(error)
         case error
         when Error::StepFailureError
-          # Step failure has already been handled (compensation and rollback for the failed step)
-          # But we need to rollback all completed steps
-          @compensation_manager.rollback_completed_steps
-
-          redact_inputs = error.context.reactor_class.inputs.select { |_, config| config[:redact] }.keys
-
-          RubyReactor::Failure(
-            error.message,
-            step_name: error.step,
-            inputs: error.context.inputs,
-            redact_inputs: redact_inputs,
-            backtrace: error.backtrace,
-            reactor_name: error.context.reactor_class.name,
-            step_arguments: error.step_arguments
-          )
+          handle_step_failure_error(error)
         when Error::InputValidationError
           # Preserve validation errors as-is for proper error handling
           RubyReactor.Failure(error)
         when Error::Base
           # Other errors need rollback
           @compensation_manager.rollback_completed_steps
-          RubyReactor.Failure("Execution error: #{error.message}")
+          RubyReactor.Failure("Execution error: #{error.message}", exception_class: error.class.name)
         else
           # Unknown errors - don't rollback as they may not be reactor-related
-          RubyReactor.Failure("Execution failed: #{error.message}")
+          RubyReactor.Failure("Execution failed: #{error.message}", exception_class: error.class.name)
         end
       end
 
@@ -85,6 +53,101 @@ module RubyReactor
 
       private
 
+      def handle_success(step_config, result, resolved_arguments)
+        validate_step_output(step_config, result.value, resolved_arguments)
+        @step_results[step_config.name] = result
+        @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments, result: result })
+        @context.set_result(step_config.name, result.value)
+        @dependency_graph.complete_step(step_config.name)
+      end
+
+      def handle_retries_exhausted(step_config, result, resolved_arguments)
+        @compensation_manager.handle_step_failure(step_config, result.original_error, resolved_arguments)
+        orig_err = result.original_error.is_a?(Exception) ? result.original_error : nil
+        error = Error::StepFailureError.new(result.error, step: step_config.name, context: @context,
+                                                          original_error: orig_err,
+                                                          step_arguments: resolved_arguments)
+        if result.respond_to?(:backtrace) && result.backtrace
+          error.set_backtrace(result.backtrace)
+        elsif orig_err
+          error.set_backtrace(orig_err.backtrace)
+        end
+        raise error
+      end
+
+      def handle_failure(step_config, result, resolved_arguments)
+        failure_result = @compensation_manager.handle_step_failure(step_config, result.error, resolved_arguments)
+        orig_err = result.error.is_a?(Exception) ? result.error : nil
+        error = Error::StepFailureError.new(failure_result.error, step: step_config.name, context: @context,
+                                                                  original_error: orig_err,
+                                                                  step_arguments: resolved_arguments)
+        if result.respond_to?(:backtrace) && result.backtrace
+          error.set_backtrace(result.backtrace)
+        elsif orig_err
+          error.set_backtrace(orig_err.backtrace)
+        end
+        raise error
+      end
+
+      def handle_unknown_result(step_config, result, resolved_arguments)
+        validate_step_output(step_config, result, resolved_arguments)
+        success_result = RubyReactor.Success(result)
+        @step_results[step_config.name] = success_result
+        @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments,
+                                                  result: success_result })
+        @context.set_result(step_config.name, result)
+        @dependency_graph.complete_step(step_config.name)
+      end
+
+      def handle_step_failure_error(error)
+        current_context = error.context || @context
+        current_context.current_step = error.step
+
+        store_failed_map_context(current_context) if current_context.map_metadata
+
+        @compensation_manager.rollback_completed_steps
+
+        redact_inputs = []
+        if error.context&.reactor_class
+          redact_inputs = error.context.reactor_class.inputs.select { |_, config| config[:redact] }.keys
+        end
+
+        create_failure_from_error(error, redact_inputs)
+      end
+
+      def store_failed_map_context(context)
+        return unless context.map_metadata && context.map_metadata[:map_id]
+
+        storage = RubyReactor.configuration.storage_adapter
+        storage.store_map_failed_context_id(
+          context.map_metadata[:map_id],
+          context.context_id,
+          context.map_metadata[:parent_reactor_class_name]
+        )
+      end
+
+      def create_failure_from_error(error, redact_inputs)
+        original_error = error.original_error
+        exception_class = original_error&.class&.name
+        backtrace = original_error&.backtrace || error.backtrace
+        file_path, line_number = extract_location(backtrace)
+        code_snippet = RubyReactor::Utils::CodeExtractor.extract(file_path, line_number) if file_path
+
+        RubyReactor.Failure(
+          error.message,
+          step_name: error.step,
+          inputs: error.context.inputs,
+          redact_inputs: redact_inputs,
+          backtrace: backtrace,
+          reactor_name: error.context.reactor_class.name,
+          step_arguments: error.step_arguments,
+          exception_class: exception_class,
+          file_path: file_path,
+          line_number: line_number,
+          code_snippet: code_snippet
+        )
+      end
+
       def validate_step_output(step_config, value, resolved_arguments = {})
         return unless step_config.output_validator
 
@@ -98,6 +161,21 @@ module RubyReactor
           step_arguments: resolved_arguments
         )
       end
+
+      def extract_location(backtrace)
+        return [nil, nil] unless backtrace && !backtrace.empty?
+
+        # Filter out internal reactor frames if needed, or just take the first one
+        # For now, let's take the first line of the backtrace which should be the error source
+        # But we might want to skip our own internal frames if we want to point to user code
+        # Let's start with the top frame, assuming backtrace is already correct (from original error)
+
+        first_line = backtrace.first
+        match = first_line.match(/^(.+?):(\d+)(?::in `.*')?$/)
+        return [nil, nil] unless match
+
+        [match[1], match[2].to_i]
+      end
     end
   end
 end

data/lib/ruby_reactor/executor/retry_manager.rb

@@ -34,6 +34,7 @@ module RubyReactor
       end
 
       def requeue_job_for_step_retry(step_config, error, reactor_class)
+        @context.current_step = step_config.name
         delay = calculate_backoff_delay(step_config, error, reactor_class)
 
         # Serialize context and requeue the job