sidekiq_solid_fetch 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f9d49a1edc5ffd25c20302adac6f5fea21eb3aacab3c441d7a8722bb42faeca
-  data.tar.gz: 8c137210e8a8febf7409379c7c207270f0c3964ae378898122cc7e1a6f7ae88d
+  metadata.gz: f17f313f19a6598d87fe5fb8970b68e176389e279c648174c9ec9c92c787aeee
+  data.tar.gz: c34a5b15685d7590b3a6acc27132cd7190418cc51c1f96e075e0dc573fb56ab8
 SHA512:
-  metadata.gz: 2df35c34eed28f7f1c3ed78e853da85b80262a21702e4334699a0c7dadc5ba2f62059dba9dea116882ee71edbfa5c503de1f682b4371e021d580409cd8640322
-  data.tar.gz: a3ffb8214437b7f4b579465b03268b3a4a4a393d481036f5ac4e90b510174ef7220f5d88a93f54038712f6e6731882889536396c7eed71b08e528163da0670e4
+  metadata.gz: ddd3e40d1b85f1014fc65d9b4a5cd91b8f4959a0c4a11855e95277d38e35e2865ae308510ea4e23fb23ac84285e9a40c746de77a78c56d9f4892cc0e89e39725
+  data.tar.gz: 55a487070c122d8696bee38047f47accb1d0518b5b7ad959f30ebbb86b9751dd7344e59b02c426425137c4c9a8a8fa98b1d53755f982d23afdedf335f097a396

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.1.1"
+  ".": "0.2.0"
 }

data/.standard.yml

@@ -1,3 +1,3 @@
 # For available configuration options, see:
 #   https://github.com/standardrb/standard
