inst-jobs 2.4.10 → 3.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65052c093825ca46de07a054fc2b62925cf2d1cb0a3fcb877b408e5c88edc865
-  data.tar.gz: '08d1c103f2c41f11f5989a0b5e2bb857e7d8ea250ba995dcd1ddae62510426cf'
+  metadata.gz: fb38d77d225501a3f9ca85561266adf7f2b873d187d0ee9e820e30f773fc5846
+  data.tar.gz: 0bdbb7e6609d0c228de6906b68ff41b7a5218b89832dd9f8958ed261d7a39fd2
 SHA512:
-  metadata.gz: 3e28511d5c23fcdccd976e9d8f9f09ae318c50154d01223b84b3f60de42e34dbb55ed6735618224865b8c8050e15eed78bd9c8505b85abb56515c41c4266c985
-  data.tar.gz: bc60ce604e1b5077251c1c5855a3bd0582950c03c0ed0423b0daf25e8750d6e2f6dfbb32b18e99ace156a1a5232ac8e827377997185bd8c4889abe20e6e7249b
+  metadata.gz: 76c59051987d523e8465c98a0aa03edfa7ee6df1fc090ebeb8238f827d3f5487dccd61f92c20acf87df9b53153de03bb866d577f44eb3d0db18bd3cd9fa44f66
+  data.tar.gz: 0262e34514a1919ff9715b1707d7c99dab2ddf4f3ef0c98e06441b61709ddb2bb36c763b73cc5a5512a03e2b2a253b507818da313213a621c40879d086fa9333

data/db/migrate/20210929204903_update_conflicting_singleton_function_to_use_index.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class UpdateConflictingSingletonFunctionToUseIndex < ActiveRecord::Migration[5.2]
+  def up
+    execute(<<~SQL)
+      CREATE OR REPLACE FUNCTION delayed_jobs_before_unlock_delete_conflicting_singletons_row_fn () RETURNS trigger AS $$
+      BEGIN
+        DELETE FROM delayed_jobs WHERE id<>OLD.id AND singleton=OLD.singleton AND locked_by IS NULL;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+  end
+
+  def down
+    execute(<<~SQL)
+      CREATE OR REPLACE FUNCTION delayed_jobs_before_unlock_delete_conflicting_singletons_row_fn () RETURNS trigger AS $$
+      BEGIN
+        IF EXISTS (SELECT 1 FROM delayed_jobs j2 WHERE j2.singleton=OLD.singleton) THEN
+          DELETE FROM delayed_jobs WHERE id<>OLD.id AND singleton=OLD.singleton;
+        END IF;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+  end
+end

