ruby_reactor 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7769f6488ce48db7f07cd9a7bb9774f697cadc6433293ca926a9e1c27b28ce3e
-  data.tar.gz: 9dd0d5edd43c8b7629474ca2c12dd8f1c755d43f7fab3bc33aaefb86a183ba7c
+  metadata.gz: 729d8c7da4954534a2775a360d79fc96326d76b5ca69c7361ca0433e4bd6571e
+  data.tar.gz: e9e545d2ea937135f19c7c04697993125fdfc38d57fc71d6a7b0aede9bf5efa9
 SHA512:
-  metadata.gz: afbabcc37d4dbba1a6fcb83fb15b88160979802b7cd5d69fd0aed47538080c4abd3196b40a7f7464047f94c2aafa6d5317e825446179e9129a960c0e5d119742
-  data.tar.gz: caef3d4d35e37a0c9bc35b273ad20f8a0dc31810e35cf2ea1b50df57d347762c85d2a42aa6b3125401e324725d0e8f17f9d1acfecb5f8f3bafeeaf9a7308a5d2
+  metadata.gz: 23aac29ebf4c4e018fc3ab4bffbc46d79fa68ea74d783034fb984094cb7d97e791fc194c767ab59fb4992be267c171f6cbcc1897fb6160df4bedeb88faa3f080
+  data.tar.gz: edffc8600293e035e1d318a4f4b7f7240ec67aa06704e941465e06c6eadda16e1939c36e2a826bd0b92183728360cb3babab4b26b877548559f61a64f2977c4a

data/.release-please-config.json

