delayed_job_active_record 4.1.2 → 4.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 587c2fcfd39aed7965f484c0e9ba9bc94dba926b
-  data.tar.gz: d71c55d818a0e780d972bb35c0d665195e47467e
+SHA256:
+  metadata.gz: 4b17b594310d702d4a5dddca0001c067751c5c70595405ab74cf5091951e8dbf
+  data.tar.gz: 2ccf2889e6d629cd46850873c8b1038eba50554ba7b76d1151974b750e70f3c1
 SHA512:
-  metadata.gz: 123564b7b3f54d4ee8cdd1673e5fb5471f564e1306a69c3fc07e4e6b4ea6608f448f493170840137604705731ba9e5f488c00ed6a1272fd9f263622e83db385e
-  data.tar.gz: fa7fff077b2f611118b21abf9e106cf8b210c5ad1b9404dc9c6c8c678164f991486bd38f885e062cef233d4a082c03badca4bc333bec92f25d138215b0215184
+  metadata.gz: d0c30a1d2e4b220a1a12e61cd8f6745e13093c275c8f323c565cf919e92d65c8b9fa6ba35ca06532f5db3316e2128012c53076099b6940de71d351d8b2c0f6b8
+  data.tar.gz: e6c1f74236b4c93a981bafda8b311d71db3edc25e90856d8bb9d72e8c9fe61df7642c23e72f30eae40fc99eecefc2a5e3e1a11393d9c66e0114ab926ecdace4b

data/README.md

