ruby_reactor 0.5.4 → 0.6.0

data/lib/ruby_reactor/sidekiq_adapter.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module RubyReactor
-  class SidekiqAdapter
-    # Identity-only payload: the worker rehydrates the live context from storage
-    # by (context_id, reactor_class_name). The caller already holds context_id, so
-    # there is no blob to deserialize here.
-    def self.perform_async(context_id, reactor_class_name = nil, intermediate_results: {})
-      job_id = SidekiqWorkers::Worker.perform_async(context_id, reactor_class_name)
-      RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: intermediate_results,
-                                   execution_id: context_id)
-    end
-
-    def self.perform_in(delay, context_id, reactor_class_name = nil, intermediate_results: {})
-      job_id = SidekiqWorkers::Worker.perform_in(delay, context_id, reactor_class_name)
-      RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: intermediate_results,
-                                   execution_id: context_id)
-    end
-
-    # rubocop:disable Metrics/ParameterLists
-    def self.perform_map_element_async(map_id:, element_id:, index:, serialized_inputs:, reactor_class_info:,
-                                       strict_ordering:, parent_context_id:, parent_reactor_class_name:, step_name:,
-                                       batch_size: nil, serialized_context: nil, fail_fast: nil)
-      job_id = RubyReactor::SidekiqWorkers::MapElementWorker.perform_async(
-        {
-          "map_id" => map_id,
-          "element_id" => element_id,
-          "index" => index,
-          "serialized_inputs" => serialized_inputs,
-          "reactor_class_info" => reactor_class_info,
-          "strict_ordering" => strict_ordering,
-          "parent_context_id" => parent_context_id,
-          "parent_reactor_class_name" => parent_reactor_class_name,
-          "step_name" => step_name,
-          "batch_size" => batch_size,
-          "serialized_context" => serialized_context,
-          "fail_fast" => fail_fast
-        }
-      )
-      RubyReactor::AsyncResult.new(job_id: job_id)
-    end
-
-    def self.perform_map_element_in(delay, map_id:, element_id:, index:, serialized_inputs:, reactor_class_info:,
-                                    strict_ordering:, parent_context_id:, parent_reactor_class_name:, step_name:,
-                                    batch_size: nil, serialized_context: nil, fail_fast: nil)
-      job_id = RubyReactor::SidekiqWorkers::MapElementWorker.perform_in(
-        delay,
-        {
-          "map_id" => map_id,
-          "element_id" => element_id,
-          "index" => index,
-          "serialized_inputs" => serialized_inputs,
-          "reactor_class_info" => reactor_class_info,
-          "strict_ordering" => strict_ordering,
-          "parent_context_id" => parent_context_id,
-          "parent_reactor_class_name" => parent_reactor_class_name,
-          "step_name" => step_name,
-          "batch_size" => batch_size,
-          "serialized_context" => serialized_context,
-          "fail_fast" => fail_fast
-        }
-      )
-      # Return an AsyncResult so RetryManager#handle_async_retry recognises the
-      # element was successfully requeued and yields a RetryQueuedResult.
-      RubyReactor::AsyncResult.new(job_id: job_id)
-    end
-    # rubocop:enable Metrics/ParameterLists
-
-    # rubocop:disable Metrics/ParameterLists
-    def self.perform_map_collection_async(parent_context_id:, map_id:, parent_reactor_class_name:, step_name:,
-                                          strict_ordering:, timeout:)
-      job_id = RubyReactor::SidekiqWorkers::MapCollectorWorker.perform_async(
-        {
-          "parent_context_id" => parent_context_id,
-          "map_id" => map_id,
-          "parent_reactor_class_name" => parent_reactor_class_name,
-          "step_name" => step_name,
-          "strict_ordering" => strict_ordering,
-          "timeout" => timeout
-        }
-      )
-      RubyReactor::AsyncResult.new(job_id: job_id)
-    end
-
-    # rubocop:enable Metrics/ParameterLists
-  end
-end

data/lib/ruby_reactor/sidekiq_workers/map_collector_worker.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module RubyReactor
-  module SidekiqWorkers
-    class MapCollectorWorker
-      include ::Sidekiq::Worker
-
-      def perform(arguments)
-        RubyReactor::Map::Collector.perform(arguments)
-      end
-    end
-  end
-end

