good_job 4.1.0 → 4.1.1

data/config/brakeman.ignore

@@ -0,0 +1,75 @@
+{
+  "ignored_warnings": [
+    {
+      "warning_type": "Dynamic Render Path",
+      "warning_code": 15,
+      "fingerprint": "041ae0dc908151bac0ef0952c625f0dce3a05d2c01a710397a613ef10083f7ae",
+      "check_name": "Render",
+      "message": "Render path contains parameter value",
+      "file": "app/controllers/good_job/frontends_controller.rb",
+      "line": 47,
+      "link": "https://brakemanscanner.org/docs/warning_types/dynamic_render_path/",
+      "code": "render(file => (self.class.js_modules[params[:id].to_sym] or raise(ActionController::RoutingError, \"Not Found\")), {})",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "GoodJob::FrontendsController",
+        "method": "module"
+      },
+      "user_input": "params[:id].to_sym",
+      "confidence": "Weak",
+      "cwe_id": [
+        22
+      ],
+      "note": "Files are explicitly enumerated in the array"
+    },
+    {
+      "warning_type": "Dynamic Render Path",
+      "warning_code": 15,
+      "fingerprint": "b0c2888c9b217671d90d0141b49b036af3b2a70c63b02968cc97ae2052c86272",
+      "check_name": "Render",
+      "message": "Render path contains parameter value",
+      "file": "app/controllers/good_job/frontends_controller.rb",
+      "line": 41,
+      "link": "https://brakemanscanner.org/docs/warning_types/dynamic_render_path/",
+      "code": "render(file => ({ :css => ({ :bootstrap => GoodJob::Engine.root.join(\"app\", \"frontend\", \"good_job\", \"vendor\", \"bootstrap\", \"bootstrap.min.css\"), :style => GoodJob::Engine.root.join(\"app\", \"frontend\", \"good_job\", \"style.css\") }), :js => ({ :bootstrap => GoodJob::Engine.root.join(\"app\", \"frontend\", \"good_job\", \"vendor\", \"bootstrap\", \"bootstrap.bundle.min.js\"), :chartjs => GoodJob::Engine.root.join(\"app\", \"frontend\", \"good_job\", \"vendor\", \"chartjs\", \"chart.min.js\"), :es_module_shims => GoodJob::Engine.root.join(\"app\", \"frontend\", \"good_job\", \"vendor\", \"es_module_shims.js\"), :rails_ujs => GoodJob::Engine.root.join(\"app\", \"frontend\", \"good_job\", \"vendor\", \"rails_ujs.js\") }), :svg => ({ :icons => GoodJob::Engine.root.join(\"app\", \"frontend\", \"good_job\", \"icons.svg\") }) }.dig(params[:format].to_sym, params[:id].to_sym) or raise(ActionController::RoutingError, \"Not Found\")), {})",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "GoodJob::FrontendsController",
+        "method": "static"
+      },
+      "user_input": "params[:id].to_sym",
+      "confidence": "Weak",
+      "cwe_id": [
+        22
+      ],
+      "note": "Files are explicitly enumerated in the array"
+    },
+    {
+      "warning_type": "SQL Injection",
+      "warning_code": 0,
+      "fingerprint": "c837568c590d9608a8bb9927b31b9597aaacc72053b6482e1a54bd02aa0dd2d7",
+      "check_name": "SQL",
+      "message": "Possible SQL injection",
+      "file": "app/models/good_job/job.rb",
+      "line": 140,
+      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
+      "code": "Arel.sql(\"(CASE #{queues.map.with_index do\n sanitize_sql_array([\"WHEN queue_name = ? THEN ?\", queue_name, index])\n end.join(\" \")} ELSE #{queues.size} END)\")",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "Job",
+        "method": null
+      },
+      "user_input": "queues.map.with_index do\n sanitize_sql_array([\"WHEN queue_name = ? THEN ?\", queue_name, index])\n end.join(\" \")",
+      "confidence": "Medium",
+      "cwe_id": [
+        89
+      ],
+      "note": "Developer provided value, queue_name, is sanitized."
+    }
+  ],
+  "updated": "2024-07-18 18:05:56 -0700",
+  "brakeman_version": "6.1.2"
+}

data/config/locales/de.yml

@@ -10,17 +10,17 @@ de:
       retry: Wiederholen
     batches:
       index:
