good_job 3.8.0 → 3.10.0

data/app/models/good_job/execution.rb

@@ -20,8 +20,12 @@ module GoodJob
     self.table_name = 'good_jobs'
     self.advisory_lockable_column = 'active_job_id'
 
+    define_model_callbacks :perform
     define_model_callbacks :perform_unlocked, only: :after
 
+    set_callback :perform, :around, :reset_batch_values
+    set_callback :perform_unlocked, :after, :continue_discard_or_finish_batch
+
     # Parse a string representing a group of queues into a more readable data
     # structure.
     # @param string [String] Queue string
@@ -43,10 +47,10 @@ module GoodJob
       case string.first
       when '-'
         exclude_queues = true
-        string = string[1..-1]
+        string = string[1..]
       when '+'
         ordered_queues = true
-        string = string[1..-1]
+        string = string[1..]
       end
 
       queues = string.split(',').map(&:strip)
@@ -65,6 +69,9 @@ module GoodJob
       end
     end
 
+    belongs_to :batch, class_name: 'GoodJob::BatchRecord', optional: true, inverse_of: :executions
+    belongs_to :batch_callback, class_name: 'GoodJob::Batch', optional: true
+
     belongs_to :job, class_name: 'GoodJob::Job', foreign_key: 'active_job_id', primary_key: 'active_job_id', optional: true, inverse_of: :executions
     after_destroy -> { self.class.active_job_id(active_job_id).delete_all }, if: -> { @_destroy_job }
 
@@ -197,6 +204,38 @@ module GoodJob
       end
     end)
 
+    # Construct a GoodJob::Execution from an ActiveJob instance.
+    def self.build_for_enqueue(active_job, overrides = {})
+      execution_args = {
+        active_job_id: active_job.job_id,
+        queue_name: active_job.queue_name.presence || DEFAULT_QUEUE_NAME,
+        priority: active_job.priority || DEFAULT_PRIORITY,
+        serialized_params: active_job.serialize,
+        scheduled_at: active_job.scheduled_at,
+      }
+      execution_args[:concurrency_key] = active_job.good_job_concurrency_key if active_job.respond_to?(:good_job_concurrency_key)
+
+      reenqueued_current_execution = CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
+      current_execution = CurrentThread.execution
+
+      if reenqueued_current_execution
+        if GoodJob::BatchRecord.migrated?
+          execution_args[:batch_id] = current_execution.batch_id
+          execution_args[:batch_callback_id] = current_execution.batch_callback_id
+        end
+        execution_args[:cron_key] = current_execution.cron_key
+      else
+        if GoodJob::BatchRecord.migrated?
+          execution_args[:batch_id] = GoodJob::Batch.current_batch_id
+          execution_args[:batch_callback_id] = GoodJob::Batch.current_batch_callback_id
+        end
+        execution_args[:cron_key] = CurrentThread.cron_key
+        execution_args[:cron_at] = CurrentThread.cron_at
+      end
+
+      new(**execution_args.merge(overrides))
+    end
+
     # Finds the next eligible Execution, acquire an advisory lock related to it, and
     # executes the job.
     # @return [ExecutionResult, nil]
@@ -244,38 +283,23 @@ module GoodJob
     # @param active_job [ActiveJob::Base]
     #   The job to enqueue.
     # @param scheduled_at [Float]
-    #   Epoch timestamp when the job should be executed.
+    #   Epoch timestamp when the job should be executed, if blank will delegate to the ActiveJob instance
     # @param create_with_advisory_lock [Boolean]
     #   Whether to establish a lock on the {Execution} record after it is created.
+    # @param persist_immediately [Boolean]
+    #   Whether to save the record immediately or just initialize it with values. When bulk-inserting
+    #   jobs the caller takes care of the persistence and sets this parameter to `false`
     # @return [Execution]
     #   The new {Execution} instance representing the queued ActiveJob job.
     def self.enqueue(active_job, scheduled_at: nil, create_with_advisory_lock: false)
       ActiveSupport::Notifications.instrument("enqueue_job.good_job", { active_job: active_job, scheduled_at: scheduled_at, create_with_advisory_lock: create_with_advisory_lock }) do |instrument_payload|
