backburner 1.7.0 → 1.9.0

data/lib/backburner/worker.rb

@@ -9,6 +9,10 @@ module Backburner
     include Backburner::Helpers
     include Backburner::Logger
 
+    # The longest a worker that doesn't have a job's class waits to hand the job out again (its TTR
+    # otherwise), so a worker that has it picks it up soon after a rollout
+    MAX_CLASS_NOT_FOUND_DELAY = 60
+
     # Backburner::Worker.known_queue_classes
     # List of known_queue_classes
     class << self
@@ -17,7 +21,8 @@ module Backburner
     end
 
     # Enqueues a job to be processed later by a worker.
-    # Options: `pri` (priority), `delay` (delay in secs), `ttr` (time to respond), `queue` (queue name)
+    # Options: `pri` (priority), `delay` (delay in secs, rounded up to whole seconds), `ttr` (time to respond),
+    # `queue` (queue name)
     #
     # @raise [Beaneater::NotConnected] If beanstalk fails to connect.
     # @example
@@ -25,7 +30,7 @@ module Backburner
     #
     def self.enqueue(job_class, args=[], opts={})
       pri   = resolve_priority(opts[:pri] || job_class)
-      delay = [0, opts[:delay].to_i].max
+      delay = whole_seconds(opts[:delay])
       ttr   = resolve_respond_timeout(opts[:ttr] || job_class)
       res   = Backburner::Hooks.invoke_hook_events(job_class, :before_enqueue, *args)
 
@@ -34,18 +39,15 @@ module Backburner
       data = { :class => job_class.name, :args => args }
       queue = opts[:queue] && (Proc === opts[:queue] ? opts[:queue].call(job_class) : opts[:queue])
 
-      begin
-        response = nil
-        connection = Backburner::Connection.new(Backburner.configuration.beanstalk_url)
+      response = nil
+      Backburner::EnqueuePool.current.with_connection do |connection|
         connection.retryable do
           tube = connection.tubes[expand_tube_name(queue || job_class)]
           serialized_data = Backburner.configuration.job_serializer_proc.call(data)
           response = tube.put(serialized_data, :pri => pri, :delay => delay, :ttr => ttr)
         end
-        return nil unless Backburner::Hooks.invoke_hook_events(job_class, :after_enqueue, *args)
-      ensure
-        connection.close if connection
       end
+      return nil unless Backburner::Hooks.invoke_hook_events(job_class, :after_enqueue, *args)
 
       response
     end
@@ -71,6 +73,7 @@ module Backburner
     # @example
     #   Worker.new(['test.job'])
     def initialize(tube_names=nil)
+      @existing_tube_names = nil # set by all_existing_queues, read by expand_tube_name
       @connection = new_connection
       @tube_names = self.process_tube_names(tube_names)
       register_signal_handlers!
@@ -102,9 +105,12 @@ module Backburner
 
     # Triggers this worker to shutdown
     def shutdown
-      Thread.new do
-        log_info 'Worker exiting...'
-      end
+      # Logs from another thread, since a trap handler can't take a logger's lock, and waits for it (a
+      # second at most): the process exits right after, and an unjoined thread never got to run
+      # ceiling: if the signal lands while the main thread holds the logger's lock, the line is lost after a
+      # second; handling the signal outside the trap (the self-pipe Threading uses) would lift it
+      Thread.new { log_info 'Worker exiting...' }.join(1)
+    ensure
       Kernel.exit
     end
 
@@ -134,7 +140,7 @@ module Backburner
       end
 
       self.log_job_begin(job.name, job.args)
-      job.process
+      wrap_in_rails_reloader { job.process }
       self.log_job_end(job.name)
 
     rescue Backburner::Job::JobFormatInvalid => e
@@ -149,17 +155,45 @@ module Backburner
 
       # NB: There's a slight chance here that the connection to beanstalkd has
       # gone down between the time we reserved / processed the job and here.
