delayed 2.2.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d365ce7fa45762c6122da4a21a7c96e30893c15534f76bb26cbb4e3f721f7c6
-  data.tar.gz: ca6deb755821f865e354a4ff62375d7c918c81e0b9b4be5f665aa9a347ee90e9
+  metadata.gz: 5fac8946441b682c8df0e1365cd446cb7d507e3831f8155d692abe6ef1d52003
+  data.tar.gz: 602f57430c6ac8b7c94bd248f270ffe768d65de07d50bc2e482bfed67fc1ca7c
 SHA512:
-  metadata.gz: 936fabfd27c2ae4ee68c5f999f8b10e778a171b7f438e191a6bdadfc4c3b16da455e5f1620ff0044fc7efa257308fe0679fc74ec879342d0c5c5a248a6d657d0
-  data.tar.gz: 5cb3cdb9e392ed6ae999d768fe910d0587fa1c5cb652cd5a2cd2f5ce2fc88a8598c105a199e831e0c3185af47cc310e82ada88bc862862fe4c9ebd291166a958
+  metadata.gz: 3d5a2383bd876172d81e9d0926d818afe6f989af71e4143c970daf0ea5149f63cad5ccf0029be97e59765b4ceae77dc555578a76fb955ed67f1caaaf92c71352
+  data.tar.gz: 0f33ed115647bbacfdfe27e9db20e075c2b7374d7ee23e57bbe1a983dacfc7d1cbea6e295fb7d672203664f98d151035675e4fccb35eeb2b627dadab921f2a4d

data/README.md

@@ -284,11 +284,11 @@ The following events will be emitted automatically by workers as jobs are reserv
 - **delayed.job.run** - an event measuring the duration of a job's execution
 - **delayed.job.error** - an event indicating that a job has errored and may be retried (no duration attached)
 - **delayed.job.failure** - an event indicating that a job has permanently failed (no duration attached)
-- **delayed.job.enqueue** - an event measuring the time it takes to enqueue a job
+- **delayed.job.enqueue** - an event measuring the time it takes to enqueue one or more jobs (fires once per `Delayed::Job.enqueue` call and once per `perform_all_later` / `enqueue_all` batch)
 - **delayed.worker.reserve_jobs** - an event measuring the duration of the job "pickup query"
 