-        older_batches: Ältere Chargen
-        title: Chargen
+        older_batches: Ältere Batches
+        title: Batches
       jobs:
         actions:
-          confirm_destroy: Sind Sie sicher, dass Sie diesen Job zerstören wollen?
-          confirm_discard: Möchten Sie diesen Job wirklich verwerfen?
-          confirm_reschedule: Möchten Sie diesen Auftrag wirklich verschieben?
-          confirm_retry: Möchten Sie diesen Job wirklich wiederholen?
-          destroy: Zerstöre Job
-          discard: Auftrag verwerfen
-          reschedule: Auftrag neu planen
+          confirm_destroy: Bist du sicher, dass du diesen Job zerstören wilst?
+          confirm_discard: Bist du sicher, dass du diesen Job verwerfen willst?
+          confirm_reschedule: Bist du sicher, dass du diesen Job verschieben willst?
+          confirm_retry: Bist du sicher, dass du diesen Job erneut versuchen willst?
+          destroy: Job zerstören
+          discard: Job verwerfen
+          reschedule: Job neu planen
           retry: Job wiederholen
           title: Aktionen
         no_jobs_found: Keine Jobs gefunden.
@@ -29,12 +29,12 @@ de:
         batched_jobs: Batch-Jobs
         callback_jobs: Callback-Jobs
       table:
-        no_batches_found: Keine Chargen gefunden.
+        no_batches_found: Keine Batches gefunden.
     cron_entries:
       actions:
-        confirm_disable: Möchten Sie diesen Cron-Eintrag wirklich deaktivieren?
-        confirm_enable: Möchten Sie diesen Cron-Eintrag wirklich aktivieren?
-        confirm_enqueue: Möchten Sie diesen Cron-Eintrag wirklich in die Warteschlange stellen?
+        confirm_disable: Bist du sicher, dass du diesen Cron-Eintrag deaktivieren willst?
+        confirm_enable: Bist du sicher, dass du diesen Cron-Eintrag aktivieren willst?
+        confirm_enqueue: Bist du sicher, dass du diesen Cron-Eintrag in die Warteschlange stellen willst?
         disable: Cron-Eintrag deaktivieren
         enable: Cron-Eintrag aktivieren
         enqueue: Cron-Eintrag jetzt einreihen
@@ -48,7 +48,7 @@ de:
         no_cron_schedules_found: Keine Cron-Zeitpläne gefunden.
         title: Cron-Zeitpläne
       show:
-        cron_entry_key: Cron-Eingabetaste
+        cron_entry_key: Cron-Schlüssel
     datetime:
       distance_in_words:
         about_x_hours:
@@ -95,11 +95,11 @@ de:
       minutes: "%{min}m %{sec}s"
       seconds: "%{sec}s"
     error_event:
-      discarded: Weggeworfen
+      discarded: Verworfen
       handled: Abgewickelt
       interrupted: Unterbrochen
       retried: Wiederholt
-      retry_stopped: Der Wiederholungsversuch wurde gestoppt
+      retry_stopped: Wiederholung gestoppt
       unhandled: Unbehandelt
     helpers:
       relative_time:
@@ -107,20 +107,20 @@ de:
         past: Vor %{time}
     jobs:
       actions:
-        confirm_destroy: Sind Sie sicher, dass Sie den Job zerstören wollen?
-        confirm_discard: Sind Sie sicher, dass Sie den Job verwerfen wollen?
-        confirm_force_discard: Sind Sie sicher, dass Sie das Verwerfen dieses Jobs erzwingen möchten? Der Job wird als verworfen markiert, aber der laufende Job wird nicht gestoppt – er wird jedoch bei Fehlern nicht erneut versucht.
-        confirm_reschedule: Möchten Sie den Auftrag wirklich verschieben?
-        confirm_retry: Möchten Sie den Job wirklich wiederholen?
-        destroy: Arbeit vernichten
-        discard: Auftrag verwerfen
+        confirm_destroy: Bist du sicher, dass du diesen Job zerstören willst?
+        confirm_discard: Bist du sicher, dass du diesen Job verwerfen willst?
+        confirm_force_discard: Bist du sicher, dass du das Verwerfen dieses Jobs erzwingen möchten? Der Job wird als verworfen markiert, aber der laufende Job wird nicht gestoppt – er wird jedoch bei Fehlern nicht erneut versucht.
+        confirm_reschedule: Bist du sicher, dass du diesen Job verschieben willst?
+        confirm_retry: Bist du sicher, dass du diesen Job wiederholen willst?
+        destroy: Job zerstören
+        discard: Job verwerfen
         force_discard: Job verwerfen erzwingen
