inst-jobs 0.15.21 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8bab4958615bf7295c579533cfb1353e1581b8b4309ea18f266d738b8eb2a0f
-  data.tar.gz: 0b1f7c4864954f603dc3f0f49d8d07ad8019dc86a4ddf51842fd6c26043c40da
+  metadata.gz: 6d65c567b52e2baf26955d266c9fededc001deab65d871e6e60a42a905d552e8
+  data.tar.gz: b4d487088aba583188c90650a42a20726f84230e346c321b4b94ddc5c25fe36e
 SHA512:
-  metadata.gz: fb55981330a060dce72fa0b5f82028ed9e1a2f647228c957826b9fbad34a0243bdebf6ae69b844e7b589693cda06180033e2218916a20fad21366274b5c1fa89
-  data.tar.gz: d0c1ee9ecf0b1371a4adafac9cff748a58afd53dfa0eb7986dec50858e2419c55a47811cb072599cb6dece55f2d17b067e00a88bae4df2bec607f168ef38927d
+  metadata.gz: 9ade674610c5a1a4a04e4a6078b45c38358e7c7af79a417d5e6941d968e1565bc5e217405ad1ca427b373ee0d89bdbc28772f8ed52047394e8760fc09a79b60a
+  data.tar.gz: 216706e128397e84ba87d495e4b09d30eb58f35ab4821e8ef6f484d5f6226a959cab04a8bfdfa22916f19dad53e7ee01bbe1128bd61fb402aad29885ac81839f

data/db/migrate/20101216224513_create_delayed_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CreateDelayedJobs < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20110208031356_add_delayed_jobs_tag.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddDelayedJobsTag < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20110426161613_add_delayed_jobs_max_attempts.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddDelayedJobsMaxAttempts < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20110516225834_add_delayed_jobs_strand.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddDelayedJobsStrand < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20110531144916_cleanup_delayed_jobs_indexes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CleanupDelayedJobsIndexes < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20110610213249_optimize_delayed_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class OptimizeDelayedJobs < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20110831210257_add_delayed_jobs_next_in_strand.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddDelayedJobsNextInStrand < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20120510004759_delayed_jobs_delete_trigger_lock_for_update.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class DelayedJobsDeleteTriggerLockForUpdate < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20120531150712_drop_psql_jobs_pop_fn.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class DropPsqlJobsPopFn < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20120607164022_delayed_jobs_use_advisory_locks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20120607181141_index_jobs_on_locked_by.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class IndexJobsOnLockedBy < ActiveRecord::Migration[4.2]
   disable_ddl_transaction! if respond_to?(:disable_ddl_transaction!)
 

data/db/migrate/20120608191051_add_jobs_run_at_index.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddJobsRunAtIndex < ActiveRecord::Migration[4.2]
   disable_ddl_transaction! if respond_to?(:disable_ddl_transaction!)
 

data/db/migrate/20120927184213_change_delayed_jobs_handler_to_text.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ChangeDelayedJobsHandlerToText < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20140505215131_add_failed_jobs_original_job_id.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddFailedJobsOriginalJobId < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20140505215510_copy_failed_jobs_original_id.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CopyFailedJobsOriginalId < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20140505223637_drop_failed_jobs_original_id.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class DropFailedJobsOriginalId < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20140512213941_add_source_to_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddSourceToJobs < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20150807133223_add_max_concurrent_to_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20151123210429_add_expires_at_to_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddExpiresAtToJobs < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20151210162949_improve_max_concurrent.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20161206323555_add_back_default_string_limits_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddBackDefaultStringLimitsJobs < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20181217155351_speed_up_max_concurrent_triggers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20190726154743_make_critical_columns_not_null.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class MakeCriticalColumnsNotNull < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20200330230722_add_id_to_get_delayed_jobs_index.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddIdToGetDelayedJobsIndex < ActiveRecord::Migration[4.2]
   disable_ddl_transaction! if respond_to?(:disable_ddl_transaction!)
 

