inst-jobs 2.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d674b7da21caf04eb87ff9823ed549c93a901219669316090d088f0699564e59
-  data.tar.gz: 021456d34f12eff8cc988db866018d701fc77ffdbb57e9fb308fc1bd25a91ecb
+  metadata.gz: 37ca25ff97580c47a56d0d40a1ab2f78c62a2f47629d0c2e5ba6c8e5c4ace0bd
+  data.tar.gz: 16d4a060bfc0c23f84360d305e35adb5482d0d96f50b50c1a45a8a0b02739c90
 SHA512:
-  metadata.gz: ad78cfdd9026db24b714c532c8ee837a875e443afc375909f0c130e3cfbf87d1f872344f982d931838bfa6649a2f1edc59430f6444a2baee08f8afb568015cfc
-  data.tar.gz: e2b127477f0687958178505628b9544aa5c49e7aa1d0ceef32892250aa26aeb1c77f12bcacd6682e17c2bc379f987b154a0f982e029852432c39f7b3a5335df8
+  metadata.gz: 7f981418c6f0493c84114777193674559f8a0a15006547600bc00cc44eaaff08232c7695f801a3b84c2919167c68c7fb7d91562aa1d4d47d9f98d28a1362b0e3
+  data.tar.gz: 4b31d64c30f9208c54b32796d6ad99f22f9beb3f405a8b4585398306d03b15063d3fde88fce2d063f4f76949da1e350bf4607b8bcf6709a4a20ff686f5c87b6d

data/db/migrate/20101216224513_create_delayed_jobs.rb

@@ -6,19 +6,21 @@ class CreateDelayedJobs < ActiveRecord::Migration[4.2]
   end
 
   def up
-    raise("#{connection.adapter_name} is not supported for delayed jobs queue") unless connection.adapter_name == 'PostgreSQL'
+    unless connection.adapter_name == "PostgreSQL"
+      raise("#{connection.adapter_name} is not supported for delayed jobs queue")
+    end
 
     create_table :delayed_jobs do |table|
       # Allows some jobs to jump to the front of the queue
-      table.integer  :priority, :default => 0
+      table.integer  :priority, default: 0
       # Provides for retries, but still fail eventually.
-      table.integer  :attempts, :default => 0
+      table.integer  :attempts, default: 0
       # YAML-encoded string of the object that will do work
-      table.text     :handler, :limit => (500 * 1024)
+      table.text     :handler, limit: (500 * 1024)
       # reason for last failure (See Note below)
       table.text     :last_error
       # The queue that this job is in
-      table.string   :queue, :default => nil
+      table.string   :queue, default: nil
       # When to run.
       # Could be Time.zone.now for immediately, or sometime in the future.
       table.datetime :run_at
@@ -32,8 +34,8 @@ class CreateDelayedJobs < ActiveRecord::Migration[4.2]
       table.timestamps
     end
 
-    add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
-    add_index :delayed_jobs, [:queue], :name => 'delayed_jobs_queue'
+    add_index :delayed_jobs, %i[priority run_at], name: "delayed_jobs_priority"
+    add_index :delayed_jobs, [:queue], name: "delayed_jobs_queue"
   end
 
   def down

data/db/migrate/20110531144916_cleanup_delayed_jobs_indexes.rb

@@ -6,23 +6,18 @@ class CleanupDelayedJobsIndexes < ActiveRecord::Migration[4.2]
   end
 
   def up
-    case connection.adapter_name
-    when 'PostgreSQL'
-      # "nulls first" syntax is postgresql specific, and allows for more
-      # efficient querying for the next job
-      connection.execute("CREATE INDEX get_delayed_jobs_index ON delayed_jobs (priority, run_at, failed_at nulls first, locked_at nulls first, queue)")
-    else
-      add_index :delayed_jobs, %w(priority run_at locked_at failed_at queue), :name => 'get_delayed_jobs_index'
-    end
+    # "nulls first" syntax is postgresql specific, and allows for more
+    # efficient querying for the next job
+    connection.execute("CREATE INDEX get_delayed_jobs_index ON delayed_jobs (priority, run_at, failed_at nulls first, locked_at nulls first, queue)")
 
     # unused indexes
-    remove_index :delayed_jobs, :name => 'delayed_jobs_queue'
-    remove_index :delayed_jobs, :name => 'delayed_jobs_priority'
+    remove_index :delayed_jobs, name: "delayed_jobs_queue"
+    remove_index :delayed_jobs, name: "delayed_jobs_priority"
   end
 
   def down
