inst-jobs 3.1.16 → 3.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f72da158c53a425c974608dd30ca4f16f0c70071f3f159e16488b40677f2efe
-  data.tar.gz: a039610f1a50c70abaf4f2b36f81a19e748429cd3c675c7c789703d0ba1f8d02
+  metadata.gz: 43f35fb4227a589dfb6d6d50c0b42ca44bdc83572ba7ac250d1ea887b8f4d558
+  data.tar.gz: 9f100f92e8bbe68961cbec784d04a12c9457c36a21c13337dcbda10d5d38f985
 SHA512:
-  metadata.gz: 6d5d65c583bd1e818918ffc927be4779129d556670d910dd7781a7c2c5be0d178e3315e1a8a1bfb1b0784d3b5b09be7b59187e402915c28a1e33fa726bad7c38
-  data.tar.gz: 2cfbe4d0840eae6ee31941dd8b0b8a681c07ab2b6dcc3c832198198eb02a146c6068f8f83081f31f03e0a93a763c9fdd5f62767e5ab1383e1214cbc84489d1e1
+  metadata.gz: 489b588fbce6951d6b965d850c255a2bba887e2423a977b41a0a6f54142c569eaa96aa04a2e38f50114ff1c57a5e79cc83121cce20794f3ddfb289c15144c143
+  data.tar.gz: 893782fd155cfb9a83575597845e9500fc9199fa042f08bc087cc42a63b0630aef37bb640b865c4649b69478a57944b63ff4cd4ec2c2a154df9885f2e5d5d722

data/lib/delayed/backend/active_record.rb

@@ -28,30 +28,31 @@ 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)
             fn_name = connection.quote_table_name("half_md5_as_bigint")
+            lock_name = connection.quote_string(lock_name)
             connection.select_value("SELECT pg_try_advisory_xact_lock(#{fn_name}('#{lock_name}'));")
           end
 
           def advisory_lock(lock_name)
             fn_name = connection.quote_table_name("half_md5_as_bigint")
+            lock_name = connection.quote_string(lock_name)
             connection.execute("SELECT pg_advisory_xact_lock(#{fn_name}('#{lock_name}'));")
           end
         end
@@ -68,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
@@ -118,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")
@@ -223,7 +215,7 @@ module Delayed
         end
 
         def self.strand_size(strand)
-          where(strand: strand).count
+          where(strand:).count
         end
 
         def self.running_jobs
@@ -248,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
@@ -344,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
@@ -366,7 +358,6 @@ module Delayed
                                              prefetch: 0,
                                              prefetch_owner: nil,
                                              forced_latency: nil)
-
           check_queue(queue)
           check_priorities(min_priority, max_priority)
 
@@ -384,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)
@@ -409,7 +400,36 @@ module Delayed
                   RETURNING #{quoted_table_name}.*
                 SQL
 
-                jobs = find_by_sql(query)
+                begin
+                  jobs = find_by_sql(query)
+                rescue ::ActiveRecord::RecordNotUnique => e
+                  # if we got a unique violation on a singleton, it's because next_in_strand
+                  # somehow got set to true on the non-running job when there is a running
+                  # job. AFAICT this is not possible from inst-jobs itself, but has happened
+                  # in production - either due to manual manipulation of jobs, or possibly
+                  # a process in something like switchman-inst-jobs
+                  raise unless e.message.include?('"index_delayed_jobs_on_singleton_running"')
+
+                  # just repair the "strand"
+                  singleton = e.message.match(/Key \(singleton\)=\((.+)\) already exists.$/)[1]
+                  raise unless singleton
+
+                  transaction do
+                    # 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:).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:, next_in_strand: true)
+                                .where(locked_by: nil)
+                                .update_all(next_in_strand: false)
+                      raise if updated.zero?
+                    end
+                  end
+
+                  retry
+                end
                 # because this is an atomic query, we don't have to return more jobs than we needed
                 # to try and lock them, nor is there a possibility we need to try again because
                 # all of the jobs we tried to lock had already been locked by someone else
@@ -468,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
 
@@ -482,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
@@ -616,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.16"
+  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.16
+  version: 3.1.18
 platform: ruby
 authors:
 - Cody Cutrer
 - Ethan Vizitei
 - Jacob Burroughs
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-01 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
@@ -131,21 +131,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: database_cleaner
+  name: database_cleaner-active_record
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -159,19 +159,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: database_cleaner-active_record
+  name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: diplomat
   requirement: !ruby/object:Gem::Requirement
@@ -187,7 +187,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.6.3
 - !ruby/object:Gem::Dependency
-  name: pg
+  name: mutex_m
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -201,7 +201,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -304,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
@@ -330,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
@@ -368,7 +368,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - cody@instructure.com
 - evizitei@instructure.com
@@ -436,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
@@ -462,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
@@ -470,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