inst-jobs 3.0.7 → 3.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35f27ce4a29cf01568ecd625274894da1c2675e7d2e7da7d307af2200520140b
-  data.tar.gz: 75f5714d9269f601af9097c739fd6cb1948ef7899509c63ad3de2c7991800310
+  metadata.gz: 80d0bc1d05ae57467d66361e81fa51a5b45e3fa391250005c59229554757ec08
+  data.tar.gz: 32d3df9f6085199fa1e9586330c6ba255f898602eb546ea94f49de52b628e7df
 SHA512:
-  metadata.gz: 7eb2a9498036a106c8a02a7878094e940b7450bd60947c34bbb9246cc31f25950d16bb8b9c7eba6e7aa6d25bce2b1bbe11d603c9ca573bd87282225d0c36686f
-  data.tar.gz: 0fe9a7d4226558e665b8a961dd1fd88b5c7e9d076ed6927925a7a259ddce279077360da42746bfd1f064d1e8ad0f602c43b53fb92064996854e76980035f7cc0
+  metadata.gz: 3befc529f42b4ebcba81aacea9bb4c4401a9daa06708c545572b6d6485db85b3d650b9d12baec0dadad9c7387b30ec5e051493b2992a0f6cd41ced9bcfca2485
+  data.tar.gz: 3a3629c08198e0e17455468fd670f4acdd05b28d76b4fbe88516f50692852b6edaf4ed29b6fc26babdfbcca669c9502e88c37616a24cbed5e82611664a3262de

data/db/migrate/20220127091200_fix_singleton_unique_constraint.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class FixSingletonUniqueConstraint < ActiveRecord::Migration[5.2]
+  disable_ddl_transaction!
+
+  def up
+    rename_index :delayed_jobs, "index_delayed_jobs_on_singleton_not_running", "index_delayed_jobs_on_singleton_not_running_old"
+    rename_index :delayed_jobs, "index_delayed_jobs_on_singleton_running", "index_delayed_jobs_on_singleton_running_old"
+
+    # only one job can be queued in a singleton
+    add_index :delayed_jobs,
+              :singleton,
+              where: "singleton IS NOT NULL AND (locked_by IS NULL OR locked_by = '#{::Delayed::Backend::Base::ON_HOLD_LOCKED_BY}')",
+              unique: true,
+              name: "index_delayed_jobs_on_singleton_not_running",
+              algorithm: :concurrently
+
+    # only one job can be running for a singleton
+    add_index :delayed_jobs,
+              :singleton,
+              where: "singleton IS NOT NULL AND locked_by IS NOT NULL AND locked_by <> '#{::Delayed::Backend::Base::ON_HOLD_LOCKED_BY}'",
+              unique: true,
+              name: "index_delayed_jobs_on_singleton_running",
+              algorithm: :concurrently
+  end
+
+  def down
+    remove_index :delayed_jobs, name: "index_delayed_jobs_on_singleton_not_running_old"
+    remove_index :delayed_jobs, name: "index_delayed_jobs_on_singleton_running_old"
+  end
+end

