sidekiq-routing 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0119411113d408ffff9aa353faf8a1d9b4dfd7572edd26efb39dc97b048d204e'
+  data.tar.gz: cec0724470361bdbf22d98b9be14387acbd46c1f895ad3f0f4f27d3f77a3f477
+SHA512:
+  metadata.gz: 6f299c288a571de2e21cfb6a8ece1be70df3b30f16b6251c1eb81eacb29ab788eea272d51187f6b919fbdbef07f8f176d6291637aefc32190699c90d20b3e702
+  data.tar.gz: fa64c7f1d15224a0011e9f5a7f16747ca1699781cdb50a6d84b69281814885481fc1ebf555bb9ea59a02727f2fa1536627900ebcc94631fb30af413b1d4f0537

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BigBinary Technologies Pvt. Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,233 @@
+# sidekiq-routing
+
+Runtime, per-job-class **queue routing for Sidekiq** — park, blackhole, or
+auto-reroute a job class **without a deploy**.
+
+Background jobs often share a handful of latency-tiered queues
+(`within_5_seconds`, `within_1_minute`, …). The queue name is a contract: every
+job on a tier should start within that window. That sharing is efficient until
+one class misbehaves — a flood, a runaway argument, a broken downstream — and
+then the only built-in lever, pausing the whole queue, punishes every other
+class on the tier. `sidekiq-routing` gives you a finer lever, applied at
+runtime to a single job class:
+
+| Kind | Purpose | Driver | Target |
+|---|---|---|---|
+| **Manual routing** | Incident response for one misbehaving class. | Operator, from a console. | `park` (reversible) or `blackhole` (drop). |
+| **Auto rerouting** | Capacity management when an SLA tier is overloaded. | Background job, latency-driven, opt-in. | The next live SLA tier. Never parks or blackholes. |
+
+Both are per-job-class. To halt a *whole* queue, use Sidekiq's own pause button.
+
+The hot path is cheap: routing state lives in a single Redis hash, read from a
+process-local snapshot refreshed at most once per `cache_ttl_seconds`, so the
+per-job cost is an in-memory lookup, not a Redis round-trip.
+
+## Installation
+
+```ruby
+gem "sidekiq-routing"
+```
+
+```sh
+bundle install
+```
+
+Requires Ruby >= 3.1 and Sidekiq >= 7.0 (tested on Sidekiq 7.3.x and 8.x). The
+gem depends only on `sidekiq` — no Rails or ActiveSupport required.
+
+## Quick start
+
+Add an initializer (e.g. `config/initializers/sidekiq_routing.rb`):
+
+```ruby
+require "sidekiq-routing"
+
+Sidekiq::Routing.setup do |config|
+  # All optional — these are the defaults.
+  # config.parked_queue = "routing_parked"
+  # config.cache_ttl_seconds = 5
+end
+
+Sidekiq::Routing.install! # registers the client + server middleware
+```
+
+`install!` prepends the client middleware (so enqueues are diverted) and adds
+the server middleware (so in-flight jobs are diverted). If
+[sidekiq-unique-jobs](https://github.com/mhenrixon/sidekiq-unique-jobs) is
+present, the routing server middleware is inserted *after* it automatically.
+
+Then, from a console during an incident:
+
+```ruby
+Sidekiq::Routing.park("FlakyReportJob")     # divert to the parking queue (reversible)
+Sidekiq::Routing.blackhole("SpamWebhookJob") # drop its jobs entirely
+Sidekiq::Routing.unpark("FlakyReportJob")    # remove the route
+```
+
+## Manual routing — incident response
+
+One job class is misbehaving and you want to disable *just that class*, at
+runtime, without pausing the rest of its queue or shipping a deploy.
+
+- **Park** (reversible) — newly enqueued and in-flight jobs for the class are
+  diverted to a worker-less parking queue (`routing_parked` by default) and
+  held. The work is preserved; recover it later.
+- **Blackhole** (irreversible) — the class's jobs are dropped entirely (never
+  added to the Dead set). Only for classes you can afford to lose.
+
+```ruby
+Sidekiq::Routing.park("HardJob")
+Sidekiq::Routing.blackhole("FireAndForgetJob")
+Sidekiq::Routing.unpark("HardJob")
+
+Sidekiq::Routing.routed?("HardJob")  # => true/false
+Sidekiq::Routing.parked?("HardJob")  # => true only when in park mode
+Sidekiq::Routing.mode("HardJob")     # => "park" | "blackhole" | nil
+Sidekiq::Routing.routes              # => { "HardJob" => { "mode" => "park", ... } }
+```
+
+A route accepts a Class or a String. ActiveJob jobs are matched by their real
+("wrapped") class, not the adapter's job wrapper.
+
+### Clearing an existing backlog into the parking queue
+
+`park` only diverts jobs from the moment it's set. To move a class's jobs that
+are *already enqueued* on a live queue into the parking queue, sweep them:
+
+```ruby
+Sidekiq::Routing.sweep("HardJob", queue: "within_1_minute")
+Sidekiq::Routing.sweep("HardJob", queue: "within_1_minute", limit: 10_000)
+```
+
+A queue must be resolvable — pass `queue:` explicitly (the sweep deliberately
+never scans every queue, which would hammer Redis during an incident).
+
+### Recovering parked work
+
+```ruby
+# Move parked jobs back to their original queue (stamps them so an active
+# route won't immediately bounce them back).
+Sidekiq::Routing.process_parked
+Sidekiq::Routing.process_parked(klass: "HardJob", limit: 1_000)
+
+# Introspection
+Sidekiq::Routing.parked_size       # O(1) count of the parking queue
+Sidekiq::Routing.parked_breakdown  # { "HardJob" => { "count" => 12, "by_original_queue" => {...} } }
+```
+
+A processed parked job has its payload rewritten to target its original queue,
+so if it later fails it retries to that queue — not back to the parking queue.
+Jobs with no stamped original queue go to `process_parked_fallback_queue`
+(`"default"`).
+
+## Auto rerouting — capacity management
+
+Optionally, move *noisy-neighbor* job classes between SLA tiers automatically
+when a tier is overloaded. It is **off unless you opt in**:
+
+```sh
+export SIDEKIQ_ROUTING_AUTO_REROUTE_ENABLED=true
+```
+
+Auto rerouting only ever moves jobs to the *next* live SLA tier
+(`within_5_seconds` → `within_1_minute` → `within_5_minutes` → `within_1_hour`).
+It never parks or blackholes.
+
+Wire it up in your initializer:
+
+```ruby
+if Sidekiq::Routing::Auto.enabled?
+  # 1. Track per-class job durations (server middleware).
+  Sidekiq.configure_server do |config|
+    config.server_middleware do |chain|
+      chain.add Sidekiq::Routing::Auto::JobDurationTracker
+    end
+  end
+end
+
+Sidekiq::Routing::Auto.setup do |config|
+  # config.capacity_threshold_percent = 80
+  # config.sla_thresholds = { "within_5_seconds" => 5, "within_1_minute" => 60, ... }
+end
+```
+
+Then schedule the driver periodically (e.g. every minute) with
+[sidekiq-cron](https://github.com/sidekiq-cron/sidekiq-cron):
+
+```yaml
+# config/schedule.yml
+routing_auto_reroute:
+  cron: "* * * * *"
+  class: "Sidekiq::Routing::Auto::RerouteJob"
+```
+
+`RerouteJob` checks each SLA queue's estimated workload against its capacity and,
+for any tier over `capacity_threshold_percent`, moves the noisiest classes to
+the next tier. `RerouteJob` itself is excluded from rerouting by default.
+
+## Web tab
+
+A read-only "Routing" tab for Sidekiq Web shows active routes and parking-queue
+depth/breakdown. Every mutating action stays on the console API — the tab never
+exposes park/blackhole/unpark/sweep, so destructive operations stay deliberate.
+
+Require it only where you mount Sidekiq Web (so worker processes never load the
+web framework):
+
+```ruby
+require "sidekiq/web"
+require "sidekiq/routing/web" # registers the "Routing" tab
+mount Sidekiq::Web => "/sidekiq"
+```
+
+## Configuration reference
+
+`Sidekiq::Routing.setup { |config| ... }`:
+
+| Option | Default | Purpose |
+|---|---|---|
+| `enabled` | `true` | Master switch for the routing middleware. |
+| `parked_queue` | `"routing_parked"` | Worker-less queue parked jobs divert to. |
+| `process_parked_fallback_queue` | `"default"` | Target when a parked job has no stamped original queue. |
+| `cache_ttl_seconds` | `5` | Hot-path snapshot freshness. `0` reads Redis every call. |
+| `batch_limit` | `nil` | Default cap on jobs moved per recovery call (`nil` = all). |
+| `batch_size` | `100` | Jobs moved per pass. |
+| `breakdown_sample_size` | `1_000` | Max jobs `parked_breakdown` scans. |
+| `logger` | `Rails.logger` or `Sidekiq.logger` | — |
+
+`Sidekiq::Routing::Auto.setup { |config| ... }`:
+
+| Option | Default | Purpose |
+|---|---|---|
+| `enabled` | `SIDEKIQ_ROUTING_AUTO_REROUTE_ENABLED == "true"` | Opt-in switch. |
+| `sla_thresholds` | the four `within_*` tiers | Queue → SLA seconds. |
+| `capacity_threshold_percent` | `80` | Reroute a tier above this % capacity. |
+| `noisy_neighbor_threshold_percent` | `50` | Share of workload that marks a class noisy. |
+| `batch_reroute_limit` | `50` | Max jobs moved per reroute pass. |
+| `duration_tracking_window` | `3600` | Seconds of duration history retained. |
+| `excluded_job_classes` | `["Sidekiq::Routing::Auto::RerouteJob"]` | Never auto-rerouted. |
+
+## How it works
+
+Manual routes live in one Redis hash. The middleware reads a frozen,
+process-local snapshot of that hash, refreshed at most once per
+`cache_ttl_seconds`, so the per-job decision is an in-memory lookup. The
+operator API (`park`/`blackhole`/`unpark`) writes through and resets the
+snapshot, so console changes take effect immediately for the writer and within
+one TTL everywhere else. Parking rewrites the `queue` field *inside the job
+payload*, which is what makes recovery and retry-to-original-queue correct.
+
+## Development
+
+```sh
+bin/setup            # or: bundle install
+bundle exec rake test
+```
+
+The test suite talks to a real Redis. It uses logical DB 15 of
+`redis://localhost:6379` by default; override with `REDIS_URL` (point it at a
+disposable Redis). No Rails or database is involved.
+
+## License
+
+Released under the [MIT License](LICENSE).

data/lib/sidekiq/routing/auto/batch_rerouter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Routing::Auto
+    class BatchRerouter
+      def reroute_jobs(from_queue, to_queue, job_classes: nil)
+        limit = Routing::Auto.configuration.batch_reroute_limit
+        moved_count = 0
+        skipped = { already_rerouted: 0, wrong_class: 0, excluded: 0 }
+        queue = Sidekiq::Queue.new(from_queue)
+
+        Routing::Auto.logger.info(
+          "[Routing::Auto] reroute_jobs: from=#{from_queue}, to=#{to_queue}, " \
+          "limit=#{limit}, job_classes=#{job_classes.inspect}"
+        )
+
+        queue.each do |job|
+          break if moved_count >= limit
+
+          if job.item["auto_rerouted"]
+            skipped[:already_rerouted] += 1
+            next
+          end
+
+          if job_classes && !job_classes.include?(job.klass)
+            skipped[:wrong_class] += 1
+            next
+          end
+
+          if Routing::Auto.configuration.excluded_job_classes.include?(job.klass)
+            skipped[:excluded] += 1
+            next
+          end
+
+          moved_count += 1 if reroute_single_job(job, from_queue, to_queue)
+        end
+
+        Routing::Auto.logger.info(
+          "[Routing::Auto] reroute_jobs: moved=#{moved_count}, skipped=#{skipped.inspect}"
+        )
+        log_reroute(from_queue, to_queue, moved_count, job_classes) if moved_count.positive?
+
+        moved_count
+      end
+
+      private
+
+        def reroute_single_job(job, from_queue, to_queue)
+          new_item = job.item.merge(
+            "queue" => to_queue,
+            "auto_rerouted" => true,
+            "original_queue" => from_queue,
+            "rerouted_at" => Time.now.to_i
+          )
+
+          job.delete if Sidekiq::Client.push(new_item)
+        end
+
+        def log_reroute(from_queue, to_queue, count, job_classes)
+          message = "[Routing::Auto] Moved #{count} jobs from #{from_queue} to #{to_queue}"
+          message += " (noisy neighbors: #{job_classes.join(', ')})" if job_classes&.any?
+
+          Routing::Auto.logger.warn(message)
+        end
+    end
+  end
+end

data/lib/sidekiq/routing/auto/configuration.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Routing::Auto
+    class << self
+      def configuration
+        @_configuration ||= Configuration.new
+      end
+
+      def setup
+        yield configuration if block_given?
+      end
+
+      def enabled?
+        configuration.enabled
+      end
+
+      def logger
+        configuration.logger
+      end
+
+      def default_enabled?
+        ENV["SIDEKIQ_ROUTING_AUTO_REROUTE_ENABLED"] == "true"
+      end
+    end
+
+    class Configuration
+      attr_accessor :enabled,
+        :logger,
+        :sla_thresholds,
+        :capacity_threshold_percent,
+        :noisy_neighbor_threshold_percent,
+        :batch_reroute_limit,
+        :duration_tracking_window,
+        :excluded_job_classes
+
+      def initialize
+        # Off unless explicitly opted in via SIDEKIQ_ROUTING_AUTO_REROUTE_ENABLED.
+        # (In the Rails-engine ancestor this was wired by an initializer; the
+        # standalone gem makes it the built-in default so auto stays safe-by-default.)
+        @enabled = Sidekiq::Routing::Auto.default_enabled?
+        @logger = if defined?(::Rails) && ::Rails.respond_to?(:logger) && ::Rails.logger
+          ::Rails.logger
+        else
+          Logger.new($stdout)
+        end
+        @sla_thresholds = {
+          "within_5_seconds" => 5,
+          "within_1_minute" => 60,
+          "within_5_minutes" => 300,
+          "within_1_hour" => 3600
+        }
+        @capacity_threshold_percent = 80
+        @noisy_neighbor_threshold_percent = 50
+        @batch_reroute_limit = 50
+        @duration_tracking_window = 3600
+        # The internal reroute job must never reroute itself.
+        @excluded_job_classes = ["Sidekiq::Routing::Auto::RerouteJob"]
+      end
+    end
+  end
+end

data/lib/sidekiq/routing/auto/job_duration_tracker.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Routing::Auto
+    class JobDurationTracker
+      REDIS_KEY_PREFIX = "sidekiq:auto_reroute:durations"
+
+      def self.average_duration(job_class, queue)
+        key = redis_key(job_class, queue)
+        cutoff = Time.now.to_i - Routing::Auto.configuration.duration_tracking_window
+
+        entries = Sidekiq.redis do |redis|
+          redis.zrangebyscore(key, cutoff, "+inf")
+        end
+
+        return nil if entries.empty?
+
+        durations = entries.map { |entry| entry.split(":").last.to_f }
+        (durations.sum / durations.size).round
+      end
+
+      def self.tracked_job_classes(queue)
+        pattern = "#{REDIS_KEY_PREFIX}:*:#{queue}"
+        prefix = "#{REDIS_KEY_PREFIX}:"
+        suffix = ":#{queue}"
+
+        # Class names contain "::" so split-by-colon mangles them. Strip the
+        # known prefix/suffix instead — works for any namespaced class.
+        Sidekiq.redis do |redis|
+          redis.keys(pattern).map { |key| key.delete_prefix(prefix).delete_suffix(suffix) }
+        end
+      end
+
+      def self.redis_key(job_class, queue)
+        "#{REDIS_KEY_PREFIX}:#{job_class}:#{queue}"
+      end
+
+      # Match Sidekiq::JobRecord#klass so duration writes line up with the
+      # name NoisyNeighborDetector queries by (job.klass already unwraps
+      # ActiveJob wrappers; without this, ActiveJob jobs would record under
+      # JobWrapper and never be looked up).
+      def self.job_class_name(worker, job)
+        job["wrapped"] || worker.class.name
+      end
+
+      def call(worker, job, queue)
+        start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        yield
+      ensure
+        duration_ms = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+        begin
+          record_duration(self.class.job_class_name(worker, job), queue, duration_ms)
+        rescue StandardError => e
+          Routing::Auto.logger.warn("[JobDurationTracker] failed to record duration: #{e.message}")
+        end
+      end
+
+      def record_duration(job_class, queue, duration_ms)
+        key = redis_key(job_class, queue)
+        timestamp = Time.now.to_i
+
+        Sidekiq.redis do |redis|
+          redis.zadd(key, timestamp, "#{timestamp}:#{duration_ms}")
+          redis.expire(key, Routing::Auto.configuration.duration_tracking_window * 2)
+
+          cutoff = timestamp - Routing::Auto.configuration.duration_tracking_window
+          redis.zremrangebyscore(key, "-inf", cutoff)
+        end
+      end
+
+      private
+
+        def redis_key(job_class, queue)
+          self.class.redis_key(job_class, queue)
+        end
+    end
+  end
+end

data/lib/sidekiq/routing/auto/noisy_neighbor_detector.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Routing::Auto
+    class NoisyNeighborDetector
+      MIN_WORKLOAD_SECONDS = 10
+
+      def initialize(queue_name)
+        @queue_name = queue_name
+        @queue = Sidekiq::Queue.new(queue_name)
+        @duration_cache = {}
+      end
+
+      def identify_noisy_neighbors
+        workload = calculate_workload_by_class
+        total_workload = workload.values.sum
+        return [] if total_workload < MIN_WORKLOAD_SECONDS
+
+        threshold = Routing::Auto.configuration.noisy_neighbor_threshold_percent
+
+        workload.select do |_job_class, workload_seconds|
+          ((workload_seconds / total_workload.to_f) * 100) > threshold
+        end.keys
+      end
+
+      def calculate_workload_by_class
+        result = Hash.new(0.0)
+
+        @queue.each do |job|
+          duration_ms = get_duration_for_class(job.klass)
+          next unless duration_ms
+
+          result[job.klass] += duration_ms / 1000.0
+        end
+
+        result
+      end
+
+      def total_estimated_workload
+        calculate_workload_by_class.values.sum
+      end
+
+      private
+
+        def get_duration_for_class(job_class)
+          return @duration_cache[job_class] if @duration_cache.key?(job_class)
+
+          @duration_cache[job_class] = JobDurationTracker.average_duration(job_class, @queue_name)
+        end
+    end
+  end
+end

data/lib/sidekiq/routing/auto/reroute_job.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+module Sidekiq
+  module Routing::Auto
+    # Periodic worker that drives latency-based rerouting: for each SLA queue
+    # breaching its capacity threshold, move (noisy-neighbor) jobs to the next
+    # tier. Schedule it via sidekiq-cron in the host app's scheduled_jobs.yml.
+    #
+    # Plain Sidekiq::Job (no app base class) so the gem carries no dependency on
+    # the host's job hierarchy.
+    class RerouteJob
+      include Sidekiq::Job
+
+      sidekiq_options queue: "within_1_minute", retry: false
+
+      def perform
+        return unless Sidekiq::Routing::Auto.enabled?
+
+        Sidekiq::Routing::Auto::Router.sla_queues.each do |queue_name|
+          process_queue(queue_name)
+        end
+      end
+
+      private
+
+        def process_queue(queue_name)
+          return unless should_reroute?(queue_name)
+
+          target_queue = Sidekiq::Routing::Auto::Router.next_queue_for(queue_name)
+          return unless target_queue
+
+          detector = Sidekiq::Routing::Auto::NoisyNeighborDetector.new(queue_name)
+          noisy_neighbors = detector.identify_noisy_neighbors
+          rerouter = Sidekiq::Routing::Auto::BatchRerouter.new
+
+          if noisy_neighbors.any?
+            rerouter.reroute_jobs(queue_name, target_queue, job_classes: noisy_neighbors)
+          else
+            rerouter.reroute_jobs(queue_name, target_queue)
+          end
+        end
+
+        def should_reroute?(queue_name)
+          sla_seconds = Sidekiq::Routing::Auto.configuration.sla_thresholds[queue_name]
+          return false unless sla_seconds
+
+          detector = Sidekiq::Routing::Auto::NoisyNeighborDetector.new(queue_name)
+          estimated_workload = detector.total_estimated_workload
+          capacity = calculate_capacity(queue_name, sla_seconds)
+          capacity_used_percent = (estimated_workload / capacity.to_f) * 100
+          threshold = Sidekiq::Routing::Auto.configuration.capacity_threshold_percent
+          queue_size = Sidekiq::Queue.new(queue_name).size
+          should_reroute = capacity_used_percent > threshold
+
+          Sidekiq::Routing::Auto.logger.info(
+            "[Routing::Auto] #{queue_name}: size=#{queue_size}, " \
+            "workload=#{estimated_workload.round(1)}s, capacity=#{capacity.round(1)}s, " \
+            "used=#{capacity_used_percent.round(1)}%, threshold=#{threshold}%, reroute=#{should_reroute}"
+          )
+
+          should_reroute
+        end
+
+        def calculate_capacity(queue_name, sla_seconds)
+          total_concurrency = Sidekiq::ProcessSet.new.sum { |process| process["concurrency"] }.nonzero? || 10
+          weight_fraction = queue_weight_fraction(queue_name)
+
+          total_concurrency * weight_fraction * sla_seconds
+        end
+
+        def queue_weight_fraction(queue_name)
+          queues = Sidekiq.default_configuration[:queues] || []
+          total_weight = 0
+          queue_weight = 1
+
+          queues.each do |queue|
+            if queue.is_a?(Array)
+              name, weight = queue
+              total_weight += weight
+              queue_weight = weight if name == queue_name
+            else
+              total_weight += 1
+              queue_weight = 1 if queue == queue_name
+            end
+          end
+
+          total_weight.zero? ? 1.0 : queue_weight.to_f / total_weight
+        end
+    end
+  end
+end

data/lib/sidekiq/routing/auto/router.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Routing::Auto
+    class Router
+      QUEUE_HIERARCHY = %w[
+        within_5_seconds
+        within_1_minute
+        within_5_minutes
+        within_1_hour
+      ].freeze
+
+      def self.next_queue_for(current_queue)
+        index = QUEUE_HIERARCHY.index(current_queue)
+        return nil unless index
+
+        QUEUE_HIERARCHY[index + 1]
+      end
+
+      def self.sla_queues
+        QUEUE_HIERARCHY
+      end
+    end
+  end
+end

data/lib/sidekiq/routing/configuration.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Routing
+    class Configuration
+      attr_accessor :enabled,
+        :logger,
+        :parked_queue,
+        :process_parked_fallback_queue,
+        :cache_ttl_seconds,
+        :batch_limit,
+        :batch_size,
+        :breakdown_sample_size
+
+      def initialize
+        @enabled = true
+        @logger = default_logger
+        @parked_queue = PARKED_QUEUE_DEFAULT
+        # Where process_parked sends a parked job that has no stamped original queue.
+        @process_parked_fallback_queue = "default"
+        # Hot-path snapshot freshness. 0 disables caching (read Redis every call).
+        @cache_ttl_seconds = 5
+        # Recovery defaults: nil limit = move everything; batch_size bounds each pass.
+        @batch_limit = nil
+        @batch_size = 100
+        # Max jobs parked_breakdown scans (the parking queue can hold millions).
+        @breakdown_sample_size = 1_000
+      end
+
+      private
+
+        def default_logger
+          if defined?(::Rails) && ::Rails.respond_to?(:logger) && ::Rails.logger
+            ::Rails.logger
+          else
+            ::Sidekiq.logger
+          end
+        end
+    end
+  end
+end