-      num_retries = job.stats.releases
-      max_job_retries = resolve_max_job_retries(job.job_class)
-      retry_status = "failed: attempt #{num_retries+1} of #{max_job_retries+1}"
-      if num_retries < max_job_retries # retry again
-        retry_delay = resolve_retry_delay(job.job_class)
-        delay = resolve_retry_delay_proc(job.job_class).call(retry_delay, num_retries) rescue retry_delay
-        job.retry(num_retries + 1, delay)
-        self.log_job_end(job.name, "#{retry_status}, retrying in #{delay}s") if job_started_at
-      else # retries failed, bury
-        job.bury
-        self.log_job_end(job.name, "#{retry_status}, burying") if job_started_at
+      class_missing = false
+      begin
+        job_class = begin
+          job.job_class
+        rescue Backburner::Job::JobNotFound # missing, or its file failed to load: see below
+          nil
+        end
+        if job_class.nil? && job.job_class_missing?
+          # This worker doesn't have its class (renamed or removed, or a worker deployed before the code
+          # that enqueues it): give it back for a worker that has it rather than burying it, once per TTR
+          # (at most a minute) as beanstalkd would, without on_error or the failure hooks (as before) or
+          # using up its retries. A class whose file fails to load goes the normal failure path instead.
+          # ceiling: beanstalkd still counts the release, so once a worker has the class, a failure there
+          # gets fewer retries; counting these releases apart would need a marker in the job body.
+          class_missing = true
+          delay = [job.ttr || queue_config.respond_timeout, MAX_CLASS_NOT_FOUND_DELAY].min
+          job.task.release(:delay => delay)
+          self.log_warn "#{job.name}: class not found; released for #{delay}s for a worker that has it"
+          return
+        end
+        num_retries = job.stats.releases
+        max_job_retries = resolve_max_job_retries(job_class)
+        retry_status = "failed: attempt #{num_retries+1} of #{max_job_retries+1}"
+        if num_retries < max_job_retries # retry again
+          retry_delay = resolve_retry_delay(job_class)
+          delay = resolve_retry_delay_proc(job_class).call(retry_delay, num_retries) rescue retry_delay
+          delay = whole_seconds(delay)
+          job.retry(num_retries + 1, delay)
+          self.log_job_end(job.name, "#{retry_status}, retrying in #{delay}s") if job_started_at
+        else # retries failed, bury
+          job.bury
+          self.log_job_end(job.name, "#{retry_status}, burying") if job_started_at
+        end
+      rescue Beaneater::NotFoundError, Beaneater::NotConnected
+        # Its TTR ran out first, or the connection was lost: beanstalkd releases a reserved job when
+        # its TTR runs out or its client disconnects (unless the server restarted and lost it).
+        # (An error raised in a rescue clause isn't caught by the method's other rescues, hence this one.)
+        self.log_error "#{job.name} was no longer reserved (its TTR ran out, or the connection was lost), so it was neither retried nor buried"
+        return if class_missing # on_error isn't called for a class this worker lacks
       end
 
       handle_error(e, job.name, job.args, job)
@@ -173,6 +207,36 @@ module Backburner
       Connection.new(Backburner.configuration.beanstalk_url) { |conn| Backburner::Hooks.invoke_hook_events(self, :on_reconnect, conn) }
     end
 