data/db/migrate/20211101190934_update_after_delete_trigger_for_singleton_index.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+class UpdateAfterDeleteTriggerForSingletonIndex < ActiveRecord::Migration[6.0]
+  def up
+    execute(<<~SQL)
+      CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
+      DECLARE
+        running_count integer;
+        should_lock boolean;
+        should_be_precise boolean;
+        update_query varchar;
+        skip_locked varchar;
+      BEGIN
+        IF OLD.strand IS NOT NULL THEN
+          should_lock := true;
+          should_be_precise := OLD.id % (OLD.max_concurrent * 4) = 0;
+
+          IF NOT should_be_precise AND OLD.max_concurrent > 16 THEN
+            running_count := (SELECT COUNT(*) FROM (
+              SELECT 1 as one FROM delayed_jobs WHERE strand = OLD.strand AND next_in_strand = 't' LIMIT OLD.max_concurrent
+            ) subquery_for_count);
+            should_lock := running_count < OLD.max_concurrent;
+          END IF;
+
+          IF should_lock THEN
+            PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
+          END IF;
+
+          -- note that we don't really care if the row we're deleting has a singleton, or if it even
+          -- matches the row(s) we're going to update. we just need to make sure that whatever
+          -- singleton we grab isn't already running (which is a simple existence check, since
+          -- the unique indexes ensure there is at most one singleton running, and one queued)
+          update_query := 'UPDATE delayed_jobs SET next_in_strand=true WHERE id IN (
+            SELECT id FROM delayed_jobs j2
+              WHERE next_in_strand=false AND
+                j2.strand=$1.strand AND
+                (j2.singleton IS NULL OR NOT EXISTS (SELECT 1 FROM delayed_jobs j3 WHERE j3.singleton=j2.singleton AND j3.id<>j2.id AND (j3.locked_by IS NULL OR j3.locked_by IS NOT NULL)))
+              ORDER BY j2.strand_order_override ASC, j2.id ASC
+              LIMIT ';
+
+          IF should_be_precise THEN
+            running_count := (SELECT COUNT(*) FROM (
+              SELECT 1 FROM delayed_jobs WHERE strand = OLD.strand AND next_in_strand = 't' LIMIT OLD.max_concurrent
+            ) s);
+            IF running_count < OLD.max_concurrent THEN
+              update_query := update_query || '($1.max_concurrent - $2)';
+            ELSE
+              -- we have too many running already; just bail
+              RETURN OLD;
+            END IF;
+          ELSE
+            update_query := update_query || '1';
+
+            -- n-strands don't require precise ordering; we can make this query more performant
+            IF OLD.max_concurrent > 1 THEN
+              skip_locked := ' SKIP LOCKED';
+            END IF;
+          END IF;
+
+          update_query := update_query || ' FOR UPDATE' || COALESCE(skip_locked, '') || ')';
+          EXECUTE update_query USING OLD, running_count;
+        ELSIF OLD.singleton IS NOT NULL THEN
+          UPDATE delayed_jobs SET next_in_strand = 't' WHERE singleton=OLD.singleton AND next_in_strand=false AND locked_by IS NULL;
+        END IF;
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+  end
+
+  def down
+    execute(<<~SQL)
+      CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
+      DECLARE
+        running_count integer;
+        should_lock boolean;
+        should_be_precise boolean;
+        update_query varchar;
+        skip_locked varchar;
+      BEGIN
+        IF OLD.strand IS NOT NULL THEN
+          should_lock := true;
+          should_be_precise := OLD.id % (OLD.max_concurrent * 4) = 0;
+
+          IF NOT should_be_precise AND OLD.max_concurrent > 16 THEN
+            running_count := (SELECT COUNT(*) FROM (
+              SELECT 1 as one FROM delayed_jobs WHERE strand = OLD.strand AND next_in_strand = 't' LIMIT OLD.max_concurrent
+            ) subquery_for_count);
+            should_lock := running_count < OLD.max_concurrent;
+          END IF;
+
+          IF should_lock THEN
+            PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
+          END IF;
+
+          -- note that we don't really care if the row we're deleting has a singleton, or if it even
+          -- matches the row(s) we're going to update. we just need to make sure that whatever
+          -- singleton we grab isn't already running (which is a simple existence check, since
+          -- the unique indexes ensure there is at most one singleton running, and one queued)
+          update_query := 'UPDATE delayed_jobs SET next_in_strand=true WHERE id IN (
+            SELECT id FROM delayed_jobs j2
+              WHERE next_in_strand=false AND
+                j2.strand=$1.strand AND
+                (j2.singleton IS NULL OR NOT EXISTS (SELECT 1 FROM delayed_jobs j3 WHERE j3.singleton=j2.singleton AND j3.id<>j2.id))
+              ORDER BY j2.strand_order_override ASC, j2.id ASC
+              LIMIT ';
+
+          IF should_be_precise THEN
+            running_count := (SELECT COUNT(*) FROM (
+              SELECT 1 FROM delayed_jobs WHERE strand = OLD.strand AND next_in_strand = 't' LIMIT OLD.max_concurrent
+            ) s);
+            IF running_count < OLD.max_concurrent THEN
+              update_query := update_query || '($1.max_concurrent - $2)';
+            ELSE
+              -- we have too many running already; just bail
+              RETURN OLD;
+            END IF;
+          ELSE
+            update_query := update_query || '1';
+
+            -- n-strands don't require precise ordering; we can make this query more performant
+            IF OLD.max_concurrent > 1 THEN
+              skip_locked := ' SKIP LOCKED';
+            END IF;
+          END IF;
+
+          update_query := update_query || ' FOR UPDATE' || COALESCE(skip_locked, '') || ')';
+          EXECUTE update_query USING OLD, running_count;
+        ELSIF OLD.singleton IS NOT NULL THEN
+          UPDATE delayed_jobs SET next_in_strand = 't' WHERE singleton=OLD.singleton AND next_in_strand=false;
+        END IF;
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+  end
+end

data/lib/delayed/backend/active_record.rb

@@ -62,14 +62,9 @@ module Delayed
             _write_attribute(column, current_time) unless attribute_present?(column)
           end
 