-ruby_version: 3.1
+ruby_version: 3.3

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.2.0](https://github.com/k0va1/sidekiq_solid_fetch/compare/v0.1.2...v0.2.0) (2026-07-29)
+
+
+### ⚠ BREAKING CHANGES
+
+* require Ruby >= 3.3
+
+### Features
+
+* require Ruby >= 3.3 ([9768dc0](https://github.com/k0va1/sidekiq_solid_fetch/commit/9768dc0001ea653220bac678b7000c4f368a4fe2))
+
+## [0.1.2](https://github.com/k0va1/sidekiq_solid_fetch/compare/v0.1.1...v0.1.2) (2026-07-29)
+
+
+### Features
+
+* add opt-in sidekiq-throttled integration ([4095131](https://github.com/k0va1/sidekiq_solid_fetch/commit/40951313fd7896f406bc8da9c38bee089bb4fa03))
+
+
+### Bug Fixes
+
+* rework orphan recovery to stop stealing live jobs and losing them ([cf54ebe](https://github.com/k0va1/sidekiq_solid_fetch/commit/cf54ebe7ede6beb73bee2911adbf8eda45c05f2b))
+
 ## [0.1.1](https://github.com/k0va1/sidekiq_solid_fetch/compare/v0.1.0...v0.1.1) (2025-12-04)
 
 

data/CLAUDE.md

@@ -9,9 +9,9 @@ SidekiqSolidFetch is an open-source Ruby gem that provides a reliable fetch stra
 ## Commands
 
 - **Install dependencies**: `bundle install`
-- **Run all tests**: `bundle exec rake spec`
-- **Run a single test file**: `bundle exec rspec spec/path/to/file_spec.rb`
-- **Run a single test by line**: `bundle exec rspec spec/path/to/file_spec.rb:LINE`
+- **Run all tests**: `bundle exec rake test`
+- **Run a single test file**: `bundle exec rake test TEST=test/path/to/file_test.rb`
+- **Run a single test by name**: `bundle exec ruby -Ilib:test test/path/to/file_test.rb -n /pattern/`
 - **Lint code**: `bundle exec rake standard`
 - **Auto-fix lint issues**: `bundle exec standardrb --fix`
 - **Run all checks (tests + lint)**: `bundle exec rake`
@@ -26,13 +26,23 @@ SidekiqSolidFetch is an open-source Ruby gem that provides a reliable fetch stra
 
 ### Fetcher Design
 
-The Fetcher uses Redis LMOVE to atomically move jobs from the source queue to a per-worker processing queue (`processing:queue:{name}:{identity}`). This ensures:
+The Fetcher uses Redis LMOVE to atomically move jobs from the source queue to a per-worker processing queue (`sidekiq_solid_fetch:processing:{capsule}:{identity}:queue:{name}`). This ensures:
 - Jobs are never lost if a worker crashes mid-execution
 - Unfinished jobs can be requeued via `bulk_requeue`
 
+Each fetcher registers its processing queues in a Redis hash (`sidekiq_solid_fetch:registry`) mapping the processing queue key to its original queue and worker identity. Orphan recovery (`SidekiqSolidFetch.requeue_orphaned_jobs`) walks this registry — never key parsing — and requeues jobs whose worker's TTL-based heartbeat key is gone, skipping entries younger than `GRACE_PERIOD`. Recovery runs on `:startup` and every `RECOVERY_INTERVAL` seconds in a background thread (deduplicated across processes by a Redis NX lock).
+
 Key classes:
-- `Fetcher` - Implements Sidekiq's fetch interface with `retrieve_work` and `bulk_requeue`
-- `UnitOfWork` - Struct wrapping a job with `acknowledge` and `requeue` methods
+- `Fetcher` - Implements Sidekiq's fetch interface with `retrieve_work` and `bulk_requeue`; sleeps `TIMEOUT` seconds when all queues are empty (Sidekiq's processor loop has no delay of its own)
+- `UnitOfWork` - Wraps a job with `acknowledge`, `requeue`, and `requeue_throttled` methods
+
+### sidekiq-throttled integration
+
+`lib/sidekiq_solid_fetch/throttled.rb` (opt-in via `require` + `SidekiqSolidFetch::Throttled.setup!`, needs sidekiq-throttled >= 2.0). Never prepend `Sidekiq::Throttled::Patches::BasicFetch` directly: its requeue path LPUSHes a copy of the job while the original stays in the processing queue, leaking duplicates. The integration patches `Strategy#re_enqueue_throttled` to atomically move our `UnitOfWork` back instead.
+
+### Testing notes
+
+The suite (Minitest) flushes Redis before every test. It defaults to `redis://localhost:6381/15` (the docker-compose Redis) — never point `REDIS_URL` at a shared Redis.
 
 ### Queue Modes
 
@@ -41,5 +51,5 @@ Key classes:
 
 ## Requirements
 
-- Ruby >= 3.1.0
+- Ruby >= 3.3.0
 - Sidekiq >= 7.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Alex Koval
+
+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/Makefile

@@ -1,4 +1,4 @@
-REDIS_URL ?= redis://localhost:6379/0
+REDIS_URL ?= redis://localhost:6381/15
 
 .PHONY: test lint-fix console install
 
@@ -9,7 +9,7 @@ console:
 	bin/console
 
 test:
-	REDIS_URL=$(REDIS_URL) bundle exec rspec $(filter-out $@,$(MAKECMDGOALS))
+	REDIS_URL=$(REDIS_URL) bundle exec rake test $(addprefix TEST=,$(filter-out $@,$(MAKECMDGOALS)))
 
 lint-fix:
 	bundle exec standardrb --fix

data/README.md

@@ -7,15 +7,18 @@ A reliable fetch strategy for Sidekiq that ensures jobs are never lost, even if
 SidekiqSolidFetch uses Redis `LMOVE` command to atomically move jobs from the queue to a per-worker processing queue. This approach ensures:
 
 - **No job loss**: Jobs are moved (not copied) to a processing queue before execution. If a worker crashes, the job remains in the processing queue.
-- **Automatic recovery**: On startup, any unfinished jobs from previous runs are automatically requeued.
+- **Automatic recovery**: Jobs stranded by dead workers are requeued on startup and periodically afterwards.
 - **Graceful shutdown**: When Sidekiq shuts down, in-progress jobs are moved back to their original queues.
 
 ### Flow
 
-1. Worker fetches a job → job is atomically moved from `queue:default` to `sidekiq_solid_fetch:processing:queue:default`
-2. Worker processes the job successfully → job is removed from the processing queue
-3. Worker crashes → job stays in the processing queue
-4. On next startup → jobs in processing queues are moved back to their original queues
+1. Worker boots → it registers its processing queues in a Redis registry (`sidekiq_solid_fetch:registry`)
+2. Worker fetches a job → job is atomically moved from `queue:default` to a per-worker processing queue (`sidekiq_solid_fetch:processing:{capsule}:{identity}:queue:default`)
+3. Worker processes the job successfully → job is removed from the processing queue
+4. Worker crashes → job stays in the processing queue
+5. Recovery (on startup of any worker, then every 5 minutes) walks the registry, detects workers whose Sidekiq heartbeat has expired, and moves their jobs back to the original queues
+
+Recovery never touches queues belonging to live workers: liveness is checked via Sidekiq's TTL-based heartbeat key, and freshly registered queues get a grace period so a worker that just booted can't be mistaken for a dead one. Delivery semantics are at-least-once — a job interrupted mid-execution will run again.
 
 ## Installation
 
@@ -48,15 +51,34 @@ end
 
 That's it! SidekiqSolidFetch will now handle job fetching with crash recovery.
 
+### Using with sidekiq-throttled
+
+Do **not** prepend `Sidekiq::Throttled::Patches::BasicFetch` to the fetcher yourself: sidekiq-throttled's default `:enqueue` requeue pushes a *copy* of the throttled job back to the queue without removing the original from the processing queue, leaking one duplicate per throttle cycle that shutdown or orphan recovery would later re-inject as real jobs.
+
+Use the built-in integration instead (requires sidekiq-throttled >= 2.0):
+
+```ruby
+require "sidekiq_solid_fetch/throttled"
+
+Sidekiq.configure_server do |config|
+  SidekiqSolidFetch.enable!(config)
+  SidekiqSolidFetch::Throttled.setup!
+end
+```
+
+`setup!` applies sidekiq-throttled's fetch patches to the fetcher and makes throttled requeues an atomic move back to the queue, so nothing is copied or lost. The `:schedule` requeue strategy works out of the box either way.
+
 ## Requirements
 
-- Ruby >= 3.1.0
+- Ruby >= 3.3.0
 - Sidekiq >= 7.0
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.
 
+The test suite flushes its Redis database before every test, so it runs against a dedicated Redis on port 6381 (db 15) by default — never point `REDIS_URL` at a Redis instance a real app uses.
+
 ```bash
 # Run tests
 docker compose up -d

data/Rakefile

@@ -1,8 +1,11 @@
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require "rake/testtask"
 
-RSpec::Core::RakeTask.new(:spec)
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test" << "lib"
+  t.pattern = "test/**/*_test.rb"
+end
 
 require "standard/rake"
 
-task default: %i[spec standard]
+task default: %i[test standard]

data/docker-compose.yml

@@ -1,11 +1,12 @@
 services:
   redis:
     image: redis:8.4-alpine
-    network_mode: host
     volumes:
       - redis:/data
     ports:
-      - 6379:6379
+      # Dedicated host port so the test suite (which flushes its database)
+      # never collides with a dev Redis running on the default 6379.
+      - 6381:6379
     healthcheck:
       test: redis-cli ping
       interval: 1s

data/lib/sidekiq_solid_fetch/fetcher.rb

@@ -6,38 +6,51 @@ module SidekiqSolidFetch
   class Fetcher
     include Sidekiq::Component
 
+    # How long to pause when every queue is empty. Mirrors BasicFetch's BRPOP
+    # timeout: Sidekiq's processor loop calls retrieve_work with no delay of
+    # its own, so blocking here is what keeps idle threads from hot-looping
+    # against Redis.
+    TIMEOUT = 2
+
     def initialize(cap)
       raise ArgumentError, "missing queue list" unless cap.queues
       @config = cap
       @strictly_ordered_queues = cap.mode == :strict
       @queues = config.queues.map { |q| "queue:#{q}" }
       @queues.uniq! if @strictly_ordered_queues
+      @identity = cap.identity
+      @processing_queues = @queues.uniq.to_h do |queue|
+        [queue, ::SidekiqSolidFetch.processing_queue_name(queue, @identity, cap.name)]
+      end
+      register_processing_queues
     end
 
     def retrieve_work
       queues_cmd.each do |queue|
-        processing_queue_name = ::SidekiqSolidFetch.processing_queue_name(queue)
+        processing_queue = @processing_queues[queue]
         work = redis do |conn|
-          conn.lmove(queue, processing_queue_name, "RIGHT", "LEFT")
+          conn.lmove(queue, processing_queue, "RIGHT", "LEFT")
         end
 
-        return ::SidekiqSolidFetch::UnitOfWork.new(queue, work, config, processing_queue_name) if work
+        return ::SidekiqSolidFetch::UnitOfWork.new(queue, work, config, processing_queue) if work
       end
+
+      sleep(TIMEOUT)
       nil
     end
 
     def bulk_requeue(*)
-      logger.info("SidekiqSolidFetch: Re-queueing terminated jobs")
+      logger.info("SidekiqSolidFetch: Re-queueing terminated jobs for #{@identity}")
 
       count = 0
       redis do |conn|
-        queues_cmd.each do |queue|
-          processing_queue_name = ::SidekiqSolidFetch.processing_queue_name(queue)
-          while conn.lmove(processing_queue_name, queue, "RIGHT", "LEFT")
+        @processing_queues.each do |queue, processing_queue|
+          while conn.lmove(processing_queue, queue, "LEFT", "RIGHT")
             count += 1
-            logger.info { "SidekiqSolidFetch: Moving job from #{processing_queue_name} back to #{queue}" }
+            logger.info { "SidekiqSolidFetch: Moving job from #{processing_queue} back to #{queue}" }
           end
         end
+        ::SidekiqSolidFetch.unregister_processing_queues(conn, @processing_queues.values)
       end
       logger.info("SidekiqSolidFetch: Re-queued #{count} jobs")
     rescue => ex
@@ -53,5 +66,17 @@ module SidekiqSolidFetch
         permute
       end
     end
+
+    private
+
+    # Registering before the first fetch guarantees recovery in other
+    # processes can always see who owns a processing queue.
+    def register_processing_queues
+      redis do |conn|
+        @processing_queues.each do |queue, processing_queue|
+          ::SidekiqSolidFetch.register_processing_queue(conn, processing_queue, queue, @identity)
+        end
+      end
+    end
   end
 end

data/lib/sidekiq_solid_fetch/throttled.rb

@@ -0,0 +1,44 @@
+require "sidekiq/throttled"
+
+module SidekiqSolidFetch
+  # Opt-in integration with sidekiq-throttled (>= 2.0).
+  #
+  # sidekiq-throttled's stock requeue path treats any non-SuperFetch fetcher
+  # like BasicFetch: it LPUSHes a copy of the throttled job back to the queue
+  # without removing the original from the processing queue. With this
+  # fetcher that leaks one duplicate per throttle cycle, which bulk_requeue
+  # or orphan recovery would later re-inject as real jobs.
+  #
+  # `setup!` prepends sidekiq-throttled's fetch patches to the Fetcher and
+  # teaches Strategy#re_enqueue_throttled to atomically MOVE our UnitOfWork
+  # back to the target queue instead of copying it.
+  #
+  #   require "sidekiq_solid_fetch/throttled"
+  #
+  #   Sidekiq.configure_server do |config|
+  #     SidekiqSolidFetch.enable!(config)
+  #     SidekiqSolidFetch::Throttled.setup!
+  #   end
+  module Throttled
+    MINIMUM_VERSION = "2.0.0"
+
+    module StrategyPatch
+      def re_enqueue_throttled(work, target_queue)
+        return super unless work.is_a?(::SidekiqSolidFetch::UnitOfWork)
+
+        target_queue = "queue:#{target_queue}" unless target_queue.start_with?("queue:")
+        work.requeue_throttled(target_queue)
+      end
+    end
+
+    def self.setup!
+      unless Gem::Version.new(Sidekiq::Throttled::VERSION) >= Gem::Version.new(MINIMUM_VERSION)
+        raise "SidekiqSolidFetch::Throttled requires sidekiq-throttled >= #{MINIMUM_VERSION} " \
+          "(found #{Sidekiq::Throttled::VERSION})"
+      end
+
+      SidekiqSolidFetch::Fetcher.prepend(Sidekiq::Throttled::Patches::BasicFetch)
+      Sidekiq::Throttled::Strategy.prepend(StrategyPatch)
+    end
+  end
+end

data/lib/sidekiq_solid_fetch/unit_of_work.rb

@@ -21,7 +21,22 @@ module SidekiqSolidFetch
       config.redis do |conn|
         conn.multi do |multi|
           multi.lrem(processing_queue, -1, job)
-          multi.lpush(queue, job)
+          # RPUSH, like Sidekiq's own requeue: the queue is consumed from the
+          # right, so an interrupted job runs next rather than going behind
+          # newly enqueued work.
+          multi.rpush(queue, job)
+        end
+      end
+    end
+
+    # Atomically move the job from the processing queue to the BACK of the
+    # target queue (LPUSH side), so a throttled job doesn't churn straight
+    # through fetch again and no copy is left behind in the processing queue.
+    def requeue_throttled(target_queue)
+      config.redis do |conn|
+        conn.multi do |multi|
+          multi.lrem(processing_queue, -1, job)
+          multi.lpush(target_queue, job)
         end
       end
     end

data/lib/sidekiq_solid_fetch/version.rb

@@ -1,3 +1,3 @@
 module SidekiqSolidFetch
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/sidekiq_solid_fetch.rb

@@ -1,39 +1,114 @@
+require "json"
+
 require_relative "sidekiq_solid_fetch/version"
 require_relative "sidekiq_solid_fetch/unit_of_work"
 require_relative "sidekiq_solid_fetch/fetcher"
 
 module SidekiqSolidFetch
-  class Error < StandardError; end
-
   PROCESSING_QUEUE_PREFIX = "sidekiq_solid_fetch:processing"
 
+  # Registry of every live processing queue. A Redis hash where each field is
+  # a processing queue key and each value is a JSON blob with the original
+  # queue, the worker identity and the registration timestamp. Recovery reads
+  # this registry instead of parsing key names, which would be ambiguous
+  # because both queue names and identities can contain colons.
+  REGISTRY_KEY = "sidekiq_solid_fetch:registry"
+
+  RECOVERY_LOCK_KEY = "sidekiq_solid_fetch:recovery_lock"
+
+  # Entries younger than this are never considered orphaned, so a freshly
+  # booted worker whose first heartbeat hasn't landed yet can't have its
+  # in-flight jobs stolen by another process running recovery.
+  GRACE_PERIOD = 60
+
+  # How often each process attempts orphan recovery after boot. Runs are
+  # deduplicated across processes with RECOVERY_LOCK_KEY.
+  RECOVERY_INTERVAL = 300
+
   def self.enable!(config)
     config[:fetch_class] = SidekiqSolidFetch::Fetcher
 
     config.on(:startup) do
-      Sidekiq.logger.info("SidekiqSolidFetch enabled")
-      requeue_not_finished_jobs(config)
+      config.logger.info("SidekiqSolidFetch enabled")
+      requeue_orphaned_jobs(config)
+      @recovery_thread = start_recovery_thread(config)
+    end
+
+    config.on(:shutdown) do
+      @recovery_thread&.kill
+      @recovery_thread = nil
     end
   end
 
-  def self.requeue_not_finished_jobs(config)
-    Sidekiq.logger.info("SidekiqSolidFetch: Re-queueing not finished jobs from previous runs")
+  # Requeue jobs from processing queues whose worker is dead. A worker is
+  # considered dead when its heartbeat key (which Sidekiq maintains with a
+  # TTL) no longer exists. Membership in the `processes` set is not used
+  # because entries for crashed workers linger there until Sidekiq's
+  # rate-limited cleanup runs.
+  def self.requeue_orphaned_jobs(config)
+    logger = config.logger
+    logger.info("SidekiqSolidFetch: Checking for orphaned jobs from dead workers")
 
     count = 0
-    Sidekiq.redis do |conn|
-      config.queues.map { |q| "queue:#{q}" }.uniq.each do |queue|
-        processing_queue_name = ::SidekiqSolidFetch.processing_queue_name(queue)
-        while conn.lmove(processing_queue_name, queue, "RIGHT", "LEFT")
+    now = Time.now.to_i
+    config.redis do |conn|
+      conn.hgetall(REGISTRY_KEY).each do |processing_queue, raw_entry|
+        entry = parse_registry_entry(raw_entry)
+        unless entry
+          conn.hdel(REGISTRY_KEY, processing_queue)
+          next
+        end
+
+        next if now - entry["registered_at"].to_i < GRACE_PERIOD
+        next if conn.exists(entry["identity"]) > 0
+
+        queue = entry["queue"]
+        while conn.lmove(processing_queue, queue, "LEFT", "RIGHT")
           count += 1
-          Sidekiq.logger.info { "SidekiqSolidFetch: Moved job from #{processing_queue_name} back to #{queue}" }
+          logger.info { "SidekiqSolidFetch: Moved orphaned job from #{processing_queue} back to #{queue}" }
+        end
+        conn.hdel(REGISTRY_KEY, processing_queue)
+      end
+    end
+
+    logger.info("SidekiqSolidFetch: Re-queued #{count} orphaned jobs")
+  end
+
+  def self.processing_queue_name(queue, identity, capsule_name)
+    "#{PROCESSING_QUEUE_PREFIX}:#{capsule_name}:#{identity}:#{queue}"
+  end
+
+  def self.register_processing_queue(conn, processing_queue, queue, identity)
+    entry = {"queue" => queue, "identity" => identity, "registered_at" => Time.now.to_i}
+    conn.hset(REGISTRY_KEY, processing_queue, JSON.generate(entry))
+  end
+
+  def self.unregister_processing_queues(conn, processing_queues)
+    conn.hdel(REGISTRY_KEY, *processing_queues) unless processing_queues.empty?
+  end
+
+  def self.start_recovery_thread(config)
+    Thread.new do
+      loop do
+        sleep(RECOVERY_INTERVAL)
+        begin
+          requeue_orphaned_jobs(config) if acquire_recovery_lock(config)
+        rescue => ex
+          config.logger.warn("SidekiqSolidFetch: Orphan recovery failed: #{ex.message}")
         end
       end
     end
+  end
 
-    Sidekiq.logger.info("SidekiqSolidFetch: Re-queued #{count} jobs from previous runs")
+  def self.acquire_recovery_lock(config)
+    config.redis { |conn| conn.set(RECOVERY_LOCK_KEY, "1", "NX", "EX", RECOVERY_INTERVAL) }
   end
 
-  def self.processing_queue_name(queue)
-    "#{PROCESSING_QUEUE_PREFIX}:#{queue}"
+  def self.parse_registry_entry(raw_entry)
+    entry = JSON.parse(raw_entry)
+    return nil unless entry.is_a?(Hash) && entry["queue"] && entry["identity"]
+    entry
+  rescue JSON::ParserError
+    nil
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq_solid_fetch
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Alex Koval
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -24,7 +23,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.0'
-description: OSS implementation of Sidekiq Pro's `super_fetch`
+description: A reliable fetch strategy for Sidekiq that prevents job loss on worker
+  crashes by atomically moving jobs to per-worker processing queues and recovering
+  orphaned jobs from dead workers. An open-source alternative to Sidekiq Pro's `super_fetch`.
 email:
 - al3xander.koval@gmail.com
 executables: []
@@ -32,26 +33,28 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".release-please-manifest.json"
-- ".rspec"
 - ".standard.yml"
 - CHANGELOG.md
 - CLAUDE.md
+- LICENSE.txt
 - Makefile
 - README.md
 - Rakefile
 - docker-compose.yml
 - lib/sidekiq_solid_fetch.rb
 - lib/sidekiq_solid_fetch/fetcher.rb
+- lib/sidekiq_solid_fetch/throttled.rb
 - lib/sidekiq_solid_fetch/unit_of_work.rb
 - lib/sidekiq_solid_fetch/version.rb
 - release-please-config.json
 homepage: https://github.com/k0va1/sidekiq_solid_fetch
-licenses: []
+licenses:
+- MIT
 metadata:
   homepage_uri: https://github.com/k0va1/sidekiq_solid_fetch
   source_code_uri: https://github.com/k0va1/sidekiq_solid_fetch
   changelog_uri: https://github.com/k0va1/sidekiq_solid_fetch/blob/master/CHANGELOG.md
-post_install_message:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -59,15 +62,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: OSS implementation of Sidekiq Pro's `super_fetch`
 test_files: []

data/.rspec

@@ -1,2 +0,0 @@
---color
---require spec_helper