inst-jobs 3.1.17 → 3.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b4b6a00b5e6b9ec0916e799819a8ae75aac19faa368e869772b336f860a8109
-  data.tar.gz: 8f6a562afbf654e5937a5dc4d2540304ead783bab594722ca5c3b5782f6fdeb6
+  metadata.gz: 43f35fb4227a589dfb6d6d50c0b42ca44bdc83572ba7ac250d1ea887b8f4d558
+  data.tar.gz: 9f100f92e8bbe68961cbec784d04a12c9457c36a21c13337dcbda10d5d38f985
 SHA512:
-  metadata.gz: 4bbd25cfe653768aa2a755eab2c3ea45530debba4d86e12b8d5a1cfd169ddf3d59fc0fef9773a0e81b2abaeaf886e0dd7be2a208c22fc0e0323fec77205e64e7
-  data.tar.gz: 9a61ada6fb4f816c0dadaf159f0852d4a31d933dff50ad7dfb5e8439e0dfc09ce9c3c1baf2dc24ab79f41fa79b6ea0b4f703d4903248d436b576924c629511a6
+  metadata.gz: 489b588fbce6951d6b965d850c255a2bba887e2423a977b41a0a6f54142c569eaa96aa04a2e38f50114ff1c57a5e79cc83121cce20794f3ddfb289c15144c143
+  data.tar.gz: 893782fd155cfb9a83575597845e9500fc9199fa042f08bc087cc42a63b0630aef37bb640b865c4649b69478a57944b63ff4cd4ec2c2a154df9885f2e5d5d722

data/lib/delayed/backend/active_record.rb

@@ -28,21 +28,20 @@ module Delayed
         attr_accessor :enqueue_result
 
         scope :next_in_strand_order, -> { order(:strand_order_override, :id) }
+        scope :locked, -> { where.not(locked_by: nil) }
+        scope :not_locked, -> { where(locked_by: nil) }
+        scope :prefetched, -> { where(arel_table[:locked_by].matches("prefetch%")) }
 
         def self.reconnect!
-          if Rails.version < "6.1"
-            ::ActiveRecord::Base.connection_handler.clear_all_connections!
-          else
-            ::ActiveRecord::Base.connection_handler.clear_all_connections!(nil)
-          end
+          ::ActiveRecord::Base.connection_handler.clear_all_connections!(nil)
         end
 
         class << self
-          def create(attributes, &block)
+          def create(attributes, &)
             on_conflict = attributes.delete(:on_conflict)
             # modified from ActiveRecord::Persistence.create and ActiveRecord::Persistence#_insert_record
-            job = new(attributes, &block)
-            job.single_step_create(on_conflict: on_conflict)
+            job = new(attributes, &)
+            job.single_step_create(on_conflict:)
           end
 
           def attempt_advisory_lock(lock_name)
@@ -70,21 +69,12 @@ module Delayed
             _write_attribute(column, current_time) unless attribute_present?(column)
           end
 
-          attribute_names = if Rails.version < "7.0"
-                              attribute_names_for_partial_writes
-                            else
-                              attribute_names_for_partial_inserts
-                            end
+          attribute_names = attribute_names_for_partial_inserts
           attribute_names = attributes_for_create(attribute_names)
           values = attributes_with_values(attribute_names)
 
-          im = if Rails.version < "7.0"
-                 self.class.arel_table.compile_insert(self.class.send(:_substitute_values, values))
-               else
-                 im = Arel::InsertManager.new(self.class.arel_table)
-                 im.insert(values.transform_keys { |name| self.class.arel_table[name] })
-                 im
-               end
+          im = Arel::InsertManager.new(self.class.arel_table)
+          im.insert(values.transform_keys { |name| self.class.arel_table[name] })
 
           lock_and_insert = values["strand"] && instance_of?(Job)
           # can't use prepared statements if we're combining multiple statemenets
@@ -120,7 +110,7 @@ module Delayed
             # but we don't need to lock when inserting into Delayed::Failed
             if values["strand"] && instance_of?(Job)
               fn_name = connection.quote_table_name("half_md5_as_bigint")
-              quoted_strand = connection.quote((Rails.version < "7.0") ? values["strand"] : values["strand"].value)
+              quoted_strand = connection.quote(values["strand"].value)
               sql = "SELECT pg_advisory_xact_lock(#{fn_name}(#{quoted_strand})); #{sql}"
             end
             result = connection.execute(sql, "#{self.class} Create")