-        execution_args = {
-          active_job_id: active_job.job_id,
-          queue_name: active_job.queue_name.presence || DEFAULT_QUEUE_NAME,
-          priority: active_job.priority || DEFAULT_PRIORITY,
-          serialized_params: active_job.serialize,
-          scheduled_at: scheduled_at,
-          create_with_advisory_lock: create_with_advisory_lock,
-        }
-
-        execution_args[:concurrency_key] = active_job.good_job_concurrency_key if active_job.respond_to?(:good_job_concurrency_key)
-
-        if CurrentThread.cron_key
-          execution_args[:cron_key] = CurrentThread.cron_key
-          execution_args[:cron_at] = CurrentThread.cron_at
-        elsif CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
-          execution_args[:cron_key] = CurrentThread.execution.cron_key
-        end
-
-        execution = GoodJob::Execution.new(**execution_args)
+        execution = build_for_enqueue(active_job, { scheduled_at: scheduled_at })
 
+        execution.create_with_advisory_lock = create_with_advisory_lock
         instrument_payload[:execution] = execution
 
         execution.save!
         active_job.provider_job_id = execution.id
-
         CurrentThread.execution.retried_good_job_id = execution.id if CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
 
         execution
@@ -288,27 +312,29 @@ module GoodJob
     #   exception raised by the job, if any. If the job completed successfully,
     #   the second array entry (the exception) will be +nil+ and vice versa.
     def perform
-      raise PreviouslyPerformedError, 'Cannot perform a job that has already been performed' if finished_at
+      run_callbacks(:perform) do
+        raise PreviouslyPerformedError, 'Cannot perform a job that has already been performed' if finished_at
 
-      self.performed_at = Time.current
-      save! if GoodJob.preserve_job_records
+        self.performed_at = Time.current
+        save! if GoodJob.preserve_job_records
 
-      result = execute
+        result = execute
 
-      job_error = result.handled_error || result.unhandled_error
-      self.error = [job_error.class, ERROR_MESSAGE_SEPARATOR, job_error.message].join if job_error
+        job_error = result.handled_error || result.unhandled_error
+        self.error = [job_error.class, ERROR_MESSAGE_SEPARATOR, job_error.message].join if job_error
 
-      reenqueued = result.retried? || retried_good_job_id.present?
-      if result.unhandled_error && GoodJob.retry_on_unhandled_error
-        save!
-      elsif GoodJob.preserve_job_records == true || reenqueued || (result.unhandled_error && GoodJob.preserve_job_records == :on_unhandled_error) || cron_key.present?
-        self.finished_at = Time.current
-        save!
-      else
-        destroy_job
-      end
+        reenqueued = result.retried? || retried_good_job_id.present?
+        if result.unhandled_error && GoodJob.retry_on_unhandled_error
+          save!
+        elsif GoodJob.preserve_job_records == true || reenqueued || (result.unhandled_error && GoodJob.preserve_job_records == :on_unhandled_error) || cron_key.present?
+          self.finished_at = Time.current
+          save!
+        else
+          destroy_job
+        end
 
-      result
+        result
+      end
     end
 
     # Tests whether this job is safe to be executed by this thread.
@@ -403,5 +429,13 @@ module GoodJob
         end
       end
     end
+
+    def reset_batch_values(&block)
+      GoodJob::Batch.within_thread(batch_id: nil, batch_callback_id: nil, &block)
+    end
+
+    def continue_discard_or_finish_batch
+      batch._continue_discard_or_finish(self) if GoodJob::BatchRecord.migrated? && batch.present?
+    end
   end
 end

data/app/models/good_job/job.rb

@@ -28,6 +28,7 @@ module GoodJob
     self.primary_key = 'active_job_id'
     self.advisory_lockable_column = 'active_job_id'
 