-          if Rails.version >= "6"
-            attribute_names = attribute_names_for_partial_writes
-            attribute_names = attributes_for_create(attribute_names)
-            values = attributes_with_values(attribute_names)
-          else
-            attribute_names = partial_writes? ? keys_for_partial_write : self.attribute_names
-            values = attributes_with_values_for_create(attribute_names)
-          end
+          attribute_names = attribute_names_for_partial_writes
+          attribute_names = attributes_for_create(attribute_names)
+          values = attributes_with_values(attribute_names)
 
           im = self.class.arel_table.compile_insert(self.class.send(:_substitute_values, values))
 
@@ -314,7 +309,7 @@ module Delayed
           if Settings.silence_periodic_log
             ::ActiveRecord::Base.logger.silence(&block)
           else
-            block.call
+            yield
           end
         end
 
@@ -553,7 +548,7 @@ module Delayed
 
         def fail!
           attrs = attributes
-          attrs["original_job_id"] = attrs.delete("id")
+          attrs["original_job_id"] = attrs.delete("id") if Failed.columns_hash.key?("original_job_id")
           attrs["failed_at"] ||= self.class.db_time_now
           attrs.delete("next_in_strand")
           attrs.delete("max_concurrent")

data/lib/delayed/backend/base.rb

@@ -176,7 +176,9 @@ module Delayed
           ignores = []
           loop do
             batch_scope = ignores.empty? ? jobs : jobs.where.not(id: ignores)
-            batch = batch_scope.to_a
+            # if we don't reload this it's possible to keep getting the
+            # same array each loop even after the jobs have been deleted.
+            batch = batch_scope.reload.to_a
             break if batch.empty?
 
             batch.each do |job|

data/lib/delayed/rails_reloader_plugin.rb

@@ -0,0 +1,30 @@
+# 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

data/lib/delayed/version.rb

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

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "activerecord-pg-extensions"
+
 module Delayed
   module WorkQueue
     class ParentProcess
@@ -192,29 +194,54 @@ module Delayed
           end
         end
 
-        def unlock_timed_out_prefetched_jobs
+        def unlock_prefetched_jobs
           @prefetched_jobs.each do |(worker_config, jobs)|
             next if jobs.empty?
-            next unless jobs.first.locked_at < Time.now.utc - Settings.parent_process[:prefetched_jobs_timeout]
+            next if block_given? && !yield(jobs)
 
-            Delayed::Job.transaction do
+            connection = Delayed::Job.connection
+            connection.transaction do
+              # make absolutely sure we don't get hung up and leave things
+              # locked in the database
+              if connection.postgresql_version >= 9_06_00 # rubocop:disable Style/NumericLiterals
+                connection.idle_in_transaction_session_timeout = 5
+              end
+              # relatively short timeout for acquiring the lock
+              connection.statement_timeout = Settings.sleep_delay
               Delayed::Job.advisory_lock(Delayed::Job.prefetch_jobs_lock_name)
+
+              # this query might take longer, and we really want to get it
+              # done if we got the lock, but still don't want an inadvertent
+              # hang
+              connection.statement_timeout = 30
               Delayed::Job.unlock(jobs)
+              @prefetched_jobs[worker_config] = []
             end
-            @prefetched_jobs[worker_config] = []
+          rescue ActiveRecord::QueryCanceled
+            # ignore; we'll retry anyway
+            logger.warn("unable to unlock prefetched jobs; skipping for now")
+          rescue ActiveRecord::StatementInvalid
+            # see if we dropped the connection
+            raise if connection.active?
+
+            # otherwise just reconnect and let it retry
+            logger.warn("failed to unlock prefetched jobs - connection terminated; skipping for now")
+            Delayed::Job.clear_all_connections!
           end
         end
 
-        def unlock_all_prefetched_jobs
-          @prefetched_jobs.each do |(_worker_config, jobs)|
-            next if jobs.empty?
+        def unlock_timed_out_prefetched_jobs
+          unlock_prefetched_jobs do |jobs|
+            jobs.first.locked_at < Time.now.utc - Settings.parent_process[:prefetched_jobs_timeout]
+          end
+        end
 
-            Delayed::Job.transaction do
-              Delayed::Job.advisory_lock(Delayed::Job.prefetch_jobs_lock_name)
-              Delayed::Job.unlock(jobs)
-            end
+        def unlock_all_prefetched_jobs
+          # we try really hard; it may not have done any work if it timed out
+          10.times do
+            unlock_prefetched_jobs
+            break if @prefetched_jobs.each_value.all?(&:empty?)
           end
-          @prefetched_jobs = {}
         end
 
         def drop_socket(socket)