data/db/migrate/20200824222232_speed_up_max_concurrent_delete_trigger.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+class SpeedUpMaxConcurrentDeleteTrigger < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Job.connection
+  end
+
+  def up
+    if connection.adapter_name == 'PostgreSQL'
+      # tl;dr sacrifice some responsiveness to max_concurrent changes for faster performance
+      # don't get the count every single time - it's usually safe to just set the next one in line
+      # since the max_concurrent doesn't change all that often for a strand
+      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;
+        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;
+        
+            IF should_be_precise 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);
+              IF running_count < OLD.max_concurrent THEN
+                UPDATE delayed_jobs SET next_in_strand = 't' WHERE id IN (
+                  SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                  j2.strand = OLD.strand ORDER BY j2.id ASC LIMIT (OLD.max_concurrent - running_count) FOR UPDATE
+                );
+              END IF;
+            ELSE
+              -- n-strands don't require precise ordering; we can make this query more performant
+              IF OLD.max_concurrent > 1 THEN
+                UPDATE delayed_jobs SET next_in_strand = 't' WHERE id =
+                (SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                  j2.strand = OLD.strand ORDER BY j2.id ASC LIMIT 1 FOR UPDATE SKIP LOCKED);
+              ELSE
+                UPDATE delayed_jobs SET next_in_strand = 't' WHERE id =
+                  (SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                    j2.strand = OLD.strand ORDER BY j2.id ASC LIMIT 1 FOR UPDATE);
+              END IF;
+            END IF;
+          END IF;
+          RETURN OLD;
+        END;
+        $$ LANGUAGE plpgsql;
+      SQL
+    end
+  end
+
+  def down
+    if connection.adapter_name == 'PostgreSQL'
+      execute(<<-SQL)
+        CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
+        DECLARE
+          running_count integer;
+        BEGIN
+          IF OLD.strand IS NOT NULL THEN
+            PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
+            IF OLD.id % 20 = 0 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);
+              IF running_count < OLD.max_concurrent THEN
+                UPDATE delayed_jobs SET next_in_strand = 't' WHERE id IN (
+                  SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                  j2.strand = OLD.strand ORDER BY j2.id ASC LIMIT (OLD.max_concurrent - running_count) FOR UPDATE
+                );
+              END IF;
+            ELSE
+              UPDATE delayed_jobs SET next_in_strand = 't' WHERE id =
+                (SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                  j2.strand = OLD.strand ORDER BY j2.id ASC LIMIT 1 FOR UPDATE);
+            END IF;
+          END IF;
+          RETURN OLD;
+        END;
+        $$ LANGUAGE plpgsql;
+      SQL
+    end
+  end
+end
+

data/db/migrate/20200825011002_add_strand_order_override.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+class AddStrandOrderOverride < ActiveRecord::Migration[4.2]
+  disable_ddl_transaction! if respond_to?(:disable_ddl_transaction!)
+
+  def connection
+    Delayed::Job.connection
+  end
+
+  def up
+    add_column :delayed_jobs, :strand_order_override, :integer, default: 0, null: false
+    add_column :failed_jobs, :strand_order_override, :integer, default: 0, null: false
+    add_index :delayed_jobs, [:strand, :strand_order_override, :id],
+      algorithm: :concurrently,
+      where: "strand IS NOT NULL",
+      name: "next_in_strand_index"
+
+    if connection.adapter_name == 'PostgreSQL'
+      # Use the strand_order_override as the primary sorting mechanism (useful when moving between jobs queues without preserving ID ordering)
+      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;
+        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;
+        
+            IF should_be_precise 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);
+              IF running_count < OLD.max_concurrent THEN
+                UPDATE delayed_jobs SET next_in_strand = 't' WHERE id IN (
+                  SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                  j2.strand = OLD.strand ORDER BY j2.strand_order_override ASC, j2.id ASC LIMIT (OLD.max_concurrent - running_count) FOR UPDATE
+                );
+              END IF;
+            ELSE
+              -- n-strands don't require precise ordering; we can make this query more performant
+              IF OLD.max_concurrent > 1 THEN
+                UPDATE delayed_jobs SET next_in_strand = 't' WHERE id =
+                (SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                  j2.strand = OLD.strand ORDER BY j2.strand_order_override ASC, j2.id ASC LIMIT 1 FOR UPDATE SKIP LOCKED);
+              ELSE
+                UPDATE delayed_jobs SET next_in_strand = 't' WHERE id =
+                  (SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                    j2.strand = OLD.strand ORDER BY j2.strand_order_override ASC, j2.id ASC LIMIT 1 FOR UPDATE);
+              END IF;
+            END IF;
+          END IF;
+          RETURN OLD;
+        END;
+        $$ LANGUAGE plpgsql;
+      SQL
+    end
+  end
+
+  def down
+    remove_column :delayed_jobs, :strand_order_override, :integer
+    remove_column :failed_jobs, :strand_order_override, :integer
+
+    if connection.adapter_name == 'PostgreSQL'
+      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;
+        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;
+        
+            IF should_be_precise 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);
+              IF running_count < OLD.max_concurrent THEN
+                UPDATE delayed_jobs SET next_in_strand = 't' WHERE id IN (
+                  SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                  j2.strand = OLD.strand ORDER BY j2.id ASC LIMIT (OLD.max_concurrent - running_count) FOR UPDATE
+                );
+              END IF;
+            ELSE
+              -- n-strands don't require precise ordering; we can make this query more performant
+              IF OLD.max_concurrent > 1 THEN
+                UPDATE delayed_jobs SET next_in_strand = 't' WHERE id =
+                (SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                  j2.strand = OLD.strand ORDER BY j2.id ASC LIMIT 1 FOR UPDATE SKIP LOCKED);
+              ELSE
+                UPDATE delayed_jobs SET next_in_strand = 't' WHERE id =
+                  (SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                    j2.strand = OLD.strand ORDER BY j2.id ASC LIMIT 1 FOR UPDATE);
+              END IF;
+            END IF;
+          END IF;
+          RETURN OLD;
+        END;
+        $$ LANGUAGE plpgsql;
+      SQL
+    end
+  end
+end