-    remove_index :delayed_jobs, :name => 'get_delayed_jobs_index'
-    add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
-    add_index :delayed_jobs, [:queue], :name => 'delayed_jobs_queue'
+    remove_index :delayed_jobs, name: "get_delayed_jobs_index"
+    add_index :delayed_jobs, %i[priority run_at], name: "delayed_jobs_priority"
+    add_index :delayed_jobs, [:queue], name: "delayed_jobs_queue"
   end
 end

data/db/migrate/20110610213249_optimize_delayed_jobs.rb

@@ -7,10 +7,10 @@ class OptimizeDelayedJobs < ActiveRecord::Migration[4.2]
 
   def up
     create_table :failed_jobs do |t|
-      t.integer  "priority",    :default => 0
-      t.integer  "attempts",    :default => 0
-      t.string   "handler",     :limit => 512000
-      t.integer  "original_id", :limit => 8
+      t.integer  "priority",    default: 0
+      t.integer  "attempts",    default: 0
+      t.string   "handler",     limit: 512_000
+      t.integer  "original_id", limit: 8
       t.text     "last_error"
       t.string   "queue"
       t.datetime "run_at"
@@ -24,14 +24,14 @@ class OptimizeDelayedJobs < ActiveRecord::Migration[4.2]
       t.string   "strand"
     end
 
-    remove_index :delayed_jobs, :name => 'get_delayed_jobs_index'
+    remove_index :delayed_jobs, name: "get_delayed_jobs_index"
     remove_index :delayed_jobs, [:strand]
 
-    add_index :delayed_jobs, %w(run_at queue locked_at strand priority), :name => 'index_delayed_jobs_for_get_next'
-    add_index :delayed_jobs, %w(strand id), :name => 'index_delayed_jobs_on_strand'
+    add_index :delayed_jobs, %w[run_at queue locked_at strand priority], name: "index_delayed_jobs_for_get_next"
+    add_index :delayed_jobs, %w[strand id], name: "index_delayed_jobs_on_strand"
 
     # move all failed jobs to the new failed table
-    Delayed::Backend::ActiveRecord::Job.where("failed_at IS NOT NULL").find_each do |job|
+    Delayed::Backend::ActiveRecord::Job.where.not(failed_at: nil).find_each do |job|
       job.fail! unless job.on_hold?
     end
   end

data/db/migrate/20110831210257_add_delayed_jobs_next_in_strand.rb

@@ -6,49 +6,49 @@ class AddDelayedJobsNextInStrand < ActiveRecord::Migration[4.2]
   end
 
   def up
-    remove_index :delayed_jobs, :name => 'index_delayed_jobs_for_get_next'
+    remove_index :delayed_jobs, name: "index_delayed_jobs_for_get_next"
 
-    add_column :delayed_jobs, :next_in_strand, :boolean, :default => true, :null => false
+    add_column :delayed_jobs, :next_in_strand, :boolean, default: true, null: false
 
     # create the new index
     connection.execute("CREATE INDEX get_delayed_jobs_index ON delayed_jobs (priority, run_at, queue) WHERE locked_at IS NULL AND next_in_strand = 't'")
 
     # create the insert trigger
-    execute(<<-CODE)
-    CREATE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
-    BEGIN
-      LOCK delayed_jobs IN SHARE ROW EXCLUSIVE MODE;
-      IF (SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand LIMIT 1) = 1 THEN
-        NEW.next_in_strand := 'f';
-      END IF;
-      RETURN NEW;
-    END;
-    $$ LANGUAGE plpgsql;
-    CODE
+    execute(<<~SQL)
+      CREATE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
+      BEGIN
+        LOCK delayed_jobs IN SHARE ROW EXCLUSIVE MODE;
+        IF (SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand LIMIT 1) = 1 THEN
+          NEW.next_in_strand := 'f';
+        END IF;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
     execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON delayed_jobs FOR EACH ROW WHEN (NEW.strand IS NOT NULL) EXECUTE PROCEDURE delayed_jobs_before_insert_row_tr_fn()")
 
     # create the delete trigger
-    execute(<<-CODE)
-    CREATE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
-    BEGIN
-      UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1);
-      RETURN OLD;
-    END;
-    $$ LANGUAGE plpgsql;
-    CODE
+    execute(<<~SQL)
+      CREATE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
+      BEGIN
+        UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1);
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
     execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON delayed_jobs FOR EACH ROW WHEN (OLD.strand IS NOT NULL AND OLD.next_in_strand = 't') EXECUTE PROCEDURE delayed_jobs_after_delete_row_tr_fn()")
 
     execute(%{UPDATE delayed_jobs SET next_in_strand = 'f' WHERE strand IS NOT NULL AND id <> (SELECT id FROM delayed_jobs j2 WHERE j2.strand = delayed_jobs.strand ORDER BY j2.strand, j2.id ASC LIMIT 1)})
   end
 
   def down