+    belongs_to :batch, class_name: 'GoodJob::BatchRecord', inverse_of: :jobs, optional: true
     has_many :executions, -> { order(created_at: :asc) }, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id', inverse_of: :job # rubocop:disable Rails/HasManyOrHasOneDependent
 
     # Only the most-recent unretried execution represents a "Job"

data/app/views/good_job/batches/_jobs.erb

@@ -0,0 +1,108 @@
+  <div class="my-3 card" data-gj-poll-replace id="jobs-table">
+    <div class="list-group list-group-flush text-nowrap table-jobs" role="table">
+      <header class="list-group-item bg-light">
+        <div class="row small text-muted text-uppercase align-items-center">
+          <div class="col-4">Jobs</div>
+          <div class="col-1">Queue</div>
+          <div class="col-1">Priority</div>
+          <div class="col-1 text-end">Attempts</div>
+          <div class="col text-end">
+            <%= tag.button type: "button", class: "btn btn-sm text-muted", role: "button",
+                           data: { bs_toggle: "collapse", bs_target: ".job-params" },
+                           aria: { expanded: false, controls: jobs.map { |job| "##{dom_id(job, "params")}" }.join(" ") } do %>
+              <%= render_icon "info" %>
+              <span class="visually-hidden">Inspect</span>
+            <% end %>
+          </div>
+        </div>
+      </header>
+
+      <% if jobs.present? %>
+        <% jobs.each do |job| %>
+          <div role="row" class="list-group-item list-group-item-action py-3">
+            <div class="row align-items-center">
+              <div class="col-4">
+                <%= tag.code link_to(job.id, job_path(job), class: "small text-muted text-decoration-none") %>
+                <%= tag.h5 tag.code(link_to(job.job_class, job_path(job), class: "text-reset text-decoration-none")), class: "text-reset mb-0" %>
+              </div>
+              <div class="col-1">
+                <span class="badge bg-primary bg-opacity-25 text-dark font-monospace"><%= job.queue_name %></span>
+              </div>
+              <div class="col-1 small text-center">
+                <span class="font-monospace fw-bold"><%= job.priority %></span>
+              </div>
+              <div class="col-1 text-center">
+                <% if job.executions_count > 0 && job.status != :finished %>
+                  <%= tag.span job.executions_count, class: "badge rounded-pill bg-danger", data: {
+                    bs_toggle: "popover",
+                    bs_trigger: "hover focus click",
+                    bs_placement: "bottom",
+                    bs_content: job.recent_error
+                  } %>
+                <% else %>
+                  <span class="badge bg-secondary bg-opacity-50 rounded-pill"><%= job.executions_count %></span>
+                <% end %>
+              </div>
+              <div class="col d-flex gap-3 align-items-center justify-content-end">
+                <%= tag.span relative_time(job.last_status_at), class: "small" %>
+                <%= status_badge job.status %>
+              </div>
+              <div class="col-auto">
+                <div class="dropdown float-end">
+                  <button class="d-flex align-items-center btn btn-sm" type="button" id="<%= dom_id(job, :actions) %>" data-bs-toggle="dropdown" aria-expanded="false">
+                    <%= render "good_job/shared/icons/dots" %>
+                    <span class="visually-hidden">Actions</span>
+                  </button>
+                  <ul class="dropdown-menu shadow" aria-labelledby="<%= dom_id(job, :actions) %>">
+                    <li>
+                      <% job_reschedulable = job.status.in? [:scheduled, :retried, :queued] %>
+                      <%= link_to reschedule_job_path(job.id), method: :put, class: "dropdown-item #{'disabled' unless job_reschedulable}", title: "Reschedule job", data: { confirm: "Confirm reschedule", disable: true } do %>
+                        <%= render "good_job/shared/icons/skip_forward" %>
+                        Reschedule
+                      <% end %>
+                    </li>
+                    <li>
+                      <% job_discardable = job.status.in? [:scheduled, :retried, :queued] %>
+                      <%= link_to discard_job_path(job.id), method: :put, class: "dropdown-item #{'disabled' unless job_discardable}", title: "Discard job", data: { confirm: "Confirm discard", disable: true } do %>
+                        <%= render "good_job/shared/icons/stop" %>
+                        Discard
+                      <% end %>
+                    </li>
+                    <li>
+                      <%= link_to retry_job_path(job.id), method: :put, class: "dropdown-item #{'disabled' unless job.status == :discarded}", title: "Retry job", data: { confirm: "Confirm retry", disable: true } do %>
+                        <%= render "good_job/shared/icons/arrow_clockwise" %>
+                        Retry
+                      <% end %>
+                    </li>
+                    <li>
+                      <%= link_to job_path(job.id), method: :delete, class: "dropdown-item #{'disabled' unless job.status.in? [:discarded, :finished]}", title: "Destroy job", data: { confirm: "Confirm destroy", disable: true } do %>
+                        <%= render_icon "trash" %>
+                        Destroy
+                      <% end %>
+                    </li>
+
+                    <li>
+                      <%= link_to "##{dom_id(job, 'params')}",
+                                  class: "dropdown-item",
+                                  data: { bs_toggle: "collapse" },
+                                  aria: { expanded: false, controls: dom_id(job, "params") } do %>
+                        <%= render_icon "info" %>
+                        Inspect
+                      <% end %>
+                    </li>
+                  </ul>
+                </div>
+              </div>
+            </div>
+          </div>
+          <%= tag.div id: dom_id(job, "params"), class: "job-params list-group-item collapse small bg-dark text-light" do %>
+            <%= tag.pre JSON.pretty_generate(job.display_serialized_params) %>
+          <% end %>
+        <% end %>
+      <% else %>
+        <div class="list-group-item py-4 text-center text-muted">
+          No jobs found.
+        </div>
+      <% end %>
+    </>
+  </div>

