pgbus 0.14.1 → 0.15.0

data/lib/pgbus/process/dispatcher.rb

@@ -51,6 +51,7 @@ module Pgbus
       # Enumerated so set_maintenance_timestamp can validate its argument.
       MAINTENANCE_TIMESTAMPS = %i[
         @last_cleanup_at @last_reap_at @last_concurrency_at @last_batch_cleanup_at
+        @last_batch_sweep_at
         @last_recurring_cleanup_at @last_archive_compaction_at @last_stream_archive_compaction_at
         @last_outbox_cleanup_at @last_job_lock_cleanup_at @last_stats_cleanup_at
         @last_orphan_stream_sweep_at @last_table_maintenance_at
@@ -107,7 +108,7 @@ module Pgbus
 
       # Test seam: set one of the @last_*_at maintenance timestamps so a task
       # becomes (or stops being) due on the next run_maintenance. The timestamps
-      # are per-task monotonic clocks with no constructor injection point (all 12
+      # are per-task monotonic clocks with no constructor injection point (all
       # default to monotonic_now at construction), so a post-construction setter
       # is the minimal way to drive the due/not-due logic deterministically.
       # ivar must be one of the recognized @last_*_at names.
@@ -233,6 +234,7 @@ module Pgbus
         results << run_if_due(now, :@last_reap_at, REAP_INTERVAL) { reap_stale_processes }
         results << run_if_due(now, :@last_concurrency_at, CONCURRENCY_INTERVAL) { cleanup_concurrency }
         results << run_if_due(now, :@last_batch_cleanup_at, BATCH_CLEANUP_INTERVAL) { cleanup_batches }
+        results << run_if_due(now, :@last_batch_sweep_at, config.batch_sweep_interval) { sweep_stalled_batches }
         results << run_if_due(now, :@last_recurring_cleanup_at, RECURRING_CLEANUP_INTERVAL) { cleanup_recurring_executions }
         results << run_if_due(now, :@last_archive_compaction_at, ARCHIVE_COMPACTION_INTERVAL) { compact_archives }
         results << run_if_due(now, :@last_stream_archive_compaction_at, ARCHIVE_COMPACTION_INTERVAL) { prune_stream_archives }
@@ -373,13 +375,23 @@ module Pgbus
       end
 
       def cleanup_batches
-        deleted = Batch.cleanup(older_than: Time.current - (7 * 24 * 3600)) # 7 days
+        retention = config.batch_retention
+        return unless retention&.positive?
+
+        deleted = Batch.cleanup(older_than: Time.current - retention)
         Pgbus.logger.debug { "[Pgbus] Cleaned up #{deleted} finished batches" } if deleted.positive?
       rescue StandardError => e
         log_maintenance_failure("Batch cleanup", e)
         e
       end
 
+      def sweep_stalled_batches
+        Batch.sweep_stalled
+      rescue StandardError => e
+        log_maintenance_failure("Batch sweep", e)
+        e
+      end
+
       def cleanup_stats
         retention = config.stats_retention
         return unless retention&.positive?
@@ -446,34 +458,46 @@ module Pgbus
         # younger could be a freshly-acquired lock whose send_message hasn't
         # committed yet.
         threshold = Time.current - (config.visibility_timeout * 2)
+        candidates = keys.select { |key| key.created_at && key.created_at < threshold && key.queue_name }
+        return 0 if candidates.empty?
 
-        orphaned = keys.select do |key|
-          next false unless key.created_at && key.created_at < threshold
-          next false unless key.queue_name
-
-          message_gone?(key)
-        end
+        bound, unbound = candidates.partition { |key| bound_lock?(key) }
+        orphaned = bound.select { |key| message_gone?(key) }
+        orphaned.concat(gone_unbound_locks(unbound))
 
         return 0 if orphaned.empty?
 
         UniquenessKey.where(lock_key: orphaned.map(&:lock_key)).delete_all
       end
 
-      # Returns true if the message referenced by this lock is definitely gone
-      # from the queue. Returns false otherwise (message present, or unknown).
+      def bound_lock?(key)
+        !Uniqueness.placeholder?(queue_name: key.queue_name, msg_id: key.msg_id)
+      end
+
+      # Unbound rows (synthetic "pending" queue and/or msg_id=0) must not probe
+      # pgmq.q_<prefix>_pending — that table does not exist, message_exists?
+      # returns nil, and the reaper would keep the lock forever (issue #418).
+      # Scan every live queue for the payload key instead.
+      def gone_unbound_locks(unbound)
+        return [] if unbound.empty?
+
+        present = Pgbus.client.uniqueness_keys_present(unbound.map(&:lock_key))
+        unbound.reject { |key| present.include?(key.lock_key) }
+      end
+
+      # Returns true if the message referenced by this bound lock is definitely
+      # gone from the queue. Returns false otherwise (message present, or unknown).
       #
       # Routes through Pgbus::Client#message_exists? so all PGMQ access stays
       # behind the client interface. The client returns nil when it can't
       # determine the answer (queue table missing, etc.); we treat that as
       # "still here" — the reaper must NEVER delete a lock when in doubt.
       def message_gone?(key)
-        msg_id = key.msg_id.to_i
-        result = if msg_id.positive?
-                   Pgbus.client.message_exists?(key.queue_name, msg_id: msg_id)
-                 else
-                   Pgbus.client.message_exists?(key.queue_name, uniqueness_key: key.lock_key)
-                 end
-
+        result = Pgbus.client.message_exists?(
+          key.queue_name,
+          msg_id: key.msg_id.to_i,
+          uniqueness_key: key.lock_key
+        )
         result == false
       rescue StandardError => e
         Pgbus.logger.warn { "[Pgbus] Reap check failed for #{key.lock_key}: #{e.message}" }

data/lib/pgbus/process/worker.rb

@@ -54,6 +54,11 @@ module Pgbus
           raise ArgumentError,
                 "Invalid group_mode: #{@group_mode.inspect}. Must be nil, :fifo, or :round_robin"
         end
+        if FairShare.enabled?(config) && (@group_mode || config.group_mode)
+          raise Pgbus::ConfigurationError,
+                "fair_share and group_mode are mutually exclusive — this worker has group_mode " \
+                "#{(@group_mode || config.group_mode).inspect} while config.fair_share is set"
+        end
         @single_active_consumer = single_active_consumer
         @consumer_priority = consumer_priority
         @lifecycle = Lifecycle.new
@@ -165,6 +170,7 @@ module Pgbus
         setup_signals
         start_heartbeat
         resolve_wildcard_queues
+        ensure_fair_indexes
         start_wake_source
         @lifecycle.transition_to!(:running)
         Pgbus.logger.info do
@@ -284,6 +290,8 @@ module Pgbus
             fetch_prioritized(active_queues, qty)
           elsif @group_mode
             fetch_grouped(active_queues, qty)
+          elsif fair_share_enabled?
+            fetch_fair(active_queues, qty)
           elsif active_queues.size == 1
             queue = active_queues.first
             messages = Pgbus.client.read_batch(queue, qty: qty) || []
@@ -391,6 +399,38 @@ module Pgbus
         results
       end
 
+      # Fair share (issue #426): one weighted-interleave read per queue, in
+      # list order with the remaining capacity — strict priority ACROSS queues
+      # (the capsule DSL contract), fair WITHIN each queue. Same loop shape as
+      # fetch_prioritized; under priority_levels the client composes both.
+      def fetch_fair(active_queues, qty)
+        remaining = qty
+        results = []
+
+        active_queues.each do |queue|
+          break if remaining <= 0
+
+          messages = Pgbus.client.read_batch_fair(queue, qty: remaining) || []
+          messages.each { |m| results << [queue, m] }
+          remaining -= messages.size
+        end
+
+        results
+      end
+
+      def fair_share_enabled?
+        FairShare.enabled?(config)
+      end
+
+      # Build the fair index on every queue this worker serves (idempotent,
+      # memoized in the client, CONCURRENTLY so a populated queue is never
+      # write-locked). Queues created later get theirs at creation time.
+      def ensure_fair_indexes
+        return unless fair_share_enabled?
+
+        queues.each { |q| Pgbus.client.ensure_fair_index(q) }
+      end
+
       def priority_enabled?
         config.priority_levels && config.priority_levels > 1
       end
@@ -448,6 +488,7 @@ module Pgbus
         return if @last_wildcard_resolve && (monotonic_now - @last_wildcard_resolve) < WILDCARD_REFRESH_INTERVAL
 
         resolve_wildcard_queues
+        ensure_fair_indexes
       end
 
       # When a "relation does not exist" error occurs, the queue was deleted.

data/lib/pgbus/recurring/schedule.rb

@@ -29,7 +29,8 @@ module Pgbus
           payload = inject_uniqueness_metadata(task, payload)
 
           Pgbus.client.ensure_queue(queue)
-          Pgbus.client.send_message(queue, payload, headers: headers)
+          msg_id = Pgbus.client.send_message(queue, payload, headers: headers)
+          bind_uniqueness_lock(acquired_key, queue, msg_id)
 
           Pgbus.logger.info do
             "[Pgbus] Enqueued recurring task #{task.key} (#{task.class_name || task.command}) " \
@@ -159,6 +160,16 @@ module Pgbus
         :already_locked # Fail closed — skip enqueue when lock check errors
       end
 
+      # Point the pre-produce lock at the real PGMQ msg_id. Fail-soft: a bind
+      # error must not roll back an already-produced message (issue #418).
+      def bind_uniqueness_lock(key, queue, msg_id)
+        return unless key.is_a?(String)
+
+        Uniqueness.bind_lock(key, queue_name: queue, msg_id: msg_id)
+      rescue StandardError => e
+        Pgbus.logger.warn { "[Pgbus] Uniqueness bind failed: #{e.message}" }
+      end
+
       # Release a uniqueness lock. Safe to call with nil or :already_locked.
       def release_uniqueness_lock(key)
         return if key.nil? || key == :already_locked

data/lib/pgbus/testing.rb

@@ -54,7 +54,8 @@ module Pgbus
           break unless event
 
           Pgbus::EventBus::Registry.instance.handlers_for(event.routing_key).each do |subscriber|
-            subscriber.handler_class.new.handle(event)
+            # Restore the publisher's Current (issue #431) like the consumer does.
+            Pgbus::CurrentAttributes.restore(event.context) { subscriber.handler_class.new.handle(event) }
           end
 
           @mutex.synchronize { @events.shift }

data/lib/pgbus/uniqueness.rb

@@ -10,9 +10,10 @@ module Pgbus
   # at any time — from enqueue through completion.
   #
   # Lock lifecycle (advisory lock + thin lookup table):
-  #   1. Enqueue: pg_advisory_xact_lock serializes concurrent attempts,
-  #      then INSERT INTO pgbus_uniqueness_keys ON CONFLICT DO NOTHING.
-  #      The lock row lives as long as the job is in the queue or executing.
+  #   1. Enqueue: INSERT INTO pgbus_uniqueness_keys ON CONFLICT DO NOTHING
+  #      (logical queue, msg_id=0). After send_message, bind! writes the
+  #      real msg_id. The lock row lives as long as the job is in the queue
+  #      or executing.
   #   2. Execution: PGMQ's visibility timeout is the execution lock —
   #      no separate claim_for_execution step needed.
   #   3. Completion/DLQ: DELETE FROM pgbus_uniqueness_keys WHERE lock_key = ?.
@@ -43,6 +44,10 @@ module Pgbus
 
     METADATA_KEY = "pgbus_uniqueness_key"
     STRATEGY_KEY = "pgbus_uniqueness_strategy"
+    # Synthetic queue stored before produce when the caller does not know the
+    # real queue yet. Never a live PGMQ queue — the reaper must not probe
+    # pgmq.q_<prefix>_pending for these rows (issue #418).
+    PLACEHOLDER_QUEUE = "pending"
 
     VALID_STRATEGIES = %i[until_executed while_executing].freeze
     VALID_CONFLICTS = %i[reject discard log].freeze
@@ -174,19 +179,25 @@ module Pgbus
                      UniquenessKey.acquire!(key, queue_name: queue_name, msg_id: msg_id)
                    else
                      # Pre-produce check: use advisory lock + ON CONFLICT
-                     UniquenessKey.acquire!(key, queue_name: queue_name || "pending", msg_id: msg_id || 0)
+                     UniquenessKey.acquire!(key, queue_name: queue_name || PLACEHOLDER_QUEUE, msg_id: msg_id || 0)
                    end
         acquired ? :acquired : :locked
       end
 
       # Acquire the uniqueness lock at execution time (:while_executing only).
       # Returns true if acquired, false if another instance is running.
-      def acquire_execution_lock(key, payload)
+      #
+      # Bound to the message being executed so a row left behind by a crashed
+      # attempt of the SAME message is re-acquired on retry instead of locking
+      # that message out until it dead-letters (issue #423). Callers without a
+      # message (legacy signature) fall back to the unbound placeholder.
+      def acquire_execution_lock(key, payload, msg_id: 0, queue_name: nil)
         strategy = extract_strategy(payload)
         return true unless strategy == :while_executing
 
-        queue_name = payload["queue_name"] || "unknown"
-        UniquenessKey.acquire!(key, queue_name: queue_name, msg_id: 0)
+        queue_name ||= payload["queue_name"] || "unknown"
+        UniquenessKey.acquire!(key, queue_name: queue_name, msg_id: msg_id.to_i,
+                                    reacquire_same_message: msg_id.to_i.positive?)
       end
 
       # Release the uniqueness lock after execution completes.
@@ -195,6 +206,23 @@ module Pgbus
 
         UniquenessKey.release!(key)
       end
+
+      # Point a pre-produce lock at the real queue + PGMQ msg_id after send.
+      # No-op when key is nil or msg_id is not a positive integer (the reaper
+      # treats those rows as unbound and scans live queues instead).
+      def bind_lock(key, queue_name:, msg_id:)
+        return unless key
+        return unless msg_id.to_i.positive?
+
+        UniquenessKey.bind!(key, queue_name: queue_name, msg_id: msg_id)
+      end
+
+      # True when the uniqueness row is not yet bound to a real PGMQ message.
+      # Covers the synthetic pending queue and any msg_id=0 placeholder
+      # (recurring scheduler, bind-not-yet-run, bind failure).
+      def placeholder?(queue_name:, msg_id:)
+        msg_id.to_i <= 0 || queue_name.to_s == PLACEHOLDER_QUEUE
+      end
     end
   end
 end

data/lib/pgbus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pgbus
-  VERSION = "0.14.1"
+  VERSION = "0.15.0"
 end

data/lib/pgbus/web/data_source.rb

@@ -669,7 +669,9 @@ module Pgbus
 
       # Batches
       def batches(limit: 100)
-        BatchEntry.order(created_at: :desc).limit(limit).map { |r| format_batch(r) }
+        records = BatchEntry.order(created_at: :desc).limit(limit).to_a
+        pending = pending_jobs_by_batch(records.map(&:batch_id))
+        records.map { |r| format_batch(r, pending_jobs: pending[r.batch_id]) }
       rescue StandardError => e
         Pgbus.logger.debug { "[Pgbus::Web] Error fetching batches: #{e.message}" }
         []
@@ -679,11 +681,14 @@ module Pgbus
         record = BatchEntry.find_by(batch_id: batch_id)
         return nil unless record
 
-        format_batch(record).merge(
+        pending = pending_jobs_by_batch([batch_id])
+        failure_callback = callback_display_name(record, :on_failure) || failure_callback_class(record)
+        format_batch(record, pending_jobs: pending[batch_id]).merge(
           properties: record.properties,
-          on_finish_class: record.on_finish_class,
-          on_success_class: record.on_success_class,
-          on_discard_class: record.on_discard_class
+          on_finish_class: callback_display_name(record, :on_finish) || record.on_finish_class,
+          on_success_class: callback_display_name(record, :on_success) || record.on_success_class,
+          on_failure_class: failure_callback,
+          on_discard_class: failure_callback
         )
       rescue StandardError => e
         Pgbus.logger.debug { "[Pgbus::Web] Error fetching batch #{batch_id}: #{e.message}" }
@@ -1351,10 +1356,12 @@ module Pgbus
         end
       end
 
-      def format_batch(record)
+      def format_batch(record, pending_jobs: nil)
         total = record.total_jobs
-        done = record.completed_jobs + record.discarded_jobs
+        failed = failure_job_count(record)
+        done = record.completed_jobs + failed
         pct = total.positive? ? ((done * 100) / total) : 100
+        pending = pending_jobs || [total - done, 0].max
 
         {
           batch_id: record.batch_id,
@@ -1362,14 +1369,45 @@ module Pgbus
           status: record.status,
           total_jobs: total,
           completed_jobs: record.completed_jobs,
-          discarded_jobs: record.discarded_jobs,
-          failed_jobs: record.failed_jobs,
+          failed_jobs: failed,
+          discarded_jobs: failed,
+          pending_jobs: pending,
           progress_pct: pct,
           created_at: record.created_at,
           finished_at: record.finished_at
         }
       end
 
+      def failure_job_count(record)
+        record.respond_to?(:discarded_jobs) ? record.discarded_jobs.to_i : record.failed_jobs.to_i
+      end
+
+      # A callback configured as an ActiveJob instance lives in the *_job jsonb
+      # column, not the legacy *_class string — show its job_class either way.
+      def callback_display_name(record, slot)
+        column = "#{slot}_job"
+        return nil unless record.respond_to?(column)
+
+        record.public_send(column).presence&.dig("job_class")
+      end
+
+      def failure_callback_class(record)
+        if record.respond_to?(:on_failure_class) && record.on_failure_class.present?
+          record.on_failure_class
+        elsif record.respond_to?(:on_discard_class)
+          record.on_discard_class
+        end
+      end
+
+      def pending_jobs_by_batch(batch_ids)
+        return {} unless Batch.executions_migrated?
+        return {} if batch_ids.empty?
+
+        BatchExecution.where(batch_id: batch_ids).group(:batch_id).count
+      rescue StandardError
+        {}
+      end
+
       def sanitize_name(name)
         QueueNameValidator.sanitize!(name)
       end

data/lib/pgbus/web/job_context.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Pgbus
+  module Web
+    # Presents the Current attributes persisted in a job payload
+    # (Pgbus::CurrentAttributes::METADATA_KEY) for the dashboard's Context
+    # card: { "Current" => { "tenant" => "gid://app/Tenant/42", ... } }.
+    #
+    # Pure presentation: ActiveJob argument encodings are unwrapped to display
+    # strings (a GlobalID shows its gid, a serialized Symbol/Time its value) —
+    # nothing is constantized or located. Callers pass the payload through
+    # PayloadFilter first (ApplicationHelper#pgbus_parse_message does), so
+    # sensitive values arrive already redacted.
+    module JobContext
+      AJ_GLOBALID = "_aj_globalid"
+      AJ_SERIALIZED = "_aj_serialized"
+      AJ_META_PREFIX = "_aj_"
+
+      module_function
+
+      def from_payload(payload)
+        data = parse(payload)
+        stored = data && data[Pgbus::CurrentAttributes::METADATA_KEY]
+        return nil unless stored.is_a?(Hash) && stored.any?
+
+        stored.to_h do |klass_name, attrs|
+          [klass_name.to_s, present_attrs(attrs)]
+        end
+      end
+
+      def present_attrs(attrs)
+        return {} unless attrs.is_a?(Hash)
+
+        attrs.each_with_object({}) do |(name, value), out|
+          next if name.to_s.start_with?(AJ_META_PREFIX)
+
+          out[name.to_s] = display(value)
+        end
+      end
+
+      # String form of a value for the card. Hashes/arrays that are ActiveJob
+      # encodings collapse to their payload; anything else renders as JSON
+      # (stable across Ruby versions — Hash#inspect changed in 3.4).
+      def display(value)
+        unwrapped = unwrap(value)
+        unwrapped.is_a?(String) ? unwrapped : JSON.generate(unwrapped)
+      end
+
+      def unwrap(value)
+        case value
+        when Hash
+          return value[AJ_GLOBALID] if value.key?(AJ_GLOBALID)
+          return unwrap(value["value"]) if value.key?(AJ_SERIALIZED) && value.key?("value")
+
+          value.each_with_object({}) do |(k, v), out|
+            next if k.to_s.start_with?(AJ_META_PREFIX)
+
+            out[k] = unwrap(v)
+          end
+        when Array
+          value.map { |v| unwrap(v) }
+        else
+          value
+        end
+      end
+
+      def parse(payload)
+        case payload
+        when Hash then payload
+        when String then JSON.parse(payload)
+        end
+      rescue JSON::ParserError
+        nil
+      end
+      private_class_method :parse
+    end
+  end
+end

data/lib/pgbus.rb

@@ -49,6 +49,8 @@ module Pgbus
   # comes back with a msg_id count that doesn't match the number of jobs sent —
   # a data-integrity signal that some jobs may not have been persisted.
   class EnqueueError < Error; end
+  # A Current attribute could not be serialized for job persistence (issue #430).
+  class CurrentAttributesError < Error; end
 
   # Raised by the execution pools when work can't be accepted: the pool is
   # shutting down, or it's momentarily at capacity. Consumer-reachable during

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgbus
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.15.0
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -150,6 +150,7 @@ files:
 - app/helpers/pgbus/streams_helper.rb
 - app/models/pgbus/application_record.rb
 - app/models/pgbus/batch_entry.rb
+- app/models/pgbus/batch_execution.rb
 - app/models/pgbus/blocked_execution.rb
 - app/models/pgbus/job_stat.rb
 - app/models/pgbus/outbox_entry.rb
@@ -210,6 +211,8 @@ files:
 - exe/pgbus
 - exe/pgbus-health
 - lib/active_job/queue_adapters/pgbus_adapter.rb
+- lib/generators/pgbus/add_batch_callback_jobs_generator.rb
+- lib/generators/pgbus/add_batch_executions_generator.rb
 - lib/generators/pgbus/add_failed_events_index_generator.rb
 - lib/generators/pgbus/add_job_stats_generator.rb
 - lib/generators/pgbus/add_job_stats_latency_generator.rb
@@ -225,6 +228,8 @@ files:
 - lib/generators/pgbus/install_generator.rb
 - lib/generators/pgbus/migrate_job_locks_generator.rb
 - lib/generators/pgbus/migration_path.rb
+- lib/generators/pgbus/templates/add_batch_callback_jobs.rb.erb
+- lib/generators/pgbus/templates/add_batch_executions.rb.erb
 - lib/generators/pgbus/templates/add_failed_events_unique_index.rb.erb
 - lib/generators/pgbus/templates/add_job_stats.rb.erb
 - lib/generators/pgbus/templates/add_job_stats_latency.rb.erb
@@ -251,9 +256,12 @@ files:
 - lib/generators/pgbus/upgrade_pgmq_generator.rb
 - lib/pgbus.rb
 - lib/pgbus/active_job/adapter.rb
+- lib/pgbus/active_job/batch_id.rb
+- lib/pgbus/active_job/current_attributes.rb
 - lib/pgbus/active_job/executor.rb
 - lib/pgbus/autovacuum_tuning.rb
 - lib/pgbus/batch.rb
+- lib/pgbus/batch/sweep.rb
 - lib/pgbus/bus_record.rb
 - lib/pgbus/circuit_breaker.rb
 - lib/pgbus/cli.rb
@@ -262,6 +270,7 @@ files:
 - lib/pgbus/client.rb
 - lib/pgbus/client/connection_health.rb
 - lib/pgbus/client/ensure_stream_queue.rb
+- lib/pgbus/client/fair_read.rb
 - lib/pgbus/client/notify_stream.rb
 - lib/pgbus/client/read_after.rb
 - lib/pgbus/client/resizable_pool.rb
@@ -270,6 +279,7 @@ files:
 - lib/pgbus/concurrency/semaphore.rb
 - lib/pgbus/configuration.rb
 - lib/pgbus/configuration/capsule_dsl.rb
+- lib/pgbus/current_attributes.rb
 - lib/pgbus/database_tasks_guard.rb
 - lib/pgbus/dedicated_connection.rb
 - lib/pgbus/dedup_cache.rb
@@ -285,6 +295,7 @@ files:
 - lib/pgbus/execution_pools/async_pool.rb
 - lib/pgbus/execution_pools/thread_pool.rb
 - lib/pgbus/failed_event_recorder.rb
+- lib/pgbus/fair_share.rb
 - lib/pgbus/generators/database_target_detector.rb
 - lib/pgbus/generators/migration_detector.rb
 - lib/pgbus/health_probe.rb
@@ -387,6 +398,7 @@ files:
 - lib/pgbus/web/data_source.rb
 - lib/pgbus/web/health_app.rb
 - lib/pgbus/web/health_server.rb
+- lib/pgbus/web/job_context.rb
 - lib/pgbus/web/metrics_serializer.rb
 - lib/pgbus/web/payload_filter.rb
 - lib/pgbus/web/stream_app.rb