@@ -225,7 +215,7 @@ module Delayed
         end
 
         def self.strand_size(strand)
-          where(strand: strand).count
+          where(strand:).count
         end
 
         def self.running_jobs
@@ -250,7 +240,7 @@ module Delayed
 
           if %w[current future].include?(flavor.to_s)
             queue = query.presence || Delayed::Settings.queue
-            scope = scope.where(queue: queue)
+            scope = scope.where(queue:)
           end
 
           scope
@@ -346,16 +336,16 @@ module Delayed
           job_count = 0
           new_strand = "tmp_strand_#{SecureRandom.alphanumeric(16)}"
           ::Delayed::Job.transaction do
-            job_count = job_scope.update_all(strand: new_strand, max_concurrent: max_concurrent, next_in_strand: false)
+            job_count = job_scope.update_all(strand: new_strand, max_concurrent:, next_in_strand: false)
             ::Delayed::Job.where(strand: new_strand).order(:id).limit(max_concurrent).update_all(next_in_strand: true)
           end
 
           [job_count, new_strand]
         end
 
-        def self.maybe_silence_periodic_log(&block)
+        def self.maybe_silence_periodic_log(&)
           if Settings.silence_periodic_log
-            ::ActiveRecord::Base.logger.silence(&block)
+            ::ActiveRecord::Base.logger.silence(&)
           else
             yield
           end
@@ -368,7 +358,6 @@ module Delayed
                                              prefetch: 0,
                                              prefetch_owner: nil,
                                              forced_latency: nil)
-
           check_queue(queue)
           check_priorities(min_priority, max_priority)
 
@@ -386,7 +375,7 @@ module Delayed
                 target_jobs = all_available(queue,
                                             min_priority,
                                             max_priority,
-                                            forced_latency: forced_latency)
+                                            forced_latency:)
                               .limit(effective_worker_names.length + prefetch)
                               .lock(lock)
                 jobs_with_row_number = all.from(target_jobs)
@@ -429,10 +418,10 @@ module Delayed
                     # very conservatively lock the locked job, so that it won't unlock from underneath us and
                     # leave an orphaned strand
                     advisory_lock("singleton:#{singleton}")
-                    locked_jobs = where(singleton: singleton).where.not(locked_by: nil).lock.pluck(:id)
+                    locked_jobs = where(singleton:).where.not(locked_by: nil).lock.pluck(:id)
                     # if it's already gone, then we're good and should be able to just retry
                     if locked_jobs.length == 1
-                      updated = where(singleton: singleton, next_in_strand: true)
+                      updated = where(singleton:, next_in_strand: true)
                                 .where(locked_by: nil)
                                 .update_all(next_in_strand: false)
                       raise if updated.zero?
@@ -499,8 +488,8 @@ module Delayed
           check_queue(queue)
           check_priorities(min_priority, max_priority)
 
-          ready_to_run(forced_latency: forced_latency)
-            .where(priority: min_priority..max_priority, queue: queue)
+          ready_to_run(forced_latency:)
+            .where(priority: min_priority..max_priority, queue:)
             .by_priority
         end
 
@@ -513,7 +502,7 @@ module Delayed
           on_conflict = options.delete(:on_conflict) || :use_earliest
 
           transaction_for_singleton(singleton, on_conflict) do
-            job = where(strand: strand, locked_at: nil).next_in_strand_order.first
+            job = where(strand:, locked_at: nil).next_in_strand_order.first
             new_job = new(options)
             if job
               new_job.initialize_defaults
@@ -647,7 +636,7 @@ module Delayed
           self.table_name = :failed_jobs
 
           def self.cleanup_old_jobs(before_date, batch_size: 10_000)
-            where("failed_at < ?", before_date).in_batches(of: batch_size).delete_all
+            where(failed_at: ...before_date).in_batches(of: batch_size).delete_all
           end
 
           def requeue!

data/lib/delayed/backend/base.rb

@@ -40,7 +40,6 @@ module Delayed
                     n_strand: nil,
                     max_attempts: Delayed::Settings.max_attempts,
                     **kwargs)
-
           unless object.respond_to?(:perform)
             raise ArgumentError, "Cannot enqueue items which do not respond to perform"
           end
@@ -307,19 +306,14 @@ module Delayed
 
       # Moved into its own method so that new_relic can trace it.
       def invoke_job