-        reschedule: Auftrag neu planen
+        reschedule: Job neu planen
         retry: Job wiederholen
       destroy:
         notice: Hiob wurde zerstört
       discard:
-        notice: Auftrag wurde verworfen
+        notice: Job wurde verworfen
       executions:
         application_trace: Application Trace
         full_trace: Full Trace
@@ -131,25 +131,25 @@ de:
         notice: Der Job wurde zwangsweise verworfen. Die Ausführung wird fortgesetzt, bei Fehlern wird der Vorgang jedoch nicht wiederholt
       index:
         job_pagination: Job-Paginierung
-        older_jobs: Ältere Berufe
+        older_jobs: Ältere Jobs
       reschedule:
-        notice: Auftrag wurde verschoben
+        notice: Job wurde neu planen
       retry:
-        notice: Auftrag wurde wiederholt
+        notice: Job wurde wiederholt
       show:
-        jobs: Arbeitsplätze
+        jobs: Jobs
       table:
         actions:
           apply_to_all:
-            one: Bewerben Sie sich auf alle 1 Stelle.
-            other: Bewerben Sie sich auf alle %{count} Stellen.
-          confirm_destroy_all: Möchten Sie die ausgewählten Jobs wirklich löschen?
-          confirm_discard_all: Möchten Sie die ausgewählten Jobs wirklich verwerfen?
-          confirm_reschedule_all: Möchten Sie die ausgewählten Jobs wirklich neu planen?
-          confirm_retry_all: Möchten Sie die ausgewählten Jobs wirklich wiederholen?
-          destroy_all: Zerstöre alle
+            one: Auf einen Job anwenden.
+            other: Auf alle %{count} Jobs anwenden.
+          confirm_destroy_all: Bist du sicher, dass du die ausgewählten Jobs löschen willst?
+          confirm_discard_all: Bist du sicher, dass du die ausgewählten Jobs verferfen willst?
+          confirm_reschedule_all: Bist du sicher, dass du die ausgewählten Jobs neu planen willst?
+          confirm_retry_all: Bist du sicher, dass du die ausgewählten Jobs wiederholen willst?
+          destroy_all: Alle zerstören
           discard_all: Alle verwerfen
-          reschedule_all: Alles neu planen
+          reschedule_all: Alle neu planen
           retry_all: Alle wiederholen
           title: Aktionen
         no_jobs_found: Keine Jobs gefunden.
@@ -165,7 +165,7 @@ de:
         enqueued_at: Eingereiht bei
         finished: Fertig
         finished_at: Fertig um
-        jobs: Arbeitsplätze
+        jobs: Jobs
         name: Name
       cron:
         class: Klasse
@@ -197,9 +197,9 @@ de:
     performance:
       index:
         average_duration: Durchschnittliche Dauer
-        chart_title: Gesamtdauer der Auftragsausführung in Sekunden
-        executions: Hinrichtungen
-        job_class: Berufsklasse
+        chart_title: Gesamtdauer der Jobs in Sekunden
+        executions: Ausführungen
+        job_class: Job-Klasse
         maximum_duration: Maximale Dauer
         minimum_duration: Mindestdauer
         title: Leistung
@@ -210,8 +210,8 @@ de:
       index:
         cron_enabled: Cron aktiviert
         no_good_job_processes_found: Keine GoodJob-Prozesse gefunden.
-        process: Verfahren
-        schedulers: Planer
+        process: Prozess
+        schedulers: Scheduler
         started: Gestartet
         title: Prozesse
         updated: Aktualisiert
@@ -224,9 +224,9 @@ de:
         all: Alle
         all_jobs: Alle Jobs
         all_queues: Alle Warteschlangen
-        clear: Klar
-        job_name: Berufsbezeichnung
-        placeholder: Suchen Sie nach Klasse, Job-ID, Jobparametern und Fehlertext.
+        clear: Löschen
+        job_name: Job-Name
+        placeholder: Suche nach Klasse, Job-ID, Jobparameter und Fehlertext.
         queue_name: Warteschlangenname
         search: Suchen
       navbar:
