solid_queue-coalesce 0.1.0 → 0.2.0

data/lib/active_job/coalescing.rb

@@ -1,114 +1,235 @@
 # frozen_string_literal: true
 
 module ActiveJob
+  # Lets many +perform_later+ calls with the same key share one pending job. See #coalesce.
   module Coalescing
     extend ActiveSupport::Concern
 
-    DEFAULT_COALESCE_LIMIT = 100
+    COALESCE_ON_CONFLICT_BEHAVIOUR = %i[ discard collect ]
+    COALESCE_ON_FULL_BEHAVIOUR = %i[ wait dispatch ]
+    DEFAULT_COALESCE_MAX_CALLS = 100
+
+    # A job created as a collecting job can't run the way its class says now, or has
+    # lost the calls it collected. Nothing has run, and the job fails with its calls.
+    class CollectedJobMismatch < StandardError; end
+
+    # One accepted call to a collecting job, as #perform_calls receives it.
+    #
+    # +id+ is the row's ID, or +nil+ for +perform_now+ and other adapters. +arguments+
+    # is the call's deserialized positional array.
+    #
+    # +job_data+ is the call's Active Job payload as it was at enqueue, frozen at the
+    # top level. A call that never went through the queue passes a Proc, so only
+    # reading it needs the arguments to be serializable.
+    class Call
+      attr_reader :id, :arguments
+
+      def initialize(id:, arguments:, job_data:)
+        @id = id
+        @arguments = arguments
+        @job_data = job_data
+      end
+
+      def job_data
+        @job_data = @job_data.call if @job_data.respond_to?(:call)
+        @job_data.freeze
+      end
+    end
 
     # Sits in front of the job's own #perform, whichever class defines it, so
-    # #arguments can keep holding this call's own arguments.
-    module CollectedPerform
+    # a collecting job runs #perform_calls instead.
+    module CollectedPerform # :nodoc:
       def perform(*)
-        super(@coalesced_calls)
+        perform_calls(coalesced_calls)
       end
     end
 
     included do
       class_attribute :coalesce_key, instance_accessor: false
-      class_attribute :coalesce_collect, default: false, instance_accessor: false
-      class_attribute :coalesce_limit, instance_accessor: false
-      class_attribute :coalesce_flush_when_full, instance_accessor: false
-
-      attr_writer :coalesced
+      class_attribute :coalesce_on_conflict, instance_accessor: false
+      class_attribute :coalesce_max_calls, instance_accessor: false
+      class_attribute :coalesce_on_full, instance_accessor: false
+      class_attribute :coalesce_debounce, instance_accessor: false
+      class_attribute :coalesce_max_wait, instance_accessor: false
     end
 
-    class_methods do
-      def coalesce(key:, collect: false, limit: nil, flush_when_full: nil)
+    # What happened to this call: +:created+, +:discarded+, +:collected+, or +nil+ if
+    # this instance has no recorded admission. It isn't serialized, so it's +nil+ on
+    # a worker's instance.
+    #
+    #   job = ReindexProductJob.perform_later(product.id)
+    #   job.coalesce_status # => :discarded
+    attr_reader :coalesce_status
+
+    # The Call objects of this run, oldest first, for perform callbacks to read.
+    # It's +nil+ for a job that doesn't collect.
+    attr_reader :coalesced_calls
+
+    private attr_writer :coalesce_status
+
+    module ClassMethods
+      # Shares one pending job between the +perform_later+ calls with the same key. The
+      # key is held until that job starts, so a call during a run opens a new job.
+      #
+      #   class ReindexProductJob < ApplicationJob
+      #     coalesce key: ->(product_id) { product_id }, debounce: 30.seconds, max_wait: 5.minutes
+      #
+      #     def perform(product_id)
+      #       Product.find(product_id).reindex!
+      #     end
+      #   end
+      #
+      # ==== Options
+      #
+      # * +:key+ - Required. A String or Symbol literal, or a Proc that receives the job's
+      #   arguments. It's scoped to the job class, and built like the key of +limits_concurrency+.
+      # * +:on_conflict+ - +:discard+, the default, suppresses a call that finds a pending
+      #   job. +:collect+ stores every call for #perform_calls.
+      # * +:max_calls+ - The most calls one run takes with +:collect+. Defaults to 100.
+      # * +:on_full+ - With +:collect+, +:wait+, the default, leaves a full job to wait for
+      #   its time. +:dispatch+ makes it ready as it fills.
+      # * +:debounce+ - A duration. Each call pushes a pending job back to that long from now.
+      # * +:max_wait+ - A duration greater than +:debounce+ that caps how far a job can move.
+      #
+      # An invalid option raises +ArgumentError+. The README has recipes for each of these:
+      # https://github.com/dtcristo/solid_queue-coalesce#recipes
+      def coalesce(key:, on_conflict: :discard, max_calls: nil, on_full: nil, debounce: nil, max_wait: nil)
         unless (key.is_a?(String) || key.is_a?(Symbol) || key.is_a?(Proc)) && key.present?
           raise ArgumentError, "`key` must be a non-blank String or Symbol, or a Proc"
         end
 