data/db/migrate/20220128084800_update_insert_trigger_for_singleton_unique_constraint_change.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class UpdateInsertTriggerForSingletonUniqueConstraintChange < ActiveRecord::Migration[5.2]
+  def change
+    reversible do |direction|
+      direction.up do
+        execute(<<~SQL)
+          CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
+          BEGIN
+            IF NEW.strand IS NOT NULL THEN
+              PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
+              IF (SELECT COUNT(*) FROM (
+                  SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand AND next_in_strand=true LIMIT NEW.max_concurrent
+                ) s) = NEW.max_concurrent THEN
+                NEW.next_in_strand := false;
+              END IF;
+            END IF;
+            IF NEW.singleton IS NOT NULL THEN
+              PERFORM pg_advisory_xact_lock(half_md5_as_bigint(CONCAT('singleton:', NEW.singleton)));
+              -- this condition seems silly, but it forces postgres to use the two partial indexes on singleton,
+              -- rather than doing a seq scan
+              PERFORM 1 FROM delayed_jobs WHERE singleton = NEW.singleton AND (locked_by IS NULL OR locked_by = '#{::Delayed::Backend::Base::ON_HOLD_LOCKED_BY}' OR locked_by <> '#{::Delayed::Backend::Base::ON_HOLD_LOCKED_BY}');
+              IF FOUND THEN
+                NEW.next_in_strand := false;
+              END IF;
+            END IF;
+            RETURN NEW;
+          END;
+          $$ LANGUAGE plpgsql;
+        SQL
+      end
+      direction.down do
+        execute(<<~SQL)
+          CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
+          BEGIN
+            IF NEW.strand IS NOT NULL THEN
+              PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
+              IF (SELECT COUNT(*) FROM (
+                  SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand AND next_in_strand=true LIMIT NEW.max_concurrent
+                ) s) = NEW.max_concurrent THEN
+                NEW.next_in_strand := false;
+              END IF;
+            END IF;
+            IF NEW.singleton IS NOT NULL THEN
+              PERFORM pg_advisory_xact_lock(half_md5_as_bigint(CONCAT('singleton:', NEW.singleton)));
+              -- this condition seems silly, but it forces postgres to use the two partial indexes on singleton,
+              -- rather than doing a seq scan
+              PERFORM 1 FROM delayed_jobs WHERE singleton = NEW.singleton AND (locked_by IS NULL OR locked_by IS NOT NULL);
+              IF FOUND THEN
+                NEW.next_in_strand := false;
+              END IF;
+            END IF;
+            RETURN NEW;
+          END;
+          $$ LANGUAGE plpgsql;
+        SQL
+      end
+    end
+  end
+end