+        ActiveSupport::ExecutionContext[:job] = self
         Delayed::Worker.lifecycle.run_callbacks(:invoke_job, self) do
           Delayed::Job.in_delayed_job = true
           begin
             payload_object.perform
           ensure
             Delayed::Job.in_delayed_job = false
-            unless Rails.env.test?
-              if Rails.version < "6.1"
-                ::ActiveRecord::Base.clear_active_connections!
-              else
-                ::ActiveRecord::Base.clear_active_connections!(nil)
-              end
-            end
+            ::ActiveRecord::Base.connection_handler.clear_active_connections!(nil) unless Rails.env.test?
           end
         end
       end
@@ -374,7 +368,7 @@ module Delayed
 
       private
 
-      PARSE_OBJECT_FROM_YAML = %r{!ruby/\w+:([^\s]+)}.freeze
+      PARSE_OBJECT_FROM_YAML = %r{!ruby/\w+:([^\s]+)}
       private_constant :PARSE_OBJECT_FROM_YAML
 
       def deserialize(source)

data/lib/delayed/batch.rb

@@ -25,8 +25,8 @@ module Delayed
     end
 
     class << self
-      def serial_batch(opts = {}, &block)
-        prepare_batches(:serial, opts, &block)
+      def serial_batch(opts = {}, &)
+        prepare_batches(:serial, opts, &)
       end
 
       private
@@ -51,7 +51,7 @@ module Delayed
             payload_object = args.delete(:payload_object)
             Delayed::Job.enqueue(payload_object, **args)
           else
-            Delayed::Job.enqueue(Delayed::Batch::PerformableBatch.new(mode, batch), **enqueue_args.merge(batch_args))
+            Delayed::Job.enqueue(Delayed::Batch::PerformableBatch.new(mode, batch), **enqueue_args, **batch_args)
           end
         end
       end

data/lib/delayed/daemon.rb

@@ -43,7 +43,7 @@ module Delayed
       # it somewhere useful
       last_ditch_logfile = Settings.last_ditch_logfile || "log/delayed_job.log"
       last_ditch_logfile = Settings.expand_rails_path(last_ditch_logfile) if last_ditch_logfile[0] != "|"
-      $stdin.reopen("/dev/null")
+      $stdin.reopen(File::NULL)
       $stdout.reopen(open(last_ditch_logfile, "a")) # rubocop:disable Security/Open
       $stderr.reopen($stdout)
       $stdout.sync = $stderr.sync = true
@@ -51,7 +51,7 @@ module Delayed
 
     # stop the currently running daemon (not this current process, the one in the pid_file)
     def stop(kill: false, pid: self.pid)
-      alive = status(pid: pid, print: false)
+      alive = status(pid:, print: false)
       if alive == :running || (kill && alive == :draining)
         puts "Stopping pool #{pid}..."
         signal = kill ? "TERM" : "QUIT"
@@ -68,9 +68,9 @@ module Delayed
 
     def wait(kill)
       if kill
-        sleep(0.5) while status(pid: pid, print: false)
+        sleep(0.5) while status(pid:, print: false)
       else
-        sleep(0.5) while status(pid: pid, print: false) == :running
+        sleep(0.5) while status(pid:, print: false) == :running
       end
     end
 

data/lib/delayed/engine.rb

@@ -2,5 +2,12 @@
 
 module Delayed
   class Engine < ::Rails::Engine
+    initializer "delayed_job.set_reloader_hook" do |app|
+      Delayed::Worker.lifecycle.around(:perform) do |worker, job, &block|
+        app.reloader.wrap(source: "application.delayed_job") do
+          block.call(worker, job)
+        end
+      end
+    end
   end
 end

data/lib/delayed/lifecycle.rb

@@ -30,34 +30,34 @@ module Delayed
       Delayed::Worker.plugins.each(&:reset!)
     end
 
-    def before(event, &block)
-      add(:before, event, &block)
+    def before(event, &)
+      add(:before, event, &)
     end
 
-    def after(event, &block)
-      add(:after, event, &block)
+    def after(event, &)
+      add(:after, event, &)
     end
 
-    def around(event, &block)
-      add(:around, event, &block)
+    def around(event, &)
+      add(:around, event, &)
     end
 
-    def run_callbacks(event, *args, &block)
+    def run_callbacks(event, *args, &)
       missing_callback(event) unless @callbacks.key?(event)
 
       unless EVENTS[event].size == args.size
         raise ArgumentError, "Callback #{event} expects #{EVENTS[event].size} parameter(s): #{EVENTS[event].join(", ")}"
       end
 