-        if limit && !collect
-          raise ArgumentError, "`limit` needs `collect: true`"
+        unless on_conflict.in?(COALESCE_ON_CONFLICT_BEHAVIOUR)
+          raise ArgumentError, "`on_conflict` must be :discard or :collect"
         end
 
-        if !flush_when_full.nil? && !collect
-          raise ArgumentError, "`flush_when_full` needs `collect: true`"
-        end
+        if on_conflict == :collect
+          max_calls = DEFAULT_COALESCE_MAX_CALLS if max_calls.nil?
 
-        limit ||= DEFAULT_COALESCE_LIMIT if collect
+          unless max_calls.is_a?(Integer) && max_calls.positive?
+            raise ArgumentError, "`max_calls` must be a positive integer"
+          end
+
+          on_full = :wait if on_full.nil?
+
+          unless on_full.in?(COALESCE_ON_FULL_BEHAVIOUR)
+            raise ArgumentError, "`on_full` must be :wait or :dispatch"
+          end
+        elsif !max_calls.nil?
+          raise ArgumentError, "`max_calls` needs `on_conflict: :collect`"
+        elsif !on_full.nil?
+          raise ArgumentError, "`on_full` needs `on_conflict: :collect`"
+        end
 
-        if limit && !(limit.is_a?(Integer) && limit.positive?)
-          raise ArgumentError, "`limit` must be a positive integer"
+        unless debounce.nil? || (debounce.is_a?(ActiveSupport::Duration) && debounce.positive?)
+          raise ArgumentError, "`debounce` must be a positive duration"
         end
 
-        flush_when_full = true if collect && flush_when_full.nil?
+        unless max_wait.nil?
+          raise ArgumentError, "`max_wait` needs `debounce`" if debounce.nil?
 
-        unless flush_when_full.nil? || flush_when_full == true || flush_when_full == false
-          raise ArgumentError, "`flush_when_full` must be true or false"
+          unless max_wait.is_a?(ActiveSupport::Duration) && max_wait > debounce
+            raise ArgumentError, "`max_wait` must be a duration greater than `debounce`"
+          end
         end
 
-        ensure_coalesce_compatible_with_concurrency_controls(collect, concurrency_on_conflict)
+        ensure_coalesce_compatible_with_concurrency_controls(on_conflict, concurrency_on_conflict)
 
         self.coalesce_key = key
-        self.coalesce_collect = collect
-        self.coalesce_limit = limit
-        self.coalesce_flush_when_full = flush_when_full
+        self.coalesce_on_conflict = on_conflict
+        self.coalesce_max_calls = max_calls
+        self.coalesce_on_full = on_full
+        self.coalesce_debounce = debounce
+        self.coalesce_max_wait = max_wait
       end
 