-The "run", "error", "failure" and "enqueue" events will include a `:job` argument in the event's payload,
-providing access to the job instance.
+The "run", "error", and "failure" events will include a `:job` argument in the event's payload,
+providing access to the job instance. The "enqueue" event will include a `:jobs` array.
 
 ```ruby
 ActiveSupport::Notifications.subscribe('delayed.job.run') do |*args|

data/app/models/delayed/job.rb

@@ -56,8 +56,6 @@ module Delayed
       arel_table[:locked_at].eq(nil).or arel_table[:locked_at].lt(as_of - lock_timeout)
     end
 
-    before_save :set_default_run_at, :set_name
-
     REENQUEUE_BUFFER = 30.seconds
 
     def self.set_delayed_job_table_name
@@ -281,12 +279,5 @@ module Delayed
     def attempts_alert?
       alert_attempts&.<= attempts
     end
-
-    private
-
-    def set_name
-      # [feat:NameColumn] remove 'if' statement and use `||=` once the 'name' column is required.
-      self.name = display_name if respond_to?(:name=) && attributes.fetch('name').nil?
-    end
   end
 end

data/db/migrate/08_add_run_at_and_name_not_null_check.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class AddRunAtAndNameNotNullCheck < ActiveRecord::Migration[6.0]
+  CONSTRAINTS = {
+    run_at: 'chk_delayed_jobs_run_at_not_null',
+    name: 'chk_delayed_jobs_name_not_null',
+  }.freeze
+
+  def up
+    return unless postgres?
+
+    CONSTRAINTS.each do |column, name|
+      execute <<~SQL.squish
+        ALTER TABLE delayed_jobs
+          ADD CONSTRAINT #{name}
+          CHECK (#{column} IS NOT NULL) NOT VALID
+      SQL
+    end
+  end
+
+  def down
+    return unless postgres?
+
+    CONSTRAINTS.each_value do |name|
+      execute "ALTER TABLE delayed_jobs DROP CONSTRAINT IF EXISTS #{name}"
+    end
+  end
+
+  private
+
+  def postgres?
+    connection.adapter_name == 'PostgreSQL'
+  end
+end

data/db/migrate/09_validate_run_at_and_name_not_null.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class ValidateRunAtAndNameNotNull < ActiveRecord::Migration[6.0]
+  CONSTRAINTS = {
+    run_at: 'chk_delayed_jobs_run_at_not_null',
+    name: 'chk_delayed_jobs_name_not_null',
+  }.freeze
+
+  def up
+    CONSTRAINTS.each do |column, name|
+      if postgres?
+        execute "ALTER TABLE delayed_jobs VALIDATE CONSTRAINT #{name}"
+        change_column_null :delayed_jobs, column, false
+        execute "ALTER TABLE delayed_jobs DROP CONSTRAINT #{name}"
+      else
+        change_column_null :delayed_jobs, column, false
+      end
+    end
+  end
+
+  def down
+    CONSTRAINTS.each do |column, name|
+      if postgres?
+        change_column_null :delayed_jobs, column, true
+        execute <<~SQL.squish
+          ALTER TABLE delayed_jobs
+            ADD CONSTRAINT #{name}
+            CHECK (#{column} IS NOT NULL) NOT VALID
+        SQL
+      else
+        change_column_null :delayed_jobs, column, true
+      end
+    end
+  end
+
+  private
+
+  def postgres?
+    connection.adapter_name == 'PostgreSQL'
+  end
+end

data/lib/delayed/active_job_adapter.rb

@@ -11,24 +11,57 @@ module Delayed
     end
 
     def enqueue_at(job, timestamp)
-      _enqueue(job, run_at: Time.at(timestamp)) # rubocop:disable Rails/TimeZone
+      job.scheduled_at = Time.at(timestamp) # rubocop:disable Rails/TimeZone
+      _enqueue(job)
+    end
+
+    def enqueue_all(jobs)
+      return 0 if jobs.empty?
+
+      assert_jobs_safe_to_enqueue!(jobs)
+
+      delayed_jobs = jobs.map { |job| build_delayed_job(job) }
+      Delayed::Job.enqueue_all(delayed_jobs)
+
+      perform_post_enqueue_assignments(jobs, delayed_jobs)
+
+      jobs.size
     end
 
     private
 
-    def _enqueue(job, opts = {})
-      if enqueue_after_transaction_commit_enabled?(job)
-        raise UnsafeEnqueueError, "The ':delayed' ActiveJob adapter is not compatible with enqueue_after_transaction_commit"
+    def _enqueue(job)
+      job.tap { |j| enqueue_all([j]) }
+    end
+
+    def assert_jobs_safe_to_enqueue!(jobs)
+      jobs.each do |job|
+        if enqueue_after_transaction_commit_enabled?(job)
+          raise UnsafeEnqueueError, "The ':delayed' ActiveJob adapter is not compatible with enqueue_after_transaction_commit"
+        end
       end
+    end
 
-      opts.merge!({ queue: job.queue_name, priority: job.priority }.compact)
-        .merge!(job.provider_attributes || {})
+    def build_delayed_job(job)
+      opts = { queue: job.queue_name, priority: job.priority }.compact
+      opts.merge!(job.provider_attributes || {})
+      opts[:run_at] = coerce_scheduled_at(job.scheduled_at) if job.scheduled_at
 
-      Delayed::Job.enqueue(JobWrapper.new(job), opts).tap do |dj|
-        job.provider_job_id = dj.id
+      prepared = Delayed::Backend::JobPreparer.new(JobWrapper.new(job), opts).prepare
+      Delayed::Job.new(prepared)
+    end
+
+    def perform_post_enqueue_assignments(active_jobs, delayed_jobs)
+      active_jobs.zip(delayed_jobs) do |active_job, delayed_job|
+        active_job.successfully_enqueued = true if active_job.respond_to?(:successfully_enqueued=)
+        active_job.provider_job_id = delayed_job.id
       end
     end
 
+    def coerce_scheduled_at(value)
+      value.is_a?(Numeric) ? Time.at(value) : value # rubocop:disable Rails/TimeZone
+    end
+
     def enqueue_after_transaction_commit_enabled?(job)
       job.class.respond_to?(:enqueue_after_transaction_commit) &&
         [true, :always].include?(job.class.enqueue_after_transaction_commit)

data/lib/delayed/backend/base.rb

@@ -14,11 +14,37 @@ module Delayed
 
         def enqueue_job(options)
           new(options).tap do |job|
-            Delayed.lifecycle.run_callbacks(:enqueue, job) do
-              job.hook(:enqueue)
-              Delayed::Worker.delay_job?(job) ? job.save : job.invoke_job
+            assert_payload_not_active_job!(job.payload_object)
+            assert_no_enqueue_hook!(job.payload_object)
+            assert_delay_jobs_not_proc!
+
+            Delayed.lifecycle.run_callbacks(:enqueue, [job]) do
+              Delayed::Worker.delay_jobs ? job.save : job.invoke_job
+            end
+          end
+        end
+
+        # Bulk-enqueue an array of pre-built Delayed::Job instances. Callers are
+        # responsible for running JobPreparer and instantiating each job via
+        # `Delayed::Job.new(...)` before calling this method.
+        def enqueue_all(jobs)
+          return 0 if jobs.empty?
+
+          jobs.each do |job|
+            assert_payload_not_active_job!(job.payload_object)
+            assert_no_enqueue_hook!(job.payload_object)
+          end
+          assert_delay_jobs_not_proc!
+
+          Delayed.lifecycle.run_callbacks(:enqueue, jobs) do
+            if Delayed::Worker.delay_jobs
+              bulk_insert_all(jobs)
+            else
+              jobs.each(&:invoke_job)
             end
           end
+
+          jobs.size
         end
 
         def reserve(worker, max_run_time = Worker.max_run_time)
@@ -41,6 +67,38 @@ module Delayed
           warn '[DEPRECATION] `Delayed::Job.work_off` is deprecated. Use `Delayed::Worker.new.work_off instead.'
           Delayed::Worker.new.work_off(num)
         end
