pgbus 0.21.0 → 0.21.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c3c6921f17cfc002f7177240a3d1b2c202a78c7127e8f0da75a75ebcaf365d1
-  data.tar.gz: b73396771876a230b1b62b6b30dceb87329be7259810c5346fd4a3fc78f59991
+  metadata.gz: 59ff2a591041f47789d41f241c5496534dbba5314ebb37a0c2fe41286f611587
+  data.tar.gz: 9f8b3c5a4f88330b96cd6ecab5d4dfe18580d48765b3aa50873e3f54150f63b1
 SHA512:
-  metadata.gz: 5667ec2a6ebd1ef9e09f5f89818e69784267b3aa0c13a0b5cef2782b346af2361c106454fbb58d67a688b48f451483327fa4f3edc0a1d9a82664aa599af52454
-  data.tar.gz: 83d7a44001fe09db593caacc788307198361279c023b7ed2ed8397fdec17fb353fa44087d9a973857951835d6cb1206314ade872a99d85586988561be2477a85
+  metadata.gz: 76c28daff8340ec68e0cf5b0b7f9a69ad48b1d024d65ff9af37fbc734167a8b710afca0b1fce9163783b43e022f0d8e6d4d465219aa91282b52eb69d770e969b
+  data.tar.gz: 8f2b9d1f6c4f899c64a9dd0fa1918b64e158799e6172bb0e42cf7beac6ca191675e5df9c31e90eaa62c4f1714c6c55eb317612e8d7b6047ab3e069d5bbab6046

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+### Fixed
+
+- **The dashboard's Retry, Discard and Discard all reach a failed job's message under priority routing (issue #577).** A failed-job row records the logical queue only, and with `priority_levels > 1` the message sits in a `_pN` sub-queue, never in the base table. Retry reset the visibility timeout on `pgmq.q_pgbus_<queue>`, which priority routing never creates, and answered "Could not retry job."; Discard and Discard all archived from that same table, so they reported the job discarded while its message stayed queued and ran again. Each sub-queue also numbers its messages from its own sequence, so the msg_id alone could name another job's message in a sibling sub-queue. The dashboard now finds the sub-queue whose message has the row's msg_id and carries the job's `job_id` (`Pgbus::Client#locate_message`, which returns that physical table or nil, and `#locate_messages` for many at once, one query per table), resets or archives the message there, and leaves a same-numbered message elsewhere alone. Discard all locates a queue's messages together and archives them in one batch per table. When no sub-queue holds it, Retry enqueues a fresh copy as before. Without priority routing there is one table and nothing changes, except that a message reusing the msg_id under another `job_id` is no longer reset or archived in the job's place. Refs #577.
+
 ## [0.21.0] - 2026-10-19
 
 ### Added
@@ -11,11 +15,15 @@
 ### Changed
 
 - **`actor:` and `reason:` are reserved keywords of `Pgbus::Workflow.start!` (issue #571).** Like `idempotency_key:`, they are taken for the audit trail and no longer reach the run's `arguments`. A workflow that receives an argument literally named `actor` or `reason` through `start!` renames it, e.g. `start!(subject, requested_by: "alice")` read as `arguments[:requested_by]`. Runs already started keep their stored arguments, and `rerun!` copies them as stored. Refs #571.
+- **`Pgbus::Client#message_exists?`, `#message_in_queue?`, `#message_archived?`, `#message_with_job_id?` and `#dead_letter_physical_name` take a logical queue name unless you pass `prefixed: false` (issue #569).** They used to guess that a name starting with `"#{queue_prefix}_"` was already physical. **If you call one of them with a physical table name, add `prefixed: false`;** without it the name is prefixed again. Under priority routing two of them also answer differently for a logical name: `message_archived?` probes every `_pN` archive (it probed a base table that priority routing never creates, and answered nil), and `dead_letter_physical_name` keeps a logical name's own `_pN` suffix (`orders_p2` → `…_orders_p2_dlq`, the queue `move_to_dead_letter` writes), stripping it only from a physical sub-queue name passed with `prefixed: false`.
+- **The batch completion callback is `on_complete`.** `Pgbus::Batch.new(on_complete:)`, the builder's `b.on_complete` and the `#on_complete` reader replace `on_finish`, which keeps working as a deprecated alias until 1.0 and logs one warning per process. The database columns stay `on_finish_class` / `on_finish_job` until the 1.0 schema cleanup, so batches created before upgrading still fire, and the `pgbus.batch_finished` instrumentation event keeps its name. The dashboard's batch page labels the callback "On Complete". Refs #538.
+
 
 ### Fixed
 
 - **The workflows one-ongoing index predicate dumps the same `schema.rb` line from a migrated and from a schema-loaded database (issue #573).** `pgbus:add_workflows` and the fresh-install migration declared `idx_pgbus_workflows_one_ongoing` with `where: "status IN ('ready','performing','waiting','paused')"`. `status` is a `varchar`, so Postgres stored the list as `varchar` literals cast to `text[]`; `db:schema:load` parses that dumped string into a different expression, and each later dump flipped the line depending on which kind of database it came from. Both templates now write `status::text IN (…)`, whose stored form replays to itself. The index means the same either way, so existing installs need nothing. An app that wants a stable dump can recreate the index in a migration of its own: `remove_index :pgbus_workflows, name: "idx_pgbus_workflows_one_ongoing"`, then `add_index :pgbus_workflows, [:workflow_class, :subject_type, :subject_id], unique: true, where: "status::text IN ('ready','performing','waiting','paused')", name: "idx_pgbus_workflows_one_ongoing"` (both run in the migration's transaction, so the constraint never lapses; `remove_index` takes an ACCESS EXCLUSIVE lock, so `pgbus_workflows` is locked against reads and writes (workers, workflow starts and the dashboard wait) until the migration commits), and dump the schema again. Refs #573.
 - **A guard that ends a `wait_for:` step after a reattempt consumes the signal the step holds (issue #572).** A woken attempt that called `reattempt!` (or failed into a pause and was resumed) kept its signal `claimed` for the next attempt, whose row carries no `signal_id` until its gate runs. When `cancel_if` or `skip_if` ended that next attempt (or a guard raised and its `on_exception` policy skipped or cancelled, or a deploy had declared the step a `removed_step` meanwhile), the signal stayed `claimed` forever. The attempt now records the held signal before its outcome, so it is consumed when the step ends and kept when it reattempts or pauses, as for any attempt. Refs #572.
+- **A queue whose logical name starts with the prefix is probed in its own table (issue #569).** `Pgbus::Client#message_exists?`, `#message_in_queue?`, `#message_archived?`, `#message_with_job_id?` and `#dead_letter_physical_name` decided whether a name was already physical by `name.start_with?("#{queue_prefix}_")`, so a logical `pgbus_mailers` (table `pgbus_pgbus_mailers`) was probed as `pgmq.q_pgbus_mailers`. The answer was "unknown", or another queue's answer when that table existed. The dispatcher kept an orphaned uniqueness lock under such a queue forever. The dashboard's failed-event Retry enqueued a copy next to the original message. The batch sweep kept an orphan execution row forever, or un-counted a dead-lettered job. The name's spelling no longer decides anything: these methods take a logical name, expanded through `config.queue_name` and the queue strategy, unless the caller passes `prefixed: false` for a physical table name. This is the `prefixed:` convention `delete_message`, `archive_message`, `set_visibility_timeout`, `purge_queue` and `drop_queue` already follow. `message_archived?` now also expands a logical name to every `_pN` archive under priority routing, as `message_exists?` already did; before, it probed a base table that does not exist there. The batch sweep now passes `prefixed: false` for a backfilled execution row (it holds the table its message went to) and the logical name for an orphan row. The caller-facing change is under Changed.
 
 ## [0.20.1] - 2026-10-18
 

data/lib/pgbus/batch/sweep.rb

@@ -38,14 +38,17 @@ module Pgbus
           swept
         end
 
+        # A row with a msg_id was backfilled with the physical table its message
+        # was sent to (the `_pN` sub-queue under priority routing), so every
+        # probe takes that name as is.
         def classify_stale(row, client)
-          in_queue = client.message_in_queue?(row.queue_name, msg_id: row.msg_id)
+          in_queue = client.message_in_queue?(row.queue_name, msg_id: row.msg_id, prefixed: false)
           return :still_present if in_queue != false
 
-          dlq = client.dead_letter_physical_name(row.queue_name)
-          return :failed if client.message_with_job_id?(dlq, job_id: row.job_id) == true
+          dlq = client.dead_letter_physical_name(row.queue_name, prefixed: false)
+          return :failed if client.message_with_job_id?(dlq, job_id: row.job_id, prefixed: false) == true
 
-          return :completed if client.message_archived?(row.queue_name, msg_id: row.msg_id) == true
+          return :completed if client.message_archived?(row.queue_name, msg_id: row.msg_id, prefixed: false) == true
 
           Pgbus.logger.warn do
             "[Pgbus] Batch execution #{row.job_id} (batch #{row.batch_id}) has no queue, " \
@@ -84,6 +87,8 @@ module Pgbus
           swept
         end
 
+        # A row without a msg_id still holds the logical queue name it was
+        # inserted with (the job's queue_name); the backfill was never applied.
         def classify_orphan(row, client)
           return :live if row.queue_name.nil?
 
@@ -91,7 +96,7 @@ module Pgbus
           return :live if in_queue != false
 
           dlq = client.dead_letter_physical_name(row.queue_name)
-          return :failed if client.message_with_job_id?(dlq, job_id: row.job_id) == true
+          return :failed if client.message_with_job_id?(dlq, job_id: row.job_id, prefixed: false) == true
 
           :orphan
         end

data/lib/pgbus/client.rb

@@ -720,16 +720,24 @@ module Pgbus
     # reaper to determine if a uniqueness lock with msg_id=0 (placeholder)
     # still has a corresponding queue message.
     #
-    # +queue_name+ may be either a logical name (e.g. "default") or an already
-    # prefixed physical name (e.g. "pgbus_default"). The client normalizes both.
+    # +queue_name+ is a logical name (e.g. "default"), expanded through the
+    # queue strategy, unless the caller passes +prefixed: false+ for a physical
+    # table name (e.g. "pgbus_default_p1"), used as is. The name's spelling
+    # decides nothing: a logical "pgbus_mailers" lives in pgbus_pgbus_mailers
+    # (issue #569).
     #
     # Returns:
     #   true  — the message definitely exists in the queue
     #   false — the message definitely does not exist
     #   nil   — could not determine (e.g. queue table missing or unknown error).
     #           Callers MUST treat nil as "exists" for safety.
-    def message_in_queue?(queue_name, msg_id:)
-      message_exists?(queue_name, msg_id: msg_id)
+    #
+    # Under priority routing a logical name probes every `_pN` table, and each
+    # table has its own msg_id sequence: a bare +msg_id+ may match a different
+    # message in a sibling sub-queue. A caller that knows the sub-queue passes
+    # its physical name with +prefixed: false+.
+    def message_in_queue?(queue_name, msg_id:, prefixed: true)
+      message_exists?(queue_name, msg_id: msg_id, prefixed: prefixed)
     end
 
     # Look up a queue row by ActiveJob job_id in the JSON payload. Used by the
@@ -738,10 +746,10 @@ module Pgbus
     #
     # Same tri-state as message_exists?: true / false / nil (unknown). A
     # logical name expands to every physical table the strategy owns (the
-    # `_pN` sub-queues under priority routing); an already-prefixed physical
-    # name probes itself only.
-    def message_with_job_id?(queue_name, job_id:)
-      tables = lookup_physical_queue_names(queue_name).map { |name| QueueNameValidator.sanitize!(name) }
+    # `_pN` sub-queues under priority routing); a physical name passed with
+    # +prefixed: false+ probes itself only.
+    def message_with_job_id?(queue_name, job_id:, prefixed: true)
+      tables = lookup_physical_queue_names(queue_name, prefixed: prefixed).map { |name| QueueNameValidator.sanitize!(name) }
       determined = false
 
       synchronized do
@@ -758,43 +766,85 @@ module Pgbus
       determined ? false : nil # rubocop:disable Style/ReturnNilInPredicateMethodDefinition -- tri-state: nil means unknown
     end
 
-    # DLQ companion of a logical or already-physical queue name. Does not
-    # re-prefix a name that resolve_full_queue_name already expanded.
-    def dead_letter_physical_name(queue_name)
-      full = resolve_full_queue_name(queue_name)
+    # The physical table that holds message +msg_id+, or nil when none does.
+    # See locate_messages.
+    def locate_message(queue_name, msg_id:, job_id: nil, prefixed: true)
+      locate_messages(queue_name, [[msg_id, job_id]], prefixed: prefixed)[msg_id.to_i]
+    end
+
+    # { msg_id => physical table } for each [msg_id, job_id] pair whose
+    # message is queued, one query per table on one connection. A logical
+    # name expands to every table the strategy owns, and under priority
+    # routing each `_pN` sub-queue numbers its messages from its own
+    # sequence: only a message carrying the pair's job_id matches, or any
+    # message with that msg_id when job_id is nil, the first table winning
+    # (issue #577). A physical name with +prefixed: false+ is probed alone.
+    # A table that does not exist holds nothing; other errors raise.
+    def locate_messages(queue_name, messages, prefixed: true)
+      wanted = messages.to_h { |msg_id, job_id| [msg_id.to_i, job_id&.to_s] }
+      tables = lookup_physical_queue_names(queue_name, prefixed: prefixed)
+      located = {}
+
+      synchronized do
+        with_raw_connection do |conn|
+          tables.each do |name|
+            pending = wanted.keys - located.keys
+            break if pending.empty?
+
+            queued_job_ids(conn, QueueNameValidator.sanitize!(name), pending).each do |row|
+              msg_id = row["msg_id"].to_i
+              job_id = wanted[msg_id]
+              located[msg_id] ||= name if job_id.nil? || row["job_id"] == job_id
+            end
+          end
+        end
+      end
+
+      located
+    end
+
+    # DLQ companion of a logical queue name, or of a physical table name passed
+    # with +prefixed: false+.
+    def dead_letter_physical_name(queue_name, prefixed: true)
+      return config.dead_letter_queue_name(queue_name) if prefixed
+
       # Priority sub-queues share the logical queue's DLQ (`pgbus_default_dlq`),
-      # not a per-priority `…_pN_dlq`. Only strip when the strategy actually
-      # creates `_pN` tables — a logical queue named `orders_p0` must keep it.
-      base = @queue_strategy.priority? ? full.sub(/_p\d+\z/, "") : full
+      # not a per-priority `…_pN_dlq`. Only a physical name can be a sub-queue,
+      # and only when the strategy actually creates `_pN` tables: a logical
+      # queue named `orders_p0` keeps its suffix.
+      name = queue_name.to_s
+      base = @queue_strategy.priority? ? name.sub(/_p\d+\z/, "") : name
       "#{base}#{Pgbus::DEAD_LETTER_SUFFIX}"
     end
 
     # Same tri-state as message_exists?: true / false / nil (unknown).
-    def message_archived?(queue_name, msg_id:)
-      full_name = resolve_full_queue_name(queue_name)
-      sanitized = QueueNameValidator.sanitize!(full_name)
+    # A logical name probes the archive of every physical table the strategy
+    # owns, like message_exists?; a physical name (prefixed: false) its own.
+    # A bare msg_id is unique per table only (see message_in_queue?).
+    def message_archived?(queue_name, msg_id:, prefixed: true)
+      tables = lookup_physical_queue_names(queue_name, prefixed: prefixed).map { |name| QueueNameValidator.sanitize!(name) }
+      determined = false
 
       synchronized do
         with_raw_connection do |conn|
-          msg_id_archived?(conn, sanitized, msg_id.to_i)
+          tables.each do |sanitized|
+            archived = probe_archive_presence(conn, sanitized, msg_id.to_i)
+            return true if archived == true
+
+            determined = true unless archived == :missing
+          end
         end
       end
-    rescue ActiveRecord::StatementInvalid => e
-      raise unless undefined_table_error?(e)
-
-      nil
-    rescue StandardError => e
-      raise unless defined?(PG::UndefinedTable) && e.is_a?(PG::UndefinedTable)
 
-      nil
+      determined ? false : nil # rubocop:disable Style/ReturnNilInPredicateMethodDefinition -- tri-state: nil means unknown
     end
 
-    def message_exists?(queue_name, msg_id: nil, uniqueness_key: nil)
+    def message_exists?(queue_name, msg_id: nil, uniqueness_key: nil, prefixed: true)
       has_msg_id = !msg_id.nil?
       has_uniqueness_key = !uniqueness_key.nil?
       raise ArgumentError, "pass msg_id, uniqueness_key, or both" unless has_msg_id || has_uniqueness_key
 
-      tables = lookup_physical_queue_names(queue_name).map { |name| QueueNameValidator.sanitize!(name) }
+      tables = lookup_physical_queue_names(queue_name, prefixed: prefixed).map { |name| QueueNameValidator.sanitize!(name) }
       determined = false
 
       synchronized do
@@ -1092,21 +1142,10 @@ module Pgbus
       end
     end
 
-    # Accept either a logical name ("default") or an already-prefixed
-    # physical name ("pgbus_default") and return the physical name.
-    # Coerces symbols to strings so callers can pass either form.
-    def resolve_full_queue_name(queue_name)
-      name = queue_name.to_s
-      prefix = "#{config.queue_prefix}_"
-      name.start_with?(prefix) ? name : config.queue_name(name)
-    end
-
     # Logical names expand through QueueFactory so a priority queue's _pN
-    # tables are included; already-prefixed physical names stay as-is.
-    def lookup_physical_queue_names(queue_name)
-      name = queue_name.to_s
-      prefix = "#{config.queue_prefix}_"
-      name.start_with?(prefix) ? [name] : @queue_strategy.physical_queue_names(name)
+    # tables are included; a physical name (prefixed: false) stays as is.
+    def lookup_physical_queue_names(queue_name, prefixed:)
+      prefixed ? @queue_strategy.physical_queue_names(queue_name.to_s) : [queue_name.to_s]
     end
 
     def probe_queue_presence(conn, sanitized, msg_id:, uniqueness_key:)
@@ -1125,6 +1164,18 @@ module Pgbus
       :missing
     end
 
+    def probe_archive_presence(conn, sanitized, msg_id)
+      msg_id_archived?(conn, sanitized, msg_id)
+    rescue ActiveRecord::StatementInvalid => e
+      raise unless undefined_table_error?(e)
+
+      :missing
+    rescue StandardError => e
+      raise unless defined?(PG::UndefinedTable) && e.is_a?(PG::UndefinedTable)
+
+      :missing
+    end
+
     def probe_job_id_presence(conn, sanitized, job_id)
       job_id_present?(conn, sanitized, job_id)
     rescue ActiveRecord::StatementInvalid => e
@@ -1137,6 +1188,22 @@ module Pgbus
       :missing
     end
 
+    # msg_ids are integers, so the array literal is safe.
+    def queued_job_ids(conn, sanitized, msg_ids)
+      conn.exec_params(
+        "SELECT msg_id, message::jsonb ->> 'job_id' AS job_id FROM pgmq.q_#{sanitized} WHERE msg_id = ANY($1::bigint[])",
+        ["{#{msg_ids.join(",")}}"]
+      )
+    rescue ActiveRecord::StatementInvalid => e
+      raise unless undefined_table_error?(e)
+
+      []
+    rescue StandardError => e
+      raise unless defined?(PG::UndefinedTable) && e.is_a?(PG::UndefinedTable)
+
+      []
+    end
+
     def scan_uniqueness_keys(conn, sanitized, keys, found)
       placeholders = keys.each_index.map { |i| "$#{i + 1}" }.join(", ")
       result = conn.exec_params(

data/lib/pgbus/version.rb

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

data/lib/pgbus/web/data_source.rb

@@ -299,9 +299,9 @@ module Pgbus
         # duplicate (the original is still in the queue waiting for retry).
         # Falls back to enqueueing a fresh copy only if the original is gone
         # (e.g., already moved to DLQ).
-        msg_id = event["msg_id"]
-        if msg_id && @client.message_exists?(event["queue_name"], msg_id: msg_id.to_i)
-          @client.set_visibility_timeout(event["queue_name"], msg_id.to_i, vt: 0)
+        physical = failed_message_queue(event)
+        if physical
+          @client.set_visibility_timeout(physical, event["msg_id"].to_i, vt: 0, prefixed: false)
         else
           payload = JSON.parse(event["payload"])
           headers = event["headers"]
@@ -1721,12 +1721,29 @@ module Pgbus
         nil
       end
 
+      # The physical queue holding a failed job's message, or nil when it is
+      # gone. The row records the logical queue only, and under priority
+      # routing a msg_id repeats across the _pN sub-queues, so the job's
+      # job_id must match too (issue #577). Two sub-queues' failures with the
+      # same msg_id share one row, which keeps the first one's payload: that
+      # is the message found (issue #583).
+      def failed_message_queue(event)
+        return unless event["queue_name"] && event["msg_id"]
+
+        @client.locate_message(event["queue_name"], msg_id: event["msg_id"].to_i, job_id: failed_job_id(event))
+      end
+
+      def failed_job_id(event)
+        payload = event["payload"]
+        payload = JSON.parse(payload) if payload.is_a?(String)
+        payload["job_id"] if payload.is_a?(Hash)
+      end
+
       # Archive the queue message a failed_event row points to. Idempotent —
       # silently no-ops if the message no longer exists in the queue.
       def archive_failed_message(event)
-        return unless event["queue_name"] && event["msg_id"]
-
-        @client.archive_message(event["queue_name"], event["msg_id"].to_i)
+        physical = failed_message_queue(event)
+        @client.archive_message(physical, event["msg_id"].to_i, prefixed: false) if physical
       rescue StandardError => e
         Pgbus.logger.debug do
           "[Pgbus::Web] Error archiving message for failed event #{event["id"]}: #{e.message}"
@@ -1734,30 +1751,30 @@ module Pgbus
       end
 
       # Archive every queue message referenced by a failed_event row.
-      # Groups by queue and uses archive_batch so an N-event discard is
-      # one SQL statement per queue instead of N per-row roundtrips.
-      # Falls back to per-row archive inside a rescue if a batch fails,
-      # so one bad queue can't block progress on the others.
+      # Groups by queue, then locates and archive_batches per physical table,
+      # so an N-event discard is two SQL statements per table instead of N
+      # per-row roundtrips. Falls back to per-row archive inside a rescue if
+      # a batch fails, so one bad queue can't block progress on the others.
       def archive_all_failed_messages
         rows = connection.select_all(
-          "SELECT id, queue_name, msg_id FROM pgbus_failed_events WHERE msg_id IS NOT NULL AND #{NOT_HANDLER_QUEUE}",
+          "SELECT id, queue_name, msg_id, payload FROM pgbus_failed_events WHERE msg_id IS NOT NULL AND #{NOT_HANDLER_QUEUE}",
           "Pgbus Collect Failed Messages", [handler_queue_names_literal]
         )
 
         grouped = rows.to_a.group_by { |row| row["queue_name"] }
         grouped.each do |queue_name, events|
-          msg_ids = events.filter_map { |row| row["msg_id"]&.to_i }
-          next if msg_ids.empty?
-
-          begin
-            @client.archive_batch(queue_name, msg_ids)
-          rescue StandardError => e
-            Pgbus.logger.debug do
-              "[Pgbus::Web] archive_batch failed for #{queue_name} (#{e.message}); " \
-                "falling back to per-row archive"
-            end
-            events.each { |row| archive_failed_message(row) }
+          # A priority queue's msg_ids repeat across its _pN sub-queues, so
+          # each message is located first and archived from its own table.
+          located = @client.locate_messages(queue_name, events.map { |row| [row["msg_id"].to_i, failed_job_id(row)] })
+          located.group_by { |_msg_id, physical| physical }.each do |physical, pairs|
+            @client.archive_batch(physical, pairs.map(&:first), prefixed: false)
+          end
+        rescue StandardError => e
+          Pgbus.logger.debug do
+            "[Pgbus::Web] archive_batch failed for #{queue_name} (#{e.message}); " \
+              "falling back to per-row archive"
           end
+          events.each { |row| archive_failed_message(row) }
         end
       rescue StandardError => e
         Pgbus.logger.debug { "[Pgbus::Web] Error archiving failed messages: #{e.message}" }

data/sig/pgbus/client.rbs

@@ -13,7 +13,7 @@ module Pgbus
     def convert_archive_partitioned: (untyped queue_name, ?partition_interval: untyped, ?retention_interval: untyped, ?leading_partition: untyped) -> untyped
     def create_fifo_index: (untyped queue_name) -> untyped
     def create_fifo_indexes_all: () -> untyped
-    def dead_letter_physical_name: (untyped queue_name) -> untyped
+    def dead_letter_physical_name: (untyped queue_name, ?prefixed: untyped) -> untyped
     def delete_batch: (untyped queue_name, untyped msg_ids, ?prefixed: untyped) -> untyped
     def delete_message: (untyped queue_name, untyped msg_id, ?prefixed: untyped) -> untyped
     def drop_queue: (untyped queue_name, ?prefixed: untyped) -> untyped
@@ -25,10 +25,12 @@ module Pgbus
     def in_recovery?: () -> bool
     def list_notify_insert_throttles: () -> untyped
     def list_queues: () -> untyped
-    def message_archived?: (untyped queue_name, msg_id: untyped) -> bool
-    def message_exists?: (untyped queue_name, ?msg_id: untyped, ?uniqueness_key: untyped) -> bool
-    def message_in_queue?: (untyped queue_name, msg_id: untyped) -> bool
-    def message_with_job_id?: (untyped queue_name, job_id: untyped) -> bool
+    def locate_message: (untyped queue_name, msg_id: untyped, ?job_id: untyped, ?prefixed: untyped) -> String?
+    def locate_messages: (untyped queue_name, Array[[untyped, untyped]] messages, ?prefixed: untyped) -> Hash[Integer, String]
+    def message_archived?: (untyped queue_name, msg_id: untyped, ?prefixed: untyped) -> bool?
+    def message_exists?: (untyped queue_name, ?msg_id: untyped, ?uniqueness_key: untyped, ?prefixed: untyped) -> bool?
+    def message_in_queue?: (untyped queue_name, msg_id: untyped, ?prefixed: untyped) -> bool?
+    def message_with_job_id?: (untyped queue_name, job_id: untyped, ?prefixed: untyped) -> bool?
     def metrics: (?untyped queue_name) -> untyped
     def move_to_dead_letter: (untyped queue_name, untyped message, ?headers: untyped) -> untyped
     def notify_enabled?: (untyped queue_name) -> bool

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgbus
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.21.1
 platform: ruby
 authors:
 - Mikael Henriksson