-    execute %{DROP TRIGGER delayed_jobs_before_insert_row_tr ON delayed_jobs}
+    execute %(DROP TRIGGER delayed_jobs_before_insert_row_tr ON delayed_jobs)
     execute %{DROP FUNCTION delayed_jobs_before_insert_row_tr_fn()}
-    execute %{DROP TRIGGER delayed_jobs_after_delete_row_tr ON delayed_jobs}
+    execute %(DROP TRIGGER delayed_jobs_after_delete_row_tr ON delayed_jobs)
     execute %{DROP FUNCTION delayed_jobs_after_delete_row_tr_fn()}
 
     remove_column :delayed_jobs, :next_in_strand
-    remove_index :delayed_jobs, :name => 'get_delayed_jobs_index'
-    add_index :delayed_jobs, %w(run_at queue locked_at strand priority), :name => 'index_delayed_jobs_for_get_next'
+    remove_index :delayed_jobs, name: "get_delayed_jobs_index"
+    add_index :delayed_jobs, %w[run_at queue locked_at strand priority], name: "index_delayed_jobs_for_get_next"
   end
 end

data/db/migrate/20120510004759_delayed_jobs_delete_trigger_lock_for_update.rb

@@ -6,28 +6,24 @@ class DelayedJobsDeleteTriggerLockForUpdate < ActiveRecord::Migration[4.2]
   end
 
   def up
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1 FOR UPDATE);
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1);
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 end

data/db/migrate/20120531150712_drop_psql_jobs_pop_fn.rb

@@ -6,9 +6,7 @@ class DropPsqlJobsPopFn < ActiveRecord::Migration[4.2]
   end
 
   def up
-    if connection.adapter_name == 'PostgreSQL'
-      connection.execute("DROP FUNCTION IF EXISTS pop_from_delayed_jobs(varchar, varchar, integer, integer, timestamp without time zone)")
-    end
+    connection.execute("DROP FUNCTION IF EXISTS pop_from_delayed_jobs(varchar, varchar, integer, integer, timestamp without time zone)")
   end
 
   def down

data/db/migrate/20120607164022_delayed_jobs_use_advisory_locks.rb

@@ -10,8 +10,7 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
     # note that we're using half of the md5, so collisions are possible, but we don't really
     # care because that would just be the old behavior, whereas for the most part locking will
     # be much smaller
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE FUNCTION half_md5_as_bigint(strand varchar) RETURNS bigint AS $$
       DECLARE
         strand_md5 bytea;
@@ -27,9 +26,9 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
                                    get_byte(strand_md5, 7);
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
@@ -39,9 +38,9 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
@@ -49,13 +48,11 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         LOCK delayed_jobs IN SHARE ROW EXCLUSIVE MODE;
@@ -65,18 +62,17 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1 FOR UPDATE);
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute('DROP FUNCTION half_md5_as_bigint(varchar)')
-    end
+    execute("DROP FUNCTION half_md5_as_bigint(varchar)")
   end
 end

data/db/migrate/20120607181141_index_jobs_on_locked_by.rb

@@ -8,7 +8,7 @@ class IndexJobsOnLockedBy < ActiveRecord::Migration[4.2]
   end
 
   def up
-    add_index :delayed_jobs, :locked_by, :algorithm => :concurrently, :where => "locked_by IS NOT NULL"
+    add_index :delayed_jobs, :locked_by, algorithm: :concurrently, where: "locked_by IS NOT NULL"
   end
 
   def down

data/db/migrate/20120608191051_add_jobs_run_at_index.rb

@@ -8,10 +8,10 @@ class AddJobsRunAtIndex < ActiveRecord::Migration[4.2]
   end
 
   def up
-    add_index :delayed_jobs, %w[run_at tag], :algorithm => :concurrently
+    add_index :delayed_jobs, %w[run_at tag], algorithm: :concurrently
   end
 
   def down
-    remove_index :delayed_jobs, :name => "index_delayed_jobs_on_run_at_and_tag"
+    remove_index :delayed_jobs, name: "index_delayed_jobs_on_run_at_and_tag"
   end
 end

data/db/migrate/20120927184213_change_delayed_jobs_handler_to_text.rb

@@ -10,6 +10,6 @@ class ChangeDelayedJobsHandlerToText < ActiveRecord::Migration[4.2]
   end
 
   def down
-    change_column :delayed_jobs, :handler, :string, :limit => 500.kilobytes
+    change_column :delayed_jobs, :handler, :string, limit: 500.kilobytes
   end
 end