-      def limits_concurrency(**)
-        super.tap { ensure_coalesce_compatible_with_concurrency_controls(coalesce_collect, concurrency_on_conflict) }
+      def coalesce_collect? # :nodoc:
+        coalesce_on_conflict == :collect
+      end
+
+      def limits_concurrency(**) # :nodoc:
+        super.tap { ensure_coalesce_compatible_with_concurrency_controls(coalesce_on_conflict, concurrency_on_conflict) }
       end
 
       private
         # A conflict destroys the job, and with it the calls it has collected
-        def ensure_coalesce_compatible_with_concurrency_controls(collect, on_conflict)
-          if collect && on_conflict == :discard
-            raise ArgumentError, "`coalesce` with `collect: true` can't be combined with `limits_concurrency` with `on_conflict: :discard`"
+        def ensure_coalesce_compatible_with_concurrency_controls(coalesce_on_conflict, concurrency_on_conflict)
+          if coalesce_on_conflict == :collect && concurrency_on_conflict == :discard
+            raise ArgumentError, "`coalesce` with `on_conflict: :collect` can't be combined with `limits_concurrency` with `on_conflict: :discard`"
           end
         end
     end
 
-    # Runs before the arguments are deserialized. Raising here reaches the rescue
-    # in ClaimedExecution#execute, which turns it into a failed execution.
-    def perform_now
+    # Runs before the arguments are deserialized, and outside the rescue_from of
+    # super, so retry_on can't swallow what's raised here. It reaches the rescue in
+    # ClaimedExecution#execute, which turns it into a failed execution.
+    def perform_now # :nodoc:
       start_coalesced_run
       super
     end
 
-    # Scoped to the job class name, and built like concurrency_key
-    def coalesce_key
+    # How the job was created is stored with the job, so it survives retries and
+    # outlives the class's declaration. Only the job's row starts with this, when it
+    # gets its key, so an instance only has it if it was read from one.
+    def serialize # :nodoc:
+      @coalesce_on_conflict ? super.merge("coalesce_on_conflict" => @coalesce_on_conflict) : super
+    end
+
+    def deserialize(job_data) # :nodoc:
+      super
+      @coalesce_on_conflict = job_data["coalesce_on_conflict"]
+    end
+
+    # Scoped to the job class name, and built like concurrency_key. In a batch it's
+    # scoped to the batch too, so each coalesced job belongs to one batch, and a call
+    # that joins it can't leave a batch waiting on another batch's job.
+    def coalesce_key # :nodoc:
       if self.class.coalesce_key
         param = compute_concurrency_parameter(self.class.coalesce_key)
 
         case param
         when ActiveRecord::Base
-          [ self.class.name, param.class.name, param.id ]
+          [ coalesce_batch_scope, self.class.name, param.class.name, param.id ]
         else
-          [ self.class.name, param ]
+          [ coalesce_batch_scope, self.class.name, param ]
         end.compact.join("/")
       end
     end
 
-    # Whether this call joined a job that was already open
-    def coalesced?
-      !!@coalesced
+    # Runs a collecting job with its Call objects, oldest first, instead of +perform+.
+    # Define it on a job with <tt>on_conflict: :collect</tt>. A retry runs all of the
+    # calls again, so it has to be idempotent.
+    #
+    #   def perform_calls(calls)
+    #     SearchIndex.bulk_index(Product.where(id: calls.map { |call| call.arguments.last }))
+    #   end
+    def perform_calls(_calls)
+      raise NotImplementedError, "#{self.class.name} uses `coalesce` with `on_conflict: :collect`, so it needs a `perform_calls(calls)` method"
     end
 
     # A retry is the same work continuing, so it can't join or suppress anything
-    def coalesced_enqueue?
+    def coalesced_enqueue? # :nodoc:
       self.class.coalesce_key.present? && executions.to_i.zero?
     end
 
+    # A call's own time if it has one, and otherwise now plus the window. A longer
+    # wait is capped without raising, because a scheduling preference shouldn't fail
+    # the caller's request.
+    def coalesced_scheduled_at(scheduled_at) # :nodoc:
+      scheduled_at ||= self.class.coalesce_debounce&.from_now || Time.current
+
+      self.class.coalesce_max_wait ? [ scheduled_at, self.class.coalesce_max_wait.from_now ].min : scheduled_at
+    end
+
     # The stored key, in case the arguments it was computed from are gone