data/app/views/good_job/batches/_table.erb

@@ -0,0 +1,61 @@
+  <div class="my-3 card" data-gj-poll-replace id="batches-table">
+    <div class="list-group list-group-flush text-nowrap table-batches" role="table">
+      <header class="list-group-item bg-light">
+        <div class="row small text-muted text-uppercase align-items-center">
+          <div class="col-4">Name</div>
+          <div class="col-1">Created</div>
+          <div class="col-1">Enqueued</div>
+          <div class="col-1">Discarded</div>
+          <div class="col-1">Finished</div>
+          <div class="col">Jobs</div>
+          <div class="col text-end">
+            <%= tag.button type: "button", class: "btn btn-sm text-muted", role: "button",
+                           data: { bs_toggle: "collapse", bs_target: ".batch-properties" },
+                           aria: { expanded: false, controls: batches.map { |batch| "##{dom_id(batch, "params")}" }.join(" ") } do %>
+              <%= render_icon "info" %>
+              <span class="visually-hidden">Inspect</span>
+            <% end %>
+          </div>
+        </div>
+      </header>
+
+      <% if batches.present? %>
+        <% batches.each do |batch| %>
+          <div id="<%= dom_id(batch) %>" class="list-group-item py-3" role="row">
+            <div class="row align-items-center">
+              <div class="col-4">
+                <%= link_to batch_path(batch), class: "text-decoration-none" do %>
+                  <code class="small text-muted">
+                    <%= batch.id %>
+                  </code>
+                  <h5 class=""><code><%= batch.on_finish %></code></h5>
+                  <div class="text-muted"><%= batch.description %></div>
+                <% end %>
+              </div>
+              <div class="col-1 text-wrap"><%= relative_time(batch.created_at)  %></div>
+              <div class="col-1 text-wrap"><%= relative_time(batch.enqueued_at) if batch.enqueued_at %></div>
+              <div class="col-1 text-wrap"><%= relative_time(batch.discarded_at) if batch.discarded_at %></div>
+              <div class="col-1 text-wrap"><%= relative_time(batch.finished_at) if batch.finished_at %></div>
+              <div class="col"><%= batch.jobs.count %></div>
+              <div class="col text-end">
+                <%= tag.button type: "button", class: "btn btn-sm text-muted ms-auto", role: "button",
+                               title: "Inspect",
+                               data: { bs_toggle: "collapse", bs_target: "##{dom_id(batch, 'properties')}" },
+                               aria: { expanded: false, controls: dom_id(batch, "state") } do %>
+                  <%= render_icon "info" %>
+                  <span class="visually-hidden">Inspect</span>
+                <% end %>
+              </div>
+            </div>
+          </div>
+          <%= tag.div id: dom_id(batch, "properties"), class: "batch-properties list-group-item collapse small bg-dark text-light" do %>
+            <%= tag.pre JSON.pretty_generate(batch.properties) %>
+          <% end %>
+        <% end %>
+      <% else %>
+        <div class="list-group-item py-4 text-center text-muted">
+          No batches found.
+        </div>
+      <% end %>
+    </div>
+  </div>