@@ -240,14 +240,14 @@ de:
         theme:
           auto: Auto
           dark: Dunkel
-          light: Licht
-          theme: Thema
+          light: Hell
+          theme: Theme
       pending_migrations: GoodJob hat ausstehende Datenbankmigrationen.
       secondary_navbar:
         inspiration: Denk daran, auch du machst einen guten Job!
         last_updated: Zuletzt aktualisiert
     status:
-      discarded: Ausrangiert
+      discarded: Verworfen
       queued: In der Warteschlange
       retried: Wiederholt
       running: Laufend

data/config/locales/es.yml

@@ -10,8 +10,8 @@ es:
       retry: Reintentar
     batches:
       index:
-        older_batches: Batches anteriores
-        title: Batches
+        older_batches: Lotes anteriores
+        title: Lotes
       jobs:
         actions:
           confirm_destroy: "¿Estás seguro que querés eliminar esta tarea?"
@@ -26,10 +26,10 @@ es:
         no_jobs_found: No hay tareas.
       show:
         attributes: Atributos
-        batched_jobs: Batched Jobs
+        batched_jobs: Tareas en lote
         callback_jobs: Callback Jobs
       table:
-        no_batches_found: No hay batches.
+        no_batches_found: No hay lotes.
     cron_entries:
       actions:
         confirm_disable: "¿Estás seguro que querés deshabilitar esta tarea programada?"
@@ -109,12 +109,12 @@ es:
       actions:
         confirm_destroy: "¿Estás seguro que querés eliminar esta tarea?"
         confirm_discard: "¿Estás seguro que querés descartar esta tarea?"
-        confirm_force_discard: "¿Está seguro de que desea forzar el descarte de este trabajo? El trabajo se marcará como descartado, pero el trabajo en ejecución no se detendrá; sin embargo, no se volverá a intentar en caso de falla.\n"
+        confirm_force_discard: "¿Está seguro de que desea forzar el descarte de esta tarea? La tarea se marcará como descartada, pero la tarea en ejecución no se detendrá; sin embargo, no se volverá a intentar en caso de falla.\n"
         confirm_reschedule: "¿Estás seguro que querés reprogramar esta tarea?"
         confirm_retry: "¿Estás seguro que querés reintentar esta tarea?"
         destroy: Eliminar tarea
         discard: Descartar tarea
-        force_discard: Forzar el descarte del trabajo
+        force_discard: Forzar el descarte de la tarea
         reschedule: Reprogramar tarea
         retry: Reiuntentar tarea
       destroy:
@@ -122,13 +122,13 @@ es:
       discard:
         notice: La tarea ha sido descartada
       executions:
-        application_trace: Application Trace
-        full_trace: Full Trace
+        application_trace: Traza de la aplicación
+        full_trace: Traza completa
         in_queue: en cola
         runtime: en ejecución
         title: Ejecuciones
       force_discard:
-        notice: Job ha sido descartado a la fuerza. Continuará ejecutándose pero no se volverá a intentar en caso de fallas.
+        notice: La tarea ha sido descartada a la fuerza. Continuará ejecutándose pero no se volverá a intentar en caso de fallas.
       index:
         job_pagination: Paginación de tareas
         older_jobs: Tareas anteriores
@@ -197,12 +197,12 @@ es:
     performance:
       index:
         average_duration: Duración promedio
-        chart_title: Tiempo total de ejecución del trabajo en segundos
+        chart_title: Tiempo total de ejecución de la tarea en segundos
         executions: Ejecuciones
-        job_class: clase de trabajo
+        job_class: clase de tarea
         maximum_duration: Duración máxima
         minimum_duration: Duración mínima
-        title: Actuación
+        title: Rendimiento
       show:
         slow: Lento
         title: Actuación
@@ -230,12 +230,12 @@ es:
         queue_name: Nombre de la cola
         search: Buscar
       navbar:
-        batches: Batches
+        batches: Lotes
         cron_schedules: Cron
         jobs: Tareas
         live_poll: En vivo
         name: "GoodJob 👍"
-        performance: Actuación
+        performance: Rendimiento
         processes: Procesos
         theme:
           auto: Auto