data/db/migrate/20220128084900_update_delete_trigger_for_singleton_unique_constraint_change.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+class UpdateDeleteTriggerForSingletonUniqueConstraintChange < ActiveRecord::Migration[6.0]
+  def up
+    execute(<<~SQL)
+      CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
+      DECLARE
+        next_strand varchar;
+        running_count integer;
+        should_lock boolean;
+        should_be_precise boolean;
+        update_query varchar;
+        skip_locked varchar;
+        transition boolean;
+      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 = ''#{::Delayed::Backend::Base::ON_HOLD_LOCKED_BY}'' OR j3.locked_by <> ''#{::Delayed::Backend::Base::ON_HOLD_LOCKED_BY}'')))
+              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;
+        END IF;
+
+        IF OLD.singleton IS NOT NULL THEN
+          PERFORM pg_advisory_xact_lock(half_md5_as_bigint(CONCAT('singleton:', OLD.singleton)));
+
+          transition := EXISTS (SELECT 1 FROM delayed_jobs AS j1 WHERE j1.singleton = OLD.singleton AND j1.strand IS DISTINCT FROM OLD.strand AND locked_by IS NULL);
+
+          IF transition THEN
+            next_strand := (SELECT j1.strand FROM delayed_jobs AS j1 WHERE j1.singleton = OLD.singleton AND j1.strand IS DISTINCT FROM OLD.strand AND locked_by IS NULL AND j1.strand IS NOT NULL LIMIT 1);
+
+            IF next_strand IS NOT NULL THEN
+              -- if the singleton has a new strand defined, we need to lock it to ensure we obey n_strand constraints --
+              IF NOT pg_try_advisory_xact_lock(half_md5_as_bigint(next_strand)) THEN
+                -- a failure to acquire the lock means that another process already has it and will thus handle this singleton --
+                RETURN OLD;
+              END IF;
+            END IF;
+          ELSIF OLD.strand IS NOT NULL THEN
+            -- if there is no transition and there is a strand then we have already handled this singleton in the case above --
+            RETURN OLD;
+          END IF;
+
+          -- handles transitioning a singleton from stranded to not stranded --
+          -- handles transitioning a singleton from unstranded to stranded --
+          -- handles transitioning a singleton from strand A to strand B --
+          -- these transitions are a relatively rare case, so we take a shortcut and --
+          -- only start the next singleton if its strand does not currently have any running jobs --
+          -- if it does, the next stranded job that finishes will start this singleton if it can --
+          UPDATE delayed_jobs SET next_in_strand=true WHERE id IN (
+            SELECT id FROM delayed_jobs j2
+              WHERE next_in_strand=false AND
+                j2.singleton=OLD.singleton AND
+                j2.locked_by IS NULL AND
+                (j2.strand IS NULL OR NOT EXISTS (SELECT 1 FROM delayed_jobs j3 WHERE j3.strand=j2.strand AND j3.id<>j2.id))
+              FOR UPDATE
+            );
+        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
+        next_strand varchar;
+        running_count integer;
+        should_lock boolean;
+        should_be_precise boolean;
+        update_query varchar;
+        skip_locked varchar;
+        transition boolean;
+      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;
+        END IF;
+
+        IF OLD.singleton IS NOT NULL THEN
+          PERFORM pg_advisory_xact_lock(half_md5_as_bigint(CONCAT('singleton:', OLD.singleton)));
+
+          transition := EXISTS (SELECT 1 FROM delayed_jobs AS j1 WHERE j1.singleton = OLD.singleton AND j1.strand IS DISTINCT FROM OLD.strand AND locked_by IS NULL);
+
+          IF transition THEN
+            next_strand := (SELECT j1.strand FROM delayed_jobs AS j1 WHERE j1.singleton = OLD.singleton AND j1.strand IS DISTINCT FROM OLD.strand AND locked_by IS NULL AND j1.strand IS NOT NULL LIMIT 1);
+
+            IF next_strand IS NOT NULL THEN
+              -- if the singleton has a new strand defined, we need to lock it to ensure we obey n_strand constraints --
+              IF NOT pg_try_advisory_xact_lock(half_md5_as_bigint(next_strand)) THEN
+                -- a failure to acquire the lock means that another process already has it and will thus handle this singleton --
+                RETURN OLD;
+              END IF;
+            END IF;
+          ELSIF OLD.strand IS NOT NULL THEN
+            -- if there is no transition and there is a strand then we have already handled this singleton in the case above --
+            RETURN OLD;
+          END IF;
+
+          -- handles transitioning a singleton from stranded to not stranded --
+          -- handles transitioning a singleton from unstranded to stranded --
+          -- handles transitioning a singleton from strand A to strand B --
+          -- these transitions are a relatively rare case, so we take a shortcut and --
+          -- only start the next singleton if its strand does not currently have any running jobs --
+          -- if it does, the next stranded job that finishes will start this singleton if it can --
+          UPDATE delayed_jobs SET next_in_strand=true WHERE id IN (
+            SELECT id FROM delayed_jobs j2
+              WHERE next_in_strand=false AND
+                j2.singleton=OLD.singleton AND
+                j2.locked_by IS NULL AND
+                (j2.strand IS NULL OR NOT EXISTS (SELECT 1 FROM delayed_jobs j3 WHERE j3.strand=j2.strand AND j3.id<>j2.id))
+              FOR UPDATE
+            );
+        END IF;
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
+  end
+end

data/db/migrate/20220203063200_remove_old_singleton_index.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class RemoveOldSingletonIndex < ActiveRecord::Migration[5.2]
+  disable_ddl_transaction!
+
+  def up
+    remove_index :delayed_jobs, name: "index_delayed_jobs_on_singleton_not_running_old"
+    remove_index :delayed_jobs, name: "index_delayed_jobs_on_singleton_running_old"
+  end
+
+  def down
+    rename_index :delayed_jobs, "index_delayed_jobs_on_singleton_not_running", "index_delayed_jobs_on_singleton_not_running_old"
+    rename_index :delayed_jobs, "index_delayed_jobs_on_singleton_running", "index_delayed_jobs_on_singleton_running_old"
+
+    # only one job can be queued in a singleton
+    add_index :delayed_jobs,
+              :singleton,
+              where: "singleton IS NOT NULL AND locked_by IS NULL",
+              unique: true,
+              name: "index_delayed_jobs_on_singleton_not_running",
+              algorithm: :concurrently
+
+    # only one job can be running for a singleton
+    add_index :delayed_jobs,
+              :singleton,
+              where: "singleton IS NOT NULL AND locked_by IS NOT NULL",
+              unique: true,
+              name: "index_delayed_jobs_on_singleton_running",
+              algorithm: :concurrently
+  end
+end