data/app/views/good_job/batches/index.html.erb

@@ -0,0 +1,16 @@
+<% if GoodJob::BatchRecord.migrated? %>
+  <%= render 'good_job/batches/table', batches: @filter.records, filter: @filter %>
+  <% if @filter.records.present? %>
+    <nav aria-label="Batch pagination" class="mt-3">
+      <ul class="pagination">
+        <li class="page-item">
+          <%= link_to(@filter.to_params(after_created_at: @filter.last.created_at, after_id: @filter.last.id), class: "page-link") do %>
+            Older batches <span aria-hidden="true">&raquo;</span>
+          <% end %>
+        </li>
+      </ul>
+    </nav>
+  <% end %>
+<% else %>
+  <h3 class="text-center my-5">GoodJob has pending database migrations.</h3>
+<% end %>

data/app/views/good_job/batches/show.html.erb

@@ -0,0 +1,30 @@
+<div class="break-out bg-light border-bottom py-2 mb-3">
+  <div class="container-fluid pt-2">
+    <div class="row align-items-center">
+      <div class="col-5">
+        <nav aria-label="breadcrumb">
+          <ol class="breadcrumb small mb-0">
+            <li class="breadcrumb-item"><%= link_to "Batches", batches_path %></li>
+            <li class="breadcrumb-item active" aria-current="page"><%= tag.code @batch.id, class: "text-muted" %></li>
+          </ol>
+          <h2 class="h5 mt-2"><%= @batch.description %></h2>
+        </nav>
+      </div>
+    </div>
+  </div>
+</div>
+
+<div class="my-4">
+  <h5>Attributes</h5>
+  <%= tag.pre JSON.pretty_generate @batch.display_attributes, class: 'text-wrap text-break' %>
+</div>
+
+<div class="my-4">
+  <h5>Callback Jobs</h5>
+  <%= render 'jobs', jobs: @batch.callback_jobs.reverse %>
+</div>
+
+<div class="my-4">
+  <h5>Batched Jobs</h5>
+  <%= render 'jobs', jobs: @batch.jobs.reverse %>
+</div>

data/app/views/good_job/shared/_navbar.erb

@@ -14,6 +14,13 @@
             <span class="badge bg-secondary rounded-pill"><%= number_to_human(jobs_count) %></span>
         <% end %>
         </li>
+        <li class="nav-item">
+          <%= link_to batches_path, class: ["nav-link", ("active" if controller_name == 'batches')] do %>
+            <%= "Batches" %>
+            <% batches_count = GoodJob::BatchRecord.migrated? ? GoodJob::BatchRecord.all.size : 0 %>
+            <span class="badge bg-secondary rounded-pill"><%= batches_count %></span>
+          <% end %>
+        </li>
         <li class="nav-item">
           <%= link_to cron_entries_path, class: ["nav-link", ("active" if controller_name == 'cron_entries')] do %>
             <%= t(".cron_schedules") %>

data/config/routes.rb