data/config/routes.rb

@@ -33,8 +33,8 @@ GoodJob::Engine.routes.draw do
 
   resources :performance, only: %i[index show]
 
-  scope :frontend, controller: :frontends do
-    get "modules/:name", action: :module, as: :frontend_module, constraints: { format: 'js' }
-    get "static/:name", action: :static, as: :frontend_static, constraints: { format: %w[css js] }
+  scope :frontend, controller: :frontends, defaults: { version: GoodJob::VERSION.tr(".", "-") } do
+    get "modules/:version/:id", action: :module, as: :frontend_module, constraints: { format: 'js' }
+    get "static/:version/:id", action: :static, as: :frontend_static, constraints: { format: %w[css js svg] }
   end
 end

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -28,28 +28,88 @@ module GoodJob
         class_attribute :good_job_concurrency_config, instance_accessor: false, default: {}
         attr_writer :good_job_concurrency_key
 
-        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
-        else
-          around_enqueue do |job, block|
-            good_job_enqueue_concurrency_check(job, on_abort: nil, on_enqueue: block)
-          end
-        end
-
         wait_key = if ActiveJob.gem_version >= Gem::Version.new("7.1.0.a")
                      :polynomially_longer
                    else
                      :exponentially_longer
                    end
-
         retry_on(
           GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError,
           attempts: Float::INFINITY,
           wait: wait_key
         )
 
+        before_enqueue do |job|
+          # Don't attempt to enforce concurrency limits with other queue adapters.
+          next 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 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 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
+
+          enqueue_throttle = job.class.good_job_concurrency_config[:enqueue_throttle]
+          enqueue_throttle = instance_exec(&enqueue_throttle) if enqueue_throttle.respond_to?(:call)
+          enqueue_throttle = nil unless enqueue_throttle.present? && enqueue_throttle.is_a?(Array) && enqueue_throttle.size == 2
+
+          limit = enqueue_limit || total_limit
+          throttle = enqueue_throttle
+          next unless limit || throttle
+
+          exceeded = nil
+          GoodJob::Job.transaction(requires_new: true, joinable: false) do
+            GoodJob::Job.advisory_lock_key(key, function: "pg_advisory_xact_lock") do
+              if limit
+                enqueue_concurrency = if enqueue_limit
+                                        GoodJob::Job.where(concurrency_key: key).unfinished.advisory_unlocked.count
+                                      else
+                                        GoodJob::Job.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 enqueue limit of #{limit} #{'job'.pluralize(limit)}"
+                  exceeded = :limit
+                  next
+                end
+              end
+
+              if throttle
+                throttle_limit = throttle[0]
+                throttle_period = throttle[1]
+                enqueued_within_period = GoodJob::Job.where(concurrency_key: key)
+                                                     .where(GoodJob::Job.arel_table[:created_at].gt(throttle_period.ago))
+                                                     .count
+
+                if (enqueued_within_period + 1) > throttle_limit
+                  logger.info "Aborted enqueue of #{job.class.name} (Job ID: #{job.job_id}) because the concurrency key '#{key}' has reached its throttle limit of #{limit} #{'job'.pluralize(limit)}"
+                  exceeded = :throttle
+                  next
+                end
+              end
+            end
+
+            # Rollback the transaction because it's potentially less expensive than committing it
+            # even though nothing has been altered in the transaction.
+            raise ActiveRecord::Rollback
+          end
+
+          throw :abort if exceeded
+        end
+
         before_perform do |job|
           # Don't attempt to enforce concurrency limits with other queue adapters.
           next unless job.class.queue_adapter.is_a?(GoodJob::Adapter)
@@ -80,30 +140,43 @@ module GoodJob
             next
           end
 