data/lib/delayed/worker/process_helper.rb

@@ -5,10 +5,10 @@ module Delayed
     module ProcessHelper
       STAT_LINUX = "stat --format=%%Y /proc/$WORKER_PID"
       STAT_MAC = "ps -o lstart -p $WORKER_PID"
-      STAT = RUBY_PLATFORM =~ /darwin/ ? STAT_MAC : STAT_LINUX
+      STAT = RUBY_PLATFORM.include?("darwin") ? STAT_MAC : STAT_LINUX
       ALIVE_CHECK_LINUX = '[ -d "/proc/$WORKER_PID" ]'
       ALIVE_CHECK_MAC = "ps -p $WORKER_PID > /dev/null"
-      ALIVE_CHECK = RUBY_PLATFORM =~ /darwin/ ? ALIVE_CHECK_MAC : ALIVE_CHECK_LINUX
+      ALIVE_CHECK = RUBY_PLATFORM.include?("darwin") ? ALIVE_CHECK_MAC : ALIVE_CHECK_LINUX
       SCRIPT_TEMPLATE = <<-BASH
         WORKER_PID="%<pid>d" # an example, filled from ruby when the check is created
         ORIGINAL_MTIME="%<mtime>s" # an example, filled from ruby when the check is created
@@ -29,7 +29,7 @@ module Delayed
       BASH
 
       def self.mtime(pid)
-        if RUBY_PLATFORM =~ /darwin/
+        if RUBY_PLATFORM.include?("darwin")
           `ps -o lstart -p #{pid}`.sub(/\n$/, "").presence
         else
           File::Stat.new("/proc/#{pid}").mtime.to_i.to_s rescue nil

data/lib/delayed/worker.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "delayed/rails_reloader_plugin"
+
 module Delayed
   class TimeoutError < RuntimeError; end
 
@@ -70,27 +72,7 @@ module Delayed
 
       @signal_queue = []
 
-      app = Rails.application
-      if app && !app.config.cache_classes
-        Delayed::Worker.lifecycle.around(:perform) do |worker, job, &block|
-          reload = app.config.reload_classes_only_on_change != true || app.reloaders.map(&:updated?).any?
-
-          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
-
+      plugins << Delayed::RailsReloaderPlugin
       plugins.each(&:inject!)
     end
 

data/spec/active_record_job_spec.rb

@@ -219,14 +219,14 @@ describe "Delayed::Backed::ActiveRecord::Job" do
   end
 
   it "gets process ids from locked_by" do
-    3.times.map { Delayed::Job.create payload_object: SimpleJob.new }
+    Array.new(3) { Delayed::Job.create payload_object: SimpleJob.new }
     Delayed::Job.get_and_lock_next_available(["job42:2", "job42:9001"])
     expect(Delayed::Job.processes_locked_locally(name: "job42").sort).to eq [2, 9001]
     expect(Delayed::Job.processes_locked_locally(name: "jobnotme")).to be_empty
   end
 
   it "allows fetching multiple jobs at once" do
-    jobs = 3.times.map { Delayed::Job.create payload_object: SimpleJob.new }
+    jobs = Array.new(3) { Delayed::Job.create payload_object: SimpleJob.new }
     locked_jobs = Delayed::Job.get_and_lock_next_available(%w[worker1 worker2])
     expect(locked_jobs.length).to eq(2)
     expect(locked_jobs.keys).to eq(%w[worker1 worker2])
@@ -235,7 +235,7 @@ describe "Delayed::Backed::ActiveRecord::Job" do
   end
 
   it "allows fetching extra jobs" do
-    jobs = 5.times.map { Delayed::Job.create payload_object: SimpleJob.new }
+    jobs = Array.new(5) { Delayed::Job.create payload_object: SimpleJob.new }
     locked_jobs = Delayed::Job.get_and_lock_next_available(["worker1"],
                                                            prefetch: 2,
                                                            prefetch_owner: "work_queue")

data/spec/delayed/work_queue/parent_process/server_spec.rb

@@ -104,6 +104,53 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     expect(Marshal.load(client)).to eq(job2)
   end
 