data/lib/delayed/backend/active_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ActiveRecord::Base
   def self.load_for_delayed_job(id)
     if id
@@ -17,6 +19,8 @@ module Delayed
         include Delayed::Backend::Base
         self.table_name = :delayed_jobs
 
+        scope :next_in_strand_order, -> { order(:strand_order_override, :id) }
+
         def self.reconnect!
           clear_all_connections!
         end
@@ -103,7 +107,7 @@ module Delayed
         # so rather than changing the strand and balancing at queue time,
         # this keeps the strand intact and uses triggers to limit the number running
         def self.n_strand_options(strand_name, num_strands)
-          {:strand => strand_name, :max_concurrent => num_strands}
+          { strand: strand_name, max_concurrent: num_strands }
         end
 
         def self.current
@@ -123,8 +127,8 @@ module Delayed
         end
 
         # a nice stress test:
-        # 10_000.times { |i| Kernel.send_later_enqueue_args(:system, { :strand => 's1', :run_at => (24.hours.ago + (rand(24.hours.to_i))) }, "echo #{i} >> test1.txt") }
-        # 500.times { |i| "ohai".send_later_enqueue_args(:reverse, { :run_at => (12.hours.ago + (rand(24.hours.to_i))) }) }
+        # 10_000.times { |i| Kernel.delay(strand: 's1', run_at: (24.hours.ago + (rand(24.hours.to_i))).system("echo #{i} >> test1.txt") }
+        # 500.times { |i| "ohai".delay(run_at: (12.hours.ago + (rand(24.hours.to_i))).reverse }
         # then fire up your workers
         # you can check out strand correctness: diff test1.txt <(sort -n test1.txt)
          def self.ready_to_run(forced_latency: nil)
@@ -286,7 +290,7 @@ module Delayed
                     lock(lock)
                 jobs_with_row_number = all.from(target_jobs).
                     select("id, ROW_NUMBER() OVER () AS row_number")
-                updates = "locked_by = CASE row_number "
+                updates = +"locked_by = CASE row_number "
                 effective_worker_names.each_with_index do |worker, i|
                   updates << "WHEN #{i + 1} THEN #{connection.quote(worker)} "
                 end
@@ -398,7 +402,7 @@ module Delayed
           strand = options[:strand]
           on_conflict = options.delete(:on_conflict) || :use_earliest
           transaction_for_singleton(strand, on_conflict) do
-            job = self.where(:strand => strand, :locked_at => nil).order(:id).first
+            job = self.where(:strand => strand, :locked_at => nil).next_in_strand_order.first
             new_job = new(options)
             if job
               new_job.initialize_defaults