ruby_reactor 0.4.1 → 0.5.1

data/lib/ruby_reactor/executor/compensation_manager.rb

@@ -51,61 +51,89 @@ module RubyReactor
 
       private
 
+      def middlewares
+        @context.middlewares || RubyReactor::MiddlewareRunner.new([])
+      end
+
       def compensate_step(step_config, error, arguments)
-        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
+        middlewares.on(:start_compensation, step_config.name, error, arguments, @context)
+        begin
+          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
 
-        @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
+          # 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 }
+
+          if compensate_result.is_a?(RubyReactor::Failure)
+            middlewares.on(:failed_compensation, step_config.name, compensate_result, @context)
+          else
+            middlewares.on(:complete_compensation, step_config.name, compensate_result, @context)
+          end
+
+          compensate_result
+        rescue StandardError => e
+          middlewares.on(:failed_compensation, step_config.name, e, @context)
+          raise e
+        end
       end
 
       def undo_step(step_config, result, arguments)
-        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
+        middlewares.on(:start_undo, step_config.name, result, arguments, @context)
+        begin
+          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
-                          undo_result
+                          RubyReactor.Success()
                         end
 
-        @context.execution_trace << { type: :undo, step: step_config.name, timestamp: Time.now, result: logged_result,
-                                      arguments: arguments }
-        undo_result
-      rescue StandardError => e
-        # Log undo failure but don't halt the rollback process
-        @context.execution_trace << { type: :undo_failure, step: step_config.name, timestamp: Time.now,
-                                      error: e.message }
-        RubyReactor.Failure(e)
+          # 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 undo_result.is_a?(RubyReactor::Failure)
+            middlewares.on(:failed_undo, step_config.name, undo_result, @context)
+          else
+            middlewares.on(:complete_undo, step_config.name, undo_result, @context)
+          end
+
+          undo_result
+        rescue StandardError => e
+          middlewares.on(:failed_undo, step_config.name, e, @context)
+          # Log undo failure but don't halt the rollback process
+          @context.execution_trace << { type: :undo_failure, step: step_config.name, timestamp: Time.now,
+                                        error: e.message }
+          RubyReactor.Failure(e)
+        end
       end
     end
   end

data/lib/ruby_reactor/executor/result_handler.rb

@@ -33,8 +33,11 @@ module RubyReactor
         when Error::StepFailureError
           handle_step_failure_error(error)
         when Error::InputValidationError
-          # Preserve validation errors as-is for proper error handling
-          RubyReactor.Failure(error, validation_errors: error.field_errors)
+          # Unified validation failure shape (inputs, step args, step output).
+          # Roll back any completed steps so saga semantics hold for mid-reactor
+          # validation failures (a no-op for input validation at reactor start).
+          @compensation_manager.rollback_completed_steps
+          build_validation_failure(error)
         when Error::Base
           # Other errors need rollback
           @compensation_manager.rollback_completed_steps
@@ -56,6 +59,25 @@ module RubyReactor
 
       private
 
+      # Failure for a validation error (reactor inputs, step arguments, or
+      # step output), carrying both the structured field errors and the step/
+      # reactor attribution stamped at the raise site (nil step_name for
+      # reactor-level input failures).
+      def build_validation_failure(error)
+        redact_inputs = []
+        redact_inputs = @context.reactor_class.inputs.select { |_, c| c[:redact] }.keys if @context.reactor_class
+
+        RubyReactor.Failure(
+          error,
+          validation_errors: error.field_errors,
+          step_name: error.step_name,
+          step_arguments: error.step_arguments || {},
+          inputs: @context.inputs,
+          redact_inputs: redact_inputs,
+          reactor_name: @context.reactor_class&.name
+        )
+      end
+
       # A step returned `RubyReactor.Skipped(...)`. Halt cleanly: record the
       # event in the trace, do NOT push to the undo stack (so existing
       # completed steps stay as-is — no compensation), and stamp the step
@@ -180,12 +202,17 @@ module RubyReactor
         output_validation_result = step_config.output_validator.call(value)
         return if output_validation_result.success?
 