-          GoodJob::Job.advisory_lock_key(key, function: "pg_advisory_lock") do
-            if limit
-              allowed_active_job_ids = GoodJob::Job.unfinished.where(concurrency_key: key)
-                                                   .advisory_locked
-                                                   .order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC"))
-                                                   .limit(limit).pluck(:active_job_id)
-              # The current job has already been locked and will appear in the previous query
-              raise GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError unless allowed_active_job_ids.include?(job.job_id)
+          exceeded = nil
+          GoodJob::Job.transaction(requires_new: true, joinable: false) do
+            GoodJob::Job.advisory_lock_key(key, function: "pg_advisory_xact_lock") do
+              if limit
+                allowed_active_job_ids = GoodJob::Job.unfinished.where(concurrency_key: key)
+                                                     .advisory_locked
+                                                     .order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC"))
+                                                     .limit(limit).pluck(:active_job_id)
+                # The current job has already been locked and will appear in the previous query
+                exceeded = :limit unless allowed_active_job_ids.include?(job.job_id)
+                next
+              end
+
+              if throttle
+                throttle_limit = throttle[0]
+                throttle_period = throttle[1]
+
+                query = Execution.joins(:job)
+                                 .where(GoodJob::Job.table_name => { concurrency_key: key })
+                                 .where(Execution.arel_table[:created_at].gt(Execution.bind_value('created_at', throttle_period.ago, ActiveRecord::Type::DateTime)))
+                allowed_active_job_ids = query.where(error: nil).or(query.where.not(error: "GoodJob::ActiveJobExtensions::Concurrency::ThrottleExceededError: GoodJob::ActiveJobExtensions::Concurrency::ThrottleExceededError"))
+                                              .order(created_at: :asc)
+                                              .limit(throttle_limit)
+                                              .pluck(:active_job_id)
+
+                exceeded = :throttle unless allowed_active_job_ids.include?(job.job_id)
+                next
+              end
             end
 
-            if throttle
-              throttle_limit = throttle[0]
-              throttle_period = throttle[1]
-
-              query = DiscreteExecution.joins(:job)
-                                       .where(GoodJob::Job.table_name => { concurrency_key: key })
-                                       .where(DiscreteExecution.arel_table[:created_at].gt(DiscreteExecution.bind_value('created_at', throttle_period.ago, ActiveRecord::Type::DateTime)))
-              allowed_active_job_ids = query.where(error: nil).or(query.where.not(error: "GoodJob::ActiveJobExtensions::Concurrency::ThrottleExceededError: GoodJob::ActiveJobExtensions::Concurrency::ThrottleExceededError"))
-                                            .order(created_at: :asc)
-                                            .limit(throttle_limit)
-                                            .pluck(:active_job_id)
+            raise ActiveRecord::Rollback
+          end
 
-              raise ThrottleExceededError unless allowed_active_job_ids.include?(job.job_id)
-            end
+          if exceeded == :limit
+            raise GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError
+          elsif exceeded == :throttle
+            raise GoodJob::ActiveJobExtensions::Concurrency::ThrottleExceededError
           end
         end
       end
@@ -139,72 +212,6 @@ module GoodJob
       def _good_job_default_concurrency_key
         self.class.name.to_s
       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
-
-        enqueue_throttle = job.class.good_job_concurrency_config[:enqueue_throttle]
-        enqueue_throttle = instance_exec(&enqueue_throttle) if enqueue_throttle.respond_to?(:call)
-        enqueue_throttle = nil unless enqueue_throttle.present? && enqueue_throttle.is_a?(Array) && enqueue_throttle.size == 2
-
-        limit = enqueue_limit || total_limit
-        throttle = enqueue_throttle
-        return on_enqueue&.call unless limit || throttle
-
-        GoodJob::Job.advisory_lock_key(key, function: "pg_advisory_lock") do
-          if limit
-            enqueue_concurrency = if enqueue_limit
-                                    GoodJob::Job.where(concurrency_key: key).unfinished.advisory_unlocked.count
-                                  else
-                                    GoodJob::Job.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 enqueue limit of #{limit} #{'job'.pluralize(limit)}"
-              on_abort&.call
-              break
-            end
-          end
-
-          if throttle
-            throttle_limit = throttle[0]
-            throttle_period = throttle[1]
-            enqueued_within_period = GoodJob::Job.where(concurrency_key: key)
-                                                 .where(GoodJob::Job.arel_table[:created_at].gt(throttle_period.ago))
-                                                 .count
-
-            if (enqueued_within_period + 1) > throttle_limit
-              logger.info "Aborted enqueue of #{job.class.name} (Job ID: #{job.job_id}) because the concurrency key '#{key}' has reached its throttle limit of #{limit} #{'job'.pluralize(limit)}"
-              on_abort&.call
-              break
-            end
-          end
-
-          on_enqueue&.call
-        end
-      end
     end
   end
 end