@@ -1,14 +1,12 @@
 **If you're viewing this at https://github.com/collectiveidea/delayed_job_active_record,
 you're reading the documentation for the master branch.
 [View documentation for the latest release
-(4.1.2).](https://github.com/collectiveidea/delayed_job_active_record/tree/v4.1.2)**
+(4.1.7).](https://github.com/collectiveidea/delayed_job_active_record/tree/v4.1.7)**
 
 # DelayedJob ActiveRecord Backend
 
 [![Gem Version](https://img.shields.io/gem/v/delayed_job_active_record.svg)](https://rubygems.org/gems/delayed_job_active_record)
-[![Build Status](https://img.shields.io/travis/collectiveidea/delayed_job_active_record.svg)](https://travis-ci.org/collectiveidea/delayed_job_active_record)
-[![Dependency Status](https://img.shields.io/gemnasium/collectiveidea/delayed_job_active_record.svg)](https://gemnasium.com/collectiveidea/delayed_job_active_record)
-[![Code Climate](https://img.shields.io/codeclimate/github/collectiveidea/delayed_job_active_record.svg)](https://codeclimate.com/github/collectiveidea/delayed_job_active_record)
+![CI](https://github.com/collectiveidea/delayed_job_active_record/workflows/CI/badge.svg)
 [![Coverage Status](https://img.shields.io/coveralls/collectiveidea/delayed_job_active_record.svg)](https://coveralls.io/r/collectiveidea/delayed_job_active_record)
 
 ## Installation

data/delayed_job_active_record.gemspec

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 Gem::Specification.new do |spec|
-  spec.add_dependency "activerecord", [">= 3.0", "< 5.2"]
+  spec.add_dependency "activerecord", [">= 3.0", "< 8.0"]
   spec.add_dependency "delayed_job",  [">= 3.0", "< 5"]
   spec.authors        = ["Brian Ryckbost", "Matt Griffin", "Erik Michaels-Ober"]
   spec.description    = "ActiveRecord backend for Delayed::Job, originally authored by Tobias Lütke"
   spec.email          = ["bryckbost@gmail.com", "matt@griffinonline.org", "sferik@gmail.com"]
-  spec.files          = %w(CONTRIBUTING.md LICENSE.md README.md delayed_job_active_record.gemspec) + Dir["lib/**/*.rb"]
+  spec.files          = %w[CONTRIBUTING.md LICENSE.md README.md delayed_job_active_record.gemspec] + Dir["lib/**/*.rb"]
   spec.homepage       = "http://github.com/collectiveidea/delayed_job_active_record"
   spec.licenses       = ["MIT"]
+  spec.metadata       = { "rubygems_mfa_required" => "true" }
   spec.name           = "delayed_job_active_record"
   spec.require_paths  = ["lib"]
   spec.summary        = "ActiveRecord backend for DelayedJob"
-  spec.version        = "4.1.2"
+  spec.version        = "4.1.7"
 end

data/lib/delayed/backend/active_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record/version"
 module Delayed
   module Backend
@@ -10,7 +12,10 @@ module Delayed
         end
 
         def reserve_sql_strategy=(val)
-          raise ArgumentError, "allowed values are :optimized_sql or :default_sql" unless val == :optimized_sql || val == :default_sql
+          if !(val == :optimized_sql || val == :default_sql)
+            raise ArgumentError, "allowed values are :optimized_sql or :default_sql"
+          end
+
           @reserve_sql_strategy = val
         end
       end
@@ -34,6 +39,9 @@ module Delayed
         end
 
         scope :by_priority, lambda { order("priority ASC, run_at ASC") }
+        scope :min_priority, lambda { where("priority >= ?", Worker.min_priority) if Worker.min_priority }
+        scope :max_priority, lambda { where("priority <= ?", Worker.max_priority) if Worker.max_priority }
+        scope :for_queues, lambda { |queues = Worker.queues| where(queue: queues) if Array(queues).any? }
 
         before_save :set_default_run_at
 
@@ -45,7 +53,12 @@ module Delayed
         set_delayed_job_table_name
 
         def self.ready_to_run(worker_name, max_run_time)
-          where("(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR locked_by = ?) AND failed_at IS NULL", db_time_now, db_time_now - max_run_time, worker_name)
+          where(
+            "((run_at <= ? AND (locked_at IS NULL OR locked_at < ?)) OR locked_by = ?) AND failed_at IS NULL",
+            db_time_now,
+            db_time_now - max_run_time,
+            worker_name
+          )
         end
 
         def self.before_fork
@@ -61,15 +74,13 @@ module Delayed
           where(locked_by: worker_name).update_all(locked_by: nil, locked_at: nil)
         end
 
-        def self.reserve(worker, max_run_time = Worker.max_run_time) # rubocop:disable CyclomaticComplexity
-          # scope to filter to records that are "ready to run"
-          ready_scope = ready_to_run(worker.name, max_run_time)
-
-          # scope to filter to the single next eligible job
-          ready_scope = ready_scope.where("priority >= ?", Worker.min_priority) if Worker.min_priority
-          ready_scope = ready_scope.where("priority <= ?", Worker.max_priority) if Worker.max_priority
-          ready_scope = ready_scope.where(queue: Worker.queues) if Worker.queues.any?
-          ready_scope = ready_scope.by_priority
+        def self.reserve(worker, max_run_time = Worker.max_run_time)
+          ready_scope =
+            ready_to_run(worker.name, max_run_time)
+            .min_priority
+            .max_priority
+            .for_queues
+            .by_priority
 
           reserve_with_scope(ready_scope, worker, db_time_now)
         end
@@ -88,41 +99,12 @@ module Delayed
 
         def self.reserve_with_scope_using_optimized_sql(ready_scope, worker, now)
           case connection.adapter_name
-          when "PostgreSQL"
-            # Custom SQL required for PostgreSQL because postgres does not support UPDATE...LIMIT
-            # This locks the single record 'FOR UPDATE' in the subquery
-            # http://www.postgresql.org/docs/9.0/static/sql-select.html#SQL-FOR-UPDATE-SHARE
-            # Note: active_record would attempt to generate UPDATE...LIMIT like
-            # SQL for Postgres if we use a .limit() filter, but it would not
-            # use 'FOR UPDATE' and we would have many locking conflicts
-            quoted_table_name = connection.quote_table_name(table_name)
-            subquery_sql      = ready_scope.limit(1).lock(true).select("id").to_sql
-            reserved          = find_by_sql(["UPDATE #{quoted_table_name} SET locked_at = ?, locked_by = ? WHERE id IN (#{subquery_sql}) RETURNING *", now, worker.name])
-            reserved[0]
+          when "PostgreSQL", "PostGIS"
+            reserve_with_scope_using_optimized_postgres(ready_scope, worker, now)
           when "MySQL", "Mysql2"
-            # Removing the millisecond precision from now(time object)
-            # MySQL 5.6.4 onwards millisecond precision exists, but the
-            # datetime object created doesn't have precision, so discarded
-            # while updating. But during the where clause, for mysql(>=5.6.4),
-            # it queries with precision as well. So removing the precision
-            now = now.change(usec: 0)
-            # This works on MySQL and possibly some other DBs that support
-            # UPDATE...LIMIT. It uses separate queries to lock and return the job
-            count = ready_scope.limit(1).update_all(locked_at: now, locked_by: worker.name)
-            return nil if count == 0
-            where(locked_at: now, locked_by: worker.name, failed_at: nil).first
+            reserve_with_scope_using_optimized_mysql(ready_scope, worker, now)
           when "MSSQL", "Teradata"
-            # The MSSQL driver doesn't generate a limit clause when update_all
-            # is called directly
-            subsubquery_sql = ready_scope.limit(1).to_sql
-            # select("id") doesn't generate a subquery, so force a subquery
-            subquery_sql = "SELECT id FROM (#{subsubquery_sql}) AS x"
-            quoted_table_name = connection.quote_table_name(table_name)
-            sql = ["UPDATE #{quoted_table_name} SET locked_at = ?, locked_by = ? WHERE id IN (#{subquery_sql})", now, worker.name]
-            count = connection.execute(sanitize_sql(sql))
-            return nil if count == 0
-            # MSSQL JDBC doesn't support OUTPUT INSERTED.* for returning a result set, so query locked row
-            where(locked_at: now, locked_by: worker.name, failed_at: nil).first
+            reserve_with_scope_using_optimized_mssql(ready_scope, worker, now)
           # Fallback for unknown / other DBMS
           else
             reserve_with_scope_using_default_sql(ready_scope, worker, now)
@@ -130,13 +112,60 @@ module Delayed
         end
 
         def self.reserve_with_scope_using_default_sql(ready_scope, worker, now)
-          # This is our old fashion, tried and true, but slower lookup
-          ready_scope.limit(worker.read_ahead).detect do |job|
+          # This is our old fashion, tried and true, but possibly slower lookup
+          # Instead of reading the entire job record for our detect loop, we select only the id,
+          # and only read the full job record after we've successfully locked the job.
+          # This can have a noticable impact on large read_ahead configurations and large payload jobs.
+          ready_scope.limit(worker.read_ahead).select(:id).detect do |job|
             count = ready_scope.where(id: job.id).update_all(locked_at: now, locked_by: worker.name)
             count == 1 && job.reload
           end
         end
 
+        def self.reserve_with_scope_using_optimized_postgres(ready_scope, worker, now)
+          # Custom SQL required for PostgreSQL because postgres does not support UPDATE...LIMIT
+          # This locks the single record 'FOR UPDATE' in the subquery
+          # http://www.postgresql.org/docs/9.0/static/sql-select.html#SQL-FOR-UPDATE-SHARE
+          # Note: active_record would attempt to generate UPDATE...LIMIT like
+          # SQL for Postgres if we use a .limit() filter, but it would not
+          # use 'FOR UPDATE' and we would have many locking conflicts
+          quoted_name = connection.quote_table_name(table_name)
+          subquery    = ready_scope.limit(1).lock(true).select("id").to_sql
+          sql         = "UPDATE #{quoted_name} SET locked_at = ?, locked_by = ? WHERE id IN (#{subquery}) RETURNING *"
+          reserved    = find_by_sql([sql, now, worker.name])
+          reserved[0]
+        end
+
+        def self.reserve_with_scope_using_optimized_mysql(ready_scope, worker, now)
+          # Removing the millisecond precision from now(time object)
+          # MySQL 5.6.4 onwards millisecond precision exists, but the
+          # datetime object created doesn't have precision, so discarded
+          # while updating. But during the where clause, for mysql(>=5.6.4),
+          # it queries with precision as well. So removing the precision
+          now = now.change(usec: 0)
+          # This works on MySQL and possibly some other DBs that support
+          # UPDATE...LIMIT. It uses separate queries to lock and return the job
+          count = ready_scope.limit(1).update_all(locked_at: now, locked_by: worker.name)
+          return nil if count == 0
+
+          where(locked_at: now, locked_by: worker.name, failed_at: nil).first
+        end
+
+        def self.reserve_with_scope_using_optimized_mssql(ready_scope, worker, now)
+          # The MSSQL driver doesn't generate a limit clause when update_all
+          # is called directly
+          subsubquery_sql = ready_scope.limit(1).to_sql
+          # select("id") doesn't generate a subquery, so force a subquery
+          subquery_sql = "SELECT id FROM (#{subsubquery_sql}) AS x"
+          quoted_table_name = connection.quote_table_name(table_name)
+          sql = "UPDATE #{quoted_table_name} SET locked_at = ?, locked_by = ? WHERE id IN (#{subquery_sql})"
+          count = connection.execute(sanitize_sql([sql, now, worker.name]))
+          return nil if count == 0
+
+          # MSSQL JDBC doesn't support OUTPUT INSERTED.* for returning a result set, so query locked row
+          where(locked_at: now, locked_by: worker.name, failed_at: nil).first
+        end
+
         # Get the current time (GMT or local depending on DB)
         # Note: This does not ping the DB to get the time, so all your clients
         # must have syncronized clocks.
@@ -146,7 +175,7 @@ module Delayed
           elsif ::ActiveRecord::Base.default_timezone == :utc
             Time.now.utc
           else
-            Time.now
+            Time.now # rubocop:disable Rails/TimeZone
           end
         end
 

data/lib/delayed_job_active_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record"
 require "delayed_job"
 require "delayed/backend/active_record"

data/lib/generators/delayed_job/active_record_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/delayed_job/delayed_job_generator"
 require "generators/delayed_job/next_migration_version"
 require "rails/generators/migration"
@@ -22,9 +24,7 @@ module DelayedJob
     private
 
     def migration_version
-      if ActiveRecord::VERSION::MAJOR >= 5
-        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
-      end
+      "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]" if ActiveRecord::VERSION::MAJOR >= 5
     end
   end
 end

data/lib/generators/delayed_job/next_migration_version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DelayedJob
   module NextMigrationVersion
     # while methods have moved around this has been the implementation

data/lib/generators/delayed_job/templates/migration.rb

@@ -1,6 +1,6 @@
 class CreateDelayedJobs < ActiveRecord::Migration<%= migration_version %>
   def self.up
-    create_table :delayed_jobs, force: true do |table|
+    create_table :delayed_jobs do |table|
       table.integer :priority, default: 0, null: false # Allows some jobs to jump to the front of the queue
       table.integer :attempts, default: 0, null: false # Provides for retries, but still fail eventually.
       table.text :handler,                 null: false # YAML-encoded string of the object that will do work

data/lib/generators/delayed_job/upgrade_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "generators/delayed_job/delayed_job_generator"
 require "generators/delayed_job/next_migration_version"
 require "rails/generators/migration"
@@ -7,7 +9,11 @@ require "rails/generators/active_record"
 module DelayedJob
   class UpgradeGenerator < ActiveRecordGenerator
     def create_migration_file
-      migration_template "upgrade_migration.rb", "db/migrate/add_queue_to_delayed_jobs.rb", migration_version: migration_version
+      migration_template(
+        "upgrade_migration.rb",
+        "db/migrate/add_queue_to_delayed_jobs.rb",
+        migration_version: migration_version
+      )
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delayed_job_active_record
 version: !ruby/object:Gem::Version
-  version: 4.1.2
+  version: 4.1.7
 platform: ruby
 authors:
 - Brian Ryckbost
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-27 00:00:00.000000000 Z
+date: 2022-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -21,7 +21,7 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '8.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -31,7 +31,7 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '8.0'
 - !ruby/object:Gem::Dependency
   name: delayed_job
   requirement: !ruby/object:Gem::Requirement
@@ -76,7 +76,8 @@ files:
 homepage: http://github.com/collectiveidea/delayed_job_active_record
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -92,8 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: ActiveRecord backend for DelayedJob