-        raise Error::StepFailureError.new(
-          "Step '#{step_config.name}' output validation failed: #{output_validation_result.error.message}",
-          step: step_config.name,
-          context: @context,
-          step_arguments: resolved_arguments
-        )
+        error = output_validation_result.error
+        error.step_name = step_config.name
+        error.step_arguments = resolved_arguments
+
+        # The step DID run — its side effect exists even though its output is
+        # invalid. Treat it like a step failure: run the step's own
+        # compensation and roll back prior steps, so the side effect is not
+        # orphaned. Then surface the structured validation error (the later
+        # rollback in handle_execution_error is a no-op — stack already clear).
+        @compensation_manager.handle_step_failure(step_config, error, resolved_arguments)
+        raise error
       end
 
       def extract_location(backtrace)

data/lib/ruby_reactor/executor/retry_manager.rb

@@ -3,8 +3,9 @@
 module RubyReactor
   class Executor
     class RetryManager
-      def initialize(context)
+      def initialize(context, middlewares = nil)
         @context = context
+        @middlewares = middlewares || context.middlewares || Executor.middlewares_for(context.reactor_class)
       end
 
       def execute_with_retry(step_config, reactor_class)
@@ -47,11 +48,10 @@ module RubyReactor
                                  @context.root_context || @context
                                end
 
-        puts "SERIALIZING CONTEXT: #{context_to_serialize.reactor_class.name}"
-        puts "INPUTS KEYS: #{context_to_serialize.inputs.keys}" if context_to_serialize.respond_to?(:inputs)
-
         reactor_class_name = context_to_serialize.reactor_class.name
 
+        @middlewares.on(:before_async_enqueue, context_to_serialize)
+
         serialized_context = ContextSerializer.serialize(context_to_serialize)
 
         if @context.map_metadata
@@ -68,7 +68,8 @@ module RubyReactor
             parent_reactor_class_name: map_args[:parent_reactor_class_name],
             step_name: map_args[:step_name],
             batch_size: map_args[:batch_size],
-            serialized_context: serialized_context
+            serialized_context: serialized_context,
+            fail_fast: map_args[:fail_fast]
           )
         else
           configuration.async_router.perform_in(delay, serialized_context, reactor_class_name)
@@ -111,6 +112,15 @@ module RubyReactor
       end
 
       def handle_retryable_failure(step_config, reactor_class, result)
+        attempt_number = @context.retry_context.attempts_for_step(step_config.name)
+        @middlewares.on(
+          :retry_attempt,
+          step_config.name,
+          attempt_number,
+          result.error,
+          @context
+        )
+
         # Check if we should requeue (async retry)
         is_async = reactor_class.async? || step_config.async? ||
                    @context.root_context&.reactor_class&.async? ||

data/lib/ruby_reactor/executor/step_executor.rb

@@ -10,6 +10,7 @@ module RubyReactor
         @retry_manager = managers[:retry_manager]
         @result_handler = managers[:result_handler]
         @compensation_manager = managers[:compensation_manager]
+        @middlewares = managers[:middlewares] || context.middlewares || Executor.middlewares_for(reactor_class)
       end
 
       def execute_all_steps
@@ -61,12 +62,28 @@ module RubyReactor
           return RubyReactor.Success(@context.get_result(step_config.name))
         end
 
-        if step_config.interrupt?
-          handle_interrupt_step(step_config)
-        elsif step_config.async? && !@context.inline_async_execution
-          handle_async_step(step_config)
-        else
-          execute_step_with_retry(step_config)
+        resolved_arguments = resolve_arguments(step_config)
+
+        @middlewares.on(:start_step, step_config.name, resolved_arguments, @context)
+        completed = false
+        begin
+          result = if step_config.interrupt?
+                     handle_interrupt_step(step_config)
+                   elsif step_config.async? && !@context.inline_async_execution
+                     handle_async_step(step_config)
+                   else
+                     execute_step_with_retry(step_config, resolved_arguments)
+                   end
+          completed = true
+          if result.is_a?(RubyReactor::Failure)
+            @middlewares.on(:failed_step, step_config.name, result, @context)
+          else
+            @middlewares.on(:complete_step, step_config.name, result, @context)
+          end
+          result
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          @middlewares.on(:failed_step, step_config.name, e, @context) unless completed
+          raise
         end
       end
 