+
+        def name_assignable?
+          column_names.include?('name')
+        end
+
+        private
+
+        def bulk_insert_all(jobs)
+          now = db_time_now
+          jobs.each { |job| job.created_at = job.updated_at = now }
+          rows = jobs.map { |job| job.attributes.compact }
+          result = insert_all(rows) # rubocop:disable Rails/SkipsModelValidations
+          return unless connection.supports_insert_returning?
+
+          ids = result.rows.map(&:first)
+          jobs.zip(ids) { |job, id| job.id = id }
+        end
+
+        def assert_payload_not_active_job!(payload)
+          raise "Delayed::Job enqueue methods do not accept ActiveJobs, use perform_later instead" if payload.is_a?(ActiveJob::Base)
+        end
+
+        def assert_no_enqueue_hook!(payload)
+          return if payload.is_a?(Delayed::JobWrapper)
+          return unless payload.respond_to?(:enqueue)
+
+          raise ":enqueue hook on #{payload.class} is no longer supported"
+        end
+
+        def assert_delay_jobs_not_proc!
+          raise 'Delayed::Worker.delay_jobs may not be a Proc' if Delayed::Worker.delay_jobs.is_a?(Proc)
+        end
       end
 
       attr_reader :error
@@ -58,7 +116,7 @@ module Delayed
       ParseObjectFromYaml = %r{!ruby/\w+:([^\s]+)} # rubocop:disable Naming/ConstantName
 
       def name
-        if self.class.column_names.include?('name')
+        if self.class.name_assignable?
           super || display_name
         else
           display_name # [feat:NameColumn] remove fallback once the "name" column is required.