data/lib/ruby_reactor/sidekiq_workers/map_element_worker.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module RubyReactor
-  module SidekiqWorkers
-    class MapElementWorker
-      include ::Sidekiq::Worker
-
-      def perform(arguments)
-        RubyReactor::Map::ElementExecutor.perform(arguments)
-      end
-    end
-  end
-end

data/lib/ruby_reactor/sidekiq_workers/sweeper_worker.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require "sidekiq"
-require "securerandom"
-
-module RubyReactor
-  module SidekiqWorkers
-    # Self-rescheduling recovery tick. Each run sweeps both the top-level reactor
-    # sweeper and the map sweeper, then schedules the next tick — a perpetual
-    # chain the host kicks once via `RubyReactor.start_sweeper!`.
-    #
-    # super_fetch safety. Sidekiq Enterprise `super_fetch` reliably re-runs a job
-    # whose worker died mid-execution. For a self-rescheduling chain that is a
-    # hazard: a tick can crash AFTER enqueuing its successor but BEFORE acking, so
-    # super_fetch recovers the crashed tick *alongside* the successor it already
-    # scheduled — the chain forks and then doubles every interval. We therefore do
-    # NOT rely on "exactly one job exists". The next tick is claimed by a
-    # per-time-window lock: every duplicate computes the SAME target window and
-    # only one wins the claim, so recovered/duplicated ticks collapse back to a
-    # single chain. The claim lock is never released — it simply expires — so no
-    # delete can race two duplicates into both winning.
-    class SweeperWorker
-      include ::Sidekiq::Worker
-
-      # retry: false — the sweep is idempotent and self-rescheduling, so a failed
-      # tick must not pile up Sidekiq retries; the next tick (or a super_fetch
-      # recovery) re-runs it anyway.
-      sidekiq_options retry: false, queue: RubyReactor.configuration.sidekiq_queue
-
-      def perform
-        config = RubyReactor.configuration
-        return unless config.sweeper_enabled
-
-        run_sweeps(config)
-      ensure
-        # Always chain forward (unless disabled), even after an error above, so a
-        # single bad sweep can't kill recovery. The window lock keeps this from
-        # forking under super_fetch.
-        self.class.schedule_next if RubyReactor.configuration.sweeper_enabled
-      end
-
-      def run_sweeps(config)
-        RubyReactor::Sweeper.run_once(limit: config.sweeper_limit)
-        RubyReactor::Map::Sweeper.run_once(limit: config.sweeper_limit)
-      rescue StandardError => e
-        config.logger.error("RubyReactor::SweeperWorker sweep failed: #{e.class}: #{e.message}")
-      end
-
-      # Enqueue the next tick for the upcoming time window, claiming that window
-      # so concurrent/duplicate/recovered ticks produce exactly one successor.
-      # Idempotent: also safe to call from `start_sweeper!` on every process boot.
-      def self.schedule_next
-        interval = RubyReactor.configuration.sweeper_interval
-        window = (Time.now.to_i / interval) + 1
-
-        lock = RubyReactor::Lock.new(
-          "sweeper:window:#{window}",
-          owner: SecureRandom.uuid,
-          ttl: interval * 2, # outlive the window; expires on its own (never released)
-          wait: 0,
-          auto_extend: false
-        )
-        lock.acquire # raises AcquisitionError if this window is already claimed
-
-        delay = (window * interval) - Time.now.to_i
-        perform_in([delay, 1].max)
-      rescue RubyReactor::Lock::AcquisitionError
-        # Another tick already scheduled this window — collapse the duplicate.
-        nil
-      end
-    end
-  end
-end

data/lib/ruby_reactor/sidekiq_workers/worker.rb

