pgbus 0.14.2 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ba7f4aa13c44c41c30fb021cbb3e087d643b147895a80a84ddbc022f40088a7
-  data.tar.gz: 3015145e2f795d83d543d786c4f5d462854123f3a9e8eb946c2b74de059ee31a
+  metadata.gz: c419d130102e92e1bd355df6e98211e44eeead76298f9ce58bd6c285b1de24a9
+  data.tar.gz: dab0eefe9c7a23aee676b928521841adffb6d38f084993c6bb3ab56f9ade207f
 SHA512:
-  metadata.gz: dc4d0ccfac9ab0f4f57c271fe98e2a7716cfbac10daba7ca5b0ad81b59f43a51a775a1780e36faa395f23ed8084376a7e21645390e8a5f6463e1100a4db007d6
-  data.tar.gz: 684ce73b5e1e43be5d9616319da6d29ed22acf98e5384d662b63d7020ed234d8b94e2783f97a45062ae532633507b0cf44afe0007a68ea4894b55b23e631b018
+  metadata.gz: d8cedff08ffed91f3b9a9c1b9df1b2147790ec9bf7e5117b22a4af19b865b239df4883d6708153ec2efc9de5207e007cb4d2cfd06440ac3b4bd25e63d1eea369
+  data.tar.gz: fcb2ec48f7daf53dc46d5c388cb3b4e1acd99a568e74e92253736efb8ba4bc52fd9704d287fbaafcea893d063676b3f68ceac3d82b79fc3906ef4d7bbc43dcd3

data/CHANGELOG.md

@@ -1,7 +1,18 @@
 ## [Unreleased]
 