+    # Runs the block (a job's processing) in the Rails app's reloader when there is one, as Rails does for Active Job
+    # jobs (whose own wrap, inside this one, then does nothing): each job starts with fresh CurrentAttributes, gives
+    # back its database connections when it's done and, in development, runs the app's latest code. On Rails 7.0+ the
+    # wrap reports the errors that leave it to Rails.error (with the source "job.backburner" on 7.1+); a RetryJob, a
+    # request to retry rather than a failure, and a SystemExit (a TERM or INT the worker stops on, or a job calling
+    # exit), which Rails 7.2+ would report too, are raised again outside it instead.
+    # ceiling: config.on_error and the on_retry and on_bury hooks run after the wrap ends, so they don't see the job's
+    # CurrentAttributes, and a database connection they use is outside the executor; running work_one_job's failure
+    # handling inside the wrap would lift it. In development, a Forking or ThreadsOnFork parent never runs the wrap, so
+    # after a file change each child reloads the app once.
+    def wrap_in_rails_reloader
+      app = ::Rails.application if defined?(::Rails) && ::Rails.respond_to?(:application)
+      return yield unless app.respond_to?(:reloader)
+      deferred = nil
+      work = proc do
+        begin
+          yield
+        rescue Backburner::Job::RetryJob, SystemExit => e
+          deferred = e
+        end
+      end
+      # Active Support 7.1+ take the source the executor reports errors with; older ones take no options
+      if ActiveSupport.gem_version >= Gem::Version.new("7.1")
+        app.reloader.wrap(source: "job.backburner", &work)
+      else
+        app.reloader.wrap(&work)
+      end
+      raise deferred if deferred
+    end
+
     # Reserve a job from the watched queues
     def reserve_job(conn, reserve_timeout = Backburner.configuration.reserve_timeout)
       Backburner::Job.new(conn.tubes.reserve(reserve_timeout))
@@ -181,11 +245,49 @@ module Backburner
     # Returns a list of all tubes known within the system
     # Filtered for tubes that match the known prefix
     def all_existing_queues