@@ -95,24 +112,26 @@ module RubyReactor
         )
       end
 
-      def execute_step_with_retry(step_config)
+      def execute_step_with_retry(step_config, resolved_arguments = nil)
+        resolved_arguments ||= resolve_arguments(step_config)
         result = @retry_manager.execute_with_retry(step_config, @reactor_class) do
-          safe_execute_step_sync(step_config)
+          safe_execute_step_sync(step_config, resolved_arguments)
         end
 
         unless result.is_a?(RetryQueuedResult) || result.is_a?(RubyReactor::AsyncResult)
-          resolved_arguments = resolve_arguments(step_config)
           @result_handler.handle_step_result(step_config, result, resolved_arguments)
         end
 
         result
       end
 
-      def safe_execute_step_sync(step_config)
-        resolved_arguments = {}
-        execute_step_sync_without_result_handling(step_config) do |args|
-          resolved_arguments = args
-        end
+      def safe_execute_step_sync(step_config, resolved_arguments = nil)
+        resolved_arguments ||= resolve_arguments(step_config)
+        execute_step_sync_without_result_handling(step_config, resolved_arguments)
+      rescue Error::InputValidationError
+        # Validation failures are not retryable and must surface as a structured
+        # InputValidationError (with field_errors), so let them propagate.
+        raise
       rescue StandardError => e
         # Identify redacted inputs
         redact_inputs = @reactor_class.inputs.select { |_, config| config[:redact] }.keys
@@ -127,7 +146,7 @@ module RubyReactor
         )
       end
 
-      def execute_step_sync(step_config)
+      def execute_step_sync(step_config, resolved_arguments = nil)
         @context.with_step(step_config.name) do
           # Check conditions and guards
           unless step_config.should_run?(@context)
@@ -136,7 +155,7 @@ module RubyReactor
           end
 
           # Resolve arguments
-          resolved_arguments = resolve_arguments(step_config)
+          resolved_arguments ||= resolve_arguments(step_config)
 
           # Validate arguments if validator is defined
           validate_step_arguments(step_config, resolved_arguments)
@@ -150,7 +169,7 @@ module RubyReactor
       end
 
       # Execute step without handling the result (used during retries)
-      def execute_step_sync_without_result_handling(step_config)
+      def execute_step_sync_without_result_handling(step_config, resolved_arguments = nil)
         @context.with_step(step_config.name) do
           # Check conditions and guards
           unless step_config.should_run?(@context)
@@ -159,7 +178,7 @@ module RubyReactor
           end
 
           # Resolve arguments
-          resolved_arguments = resolve_arguments(step_config)
+          resolved_arguments ||= resolve_arguments(step_config)
 
           yield resolved_arguments if block_given?
 
@@ -181,6 +200,9 @@ module RubyReactor
         context_to_serialize = @context.root_context || @context
         reactor_class_name = context_to_serialize.reactor_class.name
 
+        # Inject OTel context before serialization
+        @middlewares.on(:before_async_enqueue, context_to_serialize)
+
         serialized_context = ContextSerializer.serialize(context_to_serialize)
 
         configuration.async_router.perform_async(
@@ -222,11 +244,12 @@ module RubyReactor
         validation_result = step_config.args_validator.call(resolved_arguments)
         return if validation_result.success?
 
-        raise Error::StepFailureError.new(
-          "Step '#{step_config.name}' argument validation failed: #{validation_result.error.message}",
-          step: step_config.name,
-          context: @context
-        )
+        # Stamp step attribution so the resulting Failure can say WHERE the
+        # validation failed, not just what was invalid.
+        error = validation_result.error
+        error.step_name = step_config.name
+        error.step_arguments = resolved_arguments
+        raise error
       end
 
       def resolve_arguments(step_config)