-      @callbacks[event].execute(*args, &block)
+      @callbacks[event].execute(*args, &)
     end
 
     private
 
-    def add(type, event, &block)
+    def add(type, event, &)
       missing_callback(event) unless @callbacks.key?(event)
 
-      @callbacks[event].add(type, &block)
+      @callbacks[event].add(type, &)
     end
 
     def missing_callback(event)
@@ -74,12 +74,12 @@ module Delayed
       @around = ->(*args, &block) { block.call(*args) }
     end
 
-    def execute(*args, &block)
+    def execute(*args, &)
       @before.each { |c| c.call(*args) }
-      result = @around.call(*args, &block)
+      result = @around.call(*args, &)
       @after.each do |c|
         if c.arity == args.length + 1 # don't fail for methods that don't define `result:`
-          c.call(*args, result: result)
+          c.call(*args, result:)
         else
           c.call(*args)
         end

data/lib/delayed/logging.rb

@@ -24,9 +24,7 @@ module Delayed
                 end
     end
 
-    def logger
-      Delayed::Logging.logger
-    end
+    delegate :logger, to: :"Delayed::Logging"
 
     def say(message, level = :debug)
       logger.send(level, message)

data/lib/delayed/message_sending.rb

@@ -56,10 +56,10 @@ module Delayed
             connection.after_transaction_commit do
               ::Delayed::Job.enqueue(::Delayed::PerformableMethod.new(@object,
                                                                       method,
-                                                                      args: args,
-                                                                      kwargs: kwargs,
-                                                                      on_failure: on_failure,
-                                                                      on_permanent_failure: on_permanent_failure,
+                                                                      args:,
+                                                                      kwargs:,
+                                                                      on_failure:,
+                                                                      on_permanent_failure:,
                                                                       sender: @sender),
                                      **@enqueue_args)
             end
@@ -69,10 +69,10 @@ module Delayed
 
         result = ::Delayed::Job.enqueue(::Delayed::PerformableMethod.new(@object,
                                                                          method,
-                                                                         args: args,
-                                                                         kwargs: kwargs,
-                                                                         on_failure: on_failure,
-                                                                         on_permanent_failure: on_permanent_failure,
+                                                                         args:,
+                                                                         kwargs:,
+                                                                         on_failure:,
+                                                                         on_permanent_failure:,
                                                                          sender: @sender),
                                         **@enqueue_args)
         result = nil unless ignore_transaction
@@ -101,7 +101,7 @@ module Delayed
 
       sender ||= __calculate_sender_for_delay
 
-      DelayProxy.new(self, sender: sender, **enqueue_args)
+      DelayProxy.new(self, sender:, **enqueue_args)
     end
 
     def __calculate_sender_for_delay

data/lib/delayed/periodic.rb

@@ -15,7 +15,7 @@ module Delayed
     self.overrides = {}
 
     def self.add_overrides(overrides)
-      overrides.each do |_name, cron_line|
+      overrides.each_value do |cron_line|
         # throws error if the line is malformed
         Fugit.do_parse_cron(cron_line)
       end
@@ -45,7 +45,7 @@ module Delayed
     # make sure all periodic jobs are scheduled for their next run in the job queue
     # this auditing should run on the strand
     def self.perform_audit!
-      scheduled.each { |_name, periodic| periodic.enqueue }
+      scheduled.each_value(&:enqueue)
     end
 
     def initialize(name, cron_line, job_args, block)

data/lib/delayed/pool.rb

@@ -69,19 +69,11 @@ module Delayed
       say "Unlocked #{unlocked_jobs} orphaned jobs" if unlocked_jobs.positive?
       return if Rails.env.test?
 
-      if Rails.version < "6.1"
-        ActiveRecord::Base.connection_handler.clear_all_connections!
-      else
-        ActiveRecord::Base.connection_handler.clear_all_connections!(nil)
-      end
+      ActiveRecord::Base.connection_handler.clear_all_connections!(nil)
     end
 
     def spawn_all_workers
-      if Rails.version < "6.1"
-        ActiveRecord::Base.connection_handler.clear_all_connections!
-      else
-        ActiveRecord::Base.connection_handler.clear_all_connections!(nil)
-      end
+      ActiveRecord::Base.connection_handler.clear_all_connections!(nil)
 
       if @config[:work_queue] == "parent_process"
         @work_queue = WorkQueue::ParentProcess.new