@@ -1,5 +1,8 @@
 {
   "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
+  "include-component-in-tag": false,
+  "include-v-in-tag": true,
+  "always-update": true,
   "packages": {
     ".": {
       "release-type": "ruby",

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.4.0"
+  ".": "0.4.1"
 }

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.4.1](https://github.com/arturictus/ruby_reactor/compare/v0.4.0...v0.4.1) (2026-05-25)
+
+
+### Bug Fixes
+
+* trigger release pipeline ([#29](https://github.com/arturictus/ruby_reactor/issues/29)) ([862478b](https://github.com/arturictus/ruby_reactor/commit/862478b3d0811b00e920119057bf4c1bfb1808af))
+* trigger release workflows ([#31](https://github.com/arturictus/ruby_reactor/issues/31)) ([ed44dcd](https://github.com/arturictus/ruby_reactor/commit/ed44dcd00e3288e2fab99f9794821943dacc1d4b))
+
 ## [0.4.0](https://github.com/arturictus/ruby_reactor/compare/ruby_reactor-v0.3.2...ruby_reactor/v0.4.0) (2026-05-17)
 
 

data/lib/ruby_reactor/context.rb

@@ -5,7 +5,7 @@ module RubyReactor
     attr_accessor :inputs, :intermediate_results, :private_data, :current_step, :retry_count, :concurrency_key,
                   :retry_context, :reactor_class, :execution_trace, :inline_async_execution, :undo_stack,
                   :parent_context, :root_context, :composed_contexts, :context_id, :map_operations, :map_metadata,
-                  :cancelled, :cancellation_reason, :parent_context_id, :status, :failure_reason
+                  :cancelled, :cancellation_reason, :parent_context_id, :retried_from_id, :status, :failure_reason
 
     def initialize(inputs = {}, reactor_class = nil)
       @context_id = SecureRandom.uuid
@@ -29,6 +29,7 @@ module RubyReactor
       @failure_reason = nil
       @parent_context = nil
       @parent_context_id = nil
+      @retried_from_id = nil
       @root_context = nil
     end
 
@@ -119,7 +120,8 @@ module RubyReactor
         cancellation_reason: @cancellation_reason,
         status: @status,
         failure_reason: ContextSerializer.serialize_value(@failure_reason),
-        parent_context_id: @parent_context&.context_id || @parent_context_id
+        parent_context_id: @parent_context&.context_id || @parent_context_id,
+        retried_from_id: @retried_from_id
       }
     end
 
@@ -144,6 +146,7 @@ module RubyReactor
       context.status = data["status"] || "pending"
       context.failure_reason = ContextSerializer.deserialize_value(data["failure_reason"])
       context.parent_context_id = data["parent_context_id"]
+      context.retried_from_id = data["retried_from_id"]
 
       context
     end

data/lib/ruby_reactor/context_serializer.rb

@@ -181,19 +181,63 @@ module RubyReactor
       def simplify_for_api(value)
         case value
         when Hash
-          value.each_with_object({}) do |(k, v), hash|
+          simplified = value.each_with_object({}) do |(k, v), hash|
             hash[k.to_s] = simplify_for_api(v)
           end
+          enrich_failure_for_api(simplified)
         when Array
           value.map { |v| simplify_for_api(v) }
         when Success, Failure, Context
-          simplify_for_api(value.to_h)
+          enrich_failure_for_api(simplify_for_api(value.to_h))
         when Symbol
           value.to_s
         else
           value
         end
       end
+
+      def enrich_failure_for_api(hash)
+        return hash unless hash.is_a?(Hash)
+        return hash unless failure_payload?(hash)
+
+        hash = flatten_typed_failure(hash) if hash["_type"] == "Failure"
+
+        if hash["code_snippet"].is_a?(Array) && !hash["code_snippet"].empty?
+          return hash
+        end
+
+        file_path, line_number = resolve_failure_location(hash)
+        return hash unless file_path && line_number
+
+        snippet = RubyReactor::Utils::CodeExtractor.extract(file_path, line_number)
+        return hash unless snippet
+
+        normalized_snippet = snippet.map { |line| line.transform_keys(&:to_s) }
+
+        hash.merge(
+          "file_path" => file_path,
+          "line_number" => line_number,
+          "code_snippet" => normalized_snippet
+        )
+      end
+
+      def failure_payload?(hash)
+        hash["_type"] == "Failure" || (hash.key?("step_name") && hash["backtrace"].is_a?(Array))
+      end
+
+      def flatten_typed_failure(hash)
+        flattened = hash.dup
+        flattened.delete("_type")
+        flattened.merge("message" => hash["error"] || hash["message"])
+      end
+
+      def resolve_failure_location(hash)
+        file_path = hash["file_path"]
+        line_number = hash["line_number"]
+        return [file_path, line_number] if file_path && line_number
+
+        RubyReactor::Utils::BacktraceLocation.extract(hash["backtrace"])
+      end
       # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
       private

data/lib/ruby_reactor/dsl/reactor.rb

@@ -152,12 +152,21 @@ module RubyReactor
         # Entry point for running the reactor
         def run(inputs = {})
           reactor = new
-          reactor.run(inputs)
+          result = reactor.run(inputs)
+          attach_execution_id!(result, reactor.context.context_id)
         end
 
         def call(inputs = {})
           run(inputs)
         end
+
+        def attach_execution_id!(result, execution_id)
+          return result if result.respond_to?(:execution_id) && result.execution_id
+
+          result.define_singleton_method(:execution_id) { execution_id }
+          result
+        end
+        private :attach_execution_id!
       end
     end
   end

data/lib/ruby_reactor/executor/result_handler.rb

@@ -189,18 +189,7 @@ module RubyReactor
       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]
+        RubyReactor::Utils::BacktraceLocation.extract(backtrace)
       end
     end
   end

data/lib/ruby_reactor/executor.rb

@@ -75,7 +75,7 @@ module RubyReactor
       @result
     ensure
       release_locks
-      save_context
+      save_context if persist_context?
     end
 
     def resume_execution
@@ -134,6 +134,12 @@ module RubyReactor
       storage.store_context(@context.context_id, serialized_context, reactor_class_name)
     end
 
+    def persist_context?
+      @context.status.to_s != "pending" ||
+        @context.execution_trace.any? ||
+        @context.intermediate_results.any?
+    end
+
     private
 
     def acquire_locks

data/lib/ruby_reactor/reactor.rb

@@ -10,10 +10,17 @@ module RubyReactor
 
     def self.find(id)
       reactor_class_name = name
-      serialized_context = configuration.storage_adapter.retrieve_context(id, reactor_class_name)
-      raise Error::ValidationError, "Context '#{id}' not found" unless serialized_context
-
-      context = Context.deserialize_from_retry(serialized_context)
+      raw_data = configuration.storage_adapter.retrieve_context(id, reactor_class_name)
+      raise Error::ValidationError, "Context '#{id}' not found" unless raw_data
+
+      context = case raw_data
+                when String
+                  ContextSerializer.deserialize(raw_data)
+                when Hash
+                  Context.deserialize_from_retry(raw_data)
+                else
+                  raise Error::ValidationError, "Invalid context format for '#{id}'"
+                end
       new(context)
     end
 

data/lib/ruby_reactor/storage/redis_adapter.rb

@@ -196,13 +196,20 @@ module RubyReactor
       end
 
       def determine_status(data)
-        return data["status"] if data["status"] && %w[failed paused completed running].include?(data["status"])
+        status = data["status"].to_s
+        return status if status && %w[failed paused completed running skipped pending].include?(status)
         return "cancelled" if data["cancelled"]
         # Heuristic
         return "failed" if data["retry_count"]&.positive? && !data["current_step"].nil?
-        return "completed" unless data["current_step"]
+        return "running" if data["current_step"]
+        return "completed" if execution_evidence?(data)
 
-        "running"
+        "pending"
+      end
+
+      def execution_evidence?(data)
+        (data["execution_trace"] || []).any? ||
+          (data["intermediate_results"] || {}).any?
       end
 
       def store_map_element_context_id(map_id, context_id, reactor_class_name)

data/lib/ruby_reactor/storage/redis_locking.rb

@@ -245,6 +245,23 @@ module RubyReactor
       def period_marker?(key_base, every, now: Time.now.utc)
         @redis.exists?(RubyReactor::Period.key(key_base, every, now: now))
       end
+
+      # TTL in seconds for a held lock (-2 if key does not exist).
+      def lock_ttl(prefixed_key)
+        @redis.ttl(prefixed_key)
+      end
+
+      # TTL in seconds for the current rate-limit bucket (-2 if unset).
+      def rate_limit_ttl(key_base, every, now: Time.now.to_i)
+        period_seconds = RubyReactor::Period.period_seconds(every)
+        bucket = now / period_seconds
+        @redis.ttl("rate:#{key_base}:#{every}:#{bucket}")
+      end
+
+      # TTL in seconds for a period marker (-2 if unset).
+      def period_ttl(key_base, every, now: Time.now.utc)
+        @redis.ttl(RubyReactor::Period.key(key_base, every, now: now))
+      end
     end
     # rubocop:enable Naming/PredicateMethod
   end

data/lib/ruby_reactor/utils/backtrace_location.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Utils
+    class BacktraceLocation
+      # Ruby 3.x backtraces use single-quoted method names; older formats use backticks.
+      LINE_PATTERN = /^(.+?):(\d+)(?::in .*)?$/
+
+      def self.parse(line)
+        match = line.match(LINE_PATTERN)
+        return nil unless match
+
+        [match[1], match[2].to_i]
+      end
+
+      def self.internal_path?(file_path)
+        file_path.start_with?(RubyReactor.internal_lib_path)
+      end
+
+      def self.extract(backtrace)
+        return [nil, nil] unless backtrace.is_a?(Array) && backtrace.any?
+
+        skip_internal = ENV["RUBY_REACTOR_DEBUG"] != "true"
+
+        backtrace.each do |line|
+          file_path, line_number = parse(line)
+          next unless file_path
+          next if skip_internal && internal_path?(file_path)
+
+          return [file_path, line_number]
+        end
+
+        parse(backtrace.first) || [nil, nil]
+      end
+    end
+  end
+end

data/lib/ruby_reactor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyReactor
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/lib/ruby_reactor/web/api.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "roda"
+require_relative "coordination_serializer"
 
 module RubyReactor
   module Web
@@ -35,16 +36,12 @@ module RubyReactor
 
               structure = self.class.build_structure(reactor_class) if reactor_class.respond_to?(:steps)
 
+              api_status = self.class.reactor_status(data)
+
               response_data = {
                 id: data[:context_id],
                 class: data[:reactor_class].to_s,
-                status: if %w[failed paused completed running].include?(data[:status].to_s)
-                          data[:status].to_s
-                        elsif data[:cancelled]
-                          "cancelled"
-                        else
-                          (data[:current_step] ? "running" : "completed")
-                        end,
+                status: api_status,
                 current_step: data[:current_step].to_s,
                 retry_count: data[:retry_count] || 0,
                 undo_stack: data[:undo_stack] || [],
@@ -58,6 +55,11 @@ module RubyReactor
                   data[:composed_contexts] || {},
                   data[:reactor_class]&.to_s
                 ),
+                coordination: CoordinationSerializer.build(
+                  reactor_class,
+                  inputs: data[:inputs],
+                  context_id: data[:context_id]
+                ),
                 error: data[:failure_reason]
               }
 
@@ -66,7 +68,43 @@ module RubyReactor
 
             # POST /api/reactors/:id/retry
             r.post "retry" do
-              { success: true, message: "Retry scheduled" }
+              data = RubyReactor::Configuration.instance.storage_adapter.find_context_by_id(reactor_id)
+              unless data
+                response.status = 404
+                next { error: "Reactor not found" }
+              end
+
+              deserialized = ContextSerializer.deserialize_value(data)
+              unless self.class.reactor_status(deserialized) == "failed"
+                response.status = 422
+                next { error: "Reactor can only be retried when failed" }
+              end
+
+              reactor_class_name = deserialized[:reactor_class].to_s
+              reactor_class = Context.resolve_reactor_class(reactor_class_name)
+              unless reactor_class
+                response.status = 422
+                next { error: "Reactor class '#{reactor_class_name}' not found" }
+              end
+
+              begin
+                inputs = self.class.extract_retry_inputs(deserialized)
+                result = reactor_class.run(inputs)
+                new_id = result.execution_id
+
+                new_reactor = reactor_class.find(new_id)
+                new_reactor.context.retried_from_id = reactor_id
+                new_reactor.context.retry_count = (deserialized[:retry_count] || 0) + 1
+                new_reactor.send(:save_context)
+
+                { success: true, id: new_id }
+              rescue RubyReactor::Error::ValidationError => e
+                response.status = 422
+                { error: e.message }
+              rescue StandardError => e
+                response.status = 500
+                { error: e.message }
+              end
             end
 
             # POST /api/reactors/:id/cancel
@@ -107,6 +145,28 @@ module RubyReactor
         end
       end
 
+      def self.reactor_status(data)
+        status = data[:status].to_s
+        return status if %w[failed paused completed running skipped pending].include?(status)
+        return "cancelled" if data[:cancelled]
+        return "running" if data[:current_step]
+        return "completed" if execution_evidence?(data)
+
+        "pending"
+      end
+
+      def self.execution_evidence?(data)
+        (data[:execution_trace] || []).any? ||
+          (data[:intermediate_results] || {}).any?
+      end
+
+      def self.extract_retry_inputs(data)
+        inputs = data[:inputs] || {}
+        return {} unless inputs.is_a?(Hash)
+
+        inputs.transform_keys(&:to_sym)
+      end
+
       def self.build_structure(reactor_class)
         return {} unless reactor_class.respond_to?(:steps)
 

data/lib/ruby_reactor/web/coordination_serializer.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Web
+    class CoordinationSerializer
+      class << self
+        def build(reactor_class, inputs:, context_id:)
+          return {} unless reactor_class
+
+          adapter = RubyReactor.configuration.storage_adapter
+          normalized_inputs = normalize_inputs(inputs)
+          result = {}
+
+          if reactor_class.lock_config
+            result[:lock] = build_lock(reactor_class.lock_config, normalized_inputs, context_id, adapter)
+          end
+
+          if reactor_class.semaphore_config
+            result[:semaphore] = build_semaphore(reactor_class.semaphore_config, normalized_inputs, adapter)
+          end
+
+          if reactor_class.rate_limit_config
+            result[:rate_limit] = build_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
+
+          result
+        end
+
+        private
+
+        def normalize_inputs(inputs)
+          return {} unless inputs.is_a?(Hash)
+
+          inputs.transform_keys(&:to_sym)
+        end
+
+        def resolve_key(key_proc, inputs)
+          key_proc.call(inputs).to_s
+        end
+
+        def build_lock(config, inputs, context_id, adapter)
+          key = resolve_key(config[:key_proc], inputs)
+          prefixed = "lock:#{key}"
+          info = adapter.lock_info(prefixed)
+          ttl = adapter.lock_ttl(prefixed)
+
+          {
+            configured: {
+              ttl: config[:ttl],
+              wait: config[:wait],
+              auto_extend: config.fetch(:auto_extend, true)
+            },
+            key: key,
+            state: lock_state(info, context_id, ttl)
+          }
+        rescue StandardError => e
+          lock_error_payload(config, e)
+        end
+
+        def lock_state(info, context_id, ttl)
+          if info
+            {
+              held: true,
+              owner: info[:owner],
+              owned_by_this_context: info[:owner] == context_id,
+              reentrant_count: info[:count],
+              ttl: ttl
+            }
+          else
+            { held: false, ttl: ttl }
+          end
+        end
+
+        def lock_error_payload(config, error)
+          {
+            configured: {
+              ttl: config[:ttl],
+              wait: config[:wait],
+              auto_extend: config.fetch(:auto_extend, true)
+            },
+            key: nil,
+            key_error: error.message
+          }
+        end
+
+        def build_semaphore(config, inputs, adapter)
+          key = resolve_key(config[:key_proc], inputs)
+          state = adapter.semaphore_state(key)
+
+          {
+            configured: {
+              limit: config[:limit],
+              wait: config[:wait]
+            },
+            key: key,
+            state: state
+          }
+        rescue StandardError => e
+          {
+            configured: { limit: config[:limit], wait: config[:wait] },
+            key: nil,
+            key_error: e.message
+          }
+        end
+
+        def build_rate_limit(config, inputs, adapter)
+          key = resolve_key(config[:key_proc], inputs)
+          now = Time.now.to_i
+          windows = config[:limits].map do |window|
+            every = window[:name].to_sym
+            {
+              name: window[:name],
+              limit: window[:limit],
+              period_seconds: window[:period_seconds],
+              count: adapter.rate_limit_count(key, every, now: now),
+              ttl: adapter.rate_limit_ttl(key, every, now: now)
+            }
+          end
+
+          {
+            configured: {
+              limits: config[:limits].map do |window|
+                {
+                  name: window[:name],
+                  limit: window[:limit],
+                  period_seconds: window[:period_seconds]
+                }
+              end
+            },
+            key: key,
+            state: windows
+          }
+        rescue StandardError => e
+          {
+            configured: {
+              limits: config[:limits]&.map do |window|
+                {
+                  name: window[:name],
+                  limit: window[:limit],
+                  period_seconds: window[:period_seconds]
+                }
+              end
+            },
+            key: nil,
+            key_error: e.message
+          }
+        end
+
+        def build_period(config, inputs, adapter)
+          key = resolve_key(config[:key_proc], inputs)
+          every = config[:every]
+          bucket_key = RubyReactor::Period.key(key, every)
+          marked = adapter.period_marker?(key, every)
+          ttl = adapter.period_ttl(key, every)
+
+          {
+            configured: { every: every.to_s },
+            key: key,
+            bucket_key: bucket_key,
+            state: {
+              marked: marked,
+              ttl: ttl
+            }
+          }
+        rescue StandardError => e
+          {
+            configured: { every: config[:every].to_s },
+            key: nil,
+            bucket_key: nil,
+            key_error: e.message
+          }
+        end
+      end
+    end
+  end
+end