-    def concurrency_key
+    def concurrency_key # :nodoc:
       @coalesced_arguments_gone ? @coalesced_run["concurrency_key"] : super
     end
 
     # A retry that doesn't get enqueued has to fail the run: finishing would
     # destroy the job and the calls it owns, with no job left to process them.
-    def retry_job(options = {})
+    def retry_job(options = {}) # :nodoc:
+      ensure_retry_can_take_calls
+
       super.tap do |enqueued|
         if @coalesced_run && !enqueued
           raise enqueue_error || SolidQueue::Job::EnqueueError.new("Couldn't enqueue the retry of #{self.class.name} (#{job_id})")
@@ -117,18 +238,50 @@ module ActiveJob
     end
 
     private
+      def coalesce_batch_scope
+        [ SolidQueue::Batch.name, batch_id ] if batch_id
+      end
+
       # Only the run of a job a worker has claimed. perform_now on an instance that
-      # went through perform_later also has a provider_job_id.
+      # went through perform_later also has a provider_job_id. A collecting job always
+      # looks for its run, because the marker outlives the class's key and adapter.
       def start_coalesced_run
-        if self.class.coalesce_key && provider_job_id && self.class.queue_adapter_name == "solid_queue"
+        ensure_still_collecting if created_collecting?
+
+        if created_collecting? || (self.class.coalesce_key && provider_job_id && self.class.queue_adapter_name == "solid_queue")
           @coalesced_run = SolidQueue::Job.joins(:claimed_execution).find_by(id: provider_job_id)&.start_coalesced_run
+          ensure_calls_present if created_collecting?
+        end
+      end
+
+      def created_collecting?
+        @coalesce_on_conflict == "collect"
+      end
+
+      # Only Solid Queue moves the calls to the retry. On another adapter the retry
+      # would succeed, and they'd stay behind on a job that goes on to finish.
+      def ensure_retry_can_take_calls
+        if worker_coalesced_rows.any? && self.class.queue_adapter_name != "solid_queue"
+          raise CollectedJobMismatch, "#{self.class.name} (#{job_id}) owns collected calls, which can't move to a retry on the `#{self.class.queue_adapter_name}` adapter. Its calls are kept: restore the Solid Queue adapter and retry this failed job, or discard the job to delete them."
+        end
+      end
+
+      def ensure_calls_present
+        if worker_coalesced_rows.empty?
+          raise CollectedJobMismatch, "#{self.class.name} (#{job_id}) was enqueued with `coalesce on_conflict: :collect`, but it has no calls to run: either something other than Solid Queue deleted them, or this worker no longer has the job's claim. Its own arguments are only a copy of its first call, so it won't run them. If its calls are gone, discard this failed job."
+        end
+      end
+
+      def ensure_still_collecting
+        unless self.class.coalesce_collect?
+          raise CollectedJobMismatch, "#{self.class.name} (#{job_id}) was enqueued with `coalesce on_conflict: :collect`, but its class no longer has that. Its calls are kept: restore the declaration and retry this failed job, or discard the job to delete them."
         end
       end
 
       def _perform_job
-        return super unless self.class.coalesce_collect
+        return super unless self.class.coalesce_collect?
 
-        @coalesced_calls = coalesced_calls
+        @coalesced_calls = load_coalesced_calls
 
         if @coalesced_calls.any?
           extend CollectedPerform
@@ -151,37 +304,43 @@ module ActiveJob
         @coalesced_run&.fetch("calls") || []
       end
 
-      def coalesced_calls
+      def load_coalesced_calls
         if worker_coalesced_rows.any?
           calls_from_coalesced_rows
         else
-          [ coalesced_call_from(arguments) ]
+          [ Call.new(id: nil, arguments: arguments, job_data: -> { serialize }) ]
         end
       end
 