+### Fixed
+
+- **`current_attributes` capture skips an unpersisted record instead of raising at enqueue (issue #435).** An attribute holding an Active Record instance with no id — a dev-mode fallback record assigned to `Current`, a form-built model captured before `save`, a destroyed record whose locate is guaranteed to fail — made every `perform_later` in that context raise `Pgbus::CurrentAttributesError`, even though such a record can never round-trip (no id → no GlobalID) and capture is ambient: the enqueuer never opted into persisting that attribute per-call, so its momentary state must not abort the enqueue. `capture` now skips any attribute value that answers `persisted?` falsey (so destroyed-but-id-bearing records are skipped too, not just `new_record?`) with a debug log naming the class, attribute and why; the rest of the class's attributes still persist. The `except:` guidance and the loud `CurrentAttributesError` remain for genuinely unserializable values — objects without the Active Record duck-type (`respond_to?(:persisted?)`) are untouched. Applies to jobs and event-bus publish alike (same capture path). Refs #435.
+
 ### Added
 
+- **First-class `Current` support: ActiveSupport::CurrentAttributes persist across enqueue → perform (issue #430).** The executor already reset `CurrentAttributes` around every job (so nothing leaked) but nothing restored it — `Current.tenant` was always nil inside a job. New `config.current_attributes` (`nil` = off; `:auto` = every `ActiveSupport::CurrentAttributes` subclass; an Array of classes/names; or a Hash of class => `{ only: [...] }` / `{ except: [...] }`). The new `Pgbus::ActiveJob::CurrentAttributes` mixin (included on `ActiveJob::Base` by the engine next to `BatchId`) captures the assigned attributes of each persisted class in `serialize` — serialized with `ActiveJob::Arguments`, so records become GlobalIDs and fall under the `allowed_global_id_models` allowlist on the way back — under the job-hash key `pgbus_current`, and restores them by wrapping the **whole** `perform_now` in nested `Current.set`, so `before_perform`, `perform`, `rescue_from`, `retry_on` / `discard_on` blocks and jobs enqueued from inside `perform` all see the context, under the pgbus worker and Rails' `:test` / `:inline` adapters alike. A deserialized job re-serializes the context it was enqueued with, so a `retry_on` re-enqueue keeps the original; concurrency-blocked promotion, dead-letter / dashboard retry and `perform_all_later` carry it by construction. An unserializable attribute raises `Pgbus::CurrentAttributesError` at `perform_later` naming the class, attribute and the `except:` fix — nothing is dropped silently; a class that no longer exists or an attribute no longer defined is skipped with a log line (Sidekiq parity). Per job class: `self.pgbus_persist_current_attributes = false` or a spec override. Unconfigured installs have byte-identical payloads. Dashboard: failed-job and dead-letter detail pages gain a **Context** card (`Pgbus::Web::JobContext`, through `PayloadFilter`). Event bus follows in #431. Refs #430.
+
+- **Current attributes propagate publish → handler on the event bus (issue #431).** Follow-up to #430: `Pgbus.publish` from a request left `Current` empty in every event handler. With the same `config.current_attributes` switch on, the publisher now snapshots each persisted class (same `only:`/`except:` filters, same `ActiveJob::Arguments` serialization) into the **event envelope** under the same `pgbus_current` key jobs use (a sibling of `event_id`, never inside the user payload — `event.payload` is unchanged), PGMQ's topic fan-out copies it to every subscriber queue, and the handler pipeline restores it around `handle` (inside the Rails-executor wrap; previous values come back after each event — no cross-event leak on a consumer thread). `Pgbus::Event#context` exposes the raw stored form. `Pgbus::Outbox.publish_event` captures at write time — inside the app transaction, where `Current` is set — and the relay carries the envelope unchanged. GlobalIDs inside the context are gated by `allowed_global_id_models` in `Handler#build_event` before anything is located, the same boundary jobs gate at. `Pgbus::Testing` round-trips it (fake-mode events expose `context`; `drain!` and inline dispatch restore it), and the dashboard's pending-events rows show the same Context card as the failed-job pages. Default-off is byte-identical. Refs #431.
+- **Fix: outbox events now dispatch to handlers.** `Outbox.publish_event` built its envelope without `routing_key` and `pgmq.send_topic` stamps nothing on the message, so a relayed outbox event reached the right subscriber queues but the consumer read no routing key, matched **zero** handlers, and archived the event unrun. The envelope now carries `routing_key:` exactly like a direct `Pgbus.publish`. Entries written by older code (already relayed or pending) still lack it — re-publish those events if any are pending when you upgrade. Refs #431.
+- **Fair share scheduling for event-bus consumers (issue #427).** Follow-up to #426: a subscriber queue is FIFO, so a bulk import emitting `orders.created` 100 000 times for one tenant put every other tenant's events behind it in every handler subscribed to that topic. New `config.event_fair_share = ->(event) { key | [key, weight] | nil }` — the event twin of `fair_share` — receives the `Pgbus::Event` (routing key, the payload object as passed to publish, headers) at publish time on every path (`Pgbus.publish`, `publish_later`, `Pgbus::Outbox.publish_event`) and merges the same `pgbus_fair_key` / `pgbus_fair_weight` into the **event envelope** (a sibling of `event_id` / `published_at`, never inside the user payload, so `event.payload` is unchanged in handlers). Because the key lives at `message->>'pgbus_fair_key'` for events exactly as for jobs, #426's `read_batch_fair` SQL and `q_<queue>_fair_idx` index are reused verbatim; PGMQ's topic fan-out copies the tag to every bound subscriber queue, and the outbox (which stores the envelope) carries it across the relay with no extra work — a system writing `pgbus_outbox_entries` directly can set the key in the envelope JSON. `Consumer#fetch_messages` now fair-reads each active subscriber queue in list order with the remaining capacity (strict across queues, fair within; circuit-breaker-paused queues still skipped), ensures the fair index on its queues at boot, and `Subscriber#setup!` ensures it at queue creation. Independent of `fair_share` (enable either side or both); no interaction with `group_mode` (worker-only). Default-off is byte-identical. Refs #427.
+- **Fair share scheduling across tenants — weighted, work-conserving (issue #426).** A queue is FIFO, so one tenant enqueuing 100 000 jobs put every other tenant's work behind them; nothing in pgbus prevented it (multi-queue reads are strict list-order, `group_mode` serializes PGMQ FIFO groups and pgbus never set its header for jobs, `limits_concurrency` is a non-work-conserving cap). New `config.fair_share = ->(job) { key | [key, weight] | nil }` is evaluated at enqueue on every adapter path (`enqueue`, `enqueue_at`, `perform_all_later`); the key and weight ride inside the job payload as `pgbus_fair_key` / `pgbus_fair_weight` (same pattern as `pgbus_concurrency_key`, so they survive blocked-execution promotion, DLQ retry and dashboard retry). Workers then read with the new `Client#read_batch_fair` — one statement that enumerates the keys with visible messages via a loose index scan, ranks each key's oldest visible messages, and takes the `qty` lowest `rank / weight`: weight 3 vs 1 is a 3:1 split while both have work, a lone tenant still fills the whole batch, and the cost scales with the number of keys that have visible work, not backlog depth (`rake bench:fair_read`: 1.05 ms with 1 key, 4.7 ms with 200 keys, 100k-row backlog; numbers in `docs/performance.md`). Strict list-order priority across queues is preserved (fair within each queue); with `priority_levels` it is strict between levels and fair within a level; mutually exclusive with `group_mode` (`validate!` and `Worker.new` both raise). The supporting expression index `q_<queue>_fair_idx ((COALESCE(message->>'pgbus_fair_key','')), vt, msg_id)` is created at queue creation when the option is on, and built `CONCURRENTLY` by each worker for the queues it already serves (`Client#ensure_fair_index`, memoized, logs the `DROP INDEX` remediation if a concurrent build is interrupted). Within a key messages are taken oldest-visible first (`vt, msg_id`) — a deliberate deviation from `pgmq.read`'s pure `msg_id` order so a tenant's whole visible backlog is never sorted per read. Event-bus consumers get the same in #427 (below). Refs #426.
+
 - **Batches v2: open batches, a `batch` accessor on jobs and callbacks, and configured callback instances (issue #415).** ⚠️ **Breaking (pre-1.0)**: `Pgbus::Batch.find` now returns a rehydrated `Pgbus::Batch` handle instead of the raw attributes Hash — read the values off the handle (`status`, `total_jobs`, `completed_jobs`, `failed_jobs`, `pending_jobs`, `progress_percentage`, `finished?`, `description`, `properties`), or query `Pgbus::BatchEntry` for a row. Three capabilities: **(1) Open batches.** `batch.enqueue` is re-callable while the batch is unfinished — the second and later calls add to the existing group (`BatchEntry.increment_total_jobs!`, guarded on an unfinished row) instead of hitting the unique index on `batch_id`, so multi-stage workflows are possible. Adding to a finished batch raises `Pgbus::Batch::AlreadyFinished`. Execution rows are inserted as the block enqueues, before `total_jobs` is bumped, so the single-winner finish always sees outstanding work; a `check_finished!` after the bump covers a block whose jobs all completed while it was still open. Membership stays explicit: only jobs enqueued inside an `enqueue` block join the batch, so a fan-out from a batched job never silently extends it. **(2) `batch` accessor.** New `Pgbus::ActiveJob::BatchId` mixin (included on `ActiveJob::Base` from the engine alongside `Concurrency` and `Uniqueness`) adds `batch_id` / `callback_batch_id` accessors, round-trips both through `serialize`/`deserialize` — omitted from the payload when unset, so an unbatched job's serialized hash is unchanged — and exposes a memoized `batch` reader. The executor assigns `batch_id` from the payload's `pgbus_batch_id` before `perform`, so a running job can call `batch.enqueue` to add siblings. **(3) Configured callback instances.** `on_finish:` / `on_success:` / `on_failure:` accept an ActiveJob instance as well as a class: `on_finish: ReportJob.new.set(queue: :critical, wait: 5.minutes)`. `.set` options resolve at batch-creation time (matching solid_queue) into new `on_finish_job` / `on_success_job` / `on_failure_job` jsonb columns; at fire time the job is deserialized, given `callback_batch_id`, has its own `batch_id` cleared (a callback is never a member of the batch it reports on) and is enqueued on its configured queue and `scheduled_at`. Legacy class-name callbacks keep the `perform_later(properties)` signature — deprecated at 1.0 in favour of `batch.properties`. The dashboard shows a configured callback's `job_class`. Existing installs: `rails generate pgbus:add_batch_callback_jobs` (or `pgbus:update`); apps that have not migrated keep storing bare classes only. Refs #415.
 
 - **Batch completion is now self-healing via execution-row tracking (issue #414).** ⚠️ **Restart pgbus workers after `rails generate pgbus:add_batch_executions` / `db:migrate`** — a process that still writes `discarded_jobs` will error once that column is gone. `pgbus_batches` no longer finishes on `completed + discarded == total` — that arithmetic stalled a batch *forever* if a worker crashed between `archive_from` and `signal_batch_completed`, and a crash mid-`Batch#enqueue` left an immortal `pending` row (`cleanup_batches` only deletes `finished`). Each batched job now gets a `pgbus_batch_executions` row (identity = ActiveJob `job_id`) inserted *before* `send_message`, with `msg_id` + `queue_name` backfilled after send. The batch finishes when no rows remain (single-winner `UPDATE … AND NOT EXISTS`, plus a fresh `exists?` re-check for Postgres READ COMMITTED). A dispatcher sweep (`config.batch_sweep_interval`, default 5 minutes) repairs four crash windows: stale rows whose PGMQ message is gone (archived → completed, DLQ → failed, missing → completed with a warning); orphan rows with `msg_id` NULL older than 5 minutes (enqueue crashed between insert and send — blocked concurrency jobs are excluded); stalled `pending` batches; stalled `processing` batches with zero rows. `on_failure:` / `failed_jobs` are canonical (`on_discard:` / `discarded_jobs` remain deprecated aliases until 1.0). `config.batch_retention` (default 7 days, `nil` disables) replaces the hardcoded cleanup window. Existing installs: `rails generate pgbus:add_batch_executions` (or `pgbus:update`). Unmigrated apps keep the counter path via `Batch.executions_migrated?`. Refs #414.

data/README.md

@@ -646,6 +646,36 @@ end
 
 When `priority_levels` is `nil` (default), priority queues are disabled and all jobs go to a single queue per logical name.
 
+### Fair share across tenants
+
+One tenant enqueuing 100 000 jobs must not put every other tenant's work behind them. `config.fair_share` tags each job with a key (and optional weight) at enqueue, and the worker's read interleaves across keys inside each queue — a weighted, work-conserving round-robin. No per-tenant queues.
+
+```ruby
+Pgbus.configure do |config|
+  # key (String/Symbol/Integer), [key, weight], or nil to leave a job unkeyed
+  config.fair_share = ->(job) { [Current.tenant&.id, Current.tenant&.plan_weight || 1] }
+end
+```
+
+Weight 3 vs 1 yields a 3:1 split while both have work; a lone tenant still gets the whole worker. Composes with `priority_levels` (strict between levels, fair within) and `limits_concurrency`; mutually exclusive with `group_mode`. Workers build the supporting index `CONCURRENTLY` on queues they already serve. Details: [Routing & ordering](https://pgbus.zoolutions.llc/docs/routing-ordering).
+
+The event bus has the same knob: `config.event_fair_share = ->(event) { key | [key, weight] | nil }` receives the `Pgbus::Event` at publish (`Pgbus.publish`, `publish_later`, `Outbox.publish_event`), tags the event envelope — never your payload — and consumers interleave reads across keys inside each subscriber queue. Details: [Event bus](https://pgbus.zoolutions.llc/docs/event-bus).
+
+### Current attributes
+
+`ActiveSupport::CurrentAttributes` is reset around every job. Ask pgbus to carry it and `Current.tenant` / `Current.user` / `Current.request_id` are there inside `perform` — and inside `retry_on` / `discard_on` blocks, under the pgbus worker and Rails' `:test` / `:inline` adapters alike:
+
+```ruby
+Pgbus.configure do |config|
+  config.current_attributes = :auto   # or [Current, "Admin::Current"], or { Current => { except: [:request] } }
+  config.fair_share = ->(job) { Current.tenant&.id }   # pairs naturally with fair share
+end
+```
+
+Events get the same hop: `Pgbus.publish` captures `Current` into the event envelope and the consumer restores it around every `handle` — including across the transactional outbox (captured at `Outbox.publish_event`, inside your transaction). Handlers can also read the raw form via `event.context`.
+
+Captured at enqueue via `ActiveJob::Arguments` (records become GlobalIDs, gated by `allowed_global_id_models`), preserved across retries, concurrency-blocked promotion, dead-letter retry and `perform_all_later`; an unserializable attribute raises at `perform_later` with the `except:` fix, while an **unpersisted** record (no id — it could never be restored) is skipped with a debug log instead of aborting the enqueue. The dashboard shows the context on failed-job and dead-letter pages. Details: [Active Job → Current attributes](https://pgbus.zoolutions.llc/docs/active-job).
+
 ### Consumer priority
 
 When multiple workers subscribe to the same queues, higher-priority workers process messages first. Lower-priority workers back off (3x polling interval) when a higher-priority worker is active.
@@ -2176,6 +2206,9 @@ Curated headline options for the README. The full operator reference (with types
 | `priority_levels` | `nil` | Number of priority sub-queues (nil = disabled, 2-10) |
 | `default_priority` | `1` | Default priority for jobs without explicit priority |
 | `group_mode` | `nil` | Grouped-read ordering mode for a queue. Experimental — exempt from the 1.0 stability promise. |
+| `fair_share` | `nil` | Callable `->(job) { key \| [key, weight] \| nil }` evaluated at enqueue; workers interleave reads across keys (weighted, work-conserving). Mutually exclusive with `group_mode` |
+| `event_fair_share` | `nil` | Event-bus twin of `fair_share`: callable `->(event) { key \| [key, weight] \| nil }` receiving the `Pgbus::Event` at publish; consumers interleave reads across keys within each subscriber queue. Independent of `fair_share` |
+| `current_attributes` | `nil` | Persist `ActiveSupport::CurrentAttributes` across enqueue → perform: `:auto`, an Array of classes/names, or `{ Current => { except: [...] } }`. Restored around the whole `perform_now` |
 | `archive_retention` | `7.days` | How long to keep archived messages. Accepts seconds, Duration, or `nil` to disable cleanup |
 | `outbox_enabled` | `false` | Enable transactional outbox poller process |
 | `outbox_poll_interval` | `1.0` | Seconds between outbox poll cycles |

data/Rakefile

@@ -25,7 +25,7 @@ namespace :bench do
   # no-DB unit suite that bench:all runs in CI.
   db_benches = %w[connection_pool_bench integration_bench streams_bench streams_read_pool_bench
                   execution_modes_bench pool_swap_bench pool_autoscale_bench job_burst_bench
-                  notify_wake_bench notify_chaos_bench streams_hub_bench].freeze
+                  notify_wake_bench notify_chaos_bench streams_hub_bench fair_read_bench].freeze
   # The unit suite is every *_bench.rb that doesn't need a database, derived
   # from the directory so a new unit bench is picked up automatically (kept in
   # sync with bench:one, which globs the same files).
@@ -60,6 +60,11 @@ namespace :bench do
     ruby "benchmarks/integration_bench.rb"
   end
 
+  desc "Run fair share read benchmark (requires PGBUS_DATABASE_URL)"
+  task :fair_read do
+    ruby "benchmarks/fair_read_bench.rb"
+  end
+
   desc "Run streams benchmarks (requires PGBUS_DATABASE_URL; boots real Puma + SSE)"
   task :streams do
     ruby "benchmarks/streams_bench.rb"

data/app/helpers/pgbus/application_helper.rb

@@ -143,6 +143,13 @@ module Pgbus
       tag.span(I18n.t("pgbus.helpers.batch_status.#{status}", default: status), class: css)
     end
 
+    # Persisted Current attributes for a job payload, as
+    # { "Current" => { "tenant" => "gid://…", ... } } or nil (issue #430).
+    # Goes through pgbus_parse_message so PayloadFilter redaction applies.
+    def pgbus_job_context(message)
+      Pgbus::Web::JobContext.from_payload(pgbus_parse_message(message))
+    end
+
     def pgbus_parse_message(message)
       return {} unless message
 

data/app/views/pgbus/dead_letter/show.html.erb

@@ -26,6 +26,23 @@
     </dl>
   </div>
 
+  <% if (context = pgbus_job_context(@message[:message])) %>
+    <div class="rounded-lg bg-white dark:bg-gray-800 shadow ring-1 ring-gray-200 dark:ring-gray-700 p-6 mb-6" data-testid="job-context">
+      <h2 class="text-sm font-medium text-gray-500 mb-2"><%= t("pgbus.dead_letter.show.context") %></h2>
+      <% context.each do |klass_name, attrs| %>
+        <h3 class="text-xs font-semibold text-gray-700 dark:text-gray-300 mt-3 mb-1 font-mono"><%= klass_name %></h3>
+        <dl class="grid grid-cols-1 gap-x-4 gap-y-1 sm:grid-cols-2">
+          <% attrs.each do |name, value| %>
+            <div class="flex gap-2 text-xs">
+              <dt class="text-gray-500 font-mono"><%= name %></dt>
+              <dd class="text-gray-900 dark:text-white font-mono break-all"><%= value %></dd>
+            </div>
+          <% end %>
+        </dl>
+      <% end %>
+    </div>
+  <% end %>
+
   <div class="rounded-lg bg-white dark:bg-gray-800 shadow ring-1 ring-gray-200 dark:ring-gray-700 p-6 mb-6">
     <h2 class="text-sm font-medium text-gray-500 mb-2"><%= t("pgbus.dead_letter.show.payload") %></h2>
     <pre class="text-xs text-gray-600 bg-gray-50 dark:bg-gray-900 rounded p-4 overflow-x-auto"><%= JSON.pretty_generate(JSON.parse(@message[:message])) rescue @message[:message] %></pre>

data/app/views/pgbus/events/_pending_table.html.erb

@@ -102,6 +102,27 @@
                       </div>
                     </div>
                   </div>
+                  <%# Persisted Current attributes (issue #431) %>
+                  <% if (event_context = pgbus_job_context(m[:message])) %>
+                    <div class="mb-3" data-testid="job-context">
+                      <span class="text-xs font-medium text-gray-500"><%= t("pgbus.events.pending_table.context") %></span>
+                      <div class="text-xs text-gray-600 bg-white dark:bg-gray-800 rounded p-2 mt-1 space-y-2">
+                        <% event_context.each do |klass_name, attrs| %>
+                          <div>
+                            <p class="font-semibold text-gray-700 dark:text-gray-300 font-mono"><%= klass_name %></p>
+                            <dl class="grid grid-cols-1 gap-x-4 gap-y-0.5 sm:grid-cols-2">
+                              <% attrs.each do |name, value| %>
+                                <div class="flex gap-2">
+                                  <dt class="text-gray-500 font-mono"><%= name %></dt>
+                                  <dd class="text-gray-900 dark:text-white font-mono break-all"><%= value %></dd>
+                                </div>
+                              <% end %>
+                            </dl>
+                          </div>
+                        <% end %>
+                      </div>
+                    </div>
+                  <% end %>
                   <%# Edit Payload form %>
                   <details class="mt-2">
                     <summary class="text-xs font-medium text-indigo-600 cursor-pointer hover:text-indigo-500"><%= t("pgbus.events.pending_table.edit_payload") %></summary>

data/app/views/pgbus/jobs/show.html.erb

@@ -38,6 +38,23 @@
     </div>
   <% end %>
 
+  <% if (context = pgbus_job_context(@job["payload"])) %>
+    <div class="rounded-lg bg-white dark:bg-gray-800 shadow ring-1 ring-gray-200 dark:ring-gray-700 p-6 mb-6" data-testid="job-context">
+      <h2 class="text-sm font-medium text-gray-500 mb-2"><%= t("pgbus.jobs.show.context") %></h2>
+      <% context.each do |klass_name, attrs| %>
+        <h3 class="text-xs font-semibold text-gray-700 dark:text-gray-300 mt-3 mb-1 font-mono"><%= klass_name %></h3>
+        <dl class="grid grid-cols-1 gap-x-4 gap-y-1 sm:grid-cols-2">
+          <% attrs.each do |name, value| %>
+            <div class="flex gap-2 text-xs">
+              <dt class="text-gray-500 font-mono"><%= name %></dt>
+              <dd class="text-gray-900 dark:text-white font-mono break-all"><%= value %></dd>
+            </div>
+          <% end %>
+        </dl>
+      <% end %>
+    </div>
+  <% end %>
+
   <div class="rounded-lg bg-white dark:bg-gray-800 shadow ring-1 ring-gray-200 dark:ring-gray-700 p-6 mb-6">
     <h2 class="text-sm font-medium text-gray-500 mb-2"><%= t("pgbus.jobs.show.payload") %></h2>
     <pre class="text-xs text-gray-600 bg-gray-50 dark:bg-gray-900 rounded p-4 overflow-x-auto"><%= JSON.pretty_generate(pgbus_parse_message(@job["payload"])) %></pre>

data/config/locales/da.yml

@@ -131,6 +131,7 @@ da:
         total_label: beskeder i dead letter-kø
       show:
         back: Tilbage til DLQ
+        context: Kontekst
         discard: Kassér
         discard_confirm: Slet permanent?
         headers: Overskrifter
@@ -194,6 +195,7 @@ da:
         title: Begivenheder
       pending_table:
         arguments: Payload
+        context: Kontekst
         discard: Forkast
         discard_confirm: Forkast denne begivenhed? Den vil blive arkiveret.
         edit_payload: Rediger & prøv igen
@@ -372,6 +374,7 @@ da:
       show:
         back: Tilbage til job
         backtrace: Stacktrace
+        context: Kontekst
         discard: Kassér
         discard_confirm: Slet dette job permanent?
         error_message: Fejlmeddelelse

data/config/locales/de.yml

@@ -131,6 +131,7 @@ de:
         total_label: Nachrichten in der Dead-Letter-Warteschlange
       show:
         back: Zurück zur DLQ
+        context: Kontext
         discard: Verwerfen
         discard_confirm: Dauerhaft verwerfen?
         headers: Header
@@ -194,6 +195,7 @@ de:
         title: Ereignisse
       pending_table:
         arguments: Nutzlast
+        context: Kontext
         discard: Verwerfen
         discard_confirm: Dieses Ereignis verwerfen? Es wird archiviert.
         edit_payload: Bearbeiten & erneut versuchen
@@ -372,6 +374,7 @@ de:
       show:
         back: Zurück zu Jobs
         backtrace: Stacktrace
+        context: Kontext
         discard: Verwerfen
         discard_confirm: Diesen Auftrag dauerhaft verwerfen?
         error_message: Fehlermeldung

data/config/locales/en.yml

@@ -131,6 +131,7 @@ en:
         total_label: messages in dead letter queue
       show:
         back: Back to DLQ
+        context: Context
         discard: Discard
         discard_confirm: Permanently discard?
         headers: Headers
@@ -194,6 +195,7 @@ en:
         title: Events
       pending_table:
         arguments: Payload
+        context: Context
         discard: Discard
         discard_confirm: Discard this event? It will be archived.
         edit_payload: Edit & Retry
@@ -372,6 +374,7 @@ en:
       show:
         back: Back to Jobs
         backtrace: Backtrace
+        context: Context
         discard: Discard
         discard_confirm: Discard this job permanently?
         error_message: Error Message

data/config/locales/es.yml

@@ -131,6 +131,7 @@ es:
         total_label: mensajes en la cola de mensajes fallidos
       show:
         back: Volver a DLQ
+        context: Contexto
         discard: Descartar
         discard_confirm: "¿Descartar permanentemente?"
         headers: Encabezados
@@ -194,6 +195,7 @@ es:
         title: Eventos
       pending_table:
         arguments: Carga útil
+        context: Contexto
         discard: Descartar
         discard_confirm: "¿Descartar este evento? Será archivado."
         edit_payload: Editar y reintentar
@@ -372,6 +374,7 @@ es:
       show:
         back: Volver a Trabajos
         backtrace: Rastreo de pila
+        context: Contexto
         discard: Descartar
         discard_confirm: "¿Descartar este trabajo permanentemente?"
         error_message: Mensaje de error

data/config/locales/fi.yml

@@ -131,6 +131,7 @@ fi:
         total_label: viestiä dead letter -jonossa
       show:
         back: Takaisin DLQ:hon
+        context: Konteksti
         discard: Hylkää
         discard_confirm: Hylätään pysyvästi?
         headers: Otsikot
@@ -194,6 +195,7 @@ fi:
         title: Tapahtumat
       pending_table:
         arguments: Kuorma
+        context: Konteksti
         discard: Hylkää
         discard_confirm: Hylätäänkö tämä tapahtuma? Se arkistoidaan.
         edit_payload: Muokkaa ja yritä uudelleen
@@ -372,6 +374,7 @@ fi:
       show:
         back: Takaisin töihin
         backtrace: Takautumisketju
+        context: Konteksti
         discard: Hylkää
         discard_confirm: Hylkää tämä työ pysyvästi?
         error_message: Virheilmoitus

data/config/locales/fr.yml

@@ -131,6 +131,7 @@ fr:
         total_label: messages dans la file de lettres mortes
       show:
         back: Retour à la DLQ
+        context: Contexte
         discard: Ignorer
         discard_confirm: Ignorer définitivement ?
         headers: En-têtes
@@ -194,6 +195,7 @@ fr:
         title: Événements
       pending_table:
         arguments: Charge utile
+        context: Contexte
         discard: Jeter
         discard_confirm: Jeter cet événement ? Il sera archivé.
         edit_payload: Modifier & Réessayer
@@ -372,6 +374,7 @@ fr:
       show:
         back: Retour aux travaux
         backtrace: Trace de la pile
+        context: Contexte
         discard: Ignorer
         discard_confirm: Supprimer ce travail définitivement ?
         error_message: Message d'erreur

data/config/locales/it.yml

@@ -131,6 +131,7 @@ it:
         total_label: messaggi nella coda dei messaggi non recapitati
       show:
         back: Torna a DLQ
+        context: Contesto
         discard: Scarta
         discard_confirm: Scartare definitivamente?
         headers: Intestazioni
@@ -194,6 +195,7 @@ it:
         title: Eventi
       pending_table:
         arguments: Payload
+        context: Contesto
         discard: Scarta
         discard_confirm: Scartare questo evento? Verrà archiviato.
         edit_payload: Modifica e riprova
@@ -372,6 +374,7 @@ it:
       show:
         back: Torna ai Lavori
         backtrace: Traccia dello stack
+        context: Contesto
         discard: Scarta
         discard_confirm: Scartare definitivamente questo lavoro?
         error_message: Messaggio di errore

data/config/locales/ja.yml

@@ -131,6 +131,7 @@ ja:
         total_label: デッドレターキュー内のメッセージ
       show:
         back: DLQに戻る
+        context: コンテキスト
         discard: 破棄
         discard_confirm: 完全に破棄しますか？
         headers: ヘッダー
@@ -194,6 +195,7 @@ ja:
         title: イベント
       pending_table:
         arguments: ペイロード
+        context: コンテキスト
         discard: 破棄
         discard_confirm: このイベントを破棄しますか？アーカイブされます。
         edit_payload: 編集して再試行
@@ -372,6 +374,7 @@ ja:
       show:
         back: ジョブに戻る
         backtrace: バックトレース
+        context: コンテキスト
         discard: 破棄
         discard_confirm: このジョブを完全に破棄しますか？
         error_message: エラーメッセージ

data/config/locales/nb.yml

@@ -131,6 +131,7 @@ nb:
         total_label: meldinger i dead letter-kø
       show:
         back: Tilbake til DLQ
+        context: Kontekst
         discard: Forkast
         discard_confirm: Forkaste permanent?
         headers: Overskrifter
@@ -194,6 +195,7 @@ nb:
         title: Hendelser
       pending_table:
         arguments: Nyttelast
+        context: Kontekst
         discard: Forkast
         discard_confirm: Forkast denne hendelsen? Den vil bli arkivert.
         edit_payload: Rediger & prøv på nytt
@@ -372,6 +374,7 @@ nb:
       show:
         back: Tilbake til jobber
         backtrace: Tilbakekalling
+        context: Kontekst
         discard: Forkast
         discard_confirm: Slett denne jobben permanent?
         error_message: Feilmelding

data/config/locales/nl.yml

@@ -131,6 +131,7 @@ nl:
         total_label: berichten in dead letter-wachtrij
       show:
         back: Terug naar DLQ
+        context: Context
         discard: Verwerpen
         discard_confirm: Permanent verwerpen?
         headers: Headers
@@ -194,6 +195,7 @@ nl:
         title: Gebeurtenissen
       pending_table:
         arguments: Payload
+        context: Context
         discard: Verwijderen
         discard_confirm: Deze gebeurtenis verwijderen? Deze wordt gearchiveerd.
         edit_payload: Bewerken & Opnieuw Proberen
@@ -372,6 +374,7 @@ nl:
       show:
         back: Terug naar Taken
         backtrace: Stacktrace
+        context: Context
         discard: Verwijderen
         discard_confirm: Deze taak permanent verwijderen?
         error_message: Foutmelding

data/config/locales/pt.yml

@@ -131,6 +131,7 @@ pt:
         total_label: mensagens na fila de mensagens mortas
       show:
         back: Voltar para DLQ
+        context: Contexto
         discard: Descartar
         discard_confirm: Descartar permanentemente?
         headers: Cabeçalhos
@@ -194,6 +195,7 @@ pt:
         title: Eventos
       pending_table:
         arguments: Payload
+        context: Contexto
         discard: Descartar
         discard_confirm: Descartar este evento? Ele será arquivado.
         edit_payload: Editar e Tentar Novamente
@@ -372,6 +374,7 @@ pt:
       show:
         back: Voltar para Trabalhos
         backtrace: Rastreamento de Pilha
+        context: Contexto
         discard: Descartar
         discard_confirm: Descartar este trabalho permanentemente?
         error_message: Mensagem de Erro

data/config/locales/sv.yml

@@ -131,6 +131,7 @@ sv:
         total_label: meddelanden i dead letter-kö
       show:
         back: Tillbaka till DLQ
+        context: Kontext
         discard: Kassera
         discard_confirm: Kassera permanent?
         headers: Rubriker
@@ -194,6 +195,7 @@ sv:
         title: Händelser
       pending_table:
         arguments: Payload
+        context: Kontext
         discard: Kassera
         discard_confirm: Kassera denna händelse? Den kommer att arkiveras.
         edit_payload: Redigera & Försök igen
@@ -372,6 +374,7 @@ sv:
       show:
         back: Tillbaka till jobb
         backtrace: Backtrace
+        context: Kontext
         discard: Kassera
         discard_confirm: Kassera detta jobb permanent?
         error_message: Felmeddelande

data/lib/pgbus/active_job/adapter.rb

@@ -10,6 +10,7 @@ module Pgbus
         payload_hash = Serializer.serialize_job_hash(active_job)
         payload_hash = Concurrency.inject_metadata(active_job, payload_hash)
         payload_hash = Uniqueness.inject_metadata(active_job, payload_hash)
+        payload_hash = FairShare.inject_metadata(active_job, payload_hash)
         payload_hash = inject_batch_metadata(payload_hash, active_job: active_job)
 
         if uniqueness_rejected?(active_job, payload_hash, queue: queue)
@@ -25,6 +26,7 @@ module Pgbus
         payload_hash = Serializer.serialize_job_hash(active_job)
         payload_hash = Concurrency.inject_metadata(active_job, payload_hash)
         payload_hash = Uniqueness.inject_metadata(active_job, payload_hash)
+        payload_hash = FairShare.inject_metadata(active_job, payload_hash)
         payload_hash = inject_batch_metadata(payload_hash, active_job: active_job)
         delay = [(timestamp - Time.current.to_f).ceil, 0].max
 
@@ -262,7 +264,9 @@ module Pgbus
       def enqueue_immediate(queue, jobs, priority: nil)
         return if jobs.empty?
 
-        payloads = jobs.map { |j| inject_batch_metadata(Serializer.serialize_job_hash(j), track: false) }
+        payloads = jobs.map do |j|
+          inject_batch_metadata(FairShare.inject_metadata(j, Serializer.serialize_job_hash(j)), track: false)
+        end
         # One guarded increment for the whole bulk, not one per job.
         Batch.track_enqueue(payloads) if Thread.current[:pgbus_batch_id]
         physical = physical_queue(queue, priority)

data/lib/pgbus/active_job/current_attributes.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module ActiveJob
+    # Carries ActiveSupport::CurrentAttributes across enqueue → perform
+    # (issue #430). Included on ActiveJob::Base by the engine next to BatchId.
+    #
+    # * +serialize+ snapshots the persisted Current classes
+    #   (Pgbus::CurrentAttributes.capture) under +pgbus_current+. A job that
+    #   was itself deserialized re-serializes the context it was enqueued
+    #   with — so a +retry_on+ re-enqueue keeps the original context even if
+    #   Current changed during the attempt. Nothing is added when the feature
+    #   is off or no attribute is assigned: the payload is byte-for-byte what
+    #   it was before this mixin existed.
+    # * +perform_now+ is wrapped (not an +around_perform+) so the restored
+    #   context also covers +rescue_from+ / +retry_on+ / +discard_on+ blocks,
+    #   which run in +perform_now+'s rescue outside the perform callbacks —
+    #   and it works identically under the pgbus worker, Rails' :test and
+    #   :inline adapters, and a bare +job.perform_now+.
+    #
+    # Per-class control: +self.pgbus_persist_current_attributes = false+
+    # (never persist for this job class) or a spec in the same shapes as
+    # +config.current_attributes+ (an Array / Hash) to replace the config's
+    # list for this class. +nil+ (default) follows the config.
+    module CurrentAttributes
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :pgbus_current_attributes
+
+        class_attribute :pgbus_persist_current_attributes, instance_writer: false, default: nil
+      end
+
+      def serialize
+        data = super
+        captured = pgbus_current_attributes ||
+                   Pgbus::CurrentAttributes.capture(override: self.class.pgbus_persist_current_attributes)
+        data[Pgbus::CurrentAttributes::METADATA_KEY] = captured if captured
+        data
+      end
+
+      def deserialize(job_data)
+        super
+        self.pgbus_current_attributes = job_data[Pgbus::CurrentAttributes::METADATA_KEY]
+      end
+
+      def perform_now
+        Pgbus::CurrentAttributes.restore(pgbus_current_attributes) { super }
+      end
+    end
+  end
+end