@@ -15,6 +15,8 @@ GoodJob::Engine.routes.draw do
     end
   end
 
+  resources :batches, only: %i[index show]
+
   resources :cron_entries, only: %i[index show], param: :cron_key do
     member do
       post :enqueue

data/lib/generators/good_job/templates/install/migrations/create_good_jobs.rb.erb

@@ -19,6 +19,23 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
       t.text :cron_key
       t.uuid :retried_good_job_id
       t.datetime :cron_at
+
+      t.uuid :batch_id
+      t.uuid :batch_callback_id
+    end
+
+    create_table :good_job_batches, id: :uuid do |t|
+      t.timestamps
+      t.text :description
+      t.jsonb :serialized_properties
+      t.text :on_finish
+      t.text :on_success
+      t.text :on_discard
+      t.text :callback_queue_name
+      t.integer :callback_priority
+      t.datetime :enqueued_at
+      t.datetime :discarded_at
+      t.datetime :finished_at
     end
 
     create_table :good_job_processes, id: :uuid do |t|
@@ -43,5 +60,7 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
     add_index :good_jobs, [:finished_at], where: "retried_good_job_id IS NULL AND finished_at IS NOT NULL", name: :index_good_jobs_jobs_on_finished_at
     add_index :good_jobs, [:priority, :created_at], order: { priority: "DESC NULLS LAST", created_at: :asc },
       where: "finished_at IS NULL", name: :index_good_jobs_jobs_on_priority_created_at_when_unfinished
+    add_index :good_jobs, [:batch_id], where: "batch_id IS NOT NULL"
+    add_index :good_jobs, [:batch_callback_id], where: "batch_callback_id IS NOT NULL"
   end
 end

data/lib/generators/good_job/templates/update/migrations/04_create_good_job_batches.rb.erb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+class CreateGoodJobBatches < ActiveRecord::Migration<%= migration_version %>
+  def change
+    reversible do |dir|
+      dir.up do
+        # Ensure this incremental update migration is idempotent
+        # with monolithic install migration.
+        return if connection.table_exists?(:good_job_batches)
+      end
+    end
+
+    create_table :good_job_batches, id: :uuid do |t|
+      t.timestamps
+      t.text :description
+      t.jsonb :serialized_properties
+      t.text :on_finish
+      t.text :on_success
+      t.text :on_discard
+      t.text :callback_queue_name
+      t.integer :callback_priority
+      t.datetime :enqueued_at
+      t.datetime :discarded_at
+      t.datetime :finished_at
+    end
+
+    change_table :good_jobs do |t|
+      t.uuid :batch_id
+      t.uuid :batch_callback_id
+
+      t.index :batch_id, where: "batch_id IS NOT NULL"
+      t.index :batch_callback_id, where: "batch_callback_id IS NOT NULL"
+    end
+  end
+end

data/lib/good_job/active_job_extensions/batches.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module GoodJob
+  module ActiveJobExtensions
+    module Batches
+      extend ActiveSupport::Concern
+
+      def batch
+        @_batch ||= CurrentThread.execution&.batch&.to_batch
+      end
+      alias batch? batch
+    end
+  end
+end

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -25,40 +25,13 @@ module GoodJob
         class_attribute :good_job_concurrency_config, instance_accessor: false, default: {}
         attr_writer :good_job_concurrency_key
 