-      known_queues    = Backburner::Worker.known_queue_classes.map(&:queue)
-      existing_tubes  = self.connection.tubes.all.map(&:name).select { |tube| tube =~ /^#{queue_config.tube_namespace}/ }
+      known_queues    = Backburner::Worker.known_queue_classes.select(&:name).map(&:queue) # an anonymous class can't be a job
+      prefix          = expanded_tube_prefix # the start of every tube name enqueueing with this configuration gives
+      namespace       = queue_config.tube_namespace
+      cut             = namespace && "#{namespace}#{queue_config.namespace_separator}".include?(':') # every name is the prefix
+      existing_tubes  = self.connection.tubes.all.map(&:name).select do |tube| # only the names this configuration can give
+        cut ? tube == prefix : tube.start_with?(prefix) && tube[prefix.size..-1] !~ /[A-Z_]/ # the rest is dasherized
+      end
+      # ceiling: a server tube named exactly like a known queue name is still expanded like that name, as before;
+      # the workers' prepare keeping found tubes apart from queue names would lift it
+      @existing_tube_names = existing_tubes - known_queues - [queue_config.primary_queue]
       existing_tubes + known_queues + [queue_config.primary_queue]
     end
 
+    # Leaves the server's tube names all_existing_queues found as they are: expanding one again can change it
+    # ("MyApp.default" would become "MyApp.my-app.default")
+    def expand_tube_name(tube)
+      @existing_tube_names && @existing_tube_names.include?(tube) ? tube : super
+    end
+    public :expand_tube_name
+
+
+    # Merges the options the block gives for each known queue class (its queue_jobs_limit and so on)
+    # into its tube's entry in tubes_data, for tubes that are there. A class that declares its tube
+    # overrides the tube's options; a subclass sharing its parent's tube only fills in the ones still
+    # unset. Anonymous classes are skipped.
+    def merge_tube_settings(tubes_data)
+      owners, sharers = Backburner::Worker.known_queue_classes.select(&:name).partition { |queue| !shares_parent_tube?(queue) }
+      [[owners, true], [sharers, false]].each do |classes, override|
+        classes.each do |queue|
+          data = tubes_data[expand_tube_name(queue)]
+          next if data.nil?
+          data.merge!(yield(queue)) { |_key, current, setting| (override ? setting.nil? : !current.nil?) ? current : setting }
+        end
+      end
+    end
+
+    # Whether a queue class uses the same tube as its closest named Backburner::Queue ancestor
+    def shares_parent_tube?(queue)
+      return false unless queue.respond_to?(:superclass)
+      parent = queue.superclass
+      parent = parent.superclass while parent.is_a?(Backburner::Queue::ClassMethods) && parent.name.nil?
+      parent.is_a?(Backburner::Queue::ClassMethods) && expand_tube_name(parent) == expand_tube_name(queue)
+    end
 
     # Handles an error according to custom definition
     # Used when processing a job that errors out
@@ -199,6 +301,8 @@ module Backburner
           error_handler.call(e, name, args, job)
         end
       end
+    rescue => handler_error # an error reporter that fails (can't reach its service, say) mustn't stop the worker
+      log_error "The on_error handler failed for #{name}: #{exception_message(handler_error)}"
     end
 
     # Normalizes tube names given array of tube_names
@@ -217,5 +321,26 @@ module Backburner
       trap('TERM') { shutdown  }
       trap('INT')  { shutdown  }
     end
+
+    # Whether a forked child disables the GC as it exits (see with_gc_disabled_on_exit): only on CRuby 3.3
+    def self.gc_disabled_on_exit?(engine = RUBY_ENGINE, version = RUBY_VERSION)
+      engine == "ruby" && version.start_with?("3.3.")
+    end
+
+    # Runs the body of a forked child, then, on Ruby 3.3, disables the GC before the child exits by any
+    # path that tears the interpreter down: returning, an exception, or Kernel.exit (as the TERM and INT
+    # traps do). Kernel.exit! skips the ensure, and the teardown with it. The child's at_exit handlers
+    # (its own and those it inherited) then run with the GC off.
+    # ceiling: works around a Ruby 3.3 bug: a child forked while another thread of its parent runs
+    # finalizers can crash as it exits ("[BUG] lazy sweeping underway when freeing object space").
+    # GC.disable finishes the lazy sweep first. Fixed in Ruby 3.4 by ruby/ruby 868d63f0a3 (not
+    # backported to 3.3, and not seen on 3.1 or 3.2); this can go once Ruby 3.3 support is dropped.
+    # Limits: an at_exit handler that calls GC.enable itself can still crash, and a TERM that lands while
+    # a ThreadsOnFork child is starting its job threads can leave one of them running during at_exit.
+    def with_gc_disabled_on_exit
+      yield
+    ensure
+      GC.disable if Worker.gc_disabled_on_exit?
+    end
   end # Worker
 end # Backburner

data/lib/backburner/workers/forking.rb

@@ -29,8 +29,10 @@ module Backburner
       # Waits for a job, works the job, and exits
       def fork_one_job
         pid = Process.fork do
-          work_one_job
-          coolest_exit
+          with_gc_disabled_on_exit do
+            work_one_job
+            coolest_exit
+          end
         end
         Process.wait(pid)
       end

data/lib/backburner/workers/simple.rb

@@ -24,6 +24,11 @@ module Backburner
         prepare
         loop { work_one_job }
       end
+
+      # A reconnected connection only watches the default tube: watch ours again
+      def on_reconnect(conn)
+        conn.tubes.watch!(*self.tube_names)
+      end
     end # Basic
   end # Workers
 end # Backburner

data/lib/backburner/workers/threading.rb

@@ -7,6 +7,9 @@ module Backburner
 
       @shutdown_timeout = 10
 
+      # The longest a pool thread waits in reserve at a time (beanstalkd takes whole seconds)
+      SHUTDOWN_CHECK_INTERVAL = 1
+
       class << self
         attr_accessor :threads_number
         attr_accessor :shutdown_timeout
@@ -15,6 +18,7 @@ module Backburner
       # Custom initializer just to set @tubes_data
       def initialize(*args)
         @tubes_data = {}
+        @in_shutdown = false
         super
         self.process_tube_options
         @exit_on_shutdown = true
@@ -108,13 +112,7 @@ module Backburner
       # If the tube is known by existing beanstalkd queue, but not by class - skip it
       #
       def process_tube_options
-        Backburner::Worker.known_queue_classes.each do |queue|
-          next if @tubes_data[expand_tube_name(queue)].nil?
-          queue_settings = {
-            :threads => queue.queue_jobs_limit
-          }
-          @tubes_data[expand_tube_name(queue)].merge!(queue_settings){|k, v1, v2| v2.nil? ? v1 : v2 }
-        end
+        merge_tube_settings(@tubes_data) { |queue| { :threads => queue.queue_jobs_limit } }
       end
 
       # Wait for the shutdown signel
@@ -158,6 +156,18 @@ module Backburner
           end
         end
       end
+
+      protected
+
+      # Reserves for at most SHUTDOWN_CHECK_INTERVAL seconds, so an idle thread sees a shutdown
+      # and stops instead of waiting in reserve until shutdown_timeout kills it
+      # ceiling: each idle thread sends beanstalkd a reserve once a second; waking the waiting
+      # reserves at shutdown instead would avoid that polling
+      def reserve_job(conn, reserve_timeout = Backburner.configuration.reserve_timeout)
+        timeout = reserve_timeout.to_s.to_i if reserve_timeout # as beanstalkd reads what beaneater sends: "5", 2.5, 5.seconds
+        timeout = SHUTDOWN_CHECK_INTERVAL if timeout.nil? || timeout < 0 || timeout > SHUTDOWN_CHECK_INTERVAL
+        super(conn, timeout)
+      end
     end # Threading
   end # Workers
 end # Backburner

data/lib/backburner/workers/threads_on_fork.rb

@@ -69,6 +69,7 @@ module Backburner
       # Custom initializer just to set @tubes_data
       def initialize(*args)
         @tubes_data = {}
+        @watching_tube = nil
         super
         self.process_tube_options
       end
@@ -108,14 +109,8 @@ module Backburner
       # If the tube is known by existing beanstalkd queue, but not by class - skip it
       #
       def process_tube_options
-        Backburner::Worker.known_queue_classes.each do |queue|
-          next if @tubes_data[expand_tube_name(queue)].nil?
-          queue_settings = {
-              :threads => queue.queue_jobs_limit,
-              :garbage => queue.queue_garbage_limit,
-              :retries => queue.queue_retry_limit
-          }
-          @tubes_data[expand_tube_name(queue)].merge!(queue_settings){|k, v1, v2| v2.nil? ? v1 : v2 }
+        merge_tube_settings(@tubes_data) do |queue|
+          { :threads => queue.queue_jobs_limit, :garbage => queue.queue_garbage_limit, :retries => queue.queue_retry_limit }
         end
       end
 
@@ -140,18 +135,37 @@ module Backburner
         end
       end
 
+      # After a child fails, the parent waits before forking the next one: MIN_RESTART_DELAY seconds,
+      # doubling while children keep failing (beanstalkd is down, say) up to MAX_RESTART_DELAY, and
+      # starting over once a child is recycled (99) or runs for MAX_RESTART_DELAY seconds
+      MIN_RESTART_DELAY = 1
+      MAX_RESTART_DELAY = 30
+
       # Make the fork and create a thread to watch the child process
       # The exit code '99' means that the fork exited because of the garbage limit
       # Any other code is an error
       def fork_and_watch(name)
         create_thread(name) do |tube_name|
+          restart_delay = 0
           until self.class.shutdown
+            forked_at = monotonic_time
             pid = fork_tube(tube_name)
             _, status = wait_for_process(pid)
 
             # 99 = garbaged
-            if status.exitstatus != 99
-              log_error("Catastrophic failure: tube #{tube_name} exited with code #{status.exitstatus}.")
+            if status.exitstatus == 99
+              restart_delay = 0
+            elsif self.class.shutdown # stopped by SIGTERM or SIGINT, or killed by finish_forks: not forked again
+              log_info(status.exitstatus == 0 ? "Tube #{tube_name} exited normally." : "Tube #{tube_name} stopped.")
+            else
+              ran_for = monotonic_time - forked_at
+              restart_delay = ran_for >= MAX_RESTART_DELAY ? MIN_RESTART_DELAY : (restart_delay * 2).clamp(MIN_RESTART_DELAY, MAX_RESTART_DELAY)
+              if status.exitstatus == 0 # stopped by a signal sent to the child alone, or a job called exit
+                log_warn("Tube #{tube_name} exited with code 0. Forking it again in #{restart_delay}s.")
+              else
+                log_error("Catastrophic failure: tube #{tube_name} exited with code #{status.exitstatus}. Forking it again in #{restart_delay}s.")
+              end
+              Kernel.sleep(restart_delay)
             end
           end
         end
@@ -182,22 +196,37 @@ module Backburner
         @runs = 0
 
         if @threads_number == 1
+          # Each forked child needs its own socket: the parent's connection is shared by every fork
+          self.connection = new_connection
           watch_tube(name)
           run_while_can
         else
-          threads_count = Thread.list.count
-          @threads_number.times do
-            create_thread do
-              begin
-                conn = new_connection
-                watch_tube(name, conn)
-                run_while_can(conn)
-              ensure
-                conn.close if conn
+          failed = false
+          threads = []
+          begin
+            @threads_number.times do
+              threads << create_thread do
+                begin
+                  conn = new_connection
+                  watch_tube(name, conn)
+                  run_while_can(conn)
+                rescue Exception
+                  failed = true
+                  raise
+                ensure
+                  conn.close if conn
+                end
               end
             end
+            # Wait for these threads only: others can outlive them (the timeout gem's, since Ruby 3.2)
+            sleep 0.1 while threads.any?(&:alive?)
+          rescue Exception # TERM, INT or an error: on Ruby 3.3 the child runs its at_exit handlers with the GC
+            # off (see with_gc_disabled_on_exit), so its threads mustn't keep working jobs meanwhile
+            threads.each(&:kill) if Worker.gc_disabled_on_exit?
+            raise
           end
-          sleep 0.1 while Thread.list.count > threads_count
+          # Fail like a single-threaded child whose connection raised, so the parent backs off
+          Kernel.exit!(1) if failed
         end
 
         coolest_exit
@@ -233,6 +262,11 @@ module Backburner
         Thread.new(*args, &block)
       end
 
+      # Seconds on a clock that only moves forward. Easy to test
+      def monotonic_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
       # Wait for a specific process. Easy to test
       def wait_for_process(pid)
         out = Process.wait2(pid)
@@ -245,9 +279,11 @@ module Backburner
       # never shutdown
       def fork_it(&blk)
         pid = Kernel.fork do
-          self.class.is_child = true
-          $0 = "[ThreadsOnFork worker] parent: #{Process.ppid}"
-          blk.call
+          with_gc_disabled_on_exit do
+            self.class.is_child = true
+            $0 = "[ThreadsOnFork worker] parent: #{Process.ppid}"
+            blk.call
+          end
         end
         self.class.child_pids << pid
         pid

data/lib/backburner.rb

@@ -7,6 +7,7 @@ require 'backburner/helpers'
 require 'backburner/configuration'
 require 'backburner/logger'
 require 'backburner/connection'
+require 'backburner/enqueue_pool'
 require 'backburner/hooks'
 require 'backburner/performable'
 require 'backburner/worker'
@@ -15,7 +16,12 @@ require 'backburner/workers/forking'
 require 'backburner/workers/threads_on_fork'
 require 'backburner/workers/threading'
 require 'backburner/queue'
-require 'active_job/queue_adapters/backburner_adapter' if defined?(ActiveJob)
+# On Rails 7.2+ (which added AbstractAdapter) use this gem's Active Job adapter; older Rails autoload theirs.
+# Not when Rails' autoload has already loaded the adapter or is loading it (an adapter file requires backburner).
+if defined?(ActiveJob::QueueAdapters::AbstractAdapter) && (ActiveJob::QueueAdapters.autoload?(:BackburnerAdapter) ||
+   !ActiveJob::QueueAdapters.constants(false).include?(:BackburnerAdapter))
+  require 'active_job/queue_adapters/backburner_adapter'
+end
 
 module Backburner
   class << self

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: backburner
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.9.0
 platform: ruby
 authors:
 - Nathan Esquenazi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-02 00:00:00.000000000 Z
+date: 2026-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: beaneater
@@ -58,6 +58,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.1
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -86,6 +100,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 5.1.0
+- !ruby/object:Gem::Dependency
+  name: mutex_m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -136,32 +164,18 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
 - CHANGELOG.md
-- CONTRIBUTING.md
-- Gemfile
 - HOOKS.md
 - LICENSE
 - README.md
-- Rakefile
-- TODO
-- backburner.gemspec
 - bin/backburner
-- circle.yml
-- examples/custom.rb
-- examples/demo.rb
-- examples/god.rb
-- examples/hooked.rb
-- examples/retried.rb
-- examples/simple.rb
-- examples/stress.rb
 - lib/active_job/queue_adapters/backburner_adapter.rb
 - lib/backburner.rb
 - lib/backburner/async_proxy.rb
 - lib/backburner/cli.rb
 - lib/backburner/configuration.rb
 - lib/backburner/connection.rb
+- lib/backburner/enqueue_pool.rb
 - lib/backburner/helpers.rb
 - lib/backburner/hooks.rb
 - lib/backburner/job.rb
@@ -175,32 +189,14 @@ files:
 - lib/backburner/workers/simple.rb
 - lib/backburner/workers/threading.rb
 - lib/backburner/workers/threads_on_fork.rb
-- test/async_proxy_test.rb
-- test/back_burner_test.rb
-- test/connection_test.rb
-- test/fixtures/active_jobs.rb
-- test/fixtures/hooked.rb
-- test/fixtures/test_fork_jobs.rb
-- test/fixtures/test_forking_jobs.rb
-- test/fixtures/test_jobs.rb
-- test/fixtures/test_queue_settings.rb
-- test/helpers/templogger.rb
-- test/helpers_test.rb
-- test/hooks_test.rb
-- test/job_test.rb
-- test/logger_test.rb
-- test/performable_test.rb
-- test/queue_test.rb
-- test/test_helper.rb
-- test/worker_test.rb
-- test/workers/forking_worker_test.rb
-- test/workers/simple_worker_test.rb
-- test/workers/threading_worker_test.rb
-- test/workers/threads_on_fork_worker_test.rb
-homepage: http://github.com/nesquena/backburner
+homepage: https://github.com/nesquena/backburner
 licenses:
 - MIT
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/nesquena/backburner
+  changelog_uri: https://github.com/nesquena/backburner/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/nesquena/backburner/issues
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -209,37 +205,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Reliable beanstalk background job processing made easy for Ruby and Sinatra
-test_files:
-- test/async_proxy_test.rb
-- test/back_burner_test.rb
-- test/connection_test.rb
-- test/fixtures/active_jobs.rb
-- test/fixtures/hooked.rb
-- test/fixtures/test_fork_jobs.rb
-- test/fixtures/test_forking_jobs.rb
-- test/fixtures/test_jobs.rb
-- test/fixtures/test_queue_settings.rb
-- test/helpers/templogger.rb
-- test/helpers_test.rb
-- test/hooks_test.rb
-- test/job_test.rb
-- test/logger_test.rb
-- test/performable_test.rb
-- test/queue_test.rb
-- test/test_helper.rb
-- test/worker_test.rb
-- test/workers/forking_worker_test.rb
-- test/workers/simple_worker_test.rb
-- test/workers/threading_worker_test.rb
-- test/workers/threads_on_fork_worker_test.rb
+test_files: []