data/lib/delayed/backend/active_record.rb

@@ -62,11 +62,21 @@ module Delayed
             _write_attribute(column, current_time) unless attribute_present?(column)
           end
 
-          attribute_names = attribute_names_for_partial_writes
+          attribute_names = if Rails.version < "7.0"
+                              attribute_names_for_partial_writes
+                            else
+                              attribute_names_for_partial_inserts
+                            end
           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))
+          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
 
           lock_and_insert = values["strand"] && instance_of?(Job)
           # can't use prepared statements if we're combining multiple statemenets
@@ -101,7 +111,8 @@ 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")
-              sql = "SELECT pg_advisory_xact_lock(#{fn_name}(#{connection.quote(values['strand'])})); #{sql}"
+              quoted_strand = connection.quote(Rails.version < "7.0" ? values["strand"] : values["strand"].value)
+              sql = "SELECT pg_advisory_xact_lock(#{fn_name}(#{quoted_strand})); #{sql}"
             end
             result = connection.execute(sql, "#{self.class} Create")
             self.id = result.values.first&.first
@@ -471,7 +482,7 @@ module Delayed
           transaction do
             # for db performance reasons, we only need one process doing this at a time
             # so if we can't get an advisory lock, just abort. we'll try again soon
-            return unless attempt_advisory_lock(prefetch_jobs_lock_name)
+            next unless attempt_advisory_lock(prefetch_jobs_lock_name)
 
             horizon = db_time_now - (Settings.parent_process[:prefetched_jobs_timeout] * 4)
             where("locked_by LIKE 'prefetch:%' AND locked_at<?", horizon).update_all(locked_at: nil, locked_by: nil)

data/lib/delayed/backend/base.rb

@@ -12,6 +12,7 @@ module Delayed
     end
 
     module Base
+      ON_HOLD_BLOCKER = "blocker job"
       ON_HOLD_LOCKED_BY = "on hold"
       ON_HOLD_COUNT = 50
 

data/lib/delayed/periodic.rb

@@ -36,7 +36,7 @@ module Delayed
       Delayed::Job.transaction do
         # for db performance reasons, we only need one process doing this at a time
         # so if we can't get an advisory lock, just abort. we'll try again soon
-        return unless Delayed::Job.attempt_advisory_lock("Delayed::Periodic#audit_queue")
+        next unless Delayed::Job.attempt_advisory_lock("Delayed::Periodic#audit_queue")
 
         perform_audit!
       end

data/lib/delayed/settings.rb

@@ -135,7 +135,7 @@ module Delayed
     self.num_strands = ->(_strand_name) {}
     self.default_job_options = -> { {} }
     self.job_detailed_log_format = lambda { |job|
-      job.to_json(include_root: false, only: %w[tag strand priority attempts created_at max_attempts source])
+      job.to_json(include_root: false, only: %w[tag strand singleton priority attempts created_at max_attempts source])
     }
 
     # Send workers KILL after QUIT if they haven't exited within the

data/lib/delayed/version.rb

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

data/lib/delayed/worker/health_check.rb

@@ -34,7 +34,7 @@ module Delayed
             # no other worker is trying to do this right now (and if we abandon the
             # operation, the transaction will end, releasing the advisory lock).
             result = Delayed::Job.attempt_advisory_lock("Delayed::Worker::HealthCheck#reschedule_abandoned_jobs")