@@ -1,222 +0,0 @@
-# frozen_string_literal: true
-
-require "sidekiq"
-
-module RubyReactor
-  module SidekiqWorkers
-    # Sidekiq worker for executing RubyReactor reactors asynchronously
-    # with non-blocking retry capabilities
-    class Worker
-      include ::Sidekiq::Worker
-
-      # Enable Sidekiq retries for infrastructure failures only
-      sidekiq_options retry: RubyReactor.configuration.sidekiq_retry_count, dead: false,
-                      queue: RubyReactor.configuration.sidekiq_queue
-
-      sidekiq_retries_exhausted do |_, exception|
-        # Handle infrastructure failures (network, Redis, etc.)
-      end
-
-      # Identity-only payload: storage is the source of truth. Rehydrate the live
-      # context from storage by id, then resume. A nil read means the context was
-      # swept, expired, or already terminal-and-collected — nothing to resume.
-      def perform(context_id, reactor_class_name = nil, snooze_count = 0)
-        # Normalize so a nil/omitted name resolves to the same storage key the
-        # enqueue path wrote (always via reactor_storage_name). Without this a
-        # nil here builds "reactor::context:<id>" and misses the stored
-        # "reactor:AnonymousReactor:context:<id>", silently no-op'ing.
-        reactor_class_name ||= RubyReactor.reactor_storage_name(nil)
-        data = RubyReactor.configuration.storage_adapter.retrieve_context(context_id, reactor_class_name)
-        return if data.nil?
-
-        begin
-          context = ContextSerializer.deserialize_hash(data)
-        rescue RubyReactor::Error::DeserializationError,
-               RubyReactor::Error::SchemaVersionError => e
-          # Permanent failures — re-reading the same stored blob will keep
-          # failing. Mark the context as failed (best-effort) and return so
-          # Sidekiq does not burn its retry budget.
-          handle_deserialization_failure(context_id, reactor_class_name, e)
-          return
-        end
-
-        # If reactor_class_name is provided, use it to get the reactor class
-        # This handles cases where the class can't be found via const_get
-        if reactor_class_name && context.reactor_class.nil?
-          begin
-            context.reactor_class = Object.const_get(reactor_class_name)
-          rescue NameError
-            # If not found, try to find it in the current namespace
-            # This is a fallback for test environments
-            context.reactor_class = reactor_class_name.constantize if reactor_class_name.respond_to?(:constantize)
-          end
-        end
-
-        # Mark that we're executing inline to prevent nested async calls
-        context.inline_async_execution = true
-
-        begin
-          # Resume execution from the failed step
-          executor = Executor.new(context.reactor_class, {}, context)
-          executor.resume_execution
-          # No explicit save here: resume_execution's ensure block already persists
-          # the final root state (`save_context unless skip_context_persist?`), and
-          # in the worker the executor's context IS the root, so an extra checkpoint!
-          # would just re-write the identical blob to the identical key. The
-          # skip_context_persist? guard (stale-batch redelivery of an already-terminal
-          # context) is likewise honored there.
-
-          # Return the executor (which now has the result stored in it)
-          executor
-        rescue RubyReactor::Lock::AcquisitionError,
-               RubyReactor::Semaphore::AcquisitionError,
-               RubyReactor::RateLimit::ExceededError,
-               RubyReactor::OrderedLock::WaitError => e
-          # Snooze on expected concurrency, rate, or ordering contention.
-          # OrderedLock::WaitError carries a poison-pill-derived retry hint,
-          # consumed by compute_snooze_delay below. We avoid Sidekiq's native
-          # retry path so this doesn't burn the job's retry budget or appear
-          # as an error in dashboards. After the configured cap is reached we
-          # escalate by marking the reactor as failed.
-          handle_snooze(context_id, reactor_class_name, context, snooze_count, e)
-        rescue RubyReactor::RateLimitRegistry::UnknownLimitError => e
-          # Permanent configuration error — snoozing or retrying the same job
-          # will keep failing. Mark the context failed immediately.
-          escalate_snooze(context, snooze_count, e)
-        end
-      end
-
-      private
-
-      def handle_snooze(context_id, reactor_class_name, context, snooze_count, error)
-        config = RubyReactor.configuration
-        max = config.lock_snooze_max_attempts
-
-        # OrderedLock::WaitError bypasses the snooze cap. The gate's
-        # poison_pill_timeout is the only meaningful upper bound on how long a
-        # nonce can legitimately wait; capping snoozes would either fail jobs
-        # prematurely or strand the nonce in `assigned_at` until poison_pill
-        # eventually advances past it. Snooze until the gate passes (or poison
-        # auto-advance moves the cursor past us).
-        # The per-context liveness lock (`async:<id>`) is also uncapped: a
-        # duplicate of the *same* execution may wait arbitrarily long for the
-        # live original to finish (e.g. a sweeper re-enqueue racing a slow but
-        # alive worker). Capping it would fail a legitimately-waiting duplicate.
-        capped = !(error.is_a?(RubyReactor::OrderedLock::WaitError) ||
-                   error.is_a?(RubyReactor::Lock::ContextLockContention))
-
-        if capped && max != :infinity && snooze_count >= max
-          escalate_snooze(context, snooze_count, error)
-          return
-        end
-
-        delay = compute_snooze_delay(config, error)
-        # Re-enqueue by id: the context is already persisted in storage, so the
-        # rescheduled job rehydrates fresh state (no stale blob).
-        self.class.perform_in(delay, context_id, reactor_class_name, snooze_count + 1)
-      end
-
-      # Use the error's `retry_after_seconds` hint when available
-      # (RateLimit::ExceededError carries the time until the bucket rolls);
-      # otherwise fall back to the configured base + jitter for lock/semaphore
-      # contention which has no precise hint.
-      #
-      # OrderedLock::WaitError is deliberately excluded from the hint path: its
-      # `retry_after_seconds` is the poison-pill window (the upper bound before
-      # a *dead* blocker is force-advanced), NOT how long the *live* blocker
-      # will take — which is usually milliseconds. Snoozing for the full window
-      # would make every out-of-order nonce sleep up to poison_pill_timeout even
-      # though its blocker finishes immediately, collapsing throughput. Re-poll
-      # at the base delay instead; poison auto-advance still clears a genuinely
-      # dead blocker on a later gate.
-      def compute_snooze_delay(config, error)
-        jitter = config.lock_snooze_jitter.to_f
-        jitter_amount = jitter.positive? ? rand(0.0..jitter) : 0.0
-
-        if hinted_retry?(error)
-          [error.retry_after_seconds.to_f, 0.1].max + jitter_amount
-        else
-          config.lock_snooze_base_delay.to_f + jitter_amount
-        end
-      end
-
-      def hinted_retry?(error)
-        return false if error.is_a?(RubyReactor::OrderedLock::WaitError)
-
-        error.respond_to?(:retry_after_seconds) && error.retry_after_seconds
-      end
-
-      def escalate_snooze(context, snooze_count, error)
-        RubyReactor.configuration.logger.warn(
-          "RubyReactor snooze limit reached after #{snooze_count} attempts " \
-          "for context #{context.context_id}: #{error.message}"
-        )
-
-        context.status = :failed
-        context.failure_reason = {
-          message: error.message,
-          exception_class: error.class.name,
-          snooze_attempts: snooze_count
-        }
-
-        serialized = ContextSerializer.serialize(context)
-        reactor_class_name = RubyReactor.reactor_storage_name(context.reactor_class)
-        RubyReactor.configuration.storage_adapter.store_context(
-          context.context_id,
-          serialized,
-          reactor_class_name
-        )
-
-        # Escalation is a terminal Failure that never reaches the Executor's
-        # ensure path, so advance the ordered-lock cursor here. Without this
-        # the nonce stays stranded in assigned_at (successors stall for the
-        # full poison_pill_timeout) and, worse, the strict-mode chain marker
-        # is never recorded — successors would RUN instead of being skipped.
-        info = Executor::OrderedLockSupport.info_from(context)
-        Executor::OrderedLockSupport.advance_with_retry(info, failed: true) if info
-      end
-
-      def log_infrastructure_failure(msg, exception)
-        RubyReactor.configuration.logger.error("RubyReactor infrastructure failure: #{exception.message}")
-        RubyReactor.configuration.logger.error("Job details: #{msg.inspect}")
-      end
-
-      # The id-only payload already carries context_id and reactor_class_name, so
-      # there is no blob to parse for metadata — just mark the stored context
-      # failed (best-effort) so the job stops retrying a permanently-broken blob.
-      def handle_deserialization_failure(context_id, reactor_class_name, error)
-        RubyReactor.configuration.logger.error(
-          "RubyReactor deserialization failure for context " \
-          "#{context_id || "unknown"}: #{error.class.name}: #{error.message}"
-        )
-
-        return unless context_id && reactor_class_name
-
-        payload = build_failed_context_payload(context_id, reactor_class_name, error)
-        RubyReactor.configuration.storage_adapter.store_context(
-          context_id,
-          payload,
-          reactor_class_name
-        )
-      rescue StandardError => e
-        # Don't let a persistence failure mask the original deserialization error.
-        RubyReactor.configuration.logger.error(
-          "RubyReactor failed to persist deserialization failure: #{e.class.name}: #{e.message}"
-        )
-      end
-
-      def build_failed_context_payload(context_id, reactor_class_name, error)
-        JSON.generate(
-          "schema_version" => ContextSerializer::SCHEMA_VERSION,
-          "context_id" => context_id,
-          "reactor_class" => reactor_class_name,
-          "status" => "failed",
-          "failure_reason" => {
-            "message" => error.message,
-            "exception_class" => error.class.name
-          }
-        )
-      end
-    end
-  end
-end