-        around_enqueue do |job, block|
-          # Don't attempt to enforce concurrency limits with other queue adapters.
-          next(block.call) unless job.class.queue_adapter.is_a?(GoodJob::Adapter)
-
-          # Always allow jobs to be retried because the current job's execution will complete momentarily
-          next(block.call) if CurrentThread.active_job_id == job.job_id
-
-          # Only generate the concurrency key on the initial enqueue in case it is dynamic
-          job.good_job_concurrency_key ||= job._good_job_concurrency_key
-          key = job.good_job_concurrency_key
-          next(block.call) if key.blank?
-
-          enqueue_limit = job.class.good_job_concurrency_config[:enqueue_limit]
-          enqueue_limit = instance_exec(&enqueue_limit) if enqueue_limit.respond_to?(:call)
-          enqueue_limit = nil unless enqueue_limit.present? && (0...Float::INFINITY).cover?(enqueue_limit)
-
-          unless enqueue_limit
-            total_limit = job.class.good_job_concurrency_config[:total_limit]
-            total_limit = instance_exec(&total_limit) if total_limit.respond_to?(:call)
-            total_limit = nil unless total_limit.present? && (0...Float::INFINITY).cover?(total_limit)
+        if ActiveJob.gem_version >= Gem::Version.new("6.1.0")
+          before_enqueue do |job|
+            good_job_enqueue_concurrency_check(job, on_abort: -> { throw(:abort) }, on_enqueue: nil)
           end
-
-          limit = enqueue_limit || total_limit
-          next(block.call) unless limit
-
-          GoodJob::Execution.advisory_lock_key(key, function: "pg_advisory_lock") do
-            enqueue_concurrency = if enqueue_limit
-                                    GoodJob::Execution.where(concurrency_key: key).unfinished.advisory_unlocked.count
-                                  else
-                                    GoodJob::Execution.where(concurrency_key: key).unfinished.count
-                                  end
-
-            # The job has not yet been enqueued, so check if adding it will go over the limit
-            block.call unless (enqueue_concurrency + 1) > limit
+        else
+          around_enqueue do |job, block|
+            good_job_enqueue_concurrency_check(job, on_abort: nil, on_enqueue: block)
           end
         end
 
@@ -113,6 +86,50 @@ module GoodJob
         @good_job_concurrency_key || _good_job_concurrency_key
       end
 
+      private
+
+      def good_job_enqueue_concurrency_check(job, on_abort:, on_enqueue:)
+        # Don't attempt to enforce concurrency limits with other queue adapters.
+        return on_enqueue&.call unless job.class.queue_adapter.is_a?(GoodJob::Adapter)
+
+        # Always allow jobs to be retried because the current job's execution will complete momentarily
+        return on_enqueue&.call if CurrentThread.active_job_id == job.job_id
+
+        # Only generate the concurrency key on the initial enqueue in case it is dynamic
+        job.good_job_concurrency_key ||= job._good_job_concurrency_key
+        key = job.good_job_concurrency_key
+        return on_enqueue&.call if key.blank?
+
+        enqueue_limit = job.class.good_job_concurrency_config[:enqueue_limit]
+        enqueue_limit = instance_exec(&enqueue_limit) if enqueue_limit.respond_to?(:call)
+        enqueue_limit = nil unless enqueue_limit.present? && (0...Float::INFINITY).cover?(enqueue_limit)
+
+        unless enqueue_limit
+          total_limit = job.class.good_job_concurrency_config[:total_limit]
+          total_limit = instance_exec(&total_limit) if total_limit.respond_to?(:call)
+          total_limit = nil unless total_limit.present? && (0...Float::INFINITY).cover?(total_limit)
+        end
+
+        limit = enqueue_limit || total_limit
+        return on_enqueue&.call unless limit
+
+        GoodJob::Execution.advisory_lock_key(key, function: "pg_advisory_lock") do
+          enqueue_concurrency = if enqueue_limit
+                                  GoodJob::Execution.where(concurrency_key: key).unfinished.advisory_unlocked.count
+                                else
+                                  GoodJob::Execution.where(concurrency_key: key).unfinished.count
+                                end
+
+          # The job has not yet been enqueued, so check if adding it will go over the limit
+          if (enqueue_concurrency + 1) > limit
+            logger.info "Aborted enqueue of #{job.class.name} (Job ID: #{job.job_id}) because the concurrency key '#{key}' has reached its limit of #{limit} #{'job'.pluralize(limit)}"
+            on_abort&.call
+          else
+            on_enqueue&.call
+          end
+        end
+      end
+
       # Generates the concurrency key from the configuration
       # @return [Object] concurrency key
       def _good_job_concurrency_key