-            return unless result
+            next unless result
 
             horizon = 5.minutes.ago
 

data/spec/active_record_job_spec.rb

@@ -28,13 +28,13 @@ describe "Delayed::Backed::ActiveRecord::Job" do
 
     it "does not allow a second worker to get exclusive access if already successfully processed by worker1" do
       @job.destroy
-      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to eq(false)
+      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to be(false)
     end
 
     it "doesn't allow a second worker to get exclusive access if failed to be " \
        "processed by worker1 and run_at time is now in future (due to backing off behaviour)" do
       @job.update(attempts: 1, run_at: 1.day.from_now)
-      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to eq(false)
+      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to be(false)
     end
 
     it "selects the next job at random if enabled" do
@@ -55,13 +55,13 @@ describe "Delayed::Backed::ActiveRecord::Job" do
 
   it "unlocks a successfully locked job and persist the job's unlocked state" do
     job = Delayed::Job.create payload_object: SimpleJob.new
-    expect(job.send(:lock_exclusively!, "worker1")).to eq(true)
+    expect(job.send(:lock_exclusively!, "worker1")).to be(true)
     job.reload
     job.unlock
     job.save!
     job.reload
-    expect(job.locked_by).to eq(nil)
-    expect(job.locked_at).to eq(nil)
+    expect(job.locked_by).to be_nil
+    expect(job.locked_at).to be_nil
   end
 
   describe "bulk_update failed jobs" do
@@ -85,7 +85,7 @@ describe "Delayed::Backed::ActiveRecord::Job" do
       before do
         2.times do
           j = Delayed::Job.create(payload_object: SimpleJob.new)
-          expect(j.send(:lock_exclusively!, "worker1")).to eq(true)
+          expect(j.send(:lock_exclusively!, "worker1")).to be(true)
           j.fail!
         end
       end
@@ -170,13 +170,13 @@ describe "Delayed::Backed::ActiveRecord::Job" do
       it "sets one job as next_in_strand at a time with max_concurrent of 1" do
         job1 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
         job1.reload
-        expect(job1.next_in_strand).to eq(true)
+        expect(job1.next_in_strand).to be(true)
         job2 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
         job2.reload
-        expect(job2.next_in_strand).to eq(false)
+        expect(job2.next_in_strand).to be(false)
         run_job(job1)
         job2.reload
-        expect(job2.next_in_strand).to eq(true)
+        expect(job2.next_in_strand).to be(true)
       end
 
       it "sets multiple jobs as next_in_strand at a time based on max_concurrent" do
@@ -187,16 +187,16 @@ describe "Delayed::Backed::ActiveRecord::Job" do
         }) do
           job1 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
           job1.reload
-          expect(job1.next_in_strand).to eq(true)
+          expect(job1.next_in_strand).to be(true)
           job2 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
           job2.reload
-          expect(job2.next_in_strand).to eq(true)
+          expect(job2.next_in_strand).to be(true)
           job3 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
           job3.reload
-          expect(job3.next_in_strand).to eq(false)
+          expect(job3.next_in_strand).to be(false)
           run_job(job1)
           job3.reload
-          expect(job3.next_in_strand).to eq(true)
+          expect(job3.next_in_strand).to be(true)
         end
       end
     end

data/spec/delayed/work_queue/in_process_spec.rb

@@ -26,6 +26,6 @@ RSpec.describe Delayed::WorkQueue::InProcess do
     end
     job = subject.get_and_lock_next_available(*args)
     expect(job).to eq(:job)
-    expect(called).to eq(true)
+    expect(called).to be(true)
   end
 end

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

@@ -255,7 +255,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     subject.run_once
 
     expect(Marshal.load(client)).to eq(job)
-    expect(called).to eq(true)
+    expect(called).to be(true)
   end
 
   it "deletes the correct worker when transferring jobs" do

data/spec/delayed/worker_spec.rb