-      # Anything but a deleted record raises on the way, before any row has been
-      # dropped, and fails the run with its rows. When every record is gone the rows
-      # stay until the job is destroyed: if this run crashes before finishing, the
-      # re-run needs them to tell it has nothing to do, because a job without rows
-      # runs its own arguments.
+      # Calls whose records are gone are skipped for this attempt. Every row stays
+      # until its job is destroyed, and the next attempt deserializes them again.
+      # Any other error fails the run before skipped calls have been reported.
       def calls_from_coalesced_rows
-        loaded, missing = worker_coalesced_rows.map { |id, serialized| [ id, load_coalesced_row(serialized) ] }.partition(&:last)
-        drop_coalesced_rows(missing, delete: loaded.any?)
+        missing = {}
+
+        calls = worker_coalesced_rows.filter_map do |id, job_data|
+          Call.new(id: id, arguments: deserialize_call_arguments(job_data), job_data: job_data)
+        rescue ActiveJob::DeserializationError => error
+          raise unless record_not_found?(error)
+
+          missing[id] = error
+          nil
+        end
 
-        loaded.map { |_, call_arguments| coalesced_call_from(call_arguments) }
+        instrument_skipped_calls(missing)
+
+        calls
       end
 
-      def load_coalesced_row(serialized)
-        ActiveJob::Arguments.deserialize(serialized)
-      rescue ActiveJob::DeserializationError => error
-        raise unless record_not_found?(error)
+      # On an instance of its own, as in a normal run, so the job's overrides apply.
+      # That instance has no rows, so its deserialize_arguments_if_needed lets errors out.
+      def deserialize_call_arguments(job_data)
+        self.class.deserialize(job_data.dup).tap { |call| call.send(:deserialize_arguments_if_needed) }.arguments
       end
 
-      def drop_coalesced_rows(rows, delete:)
-        rows.each do |id, _|
-          SolidQueue.instrument(:drop_coalesced_argument, argument_id: id, job_id: provider_job_id, active_job_id: job_id) do
-            SolidQueue::CoalescedArgument.where(id: id).delete_all if delete
-          end
+      def instrument_skipped_calls(rows)
+        rows.each do |id, error|
+          SolidQueue.instrument(:drop_coalesced_call, call_id: id, job_id: provider_job_id, active_job_id: job_id, class_name: self.class.name, exception_class: error.class.name)
         end
       end
 
@@ -190,9 +349,5 @@ module ActiveJob
         error.cause.is_a?(ActiveRecord::RecordNotFound) ||
           (defined?(ActiveJob::DeserializationError::RecordNotFound) && error.is_a?(ActiveJob::DeserializationError::RecordNotFound))
       end
-
-      def coalesced_call_from(call_arguments)
-        call_arguments.size == 1 ? call_arguments.first : call_arguments
-      end
   end
 end

data/lib/generators/solid_queue/coalesce/install/templates/db/create_solid_queue_coalesce_tables.rb

@@ -1,10 +1,9 @@
 class CreateSolidQueueCoalesceTables < ActiveRecord::Migration[7.1]
   def change
     create_table :solid_queue_coalesce_keys do |t|
-      # MySQL's default collations treat keys that differ by case or accent as the
-      # same key, which would drop a call that should open its own job
-      t.string :key, null: false, collation: ("utf8mb4_bin" if connection.adapter_name.match?(/mysql|trilogy/i))
+      t.string :key, null: false
       t.bigint :job_id
+      t.integer :calls_count, null: false, default: 0
       t.datetime :created_at, null: false
 
       t.index :key, unique: true
@@ -12,16 +11,12 @@ class CreateSolidQueueCoalesceTables < ActiveRecord::Migration[7.1]
       t.foreign_key :solid_queue_jobs, column: :job_id, on_delete: :cascade
     end
 
-    create_table :solid_queue_coalesced_arguments do |t|
-      t.bigint :coalesce_key_id
-      t.bigint :job_id
+    create_table :solid_queue_coalesced_calls do |t|
+      t.bigint :job_id, null: false
       t.text :arguments, null: false