data/db/migrate/20140505215510_copy_failed_jobs_original_id.rb

@@ -7,9 +7,8 @@ class CopyFailedJobsOriginalId < ActiveRecord::Migration[4.2]
 
   def up
     # this is a smaller, less frequently accessed table, so we just update all at once
-    Delayed::Backend::ActiveRecord::Job::Failed.where("original_job_id is null").update_all("original_job_id = original_id")
+    Delayed::Backend::ActiveRecord::Job::Failed.where(original_job_id: nil).update_all("original_job_id = original_id")
   end
 
-  def down
-  end
+  def down; end
 end

data/db/migrate/20150807133223_add_max_concurrent_to_jobs.rb

@@ -6,10 +6,9 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
   end
 
   def up
-    add_column :delayed_jobs, :max_concurrent, :integer, :default => 1, :null => false
+    add_column :delayed_jobs, :max_concurrent, :integer, default: 1, null: false
 
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF NEW.strand IS NOT NULL THEN
@@ -21,9 +20,9 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF OLD.strand IS NOT NULL THEN
@@ -38,15 +37,13 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
     remove_column :delayed_jobs, :max_concurrent
 
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
@@ -56,9 +53,9 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
@@ -66,7 +63,6 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 end

data/db/migrate/20151210162949_improve_max_concurrent.rb

@@ -6,8 +6,7 @@ class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
   end
 
   def up
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       DECLARE
         running_count integer;
@@ -25,13 +24,11 @@ class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF OLD.strand IS NOT NULL THEN
@@ -46,7 +43,6 @@ class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 end

data/db/migrate/20161206323555_add_back_default_string_limits_jobs.rb

@@ -24,8 +24,8 @@ class AddBackDefaultStringLimitsJobs < ActiveRecord::Migration[4.2]
   end
 
   def drop_triggers
-    execute %{DROP TRIGGER delayed_jobs_before_insert_row_tr ON delayed_jobs}
-    execute %{DROP TRIGGER delayed_jobs_after_delete_row_tr ON delayed_jobs}
+    execute %(DROP TRIGGER delayed_jobs_before_insert_row_tr ON delayed_jobs)
+    execute %(DROP TRIGGER delayed_jobs_after_delete_row_tr ON delayed_jobs)
   end
 
   def readd_triggers
@@ -35,6 +35,7 @@ class AddBackDefaultStringLimitsJobs < ActiveRecord::Migration[4.2]
 
   def add_string_limit_if_missing(table, column)
     return if column_exists?(table, column, :string, limit: 255)
+
     change_column table, column, :string, limit: 255
   end
 end

data/db/migrate/20181217155351_speed_up_max_concurrent_triggers.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 
-class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
+class SpeedUpMaxConcurrentTriggers < 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(<<-CODE)
+    # 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;
@@ -36,10 +35,10 @@ class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      # don't need the full count on insert
-      execute(<<-CODE)
+    # don't need the full count on insert
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF NEW.strand IS NOT NULL THEN
@@ -53,13 +52,11 @@ class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       DECLARE
         running_count integer;
@@ -77,9 +74,9 @@ class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF NEW.strand IS NOT NULL THEN
@@ -91,7 +88,6 @@ class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 end

data/db/migrate/20200330230722_add_id_to_get_delayed_jobs_index.rb

@@ -9,19 +9,19 @@ class AddIdToGetDelayedJobsIndex < ActiveRecord::Migration[4.2]
 
   def up
     rename_index :delayed_jobs, "get_delayed_jobs_index", "get_delayed_jobs_index_old"
-    add_index :delayed_jobs, [:queue, :priority, :run_at, :id],
-      algorithm: :concurrently,
-      where: "locked_at IS NULL AND next_in_strand",
-      name: "get_delayed_jobs_index"
+    add_index :delayed_jobs, %i[queue priority run_at id],
+              algorithm: :concurrently,
+              where: "locked_at IS NULL AND next_in_strand",
+              name: "get_delayed_jobs_index"
     remove_index :delayed_jobs, name: "get_delayed_jobs_index_old"
   end
 
   def down
     rename_index :delayed_jobs, "get_delayed_jobs_index", "get_delayed_jobs_index_old"
-    add_index :delayed_jobs, [:priority, :run_at, :queue],
-      algorithm: :concurrently,
-      where: "locked_at IS NULL AND next_in_strand",
-      name: "get_delayed_jobs_index"
+    add_index :delayed_jobs, %i[priority run_at queue],
+              algorithm: :concurrently,
+              where: "locked_at IS NULL AND next_in_strand",
+              name: "get_delayed_jobs_index"
     remove_index :delayed_jobs, name: "get_delayed_jobs_index_old"
   end
 end