sidekiq-reliable_job 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 02b897ad13f432b8eecbb0e67bc800fd7ed0ada1a982f0d79d1aee13f3ba66a2
+  data.tar.gz: 14746216146d4889d85662473e6c3ed118376375ff9c4a1bc95cc1d52a92a9ac
+SHA512:
+  metadata.gz: 52c880d82c602f394faf6926beaea0838df1053d0c836f1e1ffeb0f9d6fa763a441b1a5067d3f3485bfe36b4cc6bfbca2b15c2d7128724d3181ef815749dac96
+  data.tar.gz: e1b1cc31d1cd4e430c75cc9ed910209eecfa148e0a47b2cf63a7f39fa8aab6e38556610a2531f90f85770090dde27b6871dbd7f3d0bd539446c52a5e27c58d04

data/.ruby-version

@@ -0,0 +1 @@
+3.4.7

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2024-12-15
+
+### Added
+
+- Initial release
+- Transactional outbox pattern for reliable job enqueuing
+- Client middleware for automatic outbox creation
+- Server middleware for job completion tracking
+- Support for Sidekiq 7+ and Rails 7.1+
+- Configurable outbox model and table name
+- Advisory lock-based outbox processor
+- Support for ActiveJob and native Sidekiq jobs

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Wealthsimple
+
+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,200 @@
+# Sidekiq::ReliableJob
+
+A Sidekiq extension that provides reliable job delivery by staging jobs to the database before pushing to Redis. This ensures jobs are only enqueued when database transactions commit, and provides durability during Redis outages.
+
+## Features
+
+- **Transaction Safety**: Jobs are staged to the database within your transaction. If the transaction rolls back, the job is never enqueued.
+- **Redis Outage Resilience**: Jobs continue to be accepted during Redis outages and are pushed once Redis is available.
+- **Reliable Delivery**: A background enqueuer process polls staged jobs and pushes them to Redis.
+- **Automatic Cleanup**: Jobs are automatically deleted from the staging table after successful completion.
+- **ActiveJob Support**: Works with both native Sidekiq jobs and ActiveJob.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "sidekiq-reliable_job"
+```
+
+Then execute:
+
+```bash
+bundle install
+```
+
+## Setup
+
+### 1. Run the generator to create the migration
+
+```bash
+rails generate sidekiq_reliable_job:install
+```
+
+This creates a migration for the `reliable_job_outbox` table.
+
+### 2. Run the migration
+
+```bash
+rails db:migrate
+```
+
+### 3. Configure Sidekiq
+
+In your Sidekiq initializer (`config/initializers/sidekiq.rb`):
+
+```ruby
+require "sidekiq/reliable_job"
+
+Sidekiq::ReliableJob.configure do |config|
+  # The ActiveRecord base class for the Outbox model (default: "ActiveRecord::Base")
+  config.base_class = "ApplicationRecord"
+  # Enable reliable job for all jobs (default: false)
+  config.enable_for_all_jobs = false
+  # Preserve dead jobs in outbox with "dead" status instead of deleting (default: false)
+  config.preserve_dead_jobs = false
+end
+
+Sidekiq.configure_client do |config|
+  Sidekiq::ReliableJob.configure_client!(config)
+end
+
+Sidekiq.configure_server do |config|
+  Sidekiq::ReliableJob.configure_server!(config)
+end
+```
+
+## Usage
+
+### Option 1: Enable for all jobs (recommended)
+
+When `enable_for_all_jobs` is `true`, all Sidekiq jobs are automatically staged through the outbox. No changes to job classes required.
+
+To opt-out a specific job from staged push:
+
+```ruby
+class DirectPushJob
+  include Sidekiq::Job
+  sidekiq_options reliable_job: false
+
+  def perform
+    # This job will push directly to Redis
+  end
+end
+```
+
+### Option 2: Enable per job (opt-in)
+
+If `enable_for_all_jobs` is `false` (default), use `sidekiq_options` to opt-in specific jobs:
+
+```ruby
+class MyJob
+  include Sidekiq::Job
+  sidekiq_options reliable_job: true
+
+  def perform(user_id)
+    # Your job logic here
+  end
+end
+```
+
+### ActiveJob Support
+
+ReliableJob works with ActiveJob. Configure the job using `sidekiq_options`:
+
+```ruby
+class MyActiveJob < ApplicationJob
+  queue_as :default
+  sidekiq_options reliable_job: true
+
+  def perform(user_id)
+    # Your job logic here
+  end
+end
+```
+
+### Example
+
+When you enqueue the job within a transaction, it will be staged to the database first:
+
+```ruby
+ActiveRecord::Base.transaction do
+  user = User.create!(name: "Alice")
+  MyJob.perform_async(user.id)  # Staged to database, not Redis
+
+  # If an exception is raised here, the job is never enqueued
+end
+# Transaction committed - job is now pushed to Redis by the enqueuer
+```
+
+## How It Works
+
+1. **Client Middleware**: Intercepts `perform_async` and `perform_in` calls and stages jobs to the `reliable_job_outbox` table instead of pushing directly to Redis.
+2. **Outbox Processor**: A background thread polls for pending jobs and pushes them to Redis:
+3. **Server Middleware**: After successful job completion, deletes the staged job record from the outbox.
+4. **Death Handler**: When a job exhausts all retries, removes (or optionally preserves) the record from the outbox.
+
+## Deployment & Rollout
+
+When enabling ReliableJob for the first time, use a **two-phase deployment** to avoid orphaned outbox records:
+
+### Phase 1: Deploy with ReliableJob Disabled
+
+First, deploy the gem with all jobs disabled. This installs the middleware on all containers without affecting any jobs:
+
+```ruby
+Sidekiq::ReliableJob.configure do |config|
+  config.enable_for_all_jobs = false  # No jobs use reliable delivery yet
+end
+```
+
+Wait for all containers to be running with the new code.
+
+### Phase 2: Enable ReliableJob
+
+Once all containers have the middleware installed, enable reliable delivery for your jobs:
+
+```ruby
+Sidekiq::ReliableJob.configure do |config|
+  config.enable_for_all_jobs = true  # Or enable per-job with sidekiq_options
+end
+```
+
+### Why This Matters
+
+If containers are running different versions during deployment:
+- New containers may stage jobs while old containers process them
+- Old containers don't have the server middleware, so they won't delete completed jobs from the outbox
+- This leaves orphaned "enqueued" records in the database
+
+## Configuration Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `enable_for_all_jobs` | `false` | When `true`, all jobs are staged through the outbox |
+| `base_class` | `"ActiveRecord::Base"` | The ActiveRecord base class for the Outbox model |
+| `preserve_dead_jobs` | `false` | When `true`, keeps dead jobs in outbox with "dead" status instead of deleting |
+
+## Limitations
+
+### Batch Jobs (Sidekiq Pro/Enterprise)
+
+Jobs that are part of a batch (have a `bid` in their payload) are **automatically bypassed** and pushed directly to Redis. This ensures batch callbacks and completion tracking work correctly.
+
+### Internal Sidekiq Jobs
+
+All internal Sidekiq jobs (classes starting with `Sidekiq::`) are **automatically bypassed**. This includes:
+
+- Batch callbacks (`Sidekiq::Batch::Callback`)
+- Batch empty handlers (`Sidekiq::Batch::Empty`)
+- Enterprise periodic jobs (`Sidekiq::Periodic::*`)
+- Any other internal Sidekiq system jobs
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wealthsimple/sidekiq-reliable_job.

data/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+Rake.load_rakefile "spec/dummy/Rakefile"
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/generators/sidekiq/reliable_job/install_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module SidekiqReliableJob
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates the migration for the reliable_job_outbox table"
+
+      def create_migration_file
+        migration_template(
+          "migration.rb.tt",
+          "db/migrate/create_reliable_job_outbox.rb",
+        )
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/sidekiq_reliable_job/install/install_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module SidekiqReliableJob
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates the migration for the reliable_job_outbox table"
+
+      def create_migration_file
+        migration_template(
+          "migration.rb.tt",
+          "db/migrate/create_reliable_job_outbox.rb",
+        )
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/sidekiq_reliable_job/install/templates/migration.rb.tt

@@ -0,0 +1,16 @@
+class CreateReliableJobOutbox < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :reliable_job_outbox do |t|
+      t.string :jid, null: false
+      t.string :job_class, null: false
+      t.json :payload, null: false
+      t.string :status, null: false, default: "pending"
+      t.datetime :enqueued_at
+
+      t.timestamps
+    end
+
+    add_index :reliable_job_outbox, :jid, unique: true
+    add_index :reliable_job_outbox, %i[status id]
+  end
+end

data/lib/sidekiq/reliable_job/client.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Sidekiq
+  module ReliableJob
+    # Stages jobs to the Outbox for later delivery to Redis.
+    class Client
+      class << self
+        def push(item)
+          item["jid"] ||= SecureRandom.hex(12)
+
+          Outbox.create!(
+            jid: item["jid"],
+            job_class: extract_job_class(item),
+            payload: item,
+            status: Outbox::PENDING,
+          )
+
+          item["jid"]
+        end
+
+        private
+
+        def extract_job_class(item)
+          (item["wrapped"] || item["class"]).to_s
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/reliable_job/client_middleware.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module ReliableJob
+    # Intercepts job pushes and stages them to the Outbox instead of Redis.
+    class ClientMiddleware
+      def call(_job_class, job, _queue, _redis_pool)
+        return yield if skip_staging?(job)
+
+        job["reliable_job"] = true
+        Client.push(job)
+
+        yield if testing_enabled?
+      end
+
+      private
+
+      def skip_staging?(job)
+        retry?(job) || batch?(job) || sidekiq_internal?(job) || !enabled_for?(job)
+      end
+
+      def batch?(job)
+        job.key?("bid")
+      end
+
+      # Bypass internal Sidekiq jobs (batch callbacks, Enterprise features, etc.)
+      # but not ActiveJob wrapper which should be staged
+      def sidekiq_internal?(job)
+        klass = job["class"].to_s
+        klass.start_with?("Sidekiq::") && klass != "Sidekiq::ActiveJob::Wrapper"
+      end
+
+      def enabled_for?(job)
+        option = reliable_job_option(job)
+
+        case option
+        when true then true
+        when false then false
+        else ReliableJob.configuration.enable_for_all_jobs
+        end
+      end
+
+      def reliable_job_option(job)
+        return job["reliable_job"] if job.key?("reliable_job")
+
+        wrapped_class_option(job)
+      end
+
+      def wrapped_class_option(job)
+        wrapped = job["wrapped"]
+        return unless wrapped
+
+        klass = wrapped.is_a?(Class) ? wrapped : wrapped.to_s.safe_constantize
+        klass&.sidekiq_options_hash&.dig("reliable_job")
+      end
+
+      def retry?(job)
+        job.key?("retry_count")
+      end
+
+      def testing_enabled?
+        defined?(Sidekiq::Testing) && Sidekiq::Testing.enabled?
+      end
+    end
+  end
+end

data/lib/sidekiq/reliable_job/configuration.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module ReliableJob
+    # Configuration options for ReliableJob.
+    class Configuration
+      attr_accessor :base_class, :enable_for_all_jobs, :preserve_dead_jobs
+
+      def initialize
+        @base_class = "ActiveRecord::Base"
+        @enable_for_all_jobs = false
+        @preserve_dead_jobs = false
+      end
+    end
+
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+      end
+    end
+  end
+end

data/lib/sidekiq/reliable_job/enqueuer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "sidekiq/component"
+
+module Sidekiq
+  module ReliableJob
+    # Background thread that continuously processes the Outbox.
+    class Enqueuer
+      include Sidekiq::Component
+
+      POLL_INTERVAL = 0.1
+      ERROR_SLEEP = 1
+      LOCK_RETRY_SLEEP = 20
+
+      def initialize(config)
+        @config = config
+        @done = false
+        @processor = OutboxProcessor.new
+      end
+
+      def start
+        @thread = Thread.new { run }
+      end
+
+      def stop
+        @done = true
+      end
+
+      private
+
+      def run
+        process_loop until @done
+      end
+
+      def process_loop
+        count = @processor.call
+        sleep POLL_INTERVAL if count.zero?
+      rescue WithAdvisoryLock::FailedToAcquireLock
+        sleep LOCK_RETRY_SLEEP
+      rescue StandardError => e
+        logger.error "ReliableJob::Enqueuer error: #{e.class} - #{e.message}"
+        sleep ERROR_SLEEP
+      end
+    end
+  end
+end

data/lib/sidekiq/reliable_job/outbox.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module ReliableJob
+    def self.base_class
+      @base_class ||= configuration.base_class.constantize
+    end
+
+    # ActiveRecord model for the job staging table.
+    class Outbox < base_class
+      self.table_name = "reliable_job_outbox"
+
+      PENDING = "pending"
+      ENQUEUED = "enqueued"
+      SCHEDULED = "scheduled"
+      DEAD = "dead"
+
+      scope :pending, -> { where(status: PENDING) }
+      scope :enqueued, -> { where(status: ENQUEUED) }
+      scope :scheduled, -> { where(status: SCHEDULED) }
+      scope :dead, -> { where(status: DEAD) }
+    end
+  end
+end

data/lib/sidekiq/reliable_job/outbox_processor.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module ReliableJob
+    # Fetches pending jobs from the Outbox and pushes them to Redis.
+    class OutboxProcessor
+      BATCH_SIZE = 1000
+
+      def call
+        Outbox.transaction do
+          Outbox.with_advisory_lock!("sidekiq_reliable_job", transaction: true, timeout_seconds: 0) do
+            jobs = fetch_pending_jobs
+            return 0 if jobs.empty?
+
+            immediate, scheduled = partition_jobs(jobs)
+
+            process_immediate_jobs(immediate)
+            process_scheduled_jobs(scheduled)
+
+            jobs.size
+          end
+        end
+      end
+
+      private
+
+      def fetch_pending_jobs
+        Outbox.pending.order(:id).limit(BATCH_SIZE).pluck(:id, :payload)
+      end
+
+      def partition_jobs(jobs)
+        jobs.partition { |_, payload| payload["at"].blank? }
+      end
+
+      def process_immediate_jobs(jobs)
+        return if jobs.empty?
+
+        mark_as_enqueued(jobs)
+        push_to_queues(jobs)
+      end
+
+      def process_scheduled_jobs(jobs)
+        return if jobs.empty?
+
+        mark_as_scheduled(jobs)
+        push_to_schedule(jobs)
+      end
+
+      def mark_as_enqueued(jobs)
+        ids = jobs.map(&:first)
+        Outbox.where(id: ids).update_all(status: Outbox::ENQUEUED, enqueued_at: Time.current)
+      end
+
+      def mark_as_scheduled(jobs)
+        ids = jobs.map(&:first)
+        Outbox.where(id: ids).update_all(status: Outbox::SCHEDULED, enqueued_at: Time.current)
+      end
+
+      def push_to_queues(jobs)
+        jobs_by_queue = jobs.group_by { |_, payload| payload["queue"] || "default" }
+
+        Sidekiq.redis do |conn|
+          conn.pipelined do |pipeline|
+            jobs_by_queue.each do |queue, queue_jobs|
+              payloads = queue_jobs.map { |_, payload| Sidekiq.dump_json(payload) }
+              pipeline.lpush("queue:#{queue}", payloads)
+            end
+          end
+        end
+      end
+
+      def push_to_schedule(jobs)
+        Sidekiq.redis do |conn|
+          conn.pipelined do |pipeline|
+            jobs.each do |(_id, payload)|
+              score = payload["at"].to_f
+              pipeline.zadd("schedule", score, Sidekiq.dump_json(payload))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/reliable_job/server_middleware.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "English"
+
+module Sidekiq
+  module ReliableJob
+    # Deletes staged jobs from the Outbox after successful completion.
+    class ServerMiddleware
+      include Sidekiq::ServerMiddleware
+
+      def call(_job_instance, job_payload, _queue)
+        yield
+      ensure
+        if $ERROR_INFO.nil? && job_payload["reliable_job"]
+          delete_staged_job(job_payload["jid"])
+        end
+      end
+
+      private
+
+      def delete_staged_job(jid)
+        Outbox.where(jid: jid).delete_all
+      rescue StandardError => e
+        Sidekiq.logger.error "Failed to delete reliable job #{jid}: #{e.message}"
+      end
+    end
+  end
+end

data/lib/sidekiq/reliable_job/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module ReliableJob
+    VERSION = "0.1.0"
+  end
+end

data/lib/sidekiq/reliable_job.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+require "sidekiq/job"
+require "with_advisory_lock"
+
+require_relative "reliable_job/version"
+require_relative "reliable_job/configuration"
+require_relative "reliable_job/outbox"
+require_relative "reliable_job/client"
+require_relative "reliable_job/client_middleware"
+require_relative "reliable_job/server_middleware"
+require_relative "reliable_job/outbox_processor"
+require_relative "reliable_job/enqueuer"
+
+module Sidekiq
+  module ReliableJob
+    class Error < StandardError; end
+
+    class << self
+      def configure_client!(config)
+        config.client_middleware do |chain|
+          chain.add Sidekiq::ReliableJob::ClientMiddleware
+        end
+      end
+
+      def configure_server!(config)
+        configure_client!(config)
+
+        config.server_middleware do |chain|
+          chain.add Sidekiq::ReliableJob::ServerMiddleware
+        end
+
+        config.death_handlers << method(:on_death)
+
+        enqueuer = Enqueuer.new(config)
+
+        config.on(:startup) do
+          enqueuer.start
+        end
+
+        config.on(:quiet) do
+          enqueuer.stop
+        end
+      end
+
+      def on_death(job, _exception)
+        return unless job["reliable_job"]
+
+        if configuration.preserve_dead_jobs
+          Outbox.where(jid: job["jid"]).update_all(status: Outbox::DEAD)
+        else
+          Outbox.where(jid: job["jid"]).delete_all
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-reliable_job
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Zulfiqar Ali
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: with_advisory_lock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: A Sidekiq extension that ensures jobs are only enqueued when database
+  transactions commit, jobs are deleted when they are completed.
+email:
+- zulfiqar@wealthsimple.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/generators/sidekiq/reliable_job/install_generator.rb
+- lib/generators/sidekiq_reliable_job/install/install_generator.rb
+- lib/generators/sidekiq_reliable_job/install/templates/migration.rb.tt
+- lib/sidekiq/reliable_job.rb
+- lib/sidekiq/reliable_job/client.rb
+- lib/sidekiq/reliable_job/client_middleware.rb
+- lib/sidekiq/reliable_job/configuration.rb
+- lib/sidekiq/reliable_job/enqueuer.rb
+- lib/sidekiq/reliable_job/outbox.rb
+- lib/sidekiq/reliable_job/outbox_processor.rb
+- lib/sidekiq/reliable_job/server_middleware.rb
+- lib/sidekiq/reliable_job/version.rb
+homepage: https://github.com/wealthsimple/sidekiq-reliable_job
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/wealthsimple/sidekiq-reliable_job
+  source_code_uri: https://github.com/wealthsimple/sidekiq-reliable_job
+  changelog_uri: https://github.com/wealthsimple/sidekiq-reliable_job/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Reliable enqueuing and completion tracking for Sidekiq jobs
+test_files: []