ruby_reactor 0.8.2 → 0.8.4

data/lib/ruby_reactor/web/api.rb

@@ -47,6 +47,9 @@ module RubyReactor
               structure = self.class.build_structure(reactor_class) if reactor_class.respond_to?(:steps)
 
               api_status = self.class.reactor_status(data)
+              class_name = data[:reactor_class]&.to_s
+              runs = self.class.async_step_runs(data[:composed_contexts], class_name)
+              trace = self.class.with_async_step_runs(data[:execution_trace] || [], runs)
 
               response_data = {
                 id: data[:context_id],
@@ -55,7 +58,9 @@ module RubyReactor
                 current_step: data[:current_step].to_s,
                 retry_count: data[:retry_count] || 0,
                 undo_stack: data[:undo_stack] || [],
-                step_attempts: data.dig(:retry_context, :step_attempts) || {},
+                step_attempts: self.class.with_async_step_attempts(
+                  data.dig(:retry_context, :step_attempts) || {}, runs
+                ),
                 created_at: data[:started_at],
                 inputs: data[:inputs],
                 intermediate_results: self.class.with_map_summaries(
@@ -65,15 +70,14 @@ module RubyReactor
                 # Once per reactor, never per step: the old per-step `async`
                 # field is gone because there is now exactly one hand-off point.
                 background_handoff: self.class.background_handoff_for(reactor_class),
-                steps: data[:execution_trace] || [],
-                composed_contexts: self.class.hydrate_composed_contexts(
-                  data[:composed_contexts] || {},
-                  data[:reactor_class]&.to_s
-                ),
+                steps: trace,
+                composed_contexts: self.class.hydrate_composed_contexts(data[:composed_contexts] || {}, class_name),
                 coordination: CoordinationSerializer.build(
                   reactor_class,
                   inputs: data[:inputs],
-                  context_id: data[:context_id]
+                  context_id: data[:context_id],
+                  execution_trace: trace,
+                  private_data: data[:private_data] || {}
                 ),
                 error: data[:failure_reason]
               }
@@ -294,11 +298,72 @@ module RubyReactor
           when "map_ref" then hydrate_map_ref(value, reactor_class_name)
           when "async_step_ref" then hydrate_async_step_ref(value, reactor_class_name)
           when "async_reactor_ref" then hydrate_async_reactor_ref(value)
+          when "composed" then hydrate_composed_child(value)
           else value
           end
         end
       end
 
+      # An inline `compose` child is embedded in the parent's blob, so its own
+      # `async_step` links are rebuilt the same way, one level down.
+      def self.hydrate_composed_child(value)
+        child = value[:context] || value["context"]
+        return value unless child.is_a?(RubyReactor::Context)
+
+        class_name = RubyReactor.reactor_storage_name(child.reactor_class)
+        runs = async_step_runs(child.composed_contexts, class_name)
+        view = child.to_h.merge(
+          execution_trace: with_async_step_runs(child.execution_trace, runs),
+          composed_contexts: hydrate_composed_contexts(child.composed_contexts, class_name)
+        )
+        value.merge(context: view)
+      end
+
+      # Single writer: an `async_step` unit never writes its parent, which
+      # holds only the `:async_step_ref` written at dispatch. The unit's run —
+      # arguments, attempts, when it started — is on its Step Result Record.
+      # `{ step_name => record }` for every linked unit that has started.
+      def self.async_step_runs(composed_contexts, reactor_class_name)
+        return {} unless composed_contexts.is_a?(Hash)
+
+        composed_contexts.each_with_object({}) do |(name, ref), runs|
+          next unless (ref[:type] || ref["type"]).to_s == "async_step_ref"
+
+          record = async_step_record(ref, reactor_class_name)
+          runs[name] = record if record&.key?("started_at")
+        end
+      end
+
+      def self.async_step_record(ref_data, reactor_class_name)
+        context_id = ref_data[:context_id] || ref_data["context_id"]
+        name = ref_data[:name] || ref_data["name"]
+        return nil unless context_id && name
+
+        RubyReactor.configuration.storage_adapter.retrieve_step_result(context_id, name, reactor_class_name)
+      end
+
+      # The parent's own trace, with each started unit's `:run` entry placed by
+      # its start time — the entry a same-process step writes for itself. A
+      # unit that already has one (a context saved before units stopped
+      # writing their parent) is left as it is.
+      def self.with_async_step_runs(trace, runs)
+        runs.each_with_object(trace.dup) do |(name, record), merged|
+          next if merged.any? { |e| (e[:type] || e["type"]).to_s == "run" && (e[:step] || e["step"]).to_s == name.to_s }
+
+          started = Time.iso8601(record["started_at"])
+          entry = { type: :run, step: name, timestamp: started, background: true,
+                    arguments: ContextSerializer.deserialize_value(record["arguments"]) }
+          later = merged.index { |e| e[:timestamp].is_a?(Time) && e[:timestamp] > started }
+          merged.insert(later || merged.size, entry)
+        end
+      end
+
+      def self.with_async_step_attempts(step_attempts, runs)
+        runs.each_with_object(step_attempts.dup) do |(name, record), merged|
+          merged[name] = record["attempts"] if record["attempts"]
+        end
+      end
+
       # The reference lives on the parent's context; the outcome lives in the
       # Step Result Record. Resolve it so the dashboard can show whether the
       # unit is still dispatched or has landed, mirroring hydrate_map_ref.

data/lib/ruby_reactor/web/coordination_serializer.rb

@@ -4,7 +4,7 @@ module RubyReactor
   module Web
     class CoordinationSerializer
       class << self
-        def build(reactor_class, inputs:, context_id:)
+        def build(reactor_class, inputs:, context_id:, execution_trace: [], private_data: {})
           return {} unless reactor_class
 
           adapter = RubyReactor.configuration.storage_adapter
@@ -20,18 +20,122 @@ module RubyReactor
           end
 
           if reactor_class.rate_limit_config
-            result[:rate_limit] = build_rate_limit(reactor_class.rate_limit_config, normalized_inputs, adapter)
+            result[:rate_limit] = build_rate_limit(resolve_rate_limit(reactor_class.rate_limit_config),
+                                                   normalized_inputs, adapter)
           end
 
           if reactor_class.period_config
             result[:period] = build_period(reactor_class.period_config, normalized_inputs, adapter)
           end
 
+          if reactor_class.respond_to?(:steps)
+            steps = build_steps(reactor_class, normalized_inputs, context_id, execution_trace, adapter)
+            result[:steps] = steps unless steps.empty?
+          end
+
+          waiting = private_data[:step_contention] || private_data["step_contention"] ||
+                    async_step_waiting(reactor_class, context_id, adapter)
+          result[:waiting] = normalize_waiting(waiting) if waiting
+
           result
         end
 
         private
 
+        # US7/FR-029: one row per coordinating step PER PRIMITIVE it declares,
+        # keyed to the step's OWN resolved arguments (from its latest `:run`
+        # trace entry), not the reactor's inputs. A step declaring both
+        # `with_lock` and `with_semaphore` is two rows — both gates are active,
+        # so an operator has to be able to see both. A step not yet reached is
+        # reported "pending" rather than omitted, so the list is stable.
+        def build_steps(reactor_class, inputs, context_id, execution_trace, adapter)
+          reactor_class.steps.flat_map do |name, step_config|
+            next [] unless step_config.respond_to?(:declares_coordination?) && step_config.declares_coordination?
+
+            build_step_entries(name, step_config, inputs, context_id, execution_trace, adapter)
+          end
+        end
+
+        def build_step_entries(name, step_config, inputs, context_id, execution_trace, adapter) # rubocop:disable Metrics/ParameterLists
+          entry = latest_run_entry(execution_trace, name)
+          declarations = step_config.coordination_declarations
+          return [{ step: name.to_s, state: "pending" }] if declarations.empty?
+
+          # One PENDING row per declared primitive too, matching the reached
+          # shape below — a step declaring both a lock and a semaphore has two
+          # gates to wait on, and collapsing them to a single primitive-less
+          # row hides which.
+          if entry.nil?
+            return declarations.keys.map do |primitive|
+              { step: name.to_s, primitive: primitive.to_s, state: "pending" }
+            end
+          end
+
+          # The trace records the RESOLVED arguments; the execution keyed off
+          # `coordination_arguments` of them, so the same function is applied
+          # here. A redacted value was never recorded, so a key computed from it
+          # would name a different Redis key than the one held — report it as
+          # unavailable instead of probing the wrong one.
+          traced = entry[:arguments] || entry["arguments"] || {}
+          if traced.is_a?(Hash) && traced.value?(RubyReactor::Step::InputContract::REDACTED)
+            return declarations.keys.map do |primitive|
+              { step: name.to_s, primitive: primitive.to_s, key: nil,
+                key_error: "key unavailable: the step's arguments are redacted" }
+            end
+          end
+          args = step_config.coordination_arguments(traced.transform_keys(&:to_sym), inputs)
+
+          declarations.map do |primitive, config|
+            built = build_step_primitive(primitive, config, args, context_id, adapter)
+            { step: name.to_s, primitive: primitive.to_s }.merge(built)
+          end
+        end
+
+        def build_step_primitive(primitive, config, args, context_id, adapter)
+          case primitive
+          when :lock then build_lock(config, args, context_id, adapter)
+          when :semaphore then build_semaphore(config, args, adapter)
+          when :rate_limit then build_rate_limit(resolve_rate_limit(config), args, adapter)
+          when :period then build_period(config, args, adapter)
+          else { key: resolve_key(config[:key_proc], args) }
+          end
+        rescue StandardError => e
+          { key: nil, key_error: e.message }
+        end
+
+        def latest_run_entry(execution_trace, step_name)
+          Array(execution_trace).reverse_each.find do |e|
+            type = e[:type] || e["type"]
+            step = e[:step] || e["step"]
+            type.to_s == "run" && step.to_s == step_name.to_s
+          end
+        end
+
+        # A parked `async_step` keeps its "waiting on" marker on its own Step
+        # Result Record, never on the parent's context (005 R-09).
+        def async_step_waiting(reactor_class, context_id, adapter)
+          return nil unless context_id && reactor_class.respond_to?(:steps)
+
+          namespace = RubyReactor.reactor_storage_name(reactor_class)
+          reactor_class.steps.each do |name, step_config|
+            next unless step_config.respond_to?(:async_dispatch) && step_config.async_dispatch == :step
+
+            record = adapter.retrieve_step_result(context_id, name, namespace)
+            return record["waiting"] if record.is_a?(Hash) && record["waiting"]
+          end
+          nil
+        end
+
+        def normalize_waiting(waiting)
+          {
+            step: (waiting[:step] || waiting["step"]).to_s,
+            key: waiting[:key] || waiting["key"],
+            primitive: (waiting[:primitive] || waiting["primitive"]).to_s,
+            attempts: waiting[:attempts] || waiting["attempts"],
+            next_attempt_at: waiting[:next_attempt_at] || waiting["next_attempt_at"]
+          }
+        end
+
         def normalize_inputs(inputs)
           return {} unless inputs.is_a?(Hash)
 
@@ -134,6 +238,20 @@ module RubyReactor
           }
         end
 
+        # `with_rate_limit(:name)` stores only the name; the renderer needs the
+        # registered windows and the name-as-key the limiter actually uses
+        # (mirrors `StepCoordination#rate_limit_key_and_limits`).
+        def resolve_rate_limit(config)
+          return config unless config[:name]
+
+          name = config[:name]
+          { limits: RubyReactor.configuration.rate_limits.fetch(name), key_proc: ->(_args) { name.to_s } }
+        rescue StandardError => e
+          # An unregistered name is a config mistake, not a reason for the
+          # dashboard to 500 — surface it as this row's key_error.
+          { limits: [], key_proc: ->(_args) { raise e } }
+        end
+
         def map_limits(limits)
           Array(limits).map do |window|
             {