@@ -81,7 +81,7 @@ describe Delayed::Worker do
       short_log_format = subject.log_job(job, :short)
       expect(short_log_format).to eq("RSpec::Mocks::Double")
       long_format = subject.log_job(job, :long)
-      expect(long_format).to eq("RSpec::Mocks::Double {\"priority\":25,\"attempts\":0,\"created_at\":null,\"tag\":\"RSpec::Mocks::Double#perform\",\"max_attempts\":null,\"strand\":\"test_jobs\",\"source\":null}") # rubocop:disable Layout/LineLength
+      expect(long_format).to eq("RSpec::Mocks::Double {\"priority\":25,\"attempts\":0,\"created_at\":null,\"tag\":\"RSpec::Mocks::Double#perform\",\"max_attempts\":null,\"strand\":\"test_jobs\",\"source\":null,\"singleton\":null}") # rubocop:disable Layout/LineLength
     end
 
     it "logging format can be changed with settings" do

data/spec/shared/delayed_batch.rb

@@ -13,10 +13,10 @@ shared_examples_for "Delayed::Batch" do
       batch_jobs = Delayed::Job.find_available(5)
       regular_jobs = Delayed::Job.list_jobs(:future, 5)
       expect(regular_jobs.size).to eq(1)
-      expect(regular_jobs.first.batch?).to eq(false)
+      expect(regular_jobs.first.batch?).to be(false)
       expect(batch_jobs.size).to eq(1)
       batch_job = batch_jobs.first