-      t.datetime :scheduled_at
       t.datetime :created_at, null: false
 
-      t.index :coalesce_key_id
       t.index :job_id
-      t.foreign_key :solid_queue_coalesce_keys, column: :coalesce_key_id, on_delete: :cascade
       t.foreign_key :solid_queue_jobs, column: :job_id, on_delete: :cascade
     end
   end

data/lib/solid_queue/coalesce/engine.rb

@@ -2,7 +2,7 @@
 
 module SolidQueue
   module Coalesce
-    class Engine < ::Rails::Engine
+    class Engine < ::Rails::Engine # :nodoc:
       initializer "solid_queue.coalesce.active_job", after: "solid_queue.active_job.extensions" do
         ActiveSupport.on_load :active_job do
           include ActiveJob::Coalescing

data/lib/solid_queue/coalesce/patches.rb

@@ -4,7 +4,7 @@
 # details of the version pinned in the gemspec.
 module SolidQueue
   module Coalesce
-    module Patches
+    module Patches # :nodoc: all
       # Prepended rather than added to the adapter, because RecurringTask calls
       # Job.enqueue directly.
       module Enqueuing
@@ -12,19 +12,26 @@ module SolidQueue
           coalesced_jobs, other_jobs = active_jobs.partition(&:coalesced_enqueue?)
           return super if coalesced_jobs.empty?
 
-          coalesced_jobs.each { |active_job| active_job.scheduled_at ||= Time.current }
-          ensure_coalescible(coalesced_jobs)
+          # Bulk enqueues bypass ActiveJob#enqueue, and the key depends on the batch
+          coalesced_jobs.each do |active_job|
+            active_job.scheduled_at = active_job.coalesced_scheduled_at(active_job.scheduled_at)
+            active_job.batch_id = Batch.current_batch_id || active_job.batch_id
+          end
+          ensure_coalescible
+
+          prepared_calls = prepare_all_coalesced(coalesced_jobs)
 
           super(other_jobs) if other_jobs.any?
-          enqueue_all_coalesced(coalesced_jobs)
+          enqueue_all_coalesced(prepared_calls)
 
           active_jobs.count(&:successfully_enqueued?)
         end
 
-        def enqueue(active_job, scheduled_at: Time.current)
+        # Only the adapter's enqueue_at passes a time, so a plain call passes none
+        def enqueue(active_job, **options)
           if active_job.coalesced_enqueue?
-            active_job.scheduled_at = scheduled_at
-            ensure_coalescible([ active_job ])
+            active_job.scheduled_at = active_job.coalesced_scheduled_at(options[:scheduled_at])
+            ensure_coalescible
             enqueue_coalesced(active_job.coalesce_key, [ active_job ])
           elsif active_job.class.coalesce_key
             continuing_coalesced_run(active_job) { super }
@@ -36,6 +43,8 @@ module SolidQueue
 
       module Failing
         def failed_with(exception)
+          return super unless may_hold_coalesce_key?
+
           FailedExecution.transaction(requires_new: true) do
             release_coalesce_key
             super
@@ -43,19 +52,46 @@ module SolidQueue
         end
       end
 
-      # Maintenance#start runs its steps from an inline block, so this follows
-      # the only concurrency step it can reach.
-      module Maintaining
+      # Before super, so the key is locked before the job, as in admission. A key
+      # always means a live job: one left on a job that finished without starting,
+      # because its class stopped coalescing, would accept calls that never run. A
+      # job that isn't preserved gets destroyed, and the destroy callback releases it.
+      module Finishing
+        def finished!
+          release_coalesce_key if SolidQueue.preserve_finished_jobs?
+          super
+        end
+      end
+
+      # A class can start discarding conflicts after it stopped collecting, and a
+      # conflict destroys the job. A collecting job blocks instead, whatever its class
+      # says now, so it reaches a worker and fails with its calls.
+      module ConcurrencyConflicts
         private
-          def expire_semaphores
-            super
-            release_stranded_coalesce_keys
+          def handle_concurrency_conflict
+            arguments["coalesce_on_conflict"] == "collect" ? block : super
           end
