delayed_job_active_record 4.0.2 → 4.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0ba9b64dfebf36a3cc8248ff10fff63af3a8b611
-  data.tar.gz: 506aba7854d7c39aa711c54e38c7a87e2fd7c00d
+SHA256:
+  metadata.gz: 6f3787467e904817090ad112e500a855194661f9295623517cc73c0bbb930c57
+  data.tar.gz: 200346cb19ab7030a82e86c41499220a6aab7e76bec940b14a17b39a96f13490
 SHA512:
-  metadata.gz: 7f1b5ad0fa88e075b988d4234654cfdbc0e63e8a32344d8cb1824ef7562f88b1aa7ad63952e3176df823daac164fda2bf34692735062961cb59896d10f0dec72
-  data.tar.gz: a4621ce576f0d7fb0458ccd3aa396ad79a5f5bd7ef85440c6aead1fcb8b6b11d11bc5610042b7da72f909a6fd5efeae0c1676427a80233d1d66cdc88a0f273e2
+  metadata.gz: 96b163e6ddbd7dd28c1b8bfd33fcbc7c39ee3b7c66af76774e45f7cf60f88946b26c8afa994af786ce7b4960f33c41209bcc75a99c4c0fd8b023ad83bd737c52
+  data.tar.gz: f149d6efdc7b06935639ea8f57d39f32710f1961f285b9a1baf0afd95c8bd30553d2a2c7e59e9ced337d323008a173832c6724af12d4788976808bb9bfae6f60

data/README.md