-      expect(batch_job.batch?).to eq(true)
+      expect(batch_job.batch?).to be(true)
       expect(batch_job.payload_object.mode).to eq(:serial)
       expect(batch_job.payload_object.jobs.map do |j|
                [j.payload_object.object, j.payload_object.method, j.payload_object.args]
@@ -50,7 +50,7 @@ shared_examples_for "Delayed::Batch" do
       expect(Delayed::Job.jobs_count(:current)).to eq(1)
 
       batch_job = Delayed::Job.find_available(1).first
-      expect(batch_job.batch?).to eq(true)
+      expect(batch_job.batch?).to be(true)
       jobs = batch_job.payload_object.jobs
       expect(jobs.size).to eq(2)
       expect(jobs[0]).to be_new_record

data/spec/shared/delayed_method.rb

@@ -140,7 +140,7 @@ shared_examples_for "random ruby objects" do
         obj.test_method(7, synchronous: true)
         expect(obj.ran).to eq([7])
         obj.ran = nil
-        expect(obj.ran).to eq(nil)
+        expect(obj.ran).to be_nil
         obj.test_method(8, 9, synchronous: true)
         expect(obj.ran).to eq([8, 9])
       end

data/spec/shared/shared_backend.rb

@@ -233,7 +233,7 @@ shared_examples_for "a backend" do
   describe "#transfer_lock" do
     it "works" do
       job = create_job(locked_by: "worker", locked_at: Delayed::Job.db_time_now)
-      expect(job.transfer_lock!(from: "worker", to: "worker2")).to eq true
+      expect(job.transfer_lock!(from: "worker", to: "worker2")).to be true
       expect(Delayed::Job.find(job.id).locked_by).to eq "worker2"
     end
   end
@@ -243,13 +243,13 @@ shared_examples_for "a backend" do
       job1 = create_job(strand: "myjobs")
       job2 = create_job(strand: "myjobs")
       expect(Delayed::Job.get_and_lock_next_available("w1")).to eq(job1)
-      expect(Delayed::Job.get_and_lock_next_available("w2")).to eq(nil)
+      expect(Delayed::Job.get_and_lock_next_available("w2")).to be_nil
       job1.destroy
       # update time since the failed lock pushed it forward
       job2.run_at = 1.minute.ago
       job2.save!
       expect(Delayed::Job.get_and_lock_next_available("w3")).to eq(job2)
-      expect(Delayed::Job.get_and_lock_next_available("w4")).to eq(nil)
+      expect(Delayed::Job.get_and_lock_next_available("w4")).to be_nil
     end
 
     it "fails to lock if an earlier job gets locked" do
@@ -301,7 +301,7 @@ shared_examples_for "a backend" do
       locked = [Delayed::Job.get_and_lock_next_available("w1"),
                 Delayed::Job.get_and_lock_next_available("w2")]
       expect(jobs).to eq locked
-      expect(Delayed::Job.get_and_lock_next_available("w3")).to eq(nil)
+      expect(Delayed::Job.get_and_lock_next_available("w3")).to be_nil
     end
 
     it "does not interfere with jobs in other strands" do
@@ -309,7 +309,7 @@ shared_examples_for "a backend" do
       locked = [Delayed::Job.get_and_lock_next_available("w1"),
                 Delayed::Job.get_and_lock_next_available("w2")]
       expect(jobs).to eq locked
-      expect(Delayed::Job.get_and_lock_next_available("w3")).to eq(nil)
+      expect(Delayed::Job.get_and_lock_next_available("w3")).to be_nil
     end
 
     it "does not find next jobs when given no priority" do
@@ -317,7 +317,7 @@ shared_examples_for "a backend" do
       first = Delayed::Job.get_and_lock_next_available("w1", Delayed::Settings.queue, nil, nil)
       second = Delayed::Job.get_and_lock_next_available("w2", Delayed::Settings.queue, nil, nil)
       expect(first).to eq jobs.first
-      expect(second).to eq nil
+      expect(second).to be_nil
     end
 
     it "complains if you pass more than one strand-based option" do
@@ -538,11 +538,11 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job2 = create_job(singleton: "myjobs")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be false
 
           @job1.destroy
-          expect(@job2.reload.next_in_strand).to eq true
+          expect(@job2.reload.next_in_strand).to be true
         end
 
         it "handles transitions correctly when going from not stranded to stranded" do
@@ -552,13 +552,13 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job3 = create_job(singleton: "myjobs", strand: "myjobs2")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
 
           @job2.destroy
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq true
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be true
         end
 
         it "does not violate n_strand=1 constraints when going from not stranded to stranded" do
@@ -568,13 +568,13 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job3 = create_job(singleton: "myjobs", strand: "myjobs")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
 
           @job2.destroy
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
         end
 
         it "handles transitions correctly when going from stranded to another strand" do
@@ -582,11 +582,11 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job2 = create_job(singleton: "myjobs", strand: "myjobs2")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be false
 
           @job1.destroy
-          expect(@job2.reload.next_in_strand).to eq true
+          expect(@job2.reload.next_in_strand).to be true
         end
 
         it "does not violate n_strand=1 constraints when going from stranded to another strand" do
@@ -596,24 +596,24 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job3 = create_job(singleton: "myjobs", strand: "myjobs2")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
 
           @job2.destroy
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
         end
 
         it "creates first as true, and second as false, then transitions to second when deleted" do
           @job1 = create_job(singleton: "myjobs")
           Delayed::Job.get_and_lock_next_available("w1")
           @job2 = create_job(singleton: "myjobs")
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be false
 
           @job1.destroy
-          expect(@job2.reload.next_in_strand).to eq true
+          expect(@job2.reload.next_in_strand).to be true
         end
 
         it "when combined with a strand" do
@@ -834,9 +834,9 @@ shared_examples_for "a backend" do
 
   it "sets in_delayed_job?" do
     job = InDelayedJobTest.delay(ignore_transaction: true).check_in_job
-    expect(Delayed::Job.in_delayed_job?).to eq(false)
+    expect(Delayed::Job.in_delayed_job?).to be(false)
     job.invoke_job
-    expect(Delayed::Job.in_delayed_job?).to eq(false)
+    expect(Delayed::Job.in_delayed_job?).to be(false)
   end
 
   it "fails on job creation if an unsaved AR object is used" do

data/spec/shared/worker.rb

@@ -244,7 +244,7 @@ shared_examples_for "Delayed::Worker" do
       end
 
       it "is failed if it failed more than Settings.max_attempts times" do
-        expect(@job.failed_at).to eq(nil)
+        expect(@job.failed_at).to be_nil
         Delayed::Settings.max_attempts.times { @job.reschedule }
         expect(Delayed::Job.list_jobs(:failed, 100).size).to eq(1)
       end
@@ -252,7 +252,7 @@ shared_examples_for "Delayed::Worker" do
       it "is not failed if it failed fewer than Settings.max_attempts times" do
         (Delayed::Settings.max_attempts - 1).times { @job.reschedule }
         @job = Delayed::Job.find(@job.id)
-        expect(@job.failed_at).to eq(nil)
+        expect(@job.failed_at).to be_nil
       end
 
       it "is failed if it has expired" do
@@ -396,7 +396,7 @@ shared_examples_for "Delayed::Worker" do
       expect(@worker).to receive(:exit?).and_return(true)
       Delayed::Worker.lifecycle.before(:execute) { |w| w == @worker && fired = true }
       @worker.start
-      expect(fired).to eq(true)
+      expect(fired).to be(true)
     end
   end
 

data/spec/spec_helper.rb

@@ -55,14 +55,16 @@ connection_config = {
   encoding: "utf8",
   username: ENV["TEST_DB_USERNAME"],
   database: ENV["TEST_DB_DATABASE"],
-  min_messages: "notice"
+  min_messages: "notice",
+  # Ensure the pool is big enough the deadlock tests don't get starved for connections by rails instead
+  pool: 20
 }
 
 def migrate(file)
   ActiveRecord::MigrationContext.new(file, ActiveRecord::SchemaMigration).migrate
 end
 
-# create the test db if it does not exist, to help out wwtd
+# create the test db if it does not exist
 ActiveRecord::Base.establish_connection(connection_config.merge(database: "postgres"))
 begin
   ActiveRecord::Base.connection.create_database(connection_config[:database])

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: inst-jobs
 version: !ruby/object:Gem::Version
-  version: 3.0.7
+  version: 3.0.10
 platform: ruby
 authors:
 - Cody Cutrer
 - Ethan Vizitei
 - Jacob Burroughs
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-11 00:00:00.000000000 Z
+date: 2022-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -32,14 +32,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.4.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.4.4
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -410,21 +410,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: wwtd
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
-description: 
+description:
 email:
 - cody@instructure.com
 - evizitei@instructure.com
@@ -469,6 +455,10 @@ files:
 - db/migrate/20211207094200_update_after_delete_trigger_for_singleton_transition_cases.rb
 - db/migrate/20211220112800_fix_singleton_race_condition_insert.rb
 - db/migrate/20211220113000_fix_singleton_race_condition_delete.rb
+- db/migrate/20220127091200_fix_singleton_unique_constraint.rb
+- db/migrate/20220128084800_update_insert_trigger_for_singleton_unique_constraint_change.rb
+- db/migrate/20220128084900_update_delete_trigger_for_singleton_unique_constraint_change.rb
+- db/migrate/20220203063200_remove_old_singleton_index.rb
 - exe/inst_jobs
 - lib/delayed/backend/active_record.rb
 - lib/delayed/backend/base.rb
@@ -534,8 +524,9 @@ files:
 - spec/spec_helper.rb
 homepage: https://github.com/instructure/inst-jobs
 licenses: []
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -551,31 +542,31 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.4
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Instructure-maintained fork of delayed_job
 test_files:
-- spec/active_record_job_spec.rb
+- 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/delayed/cli_spec.rb
 - spec/delayed/daemon_spec.rb
-- spec/delayed/message_sending_spec.rb
+- spec/delayed/worker_spec.rb
 - spec/delayed/periodic_spec.rb
-- spec/delayed/server_spec.rb
+- spec/delayed/message_sending_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/work_queue/parent_process_spec.rb
-- spec/delayed/worker/consul_health_check_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
+- spec/delayed/worker/consul_health_check_spec.rb
+- spec/active_record_job_spec.rb