+      end
 
-          def release_stranded_coalesce_keys
-            wrap_in_app_executor do
-              CoalesceKey.release_stranded(batch_size) if CoalesceKey.migrated?
-            end
+      # Prepended to each execution class that can be discarded, rather than to their
+      # parent, because ReadyExecution signals semaphores in its own discard_jobs.
+      # Admission locks the key, then the job and its semaphore, so this has to lock
+      # the key before either. Left to the cascade, they'd deadlock. On MySQL they
+      # still can, because the locks on the executions also cover the gaps where
+      # admission inserts its own, so these get retried like admission.
+      module BulkDiscarding
+        def discard_all_in_batches(...)
+          Job.retrying_deadlocks { super }
+        end
+
+        def discard_all_from_jobs(...)
+          Job.retrying_deadlocks { super }
+        end
+
+        private
+          def discard_jobs(job_ids)
+            CoalesceKey.release_all(job_ids) if CoalesceKey.migrated?
+            super
           end
       end
 
@@ -64,14 +100,23 @@ module SolidQueue
 
         included do
           validate :ensure_job_class_not_collecting
+          validate :ensure_job_class_not_debounced
         end
 
         private
           # A tick that joins an open job would record that job again, and the unique
           # index on recurring_executions.job_id would roll back the call it collected.
           def ensure_job_class_not_collecting
-            if class_name.present? && job_class&.try(:coalesce_collect)
-              errors.add :class_name, :collecting, message: "can't be a job that uses `coalesce` with `collect: true`"
+            if class_name.present? && job_class&.try(:coalesce_collect?)
+              errors.add :class_name, :collecting, message: "can't be a job that uses `coalesce` with `on_conflict: :collect`"
+            end
+          end
+
+          # A tick passes no time, so the window applies, and a tick that joins pushes
+          # the job back. With an interval shorter than the window it would never run.
+          def ensure_job_class_not_debounced
+            if class_name.present? && job_class&.try(:coalesce_debounce)
+              errors.add :class_name, :debounced, message: "can't be a job that uses `coalesce` with `debounce`"
             end
           end
       end
@@ -80,19 +125,24 @@ module SolidQueue
         SolidQueue::Job.include SolidQueue::Job::Coalescible
         SolidQueue::Job.singleton_class.prepend Enqueuing
         SolidQueue::Job.prepend Failing
+        SolidQueue::Job.prepend Finishing
+        SolidQueue::Job.prepend ConcurrencyConflicts
+        [ ReadyExecution, ScheduledExecution, BlockedExecution, FailedExecution ].each { |execution| execution.singleton_class.prepend BulkDiscarding }
         SolidQueue::RecurringTask.include RecurringValidation
-        SolidQueue::Dispatcher::Maintenance.prepend Maintaining
       end
     end
   end
 end
 
 class SolidQueue::LogSubscriber
-  def coalesce(event)
-    debug formatted_event(event, action: "Coalesce call", **event.payload.slice(:key, :job_id, :active_job_id), outcome: event.payload[:action])
+  # This one fires for every call, so above debug it shouldn't build a line for each
+  subscribe_log_level :coalesce, :debug
+
+  def coalesce(event) # :nodoc:
+    debug formatted_event(event, action: "Coalesce call", **event.payload.slice(:job_id, :active_job_id, :class_name), outcome: event.payload[:status])
   end
 
-  def drop_coalesced_argument(event)
-    warn formatted_event(event, action: "Drop coalesced call for a deleted record", **event.payload.slice(:argument_id, :job_id, :active_job_id))
+  def drop_coalesced_call(event) # :nodoc:
+    warn formatted_event(event, action: "Skip coalesced call for a deleted record", **event.payload.slice(:call_id, :job_id, :active_job_id, :class_name, :exception_class))
   end
 end

data/lib/solid_queue/coalesce/version.rb

@@ -1,5 +1,5 @@
 module SolidQueue
   module Coalesce
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end