+  context "prefetched job unlocking" do
+    let(:job_args) do
+      [["worker_name1"], "queue_name", 1, 2,
+       { prefetch: 4, prefetch_owner: "prefetch:work_queue:X", forced_latency: 6.0 }]
+    end
+    let(:job2) { Delayed::Job.new(tag: "tag").tap { |j| j.create_and_lock!("prefetch:work_queue:X") } }
+    let(:job3) { Delayed::Job.new(tag: "tag").tap { |j| j.create_and_lock!("prefetch:work_queue:X") } }
+
+    before do
+      client = Socket.unix(subject.listen_socket.local_address.unix_path)
+      subject.run_once
+
+      jobs = { "worker_name1" => job, "prefetch:work_queue:X" => [job2, job3] }
+      allow(subject).to receive(:prefetch_owner).and_return("prefetch:work_queue:X")
+      allow(Delayed::Job).to receive(:get_and_lock_next_available).once.with(*job_args).and_return(jobs)
+      Marshal.dump(["worker_name1", worker_config], client)
+      subject.run_once
+    end
+
+    it "doesn't unlock anything if nothing is timed out" do
+      expect(Delayed::Job).not_to receive(:advisory_lock)
+      expect(Delayed::Job).not_to receive(:unlock)
+      subject.unlock_timed_out_prefetched_jobs
+    end
+
+    it "unlocks timed out prefetched jobs" do
+      allow(Delayed::Settings).to receive(:parent_process).and_return(prefetched_jobs_timeout: -1)
+      expect(Delayed::Job).to receive(:unlock).with([job2, job3])
+      subject.unlock_timed_out_prefetched_jobs
+      expect(subject.instance_variable_get(:@prefetched_jobs).values.sum(&:length)).to eq 0
+    end
+
+    it "fails gracefully if the lock times out" do
+      allow(Delayed::Settings).to receive(:parent_process).and_return(prefetched_jobs_timeout: -1)
+      expect(Delayed::Job).not_to receive(:unlock)
+      expect(Delayed::Job).to receive(:advisory_lock).and_raise(ActiveRecord::QueryCanceled)
+      subject.unlock_timed_out_prefetched_jobs
+      expect(subject.instance_variable_get(:@prefetched_jobs).values.sum(&:length)).to eq 2
+    end
+
+    it "unlocks all jobs" do
+      expect(Delayed::Job).to receive(:unlock).with([job2, job3])
+      subject.unlock_all_prefetched_jobs
+      expect(subject.instance_variable_get(:@prefetched_jobs).values.sum(&:length)).to eq 0
+    end
+  end
+
   it "doesn't respond immediately if there are no jobs available" do
     client = Socket.unix(subject.listen_socket.local_address.unix_path)
     subject.run_once

data/spec/delayed/worker_spec.rb

@@ -44,7 +44,7 @@ describe Delayed::Worker do
       expect(output_count).to eq(1)
     end
 