@@ -97,7 +89,7 @@ module Delayed
       parent_pid = Process.pid
       pid = fork_with_reconnects do
         $0 = "delayed_jobs_work_queue#{Settings.pool_procname_suffix}"
-        @work_queue.server(parent_pid: parent_pid).run
+        @work_queue.server(parent_pid:).run
       end
       workers[pid] = :work_queue
     end

data/lib/delayed/server.rb

@@ -37,13 +37,7 @@ module Delayed
 
     # Release any used connections back to the pool
     after do
-      if using_active_record?
-        if Rails.version < "6.1"
-          ::ActiveRecord::Base.clear_active_connections!
-        else
-          ::ActiveRecord::Base.clear_active_connections!(nil)
-        end
-      end
+      ::ActiveRecord::Base.connection_handler.clear_active_connections!(nil) if using_active_record?
     end
 
     configure :development do

data/lib/delayed/settings.rb

@@ -88,7 +88,7 @@ module Delayed
 
       def apply_worker_config!(config)
         SETTINGS.each do |setting|
-          send("#{setting}=", config[setting.to_s]) if config.key?(setting.to_s)
+          send(:"#{setting}=", config[setting.to_s]) if config.key?(setting.to_s)
         end
         if config.key?("parent_process_client_timeout")
           parent_process.client_timeout = config["parent_process_client_timeout"]

data/lib/delayed/testing.rb

@@ -17,8 +17,8 @@ module Delayed
       end
     end
 
-    def self.track_created(&block)
-      job_tracking = JobTracking.track(&block)
+    def self.track_created(&)
+      job_tracking = JobTracking.track(&)
       job_tracking.created
     end
 

data/lib/delayed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayed
-  VERSION = "3.1.17"
+  VERSION = "3.1.18"
 end

data/lib/delayed/work_queue/parent_process/server.rb

@@ -75,7 +75,7 @@ module Delayed
           readable, = IO.select(handles, nil, nil, timeout)
           readable&.each { |s| handle_read(s) }
           Delayed::Worker.lifecycle.run_callbacks(:check_for_work, self) do
-            check_for_work(forced_latency: forced_latency)
+            check_for_work(forced_latency:)
           end
           unlock_timed_out_prefetched_jobs
         end
@@ -159,8 +159,8 @@ module Delayed
                 worker_config[:min_priority],
                 worker_config[:max_priority],
                 prefetch: (Settings.fetch_batch_size * (worker_config[:workers] || 1)) - recipients.length,