@@ -105,9 +163,11 @@ module Delayed
 
       def hook(name, *args)
         if payload_object.respond_to?(name)
-          if payload_object.is_a?(Delayed::JobWrapper)
-            return if name == :enqueue # this callback is not supported due to method naming conflicts.
+          if name == :enqueue
+            raise ':enqueue hook is no longer supported'
+          end
 
+          if payload_object.is_a?(Delayed::JobWrapper)
             warn '[DEPRECATION] Job hook methods (`before`, `after`, `success`, etc) are deprecated. Use ActiveJob callbacks instead.'
           end
 
@@ -158,17 +218,13 @@ module Delayed
         @display_name ||= payload_object.display_name if payload_object.respond_to?(:display_name)
         @display_name ||= payload_object.class.name
       rescue DeserializationError # [feat:NameColumn] remove this `rescue` once the "name" column is required.
-        raise if !persisted? && self.class.column_names.include?('name')
+        raise if !persisted? && self.class.name_assignable?
 
         ParseObjectFromYaml.match(handler)[1]
       end
 
       protected
 
-      def set_default_run_at
-        self.run_at ||= self.class.db_time_now
-      end
-
       # Call during reload operation to clear out internal state
       def reset
         @payload_object = nil

data/lib/delayed/backend/job_preparer.rb

@@ -12,6 +12,8 @@ module Delayed
         set_payload
         set_queue_name
         set_priority
+        set_run_at
+        set_name
         handle_dst
         reject_stale_run_at
         handle_deprecation
@@ -34,6 +36,24 @@ module Delayed
         options[:priority] ||= Delayed::Worker.default_priority
       end
 
+      def set_run_at
+        options[:run_at] ||= Job.db_time_now
+      end
+
+      def set_name
+        return if options[:name] || !Job.name_assignable?
+
+        payload = options[:payload_object]
+        options[:name] =
+          if payload.respond_to?(:job_data)
+            payload.job_data['job_class']
+          elsif payload.respond_to?(:display_name)
+            payload.display_name
+          else
+            payload.class.name
+          end
+      end
+
       def scheduled_into_fall_back_hour?
         options[:run_at] &&
           !options[:run_at].in_time_zone.dst? &&

data/lib/delayed/lifecycle.rb

@@ -4,7 +4,7 @@ module Delayed
   class Lifecycle
     EVENTS = {
       execute: [nil],
-      enqueue: [:job],
+      enqueue: [:jobs],
       perform: %i(worker job),
       error: %i(worker job),
       failure: %i(worker job),

data/lib/delayed/plugins/instrumentation.rb

@@ -2,9 +2,9 @@ module Delayed
   module Plugins
     class Instrumentation < Plugin
       callbacks do |lifecycle|
-        lifecycle.around(:enqueue) do |job, *args, &block|
-          ActiveSupport::Notifications.instrument('delayed.job.enqueue', active_support_notifications_tags(job)) do
-            block.call(job, *args)
+        lifecycle.around(:enqueue) do |jobs, &block|
+          ActiveSupport::Notifications.instrument('delayed.job.enqueue', bulk_enqueue_tags(jobs)) do
+            block.call(jobs)
           end
         end
 
@@ -34,6 +34,12 @@ module Delayed
           job: job,
         }
       end
+
+      def self.bulk_enqueue_tags(jobs)
+        {
+          jobs: jobs.map { |job| active_support_notifications_tags(job) },
+        }
+      end
     end
   end
 end

data/lib/delayed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayed
-  VERSION = '2.2.0'
+  VERSION = '3.0.0'
 end

data/lib/delayed/worker.rb

@@ -37,14 +37,6 @@ module Delayed
                :default_log_level, :default_log_level=, to: Delayed
     end
 
-    def self.delay_job?(job)
-      if delay_jobs.is_a?(Proc)
-        delay_jobs.arity == 1 ? delay_jobs.call(job) : delay_jobs.call
-      else
-        delay_jobs
-      end
-    end
-
     def initialize
       @failed_reserve_count = 0