-    it "reloads" do
+    it "reloads Rails classes (never more than once)" do
       fake_application = double("Rails.application",
                                 config: double("Rails.application.config",
                                                cache_classes: false,
@@ -59,6 +59,11 @@ describe Delayed::Worker do
         expect(ActionDispatch::Reloader).to receive(:cleanup!).once
       end
       job = double(job_attrs)
+
+      # Create extra workers to make sure we don't reload multiple times
+      described_class.new(worker_config.dup)
+      described_class.new(worker_config.dup)
+
       subject.perform(job)
     end
   end

data/spec/shared/shared_backend.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "timeout"
+
 module InDelayedJobTest
   def self.check_in_job
     Delayed::Job.in_delayed_job?.should == true
@@ -960,6 +962,21 @@ shared_examples_for "a backend" do
     end
   end
 
+  it "removes an un-reschedulable job" do
+    change_setting(Delayed::Settings, :max_attempts, -1) do
+      job = Delayed::Job.new(tag: "tag")
+      `echo ''`
+      child_pid = $?.pid
+      job.create_and_lock!("Jobworker:#{child_pid}")
+      Timeout.timeout(1) do
+        # if this takes longer than a second it's hung
+        # in an infinite loop, which would be bad.
+        expect(Delayed::Job.unlock_orphaned_jobs(nil, "Jobworker")).to eq(1)
+      end
+      expect { Delayed::Job.find(job.id) }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+  end
+
   it "unlocks orphaned jobs given a pid" do
     change_setting(Delayed::Settings, :max_attempts, 2) do
       job1 = Delayed::Job.new(tag: "tag")

data/spec/spec_helper.rb

@@ -58,11 +58,7 @@ connection_config = {
 }
 
 def migrate(file)
-  if ::Rails.version >= "6"
-    ActiveRecord::MigrationContext.new(file, ActiveRecord::SchemaMigration).migrate
-  else
-    ActiveRecord::MigrationContext.new(file).migrate
-  end
+  ActiveRecord::MigrationContext.new(file, ActiveRecord::SchemaMigration).migrate
 end
 
 # create the test db if it does not exist, to help out wwtd
@@ -73,6 +69,11 @@ rescue ActiveRecord::StatementInvalid
   nil
 end
 ActiveRecord::Base.establish_connection(connection_config)
+
+# we need to ensure this callback is called for activerecord-pg-extensions,
+# which isn't running because we're not using Rails to setup the database
+ActiveRecord::PGExtensions::Railtie.run_initializers
+
 # TODO: reset db and migrate again, to test migrations
 
 migrate("db/migrate")

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: inst-jobs
 version: !ruby/object:Gem::Version
-  version: 2.4.10
+  version: 3.0.3
 platform: ruby
 authors:
-- Tobias Luetke
-- Brian Palmer
-autorequire:
+- Cody Cutrer
+- Ethan Vizitei
+- Jacob Burroughs
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-09-28 00:00:00.000000000 Z
+date: 2021-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -17,28 +18,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord-pg-extensions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: after_transaction_commit
   requirement: !ruby/object:Gem::Requirement
@@ -93,14 +108,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -283,6 +298,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.19'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.12.0
 - !ruby/object:Gem::Dependency
   name: rubocop-rails
   requirement: !ruby/object:Gem::Requirement
@@ -395,9 +424,11 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.4.0
-description:
+description: 
 email:
-- brianp@instructure.com
+- cody@instructure.com
+- evizitei@instructure.com
+- jburroughs@instructure.com
 executables:
 - inst_jobs
 extensions: []
@@ -433,6 +464,8 @@ files:
 - db/migrate/20210812210128_add_singleton_column.rb
 - db/migrate/20210917232626_add_delete_conflicting_singletons_before_unlock_trigger.rb
 - db/migrate/20210928174754_fix_singleton_condition_in_before_insert.rb
+- db/migrate/20210929204903_update_conflicting_singleton_function_to_use_index.rb
+- db/migrate/20211101190934_update_after_delete_trigger_for_singleton_index.rb
 - exe/inst_jobs
 - lib/delayed/backend/active_record.rb
 - lib/delayed/backend/base.rb
@@ -450,6 +483,7 @@ 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
@@ -498,7 +532,7 @@ files:
 homepage: https://github.com/instructure/inst-jobs
 licenses: []
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -513,32 +547,32 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.24
-signing_key:
+rubygems_version: 3.2.15
+signing_key: 
 specification_version: 4
 summary: Instructure-maintained fork of delayed_job
 test_files:
-- spec/sample_jobs.rb
-- spec/spec_helper.rb
-- spec/shared_jobs_specs.rb
-- spec/shared/performable_method.rb
-- spec/shared/testing.rb
-- spec/shared/delayed_batch.rb
-- spec/shared/worker.rb
-- spec/shared/delayed_method.rb
-- spec/shared/shared_backend.rb
-- spec/migrate/20140924140513_add_story_table.rb
-- spec/delayed/server_spec.rb
+- spec/active_record_job_spec.rb
 - spec/delayed/cli_spec.rb
 - spec/delayed/daemon_spec.rb
-- spec/delayed/worker_spec.rb
-- spec/delayed/periodic_spec.rb
 - spec/delayed/message_sending_spec.rb
+- spec/delayed/periodic_spec.rb
+- spec/delayed/server_spec.rb
 - spec/delayed/settings_spec.rb
 - spec/delayed/work_queue/in_process_spec.rb
-- spec/delayed/work_queue/parent_process_spec.rb
 - spec/delayed/work_queue/parent_process/client_spec.rb
 - spec/delayed/work_queue/parent_process/server_spec.rb
-- spec/delayed/worker/health_check_spec.rb
+- spec/delayed/work_queue/parent_process_spec.rb
 - spec/delayed/worker/consul_health_check_spec.rb
-- spec/active_record_job_spec.rb
+- spec/delayed/worker/health_check_spec.rb
+- spec/delayed/worker_spec.rb
+- spec/migrate/20140924140513_add_story_table.rb
+- spec/sample_jobs.rb
+- spec/shared/delayed_batch.rb
+- spec/shared/delayed_method.rb
+- spec/shared/performable_method.rb
+- spec/shared/shared_backend.rb
+- spec/shared/testing.rb
+- spec/shared/worker.rb
+- spec/shared_jobs_specs.rb
+- spec/spec_helper.rb