good_job 4.22.0 → 4.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3707d55ab1de17d450f3b52e30739b25350ed229e7fad992ab9f56aa01c88fc
-  data.tar.gz: 1af86ced85ba5487a1b3c13eac8e4f2988c6685153fee444fd34afa62533ef7b
+  metadata.gz: 9ce4bd5cfbb7e4fcc44f90099bc1aa892ef59e1294c69eac5d4279c3968db9c0
+  data.tar.gz: '093ba2cc69d8d51f38bbf4cd93d9bf97aa65d995768f00a6b0d27dbe1aacdd08'
 SHA512:
-  metadata.gz: 56311442c755f60a717bc23c42f193f3bfc15f31254527320e9183cc681cc43c9a87d89fd5e9c2efe305d14f87f6c3cafa0d9a2e5443c5cad3eafa7da31f5674
-  data.tar.gz: '0875bd2051120c9cd80d11e781713b2c13a6a05d2fdfa38f54dfdb0c3a616b3cbe4d23769db811211feaf7feb49cb1d2a1bf4e72baa31a9127f10b82ce18f5fd'
+  metadata.gz: bcbcad67274883a3cb3d4405d7d43015c5c154241dab9c1d136ccbcae7ea53bf9e6606d4713761b7c565826487f042c0e869ecc14eafacfa46ce3bfb9de6dc26
+  data.tar.gz: 56b86db61ba722ebbe770f0f0be2f20eaea6a132af9a3d9e5f688a2c2138d3782d92a3a425ff47b0e1881539c7bfe8135c18444b887665105edc385d3f3aa3a7

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [v4.22.1](https://github.com/bensheldon/good_job/tree/v4.22.1) (2026-10-13)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.22.0...v4.22.1)
+
+**Implemented enhancements:**
+
+- Show full job labels under the job name in dashboard tables [\#1862](https://github.com/bensheldon/good_job/pull/1862) ([olivier-thatch](https://github.com/olivier-thatch))
+
+**Fixed bugs:**
+
+- Keep the process id when refresh recreates a deleted process record [\#1866](https://github.com/bensheldon/good_job/pull/1866) ([wivern-co-uk](https://github.com/wivern-co-uk))
+- Don't apply a concurrency lock when a rule's label resolves to blank [\#1864](https://github.com/bensheldon/good_job/pull/1864) ([bensheldon](https://github.com/bensheldon))
+
+**Merged pull requests:**
+
+- Support enqueuing jobs from non-main Ractors [\#1863](https://github.com/bensheldon/good_job/pull/1863) ([bensheldon](https://github.com/bensheldon))
+
 ## [v4.22.0](https://github.com/bensheldon/good_job/tree/v4.22.0) (2026-10-09)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.21.1...v4.22.0)

data/app/frontend/good_job/style.css

@@ -186,3 +186,8 @@
   border-top-left-radius: 0 !important;
   border-bottom-left-radius: 0 !important;
 }
+
+/* Stop a long job name from widening its cell, so label badges clip at the column edge. */
+.min-width-0 {
+  min-width: 0;
+}

data/app/helpers/good_job/application_helper.rb

@@ -27,14 +27,15 @@ module GoodJob
     # Renders a job's label as a badge. Labels on which the job has a concurrency claim
     # are colored and prefixed with an icon for the claim's state.
     # Claims are only shown when the job's +concurrency_claims+ are already loaded.
-    def job_label_badge(job, label, url: nil)
+    # With +full: true+, the badge shows the full label and CSS clips it at the container width.
+    def job_label_badge(job, label, url: nil, full: false)
       claim = job.concurrency_claims.find { |job_claim| job_claim.label == label } if job.association(:concurrency_claims).loaded?
       state_name = claim&.state_name
-      truncated_label = truncate(label, length: 15)
+      truncated_label = full ? label : truncate(label, length: 15)
       state_text = t(state_name, scope: "good_job.concurrency_claims.states") if state_name
-      title = [(label if truncated_label != label), state_text].compact.join(" · ")
+      title = [(label if full || truncated_label != label), state_text].compact.join(" · ")
 
-      options = { class: "badge font-monospace text-decoration-none #{CONCURRENCY_CLAIM_BADGE_CLASSES.fetch(state_name)}" }
+      options = { class: "badge font-monospace text-decoration-none #{'text-truncate mw-100 ' if full}#{CONCURRENCY_CLAIM_BADGE_CLASSES.fetch(state_name)}" }
       if title.present?
         options[:title] = title
         options[:data] = { bs_toggle: "tooltip" }

data/app/models/concerns/good_job/advisory_lockable.rb

@@ -62,8 +62,22 @@ module GoodJob
     # require additional synchronization.
     #
     # Per-key structure: [session_count, xact_txns, cte]
-    #   xact_txns: Array of WeakRefs to AR transaction objects
+    #   xact_txns: Array of TransactionRefs to AR transaction objects
     class AdvisoryLockCounter
+      # A weak reference to an Active Record transaction. Unlike +WeakRef+,
+      # which uses a class variable, this can be used from non-main Ractors.
+      class TransactionRef
+        def initialize(transaction)
+          @ref = ObjectSpace::WeakMap.new
+          @ref[:transaction] = transaction
+        end
+
+        def open?
+          transaction = @ref[:transaction]
+          !transaction.nil? && transaction.open?
+        end
+      end
+
       def initialize
         if defined?(ObjectSpace::WeakKeyMap)
           # WeakKeyMap (Ruby 3.3+) holds weak keys with strong values:
@@ -144,13 +158,13 @@ module GoodJob
 
       # Record a lock acquisition.
       # Per-key structure: [session_count, xact_txns, cte]
-      #   xact_txns is an Array of WeakRefs to transaction objects
+      #   xact_txns is an Array of TransactionRefs
       def record_lock(conn, key, cte: false, xact: false)
         prune(conn)
         counts = self[conn] || (self[conn] = {})
         session_count, xact_txns, was_cte = counts[key] || [0, [], false]
         if xact
-          xact_txns += [WeakRef.new(conn.current_transaction)]
+          xact_txns += [TransactionRef.new(conn.current_transaction)]
         else
           session_count += 1
         end
@@ -191,11 +205,7 @@ module GoodJob
         return unless counts
 
         counts.each do |key, (session_count, xact_txns, cte)|
-          live_txns = xact_txns.select do |ref|
-            ref.weakref_alive? && ref.open?
-          rescue WeakRef::RefError
-            false
-          end
+          live_txns = xact_txns.select(&:open?)
 
           if session_count.zero? && live_txns.empty?
             counts.delete(key)
@@ -206,8 +216,14 @@ module GoodJob
       end
     end
 
-    ADVISORY_LOCK_COUNTS = AdvisoryLockCounter.new
-    private_constant :ADVISORY_LOCK_COUNTS
+    # Lock counts are tracked per connection, and connections are not shared
+    # across Ractors, so each Ractor has its own counter.
+    # @api private
+    # @return [AdvisoryLockCounter]
+    def self.advisory_lock_counts
+      GoodJob::Ractors.local(:good_job_advisory_lock_counts) { AdvisoryLockCounter.new }
+    end
+
     AREL_TABLE_NEW_KWARGS = Arel::Table.instance_method(:initialize).parameters.any? { |type, name| type == :key && name == :name }
 
     included do
@@ -447,7 +463,7 @@ module GoodJob
       # @return [Boolean] whether the lock was released.
       def advisory_unlock_key(key, function: advisory_unlockable_function, connection: nil)
         conn = connection || lease_connection
-        session_count, _xact_count, cte = ADVISORY_LOCK_COUNTS.counts_for(conn, key)
+        session_count, _xact_count, cte = AdvisoryLockable.advisory_lock_counts.counts_for(conn, key)
 
         if session_count <= 1 && cte
           advisory_unlock_key!(key, function: function, connection: conn)
@@ -474,7 +490,7 @@ module GoodJob
       # @return [void]
       def advisory_unlock_key!(key, function: advisory_unlockable_function, connection: nil)
         conn = connection || lease_connection
-        _, xact_count, = ADVISORY_LOCK_COUNTS.counts_for(conn, key)
+        _, xact_count, = AdvisoryLockable.advisory_lock_counts.counts_for(conn, key)
 
         if xact_count.positive?
           # An active xact lock on the same key means owns_advisory_lock_key? will
@@ -617,15 +633,15 @@ module GoodJob
       end
 
       def record_advisory_lock(conn, key, cte: false, xact: false)
-        ADVISORY_LOCK_COUNTS.record_lock(conn, key, cte: cte, xact: xact)
+        AdvisoryLockable.advisory_lock_counts.record_lock(conn, key, cte: cte, xact: xact)
       end
 
       def record_advisory_unlock(conn, key)
-        ADVISORY_LOCK_COUNTS.record_unlock(conn, key)
+        AdvisoryLockable.advisory_lock_counts.record_unlock(conn, key)
       end
 
       def prune_advisory_locks(conn)
-        ADVISORY_LOCK_COUNTS.prune(conn)
+        AdvisoryLockable.advisory_lock_counts.prune(conn)
       end
 
       # Postgres advisory unlocking function for the class
@@ -643,7 +659,7 @@ module GoodJob
       # @return [void]
       def advisory_unlock_session(connection: nil)
         conn = connection || lease_connection
-        ADVISORY_LOCK_COUNTS.clear_session_locks(conn)
+        AdvisoryLockable.advisory_lock_counts.clear_session_locks(conn)
         conn.exec_query("SELECT pg_advisory_unlock_all()::text AS unlocked", 'GoodJob::Lockable Unlock Session').first[:unlocked]
       end
 
@@ -745,7 +761,7 @@ module GoodJob
     def advisory_lock_active_on?(connection, key: lockable_key)
       return false unless connection&.active?
 
-      ADVISORY_LOCK_COUNTS.counts_for(connection, key).first.positive?
+      AdvisoryLockable.advisory_lock_counts.counts_for(connection, key).first.positive?
     end
 
     # Releases all advisory locks on the record that are held by the current

data/app/models/good_job/batch_record.rb

@@ -11,7 +11,6 @@ module GoodJob
     self.implicit_order_column = 'created_at'
 
     has_many :jobs, class_name: 'GoodJob::Job', inverse_of: :batch, foreign_key: :batch_id, dependent: nil
-    has_many :executions, class_name: 'GoodJob::Execution', foreign_key: :batch_id, inverse_of: :batch, dependent: nil
     has_many :callback_jobs, class_name: 'GoodJob::Job', foreign_key: :batch_callback_id, dependent: nil # rubocop:disable Rails/InverseOf
 
     scope :finished, -> { where.not(finished_at: nil) }

data/app/models/good_job/concurrency_claim.rb

@@ -127,7 +127,7 @@ module GoodJob
       def upsert_claim(key:, job_id:, locked_by_id:, state:)
         # Raw SQL because `upsert(update_only:)` requires Rails 7.0+
         now = Time.current
-        lease_connection.exec_update(sanitize_sql_array([<<~SQL.squish, key, job_id, locked_by_id, state, now, now]))
+        lease_connection.update(sanitize_sql_array([<<~SQL.squish, key, job_id, locked_by_id, state, now, now]))
           INSERT INTO #{quoted_table_name} (key, job_id, locked_by_id, state, created_at, updated_at)
           VALUES (?, ?, ?, ?, ?, ?)
           ON CONFLICT (key, job_id)

data/app/models/good_job/process.rb

@@ -137,6 +137,7 @@ module GoodJob # :nodoc:
     rescue ActiveRecord::RecordNotFound
       @new_record = true
       self.created_at = self.updated_at = nil
+      id_will_change!
       state_will_change!
       save
     end

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

@@ -2,10 +2,9 @@
     <div class="list-group list-group-flush text-nowrap table-jobs" role="table">
       <header class="list-group-item bg-body-tertiary">
         <div class="row small text-muted text-uppercase align-items-center">
-        <div class="col-4"><%= t("good_job.models.batch.jobs") %></div>
+        <div class="col-5"><%= t("good_job.models.batch.jobs") %></div>
           <div class="d-none d-lg-block col-lg-1 text-lg-center"><%= t "good_job.models.job.queue" %></div>
           <div class="d-none d-lg-block col-lg-1 text-lg-end"><%= t "good_job.models.job.priority" %></div>
-          <div class="d-none d-lg-block col-lg-1 text-lg-end"><%= t "good_job.models.job.labels" %></div>
           <div class="d-none d-lg-block col-lg-1 text-lg-end"><%= t "good_job.models.job.attempts" %></div>
           <div class="col text-end">
             <%= tag.button type: "button", class: "btn btn-sm text-muted", role: "button",
@@ -22,9 +21,16 @@
         <% 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-lg-4">
+              <div class="col-lg-5">
                 <%= tag.code link_to(job.id, job_path(job), class: "small text-muted text-decoration-none") %>
                 <%= tag.h5 tag.code(link_to(job.display_name, job_path(job), class: "text-reset text-decoration-none")), class: "text-reset mb-0" %>
+                <% if job.labels.present? %>
+                  <div class="mt-1 d-flex flex-wrap gap-1" aria-label="<%= t "good_job.models.job.labels" %>" role="group">
+                    <% job.labels.each do |label| %>
+                      <%= job_label_badge(job, label, full: true) %>
+                    <% end %>
+                  </div>
+                <% end %>
               </div>
               <div class="col-4 col-lg-1 text-lg-center">
                 <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.job.queue" %></div>
@@ -34,12 +40,6 @@
                 <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.job.priority" %></div>
                 <span class="font-monospace fw-bold"><%= job.priority %></span>
               </div>
-              <div class="col-4 col-lg-1 text-lg-end">
-                <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.job.labels" %></div>
-                <% job.labels&.each do |label| %>
-                  <%= job_label_badge(job, label) %>
-                <% end %>
-              </div>
               <div class="col-4 col-lg-1 text-lg-end">
                 <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.job.attempts" %></div>
                 <% if job.error %>

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

@@ -6,7 +6,7 @@
     <div class="list-group list-group-flush text-nowrap table-jobs" role="table">
       <header class="list-group-item bg-body-tertiary">
         <div class="row small text-muted text-uppercase align-items-center">
-          <div class="col-lg-4 d-flex gap-2 flex-wrap">
+          <div class="col-lg-5 d-flex gap-2 flex-wrap">
             <div class="form-check d-flex flex-row px-0 mb-0">
               <%= check_box_tag('toggle_job_ids', "1", false, data: { "checkbox-toggle-target": "all", action: "change->checkbox-toggle#toggleAll" }) %>
               <%= label_tag('toggle_job_ids', t(".toggle_all_jobs"), class: "visually-hidden") %>
@@ -53,7 +53,6 @@
           </div>
           <div class="d-none d-lg-block col-lg-1 text-lg-center"><%= t "good_job.models.job.queue" %></div>
           <div class="d-none d-lg-block col-lg-1 text-lg-end"><%= t "good_job.models.job.priority" %></div>
-          <div class="d-none d-lg-block col-lg-1 text-lg-end"><%= t "good_job.models.job.labels" %></div>
           <div class="d-none d-lg-block col-lg-1 text-lg-end"><%= t "good_job.models.job.attempts" %></div>
           <div class="col text-end">
             <%= tag.button type: "button", class: "btn btn-sm text-muted", role: "button",
@@ -80,11 +79,18 @@
         <% jobs.each do |job| %>
           <%= label_tag dom_id(job, :checkbox), id: dom_id(job), role: "row", class: "list-group-item list-group-item-action py-3" do %>
             <div class="row align-items-center">
-              <div class="col-lg-4 d-flex">
+              <div class="col-lg-5 d-flex">
                 <%= check_box_tag 'job_ids[]', job.id, false, id: dom_id(job, :checkbox), data: { "checkbox-toggle-target": "each", action: "change->checkbox-toggle#syncAll" } %>
-                <div class="ms-2">
+                <div class="ms-2 min-width-0">
                   <%= tag.code link_to(job.id, job_path(job), class: "small text-muted text-decoration-none") %>
                   <%= tag.h5 tag.code(link_to(job.display_name, job_path(job), class: "text-reset text-decoration-none")), class: "text-reset mb-0" %>
+                  <% if job.labels.present? %>
+                    <div class="mt-1 d-flex flex-wrap gap-1" aria-label="<%= t "good_job.models.job.labels" %>" role="group">
+                      <% job.labels.each do |label| %>
+                        <%= job_label_badge(job, label, url: filter.to_params(label: label), full: true) %>
+                      <% end %>
+                    </div>
+                  <% end %>
                   <% if job.error %>
                     <div class="mt-1 small">
                       <strong class="small text-danger"><%= t "good_job.shared.error" %>:</strong>
@@ -101,12 +107,6 @@
                 <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.job.priority" %></div>
                 <%= job.priority %>
               </div>
-              <div class="col-4 col-lg-1 text-wrap text-lg-end">
-                <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.job.labels" %></div>
-                <% job.labels&.each do |label| %>
-                  <%= job_label_badge(job, label, url: filter.to_params(label: label)) %>
-                <% end %>
-              </div>
               <div class="col-4 col-lg-1 text-lg-end">
                 <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.job.attempts" %></div>
                 <% if job.error %>

data/config/brakeman.ignore

@@ -49,13 +49,13 @@
     {
       "warning_type": "Dangerous Eval",
       "warning_code": 13,
-      "fingerprint": "54b7ac445eea2aa1735ae97fab1d841e15405a747ba0fdb577cf779286647534",
+      "fingerprint": "f7e62770ef61ea7bb2b3a0a8c19b3fa6f869fbaa51322cb56eb86f21b384ba5a",
       "check_name": "Evaluation",
       "message": "Dynamic string evaluated as code",
       "file": "lib/good_job/log_subscriber.rb",
-      "line": 356,
+      "line": 365,
       "link": "https://brakemanscanner.org/docs/warning_types/dangerous_eval/",
-      "code": "class_eval(\"        def #{level}(progname = nil, tags: [], &block)   # def info(progname = nil, tags: [], &block)\\n          return unless logger                           #   return unless logger\\n                                                         #\\n          tag_logger(*tags) do                           #   tag_logger(*tags) do\\n            logger.#{level}(progname, &block)            #     logger.info(progname, &block)\\n          end                                            #   end\\n        end                                              #\\n\", \"lib/good_job/log_subscriber.rb\", (356 + 1))",
+      "code": "class_eval(\"        def #{level}(progname = nil, tags: [], &block)   # def info(progname = nil, tags: [], &block)\\n          return unless logger                           #   return unless logger\\n                                                         #\\n          tag_logger(*tags) do                           #   tag_logger(*tags) do\\n            logger.#{level}(progname, &block)            #     logger.info(progname, &block)\\n          end                                            #   end\\n        end                                              #\\n\", \"lib/good_job/log_subscriber.rb\", (365 + 1))",
       "render_path": null,
       "location": {
         "type": "method",

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -6,6 +6,8 @@ module GoodJob
       extend ActiveSupport::Concern
 
       VALID_TYPES = [String, Symbol, Numeric, Date, Time, TrueClass, FalseClass, NilClass].freeze
+      # The lock and claim key for a rule without a label or key, which counts all jobs.
+      ALL_KEY = "all"
 
       class ConcurrencyExceededError < StandardError
         def backtrace
@@ -52,6 +54,9 @@ module GoodJob
 
         def evaluate(job, stage)
           resolved_label = resolve_label(job)
+          # A rule with a label that resolves to blank does not apply
+          return nil if @label.present? && resolved_label.blank?
+
           resolved_key = resolve_key(job, resolved_label)
           return nil if resolved_key.blank? && resolved_label.blank?
 
@@ -77,8 +82,10 @@ module GoodJob
         end
 
         def resolve_key(job, label)
-          if label.present? || key.blank?
+          if label.present?
             "label:#{label}"
+          elsif key.blank?
+            ALL_KEY
           else
             key_value = @key.respond_to?(:call) ? job.instance_exec(&@key) : @key
             raise TypeError, "Concurrency key must be a String; was a #{key_value.class}" if key_value.present? && VALID_TYPES.none? { |type| key_value.is_a?(type) }
@@ -117,7 +124,7 @@ module GoodJob
           elsif key_explicit? && key.present?
             "key:#{key}"
           else
-            "all"
+            ALL_KEY
           end
         end
 

data/lib/good_job/adapter.rb

@@ -11,6 +11,13 @@ module GoodJob
     #   @return [Array<GoodJob::Adapter>, nil]
     cattr_reader :instances, default: Concurrent::Array.new, instance_reader: false
 
+    # Mutable per-adapter state (the capsule and whether it was started), kept
+    # off the adapter instance so that the adapter itself can be made
+    # Ractor-shareable. Only accessed from the main Ractor.
+    Runtime = Struct.new(:capsule, :async_started)
+    RUNTIMES = Concurrent::Map.new
+    private_constant :Runtime, :RUNTIMES
+
     # @param execution_mode [Symbol, nil] specifies how and where jobs should be executed. You can also set this with the environment variable +GOOD_JOB_EXECUTION_MODE+.
     #
     #  - +:inline+ executes jobs immediately in whatever process queued them (usually the web server process). This should only be used in test and development environments.
@@ -28,7 +35,7 @@ module GoodJob
     def initialize(execution_mode: nil, _capsule: GoodJob.capsule) # rubocop:disable Lint/UnderscorePrefixedVariableName
       @_execution_mode_override = execution_mode
       GoodJob::Configuration.validate_execution_mode(@_execution_mode_override) if @_execution_mode_override
-      @capsule = _capsule
+      RUNTIMES[self] = Runtime.new(_capsule, false)
 
       start_async if GoodJob.async_ready?
       self.class.instances << self
@@ -75,16 +82,19 @@ module GoodJob
         lock_id = nil
 
         if execute_inline?
-          @capsule.tracker.register
+          lock_id = register_tracker
           tracker_registered = true
-          lock_id = @capsule.tracker.id_for_lock
         end
 
         begin
           GoodJob::Job.transaction(requires_new: true, joinable: false) do
-            column_names = GoodJob::Job.column_names
-            job_attributes = jobs.map { |job| job.attributes.slice(*column_names) }
-            results = GoodJob::Job.insert_all(job_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
+            results = if GoodJob::Ractors.main?
+                        column_names = GoodJob::Job.column_names
+                        job_attributes = jobs.map { |job| job.attributes.slice(*column_names) }
+                        GoodJob::Job.insert_all(job_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
+                      else
+                        insert_individually(jobs)
+                      end
 
             job_id_to_provider_job_id = results.to_h { |result| [result['active_job_id'], result['id']] }
             active_jobs.each do |active_job|
@@ -120,16 +130,16 @@ module GoodJob
               end
             ensure
               inline_jobs.each(&:advisory_unlock)
-              @capsule.tracker.unregister if tracker_registered
+              unregister_tracker if tracker_registered
               tracker_registered = false
             end
           elsif tracker_registered
-            @capsule.tracker.unregister
+            unregister_tracker
             tracker_registered = false
           end
         rescue StandardError
           if tracker_registered
-            @capsule.tracker.unregister
+            unregister_tracker
             tracker_registered = false
           end
           raise
@@ -147,7 +157,7 @@ module GoodJob
               state = { queue_name: queue_name, count: jobs_by_queue_and_scheduled_at.size }
               state[:scheduled_at] = scheduled_at if scheduled_at
 
-              executed_locally = execute_async? && @capsule&.create_thread(state)
+              executed_locally = execute_async? && create_capsule_thread(state)
               unless executed_locally
                 state[:count] = job_id_to_active_jobs.values_at(*jobs_by_queue_and_scheduled_at.map(&:active_job_id)).count { |active_job| send_notify?(active_job) }
                 Notifier.notify(state) unless state[:count].zero?
@@ -183,8 +193,7 @@ module GoodJob
           )
         elsif will_execute_inline
           lock_strategy = GoodJob::Job.effective_lock_strategy
-          @capsule.tracker.register
-          lock_id = @capsule.tracker.id_for_lock
+          lock_id = register_tracker
           tracker_registered = true
           begin
             job = case lock_strategy
@@ -198,12 +207,12 @@ module GoodJob
             InlineBuffer.perform_now_or_defer do
               perform_inline(job, notify: send_notify?(active_job), already_claimed: lock_strategy != :advisory, advisory_unlock: lock_strategy != :skiplocked)
             ensure
-              @capsule.tracker.unregister if tracker_registered
+              unregister_tracker if tracker_registered
               tracker_registered = false
             end
           rescue StandardError
             if tracker_registered
-              @capsule.tracker.unregister
+              unregister_tracker
               tracker_registered = false
             end
             raise
@@ -215,7 +224,7 @@ module GoodJob
           )
 
           if job
-            executed_locally = execute_async? && @capsule&.create_thread(job.job_state)
+            executed_locally = execute_async? && create_capsule_thread(job.job_state)
             Notifier.notify(job.job_state) if !executed_locally && send_notify?(active_job)
           end
         end
@@ -246,8 +255,9 @@ module GoodJob
     #   * A positive number will wait that many seconds before stopping any remaining active threads.
     # @return [void]
     def shutdown(timeout: NONE)
-      @capsule&.shutdown(timeout: timeout)
-      @_async_started = false
+      runtime = RUNTIMES[self]
+      runtime.capsule&.shutdown(timeout: timeout)
+      runtime.async_started = false
     end
 
     # This adapter's execution mode
@@ -282,19 +292,52 @@ module GoodJob
     def start_async
       return unless execute_async?
 
-      @capsule.start
-      @capsule.lower_thread_priority = true if GoodJob.configuration.lower_thread_priority.in?([true, nil])
-      @_async_started = true
+      runtime = RUNTIMES[self]
+      runtime.capsule.start
+      runtime.capsule.lower_thread_priority = true if GoodJob.configuration.lower_thread_priority.in?([true, nil])
+      runtime.async_started = true
     end
 
     # Whether the async executors are running
     # @return [Boolean]
     def async_started?
-      @_async_started
+      GoodJob::Ractors.on_main(self) { RUNTIMES[self].async_started }
     end
 
     private
 
+    # The capsule is not Ractor-shareable, so it is always used on the main Ractor.
+    def create_capsule_thread(state)
+      job_state = GoodJob::Ractors.main? ? state : GoodJob::Ractors.make_shareable(state.dup)
+      GoodJob::Ractors.on_main(self) { RUNTIMES[self].capsule&.create_thread(job_state) }
+    end
+
+    def register_tracker
+      GoodJob::Ractors.on_main(self) do
+        tracker = RUNTIMES[self].capsule.tracker
+        tracker.register
+        tracker.id_for_lock
+      end
+    end
+
+    def unregister_tracker
+      GoodJob::Ractors.on_main(self) { RUNTIMES[self].capsule.tracker.unregister }
+    end
+
+    def tracker_id_for_lock
+      GoodJob::Ractors.on_main(self) { RUNTIMES[self].capsule.tracker.id_for_lock }
+    end
+
+    # Active Record does not support +insert_all+ outside of the main Ractor.
+    def insert_individually(jobs)
+      jobs.filter_map do |job|
+        GoodJob::Job.transaction(requires_new: true) { job.save!(validate: false) }
+        { 'id' => job.id, 'active_job_id' => job.active_job_id }
+      rescue ActiveRecord::RecordNotUnique
+        nil
+      end
+    end
+
     def send_notify?(active_job)
       return false unless GoodJob.configuration.enable_listen_notify
       return true unless active_job.respond_to?(:good_job_notify)
@@ -309,7 +352,7 @@ module GoodJob
       retried_job = nil
 
       loop do
-        result = job.perform(lock_id: @capsule.tracker.id_for_lock, already_claimed: already_claimed)
+        result = job.perform(lock_id: tracker_id_for_lock, already_claimed: already_claimed)
         already_claimed = false # only skip lock-write on first iteration
         retried_job = result.retried_job
         break if retried_job.nil? || retried_job.scheduled_at.nil? || retried_job.scheduled_at > Time.current

data/lib/good_job/configuration.rb

@@ -528,6 +528,15 @@ module GoodJob
       (options[:dequeue_query_sort] || rails_config[:dequeue_query_sort] || :created_at).to_sym
     end
 
+    # Resolves lazily memoized values so the configuration can be frozen.
+    # @return [self]
+    def prepare_for_sharing
+      in_webserver?
+      validator
+      @_rails_config = rails_config
+      self
+    end
+
     private
 
     # Reads a configuration value from one or more deprecated sources, emitting a
@@ -586,7 +595,7 @@ module GoodJob
     end
 
     def rails_config
-      Rails.application.config.good_job
+      @_rails_config || Rails.application.config.good_job
     end
   end
 end

data/lib/good_job/engine.rb

@@ -10,6 +10,10 @@ module GoodJob
     config.good_job = ActiveSupport::OrderedOptions.new
     config.good_job.cron = {}
 
+    initializer "good_job.ractors" do |app|
+      app.singleton_class.prepend(GoodJob::Ractors::ApplicationExtension) if GoodJob::Ractors.enabled? && app.respond_to?(:ractorize!)
+    end
+
     initializer "good_job.logger" do |_app|
       ActiveSupport.on_load(:good_job) do
         self.logger = ::Rails.logger if GoodJob.logger == GoodJob::DEFAULT_LOGGER

data/lib/good_job/log_subscriber.rb

@@ -316,6 +316,15 @@ module GoodJob
       def reset_logger
         @_logger = nil
       end
+
+      # Builds {LogSubscriber.logger} so that it can be read from non-main
+      # Ractors. A single logger is used directly because
+      # +ActiveSupport::BroadcastLogger+ is not Ractor-shareable.
+      # @return [void]
+      def prepare_for_sharing
+        @_loggers = GoodJob::Ractors.make_shareable(loggers)
+        @_logger = loggers.size == 1 ? loggers.first : GoodJob::Ractors.try_make_shareable(logger)
+      end
     end
 
     private

data/lib/good_job/ractors.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module GoodJob
+  # Compatibility layer for running GoodJob in a Ractor-ized Rails application.
+  #
+  # Delegates to +ActiveSupport::Ractors+ when the Rails version provides it,
+  # and otherwise falls back to behavior identical to a single-Ractor process.
+  # All Ractor-related calls in GoodJob should go through this module so that
+  # older Rails versions are unaffected and changes to Rails' (internal)
+  # Ractor API are contained in one place.
+  module Ractors
+    NATIVE = begin
+      require "active_support/ractors"
+      ActiveSupport::Ractors.respond_to?(:on_main) && ActiveSupport::Ractors.respond_to?(:store_if_absent)
+    rescue LoadError
+      false
+    end
+
+    # Prepended to the Rails application's singleton class so that +Rails.application.ractorize!+
+    # also makes GoodJob's global state shareable.
+    module ApplicationExtension
+      def ractorize!
+        GoodJob.ractorize!
+        super
+      end
+    end
+
+    LOCAL_STORAGE = Concurrent::Map.new
+    private_constant :LOCAL_STORAGE
+
+    class << self
+      # Whether the current Rails version supports Ractors.
+      # @return [Boolean]
+      def enabled?
+        NATIVE
+      end
+
+      # Whether the current Ractor is the main Ractor.
+      # @return [Boolean]
+      def main?
+        NATIVE ? ActiveSupport::Ractors.main? : true
+      end
+
+      # Deep-freezes +obj+ so it can be shared across Ractors.
+      # @return [Object]
+      def make_shareable(obj)
+        NATIVE ? ActiveSupport::Ractors.make_shareable(obj) : obj
+      end
+
+      # Attempts to make +obj+, which may contain user-provided procs,
+      # shareable. If it cannot be made shareable, the application's
+      # +ActiveSupport::Ractors.unshareable_proc_action+ decides whether to
+      # raise, warn, or return it unchanged.
+      # @return [Object]
+      def try_make_shareable(obj)
+        return obj unless NATIVE
+
+        ActiveSupport::Ractors.make_shareable(obj)
+      rescue Ractor::IsolationError
+        raise unless ActiveSupport::Ractors.unshareable_proc_action
+
+        ActiveSupport::Ractors.try_make_shareable(obj)
+      end
+
+      # Attempts to make a user-provided proc shareable, according to the
+      # application's +ActiveSupport::Ractors.unshareable_proc_action+.
+      # @return [Proc, nil]
+      def try_shareable_proc(proc)
+        return proc unless NATIVE && proc.is_a?(Proc)
+
+        ActiveSupport::Ractors.try_shareable_proc(proc)
+      end
+
+      # Runs the block on the main Ractor and returns its (shareable) result.
+      # When already on the main Ractor, or Ractors are unsupported, the block
+      # is called directly.
+      def on_main(obj = nil, &block)
+        if NATIVE
+          ActiveSupport::Ractors.on_main(obj, &block)
+        else
+          obj.instance_eval(&block)
+        end
+      end
+
+      # Returns the value stored under +key+ for the current Ractor,
+      # initializing it with the block on first access. Without Ractor
+      # support, the value is process-wide.
+      def local(key, &block)
+        if NATIVE
+          ActiveSupport::Ractors.store_if_absent(key, &block)
+        else
+          LOCAL_STORAGE.compute_if_absent(key, &block)
+        end
+      end
+    end
+  end
+end

data/lib/good_job/version.rb

@@ -2,7 +2,7 @@
 
 module GoodJob
   # GoodJob gem version.
-  VERSION = '4.22.0'
+  VERSION = '4.22.1'
 
   # GoodJob version as Gem::Version object
   GEM_VERSION = Gem::Version.new(VERSION)

data/lib/good_job.rb

@@ -5,6 +5,7 @@ require "active_job/queue_adapters"
 
 require_relative "good_job/version"
 require_relative "good_job/engine"
+require_relative "good_job/ractors"
 
 require_relative "good_job/adapter"
 require_relative "good_job/adapter/inline_buffer"
@@ -77,7 +78,8 @@ module GoodJob
   #   @return [ActiveRecord::Base]
   #   @example Change the base class:
   #     GoodJob.active_record_parent_class = "CustomApplicationRecord"
-  mattr_accessor :active_record_parent_class, default: nil
+  singleton_class.attr_accessor :active_record_parent_class
+  self.active_record_parent_class = nil
 
   # @!attribute [rw] logger
   #   @!scope class
@@ -86,7 +88,8 @@ module GoodJob
   #   @return [Logger, nil]
   #   @example Output GoodJob logs to a file:
   #     GoodJob.logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new("log/my_logs.log"))
-  mattr_accessor :logger, default: DEFAULT_LOGGER
+  singleton_class.attr_accessor :logger
+  self.logger = DEFAULT_LOGGER
 
   # @!attribute [rw] preserve_job_records
   #   @!scope class
@@ -99,7 +102,8 @@ module GoodJob
   #   @example Preserve only jobs that were discarded
   #     GoodJob.preserve_job_records = ->(active_job, exception, error_event) { error_event == :discarded }
   #   @return [Boolean, Symbol, Proc, nil]
-  mattr_accessor :preserve_job_records, default: true
+  singleton_class.attr_accessor :preserve_job_records
+  self.preserve_job_records = true
 
   # @!attribute [rw] retry_on_unhandled_error
   #   @!scope class
@@ -108,7 +112,8 @@ module GoodJob
   #   If +false+, jobs will be discarded or marked as finished if they raise an instance of a handled exception.
   #   @see GoodJob.handled_exceptions
   #   @return [Boolean, nil]
-  mattr_accessor :retry_on_unhandled_error, default: false
+  singleton_class.attr_accessor :retry_on_unhandled_error
+  self.retry_on_unhandled_error = false
 
   # @!attribute [rw] handled_exceptions
   #   @!scope class
@@ -118,7 +123,8 @@ module GoodJob
   #   @example Also rescue ScriptError
   #     GoodJob.handled_exceptions = [StandardError, NotImplementedError, ScriptError]
   #   @return [Array<Class, String>]
-  mattr_accessor :handled_exceptions, default: [StandardError, NotImplementedError]
+  singleton_class.attr_accessor :handled_exceptions
+  self.handled_exceptions = [StandardError, NotImplementedError]
 
   # Resolved exception classes from {handled_exceptions}.
   # @return [Array<Class>]
@@ -134,19 +140,22 @@ module GoodJob
   #     # config/initializers/good_job.rb
   #     GoodJob.on_thread_error = -> (exception) { Raven.capture_exception(exception) }
   #   @return [Proc, nil]
-  mattr_accessor :on_thread_error, default: nil
+  singleton_class.attr_accessor :on_thread_error
+  self.on_thread_error = nil
 
   # @!attribute [rw] configuration
   #   @!scope class
   #   Global configuration object for GoodJob.
   #   @return [GoodJob::Configuration, nil]
-  mattr_accessor :configuration, default: GoodJob::Configuration.new({})
+  singleton_class.attr_accessor :configuration
+  self.configuration = GoodJob::Configuration.new({})
 
   # @!attribute [rw] capsule
   #   @!scope class
   #   Global/default execution capsule for GoodJob.
   #   @return [GoodJob::Capsule, nil]
-  mattr_accessor :capsule, default: GoodJob::Capsule.new(configuration: configuration)
+  singleton_class.attr_accessor :capsule
+  self.capsule = GoodJob::Capsule.new(configuration: configuration)
 
   # Called with exception when a GoodJob thread raises an exception
   # @param exception [Exception] Exception that was raised
@@ -167,7 +176,57 @@ module GoodJob
     self._active_record_configuration = block
   end
 
-  mattr_accessor :_active_record_configuration, default: nil
+  singleton_class.attr_accessor :_active_record_configuration
+  self._active_record_configuration = nil
+
+  # Makes GoodJob's global state Ractor-shareable so that jobs can be enqueued
+  # and performed from non-main Ractors. Called automatically by
+  # +Rails.application.ractorize!+ on Rails versions that support Ractors.
+  # Background execution (capsules, schedulers, the notifier) remains on the
+  # main Ractor.
+  # @return [void]
+  def self.ractorize!
+    _load_record_schemas
+    LogSubscriber.prepare_for_sharing
+    Ractors.make_shareable(configuration.prepare_for_sharing)
+    Ractors.make_shareable(handled_exceptions)
+    Ractors.make_shareable(logger)
+    self.preserve_job_records = Ractors.try_shareable_proc(preserve_job_records)
+    self.on_thread_error = Ractors.try_shareable_proc(on_thread_error)
+    _make_job_classes_shareable
+  end
+
+  # Concurrency and label settings are class attributes that may hold
+  # user-provided procs; they are frozen in place on each job class.
+  # @return [void]
+  def self._make_job_classes_shareable
+    attributes = %i[good_job_concurrency_config good_job_concurrency_rules good_job_labels]
+    [ActiveJob::Base, *ActiveJob::Base.descendants].each do |job_class|
+      attributes.each do |attribute|
+        Ractors.try_make_shareable(job_class.public_send(attribute)) if job_class.respond_to?(attribute)
+      end
+    end
+  end
+
+  # Active Record schemas and GoodJob's database capability checks are
+  # lazily loaded into class-level state, which can only be written from
+  # the main Ractor.
+  # @return [void]
+  def self._load_record_schemas
+    GoodJob::AdvisoryLockable.hash_function
+    GoodJob::BaseRecord.descendants.each do |record_class|
+      next if record_class.abstract_class?
+
+      record_class.load_schema
+      record_class.define_attribute_methods
+    end
+    GoodJob::Job.lock_type_column_exists?
+    GoodJob::Job.supports_cte_materialization_specifiers?
+    GoodJob::Job.database_supports_websearch_to_tsquery?
+    GoodJob::BatchRecord.database_supports_websearch_to_tsquery?
+  rescue ActiveRecord::ActiveRecordError => e
+    logger&.warn("GoodJob could not load its database schema before ractorizing: #{e.message}")
+  end
 
   # Stop executing jobs.
   # GoodJob does its work in pools of background threads.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 4.22.0
+  version: 4.22.1
 platform: ruby
 authors:
 - Ben Sheldon
@@ -432,6 +432,7 @@ files:
 - lib/good_job/probe_server/not_found_app.rb
 - lib/good_job/probe_server/simple_handler.rb
 - lib/good_job/probe_server/webrick_handler.rb
+- lib/good_job/ractors.rb
 - lib/good_job/safe_state.rb
 - lib/good_job/scheduler.rb
 - lib/good_job/sd_notify.rb