-                prefetch_owner: prefetch_owner,
-                forced_latency: forced_latency
+                prefetch_owner:,
+                forced_latency:
               )
               logger.debug(
                 "Fetched and locked #{response.values.flatten.size} new jobs for workers (#{response.keys.join(", ")})."
@@ -226,11 +226,7 @@ module Delayed
 
             # otherwise just reconnect and let it retry
             logger.warn("failed to unlock prefetched jobs - connection terminated; skipping for now")
-            if Rails.version < "6.1"
-              ::Delayed::Job.clear_all_connections!
-            else
-              ::Delayed::Job.clear_all_connections!(nil)
-            end
+            ::Delayed::Job.clear_all_connections!(nil)
           end
         end
 
@@ -274,8 +270,8 @@ module Delayed
           @parent_pid && @parent_pid != Process.ppid
         end
 
-        def client_timeout(&block)
-          Timeout.timeout(@client_timeout, &block)
+        def client_timeout(&)
+          Timeout.timeout(@client_timeout, &)
         end
 
         ClientState = Struct.new(:working, :socket, :name)

data/lib/delayed/work_queue/parent_process.rb

@@ -43,7 +43,7 @@ module Delayed
         # The unix_server_socket method takes care of cleaning up any existing
         # socket for us if the work queue process dies and is restarted.
         listen_socket = Socket.unix_server_socket(@server_address)
-        Server.new(listen_socket, parent_pid: parent_pid, config: @config)
+        Server.new(listen_socket, parent_pid:, config: @config)
       end
 
       def client

data/lib/delayed/worker/consul_health_check.rb

@@ -22,7 +22,7 @@ module Delayed
         if config.keys.any? { |k| CONSUL_CONFIG_KEYS.include?(k) }
           consul_config = Diplomat::Configuration.new.tap do |conf|
             CONSUL_CONFIG_KEYS.each do |key|
-              conf.send("#{key}=", config[key]) if config[key]
+              conf.send(:"#{key}=", config[key]) if config[key]
             end
           end
           @service_client = Diplomat::Service.new(configuration: consul_config)

data/lib/delayed/worker/health_check.rb

@@ -19,7 +19,7 @@ module Delayed
           klass = @subclasses.find { |sc| sc.type_name == type }
           raise ArgumentError, "Unable to build a HealthCheck for type #{type}" unless klass
 
-          klass.new(worker_name: worker_name, config: config)
+          klass.new(worker_name:, config:)
         end
 
         def reschedule_abandoned_jobs

data/lib/delayed/worker/process_helper.rb

@@ -9,7 +9,7 @@ module Delayed
       ALIVE_CHECK_LINUX = '[ -d "/proc/$WORKER_PID" ]'
       ALIVE_CHECK_MAC = "ps -p $WORKER_PID > /dev/null"
       ALIVE_CHECK = RUBY_PLATFORM.include?("darwin") ? ALIVE_CHECK_MAC : ALIVE_CHECK_LINUX
-      SCRIPT_TEMPLATE = <<~SH
+      SCRIPT_TEMPLATE = <<~SH.freeze
         WORKER_PID="%{pid}" # an example, filled from ruby when the check is created
         ORIGINAL_MTIME="%{mtime}" # an example, filled from ruby when the check is created
 
@@ -37,7 +37,7 @@ module Delayed
       end
 
       def self.check_script(pid, mtime)
-        format(SCRIPT_TEMPLATE, { pid: pid, mtime: mtime })
+        format(SCRIPT_TEMPLATE, { pid:, mtime: })
       end
 
       def self.process_is_still_running?(pid, mtime)

data/lib/delayed/worker.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "delayed/rails_reloader_plugin"
-
 module Delayed
   class TimeoutError < RuntimeError; end
 
@@ -73,7 +71,6 @@ module Delayed
 
       @signal_queue = []
 
-      plugins << Delayed::RailsReloaderPlugin
       plugins.each(&:inject!)
     end
 

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: inst-jobs
 version: !ruby/object:Gem::Version
-  version: 3.1.17
+  version: 3.1.18
 platform: ruby
 authors:
 - Cody Cutrer
 - Ethan Vizitei
 - Jacob Burroughs
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-23 00:00:00.000000000 Z
+date: 2025-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,14 +18,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: activerecord-pg-extensions
   requirement: !ruby/object:Gem::Requirement
@@ -46,14 +46,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: after_transaction_commit
   requirement: !ruby/object:Gem::Requirement
@@ -186,6 +186,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.6.3
+- !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: pg
   requirement: !ruby/object:Gem::Requirement
@@ -290,14 +304,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: sinatra
   requirement: !ruby/object:Gem::Requirement
@@ -316,16 +330,16 @@ dependencies:
   name: sinatra-contrib
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
@@ -354,7 +368,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - cody@instructure.com
 - evizitei@instructure.com
@@ -422,7 +436,6 @@ files:
 - lib/delayed/periodic.rb
 - lib/delayed/plugin.rb
 - lib/delayed/pool.rb
-- lib/delayed/rails_reloader_plugin.rb
 - lib/delayed/server.rb
 - lib/delayed/server/helpers.rb
 - lib/delayed/server/public/css/app.css
@@ -448,7 +461,7 @@ homepage: https://github.com/instructure/inst-jobs
 licenses: []
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -456,15 +469,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Instructure-maintained fork of delayed_job
 test_files: []

data/lib/delayed/rails_reloader_plugin.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require "delayed/plugin"
-
-module Delayed
-  class RailsReloaderPlugin < Plugin
-    callbacks do |lifecycle|
-      app = Rails.application
-      if app && !app.config.cache_classes
-        lifecycle.around(:perform) do |worker, job, &block|
-          reload = !app.config.reload_classes_only_on_change || app.reloaders.any?(&:updated?)
-
-          if reload
-            if defined?(ActiveSupport::Reloader)
-              Rails.application.reloader.reload!
-            else
-              ActionDispatch::Reloader.prepare!
-            end
-          end
-
-          begin
-            block.call(worker, job)
-          ensure
-            ActionDispatch::Reloader.cleanup! if reload && !defined?(ActiveSupport::Reloader)
-          end
-        end
-      end
-    end
-  end
-end