@@ -1,10 +1,13 @@
+**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.7).](https://github.com/collectiveidea/delayed_job_active_record/tree/v4.1.8)**
+
 # DelayedJob ActiveRecord Backend
 
-[![Gem Version](https://badge.fury.io/rb/delayed_job_active_record.png)](https://rubygems.org/gems/delayed_job_active_record)
-[![Build Status](https://travis-ci.org/collectiveidea/delayed_job_active_record.png)](https://travis-ci.org/collectiveidea/delayed_job_active_record)
-[![Dependency Status](https://gemnasium.com/collectiveidea/delayed_job_active_record.png)](https://gemnasium.com/collectiveidea/delayed_job_active_record)
-[![Code Climate](https://codeclimate.com/github/collectiveidea/delayed_job_active_record.png)](https://codeclimate.com/github/collectiveidea/delayed_job_active_record)
-[![Coverage Status](https://coveralls.io/repos/collectiveidea/delayed_job_active_record/badge.png?branch=master)](https://coveralls.io/r/collectiveidea/delayed_job_active_record)
+[![Gem Version](https://img.shields.io/gem/v/delayed_job_active_record.svg)](https://rubygems.org/gems/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
 
@@ -20,6 +23,12 @@ delayed_job table.
     rails g delayed_job:active_record
     rake db:migrate
 
+## Problems locking jobs
+
+You can try using the legacy locking code. It is usually slower but works better for certain people.
+
+    Delayed::Backend::ActiveRecord.configuration.reserve_sql_strategy = :default_sql
+
 ## Upgrading from 2.x to 3.0.0
 
 If you're upgrading from Delayed Job 2.x, run the upgrade generator to create a

data/delayed_job_active_record.gemspec

@@ -1,19 +1,17 @@
-# coding: utf-8
+# frozen_string_literal: true
 
 Gem::Specification.new do |spec|
-  spec.add_dependency 'activerecord', ['>= 3.0', '< 4.2']
-  spec.add_dependency 'delayed_job',  ['>= 3.0', '< 4.1']
-  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 Rakefile delayed_job_active_record.gemspec]
-  spec.files         += Dir.glob('lib/**/*.rb')
-  spec.files         += Dir.glob('spec/**/*')
-  spec.homepage       = 'http://github.com/collectiveidea/delayed_job_active_record'
-  spec.licenses       = ['MIT']
-  spec.name           = 'delayed_job_active_record'
-  spec.require_paths  = ['lib']
-  spec.summary        = 'ActiveRecord backend for DelayedJob'
-  spec.test_files     = Dir.glob('spec/**/*')
-  spec.version        = '4.0.2'
+  spec.add_dependency "activerecord", [">= 3.0", "< 8.0"]
+  spec.add_dependency "delayed_job",  [">= 3.0", "< 5"]
+  spec.authors        = ["David Genord II", "Brian Ryckbost", "Matt Griffin", "Erik Michaels-Ober"]
+  spec.description    = "ActiveRecord backend for Delayed::Job, originally authored by Tobias Lütke"
+  spec.email          = ["david@collectiveidea.com", "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.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.8"
 end

data/lib/delayed/backend/active_record.rb

@@ -1,7 +1,33 @@
-require 'active_record/version'
+# frozen_string_literal: true
+
+require "active_record/version"
 module Delayed
   module Backend
     module ActiveRecord
+      class Configuration
+        attr_reader :reserve_sql_strategy
+
+        def initialize
+          self.reserve_sql_strategy = :optimized_sql
+        end
+
+        def reserve_sql_strategy=(val)
+          if !(val == :optimized_sql || val == :default_sql)
+            raise ArgumentError, "allowed values are :optimized_sql or :default_sql"
+          end
+
+          @reserve_sql_strategy = val
+        end
+      end
+
+      def self.configuration
+        @configuration ||= Configuration.new
+      end
+
+      def self.configure
+        yield(configuration)
+      end
+
       # A job object that is persisted to the database.
       # Contains the work object as a YAML field.
       class Job < ::ActiveRecord::Base
@@ -12,7 +38,10 @@ module Delayed
                           :failed_at, :locked_at, :locked_by, :handler
         end
 
-        scope :by_priority, lambda { order('priority ASC, run_at ASC') }
+        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
 
@@ -24,11 +53,16 @@ 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
-          ::ActiveRecord::Base.clear_all_connections!
+          ::ActiveRecord::Base.connection_handler.clear_all_connections!
         end
 
         def self.after_fork
@@ -37,73 +71,119 @@ module Delayed
 
         # When a worker is exiting, make sure we don't have any locked jobs.
         def self.clear_locks!(worker_name)
-          where(:locked_by => worker_name).update_all(:locked_by => nil, :locked_at => nil)
+          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
 
         def self.reserve_with_scope(ready_scope, worker, now)
+          case Delayed::Backend::ActiveRecord.configuration.reserve_sql_strategy
           # Optimizations for faster lookups on some common databases
+          when :optimized_sql
+            reserve_with_scope_using_optimized_sql(ready_scope, worker, now)
+          # Slower but in some cases more unproblematic strategy to lookup records
+          # See https://github.com/collectiveidea/delayed_job_active_record/pull/89 for more details.
+          when :default_sql
+            reserve_with_scope_using_default_sql(ready_scope, worker, now)
+          end
+        end
+
+        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 'MySQL', 'Mysql2'
-            # 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
-          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
+          when "PostgreSQL", "PostGIS"
+            reserve_with_scope_using_optimized_postgres(ready_scope, worker, now)
+          when "MySQL", "Mysql2"
+            reserve_with_scope_using_optimized_mysql(ready_scope, worker, now)
+          when "MSSQL", "Teradata"
+            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)
           end
         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|
-            count = ready_scope.where(:id => job.id).update_all(:locked_at => now, :locked_by => worker.name)
+          # 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.
         def self.db_time_now
           if Time.zone
             Time.zone.now
-          elsif ::ActiveRecord::Base.default_timezone == :utc
+          elsif default_timezone == :utc
             Time.now.utc
           else
-            Time.now
+            Time.now # rubocop:disable Rails/TimeZone
+          end
+        end
+
+        def self.default_timezone
+          if ::ActiveRecord.respond_to?(:default_timezone)
+            ::ActiveRecord.default_timezone
+          else
+            ::ActiveRecord::Base.default_timezone
           end
         end
 

data/lib/delayed_job_active_record.rb

@@ -1,5 +1,7 @@
-require 'active_record'
-require 'delayed_job'
-require 'delayed/backend/active_record'
+# frozen_string_literal: true
+
+require "active_record"
+require "delayed_job"
+require "delayed/backend/active_record"
 
 Delayed::Worker.backend = :active_record

data/lib/generators/delayed_job/active_record_generator.rb

@@ -1,7 +1,9 @@
-require 'generators/delayed_job/delayed_job_generator'
-require 'generators/delayed_job/next_migration_version'
-require 'rails/generators/migration'
-require 'rails/generators/active_record'
+# frozen_string_literal: true
+
+require "generators/delayed_job/delayed_job_generator"
+require "generators/delayed_job/next_migration_version"
+require "rails/generators/migration"
+require "rails/generators/active_record"
 
 # Extend the DelayedJobGenerator so that it creates an AR migration
 module DelayedJob
@@ -9,14 +11,20 @@ module DelayedJob
     include Rails::Generators::Migration
     extend NextMigrationVersion
 
-    source_paths << File.join(File.dirname(__FILE__), 'templates')
+    source_paths << File.join(File.dirname(__FILE__), "templates")
 
     def create_migration_file
-      migration_template 'migration.rb', 'db/migrate/create_delayed_jobs.rb'
+      migration_template "migration.rb", "db/migrate/create_delayed_jobs.rb", migration_version: migration_version
     end
 
     def self.next_migration_number(dirname)
       ActiveRecord::Generators::Base.next_migration_number dirname
     end
+
+    private
+
+    def migration_version
+      "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]" if ActiveRecord::VERSION::MAJOR >= 5
+    end
   end
 end

data/lib/generators/delayed_job/next_migration_version.rb

@@ -1,13 +1,22 @@
+# frozen_string_literal: true
+
 module DelayedJob
   module NextMigrationVersion
     # while methods have moved around this has been the implementation
     # since ActiveRecord 3.0
     def next_migration_number(dirname)
       next_migration_number = current_migration_number(dirname) + 1
-      if ActiveRecord::Base.timestamped_migrations
-        [Time.now.utc.strftime('%Y%m%d%H%M%S'), format('%.14d', next_migration_number)].max
+      timestamped_migrations =
+        if ActiveRecord.respond_to?(:timestamped_migrations)
+          ActiveRecord.timestamped_migrations
+        else
+          ActiveRecord::Base.timestamped_migrations
+        end
+
+      if timestamped_migrations
+        [Time.now.utc.strftime("%Y%m%d%H%M%S"), format("%.14d", next_migration_number)].max
       else
-        format('%.3d', next_migration_number)
+        format("%.3d", next_migration_number)
       end
     end
   end

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

@@ -1,19 +1,19 @@
-class CreateDelayedJobs < ActiveRecord::Migration
+class CreateDelayedJobs < ActiveRecord::Migration<%= migration_version %>
   def self.up
-    create_table :delayed_jobs, :force => true 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
-      table.text :last_error                                 # reason for last failure (See Note below)
-      table.datetime :run_at                                 # When to run. Could be Time.zone.now for immediately, or sometime in the future.
-      table.datetime :locked_at                              # Set when a client is working on this object
-      table.datetime :failed_at                              # Set when all retries have failed (actually, by default, the record is deleted instead)
-      table.string :locked_by                                # Who is working on this object (if locked)
-      table.string :queue                                    # The name of the queue this job is in
-      table.timestamps
+    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
+      table.text :last_error                           # reason for last failure (See Note below)
+      table.datetime :run_at                           # When to run. Could be Time.zone.now for immediately, or sometime in the future.
+      table.datetime :locked_at                        # Set when a client is working on this object
+      table.datetime :failed_at                        # Set when all retries have failed (actually, by default, the record is deleted instead)
+      table.string :locked_by                          # Who is working on this object (if locked)
+      table.string :queue                              # The name of the queue this job is in
+      table.timestamps null: true
     end
 
-    add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
+    add_index :delayed_jobs, [:priority, :run_at], name: "delayed_jobs_priority"
   end
 
   def self.down

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

@@ -1,4 +1,4 @@
-class AddQueueToDelayedJobs < ActiveRecord::Migration
+class AddQueueToDelayedJobs < ActiveRecord::Migration<%= migration_version %>
   def self.up
     add_column :delayed_jobs, :queue, :string
   end

data/lib/generators/delayed_job/upgrade_generator.rb

@@ -1,22 +1,19 @@
-require 'generators/delayed_job/delayed_job_generator'
-require 'generators/delayed_job/next_migration_version'
-require 'rails/generators/migration'
-require 'rails/generators/active_record'
+# frozen_string_literal: true
+
+require "generators/delayed_job/delayed_job_generator"
+require "generators/delayed_job/next_migration_version"
+require "rails/generators/migration"
+require "rails/generators/active_record"
 
 # Extend the DelayedJobGenerator so that it creates an AR migration
 module DelayedJob
-  class UpgradeGenerator < ::DelayedJobGenerator
-    include Rails::Generators::Migration
-    extend NextMigrationVersion
-
-    source_paths << File.join(File.dirname(__FILE__), 'templates')
-
+  class UpgradeGenerator < ActiveRecordGenerator
     def create_migration_file
-      migration_template 'upgrade_migration.rb', 'db/migrate/add_queue_to_delayed_jobs.rb'
-    end
-
-    def self.next_migration_number(dirname)
-      ActiveRecord::Generators::Base.next_migration_number dirname
+      migration_template(
+        "upgrade_migration.rb",
+        "db/migrate/add_queue_to_delayed_jobs.rb",
+        migration_version: migration_version
+      )
     end
   end
 end

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: delayed_job_active_record
 version: !ruby/object:Gem::Version
-  version: 4.0.2
+  version: 4.1.8
 platform: ruby
 authors:
+- David Genord II
 - Brian Ryckbost
 - Matt Griffin
 - Erik Michaels-Ober
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-08-19 00:00:00.000000000 Z
+date: 2023-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -21,7 +22,7 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '8.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -31,7 +32,7 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '8.0'
 - !ruby/object:Gem::Dependency
   name: delayed_job
   requirement: !ruby/object:Gem::Requirement
@@ -41,7 +42,7 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -51,10 +52,11 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5'
 description: ActiveRecord backend for Delayed::Job, originally authored by Tobias
   Lütke
 email:
+- david@collectiveidea.com
 - bryckbost@gmail.com
 - matt@griffinonline.org
 - sferik@gmail.com
@@ -65,7 +67,6 @@ files:
 - CONTRIBUTING.md
 - LICENSE.md
 - README.md
-- Rakefile
 - delayed_job_active_record.gemspec
 - lib/delayed/backend/active_record.rb
 - lib/delayed_job_active_record.rb
@@ -74,15 +75,12 @@ files:
 - lib/generators/delayed_job/templates/migration.rb
 - lib/generators/delayed_job/templates/upgrade_migration.rb
 - lib/generators/delayed_job/upgrade_generator.rb
-- spec/database.yml
-- spec/delayed/backend/active_record_spec.rb
-- spec/delayed/serialization/active_record_spec.rb
-- spec/helper.rb
 homepage: http://github.com/collectiveidea/delayed_job_active_record
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -97,13 +95,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.1
-signing_key: 
+rubygems_version: 3.4.20
+signing_key:
 specification_version: 4
 summary: ActiveRecord backend for DelayedJob
-test_files:
-- spec/database.yml
-- spec/delayed/backend/active_record_spec.rb
-- spec/delayed/serialization/active_record_spec.rb
-- spec/helper.rb
+test_files: []

data/Rakefile

@@ -1,38 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'bundler/gem_helper'
-Bundler::GemHelper.install_tasks
-
-require 'rspec/core/rake_task'
-
-ADAPTERS = %w[mysql postgresql sqlite3]
-
-ADAPTERS.each do |adapter|
-  desc "Run RSpec code examples for #{adapter} adapter"
-  RSpec::Core::RakeTask.new(adapter => "#{adapter}:adapter")
-
-  namespace adapter do
-    task :adapter do
-      ENV['ADAPTER'] = adapter
-    end
-  end
-end
-
-task :coverage do
-  ENV['COVERAGE'] = 'true'
-end
-
-task :adapter do
-  ENV['ADAPTER'] = nil
-end
-
-Rake::Task[:spec].enhance do
-  require 'simplecov'
-  require 'coveralls'
-
-  Coveralls::SimpleCov::Formatter.new.format(SimpleCov.result)
-end
-
-require 'rubocop/rake_task'
-RuboCop::RakeTask.new
-
-task :default => ([:coverage] + ADAPTERS + [:adapter] + [:rubocop])

data/spec/database.yml

@@ -1,14 +0,0 @@
-mysql:
-  adapter: mysql
-  database: delayed_job_test
-  username: root
-  encoding: utf8
-
-postgresql:
-  adapter: postgresql
-  database: delayed_job_test
-  username: postgres
-
-sqlite3:
-  adapter: sqlite3
-  database: ":memory:"

data/spec/delayed/backend/active_record_spec.rb

@@ -1,101 +0,0 @@
-require 'helper'
-require 'delayed/backend/active_record'
-
-describe Delayed::Backend::ActiveRecord::Job do
-  it_behaves_like 'a delayed_job backend'
-
-  describe "reserve_with_scope" do
-    let(:worker) { double(name: "worker01", read_ahead: 1) }
-    let(:scope)  { double(limit: limit, where: double(update_all: nil)) }
-    let(:limit)  { double(job: job) }
-    let(:job)    { double(id: 1) }
-
-    before do
-      allow(Delayed::Backend::ActiveRecord::Job.connection).to receive(:adapter_name).at_least(:once).and_return(dbms)
-    end
-
-    context "for a dbms without a specific implementation" do
-      let(:dbms) { "OtherDB" }
-
-      it "uses the plain sql version" do
-        expect(Delayed::Backend::ActiveRecord::Job).to receive(:reserve_with_scope_using_default_sql).once
-        Delayed::Backend::ActiveRecord::Job.reserve_with_scope(scope, worker, Time.now)
-      end
-    end
-  end
-
-  context 'db_time_now' do
-    after do
-      Time.zone = nil
-      ActiveRecord::Base.default_timezone = :local
-    end
-
-    it 'returns time in current time zone if set' do
-      Time.zone = 'Eastern Time (US & Canada)'
-      expect(%(EST EDT)).to include(Delayed::Job.db_time_now.zone)
-    end
-
-    it 'returns UTC time if that is the AR default' do
-      Time.zone = nil
-      ActiveRecord::Base.default_timezone = :utc
-      expect(Delayed::Backend::ActiveRecord::Job.db_time_now.zone).to eq 'UTC'
-    end
-
-    it 'returns local time if that is the AR default' do
-      Time.zone = 'Central Time (US & Canada)'
-      ActiveRecord::Base.default_timezone = :local
-      expect(%w[CST CDT]).to include(Delayed::Backend::ActiveRecord::Job.db_time_now.zone)
-    end
-  end
-
-  describe 'after_fork' do
-    it 'calls reconnect on the connection' do
-      allow(ActiveRecord::Base).to receive(:establish_connection)
-      Delayed::Backend::ActiveRecord::Job.after_fork
-    end
-  end
-
-  describe 'enqueue' do
-    it 'allows enqueue hook to modify job at DB level' do
-      later = described_class.db_time_now + 20.minutes
-      job = Delayed::Backend::ActiveRecord::Job.enqueue :payload_object => EnqueueJobMod.new
-      expect(Delayed::Backend::ActiveRecord::Job.find(job.id).run_at).to be_within(1).of(later)
-    end
-  end
-
-  if ::ActiveRecord::VERSION::MAJOR < 4 || defined?(::ActiveRecord::MassAssignmentSecurity)
-    context 'ActiveRecord::Base.send(:attr_accessible, nil)' do
-      before do
-        Delayed::Backend::ActiveRecord::Job.send(:attr_accessible, nil)
-      end
-
-      after do
-        Delayed::Backend::ActiveRecord::Job.send(:attr_accessible, *Delayed::Backend::ActiveRecord::Job.new.attributes.keys)
-      end
-
-      it 'is still accessible' do
-        job = Delayed::Backend::ActiveRecord::Job.enqueue :payload_object => EnqueueJobMod.new
-        expect(Delayed::Backend::ActiveRecord::Job.find(job.id).handler).to_not be_blank
-      end
-    end
-  end
-
-  context 'ActiveRecord::Base.table_name_prefix' do
-    it "when prefix is not set, use 'delayed_jobs' as table name" do
-      ::ActiveRecord::Base.table_name_prefix = nil
-      Delayed::Backend::ActiveRecord::Job.set_delayed_job_table_name
-
-      expect(Delayed::Backend::ActiveRecord::Job.table_name).to eq 'delayed_jobs'
-    end
-
-    it 'when prefix is set, prepend it before default table name' do
-      ::ActiveRecord::Base.table_name_prefix = 'custom_'
-      Delayed::Backend::ActiveRecord::Job.set_delayed_job_table_name
-
-      expect(Delayed::Backend::ActiveRecord::Job.table_name).to eq 'custom_delayed_jobs'
-
-      ::ActiveRecord::Base.table_name_prefix = nil
-      Delayed::Backend::ActiveRecord::Job.set_delayed_job_table_name
-    end
-  end
-end

data/spec/delayed/serialization/active_record_spec.rb

@@ -1,15 +0,0 @@
-require 'helper'
-
-describe ActiveRecord do
-  it 'loads classes with non-default primary key' do
-    expect do
-      YAML.load(Story.create.to_yaml)
-    end.not_to raise_error
-  end
-
-  it 'loads classes even if not in default scope' do
-    expect do
-      YAML.load(Story.create(:scoped => false).to_yaml)
-    end.not_to raise_error
-  end
-end

data/spec/helper.rb

@@ -1,78 +0,0 @@
-require 'simplecov'
-require 'coveralls'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-]
-
-SimpleCov.start do
-  add_filter '/spec/'
-  minimum_coverage(73.33)
-end
-
-require 'logger'
-require 'rspec'
-
-begin
-  require 'protected_attributes'
-rescue LoadError # rubocop:disable HandleExceptions
-end
-require 'delayed_job_active_record'
-require 'delayed/backend/shared_spec'
-
-Delayed::Worker.logger = Logger.new('/tmp/dj.log')
-ENV['RAILS_ENV'] = 'test'
-
-db_adapter, gemfile = ENV['ADAPTER'], ENV['BUNDLE_GEMFILE']
-db_adapter ||= gemfile && gemfile[%r{gemfiles/(.*?)/}] && $1 # rubocop:disable PerlBackrefs
-db_adapter ||= 'sqlite3'
-
-config = YAML.load(File.read('spec/database.yml'))
-ActiveRecord::Base.establish_connection config[db_adapter]
-ActiveRecord::Base.logger = Delayed::Worker.logger
-ActiveRecord::Migration.verbose = false
-
-ActiveRecord::Schema.define do
-  create_table :delayed_jobs, :force => true do |table|
-    table.integer :priority, :default => 0
-    table.integer :attempts, :default => 0
-    table.text :handler
-    table.text :last_error
-    table.datetime :run_at
-    table.datetime :locked_at
-    table.datetime :failed_at
-    table.string :locked_by
-    table.string :queue
-    table.timestamps
-  end
-
-  add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
-
-  create_table :stories, :primary_key => :story_id, :force => true do |table|
-    table.string :text
-    table.boolean :scoped, :default => true
-  end
-end
-
-# Purely useful for test cases...
-class Story < ActiveRecord::Base
-  if ::ActiveRecord::VERSION::MAJOR < 4 && ActiveRecord::VERSION::MINOR < 2
-    set_primary_key :story_id
-  else
-    self.primary_key = :story_id
-  end
-  def tell
-    text
-  end
-
-  def whatever(n, _)
-    tell * n
-  end
-  default_scope { where(:scoped => true) }
-
-  handle_asynchronously :whatever
-end
-
-# Add this directory so the ActiveSupport autoloading works
-ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__)