pgbus 0.6.7 → 0.6.9

data/lib/generators/pgbus/install_generator.rb

@@ -2,11 +2,13 @@
 
 require "rails/generators"
 require "rails/generators/active_record"
+require_relative "migration_path"
 
 module Pgbus
   module Generators
     class InstallGenerator < Rails::Generators::Base
       include ActiveRecord::Generators::Migration
+      include MigrationPath
 
       source_root File.expand_path("templates", __dir__)
 
@@ -25,13 +27,8 @@ module Pgbus
                          "Migrations go to db/pgbus_migrate/ and schema to db/pgbus_schema.rb"
 
       def create_migration_file
-        if separate_database?
-          migration_template "migration.rb.erb",
-                             "db/pgbus_migrate/create_pgbus_tables.rb"
-        else
-          migration_template "migration.rb.erb",
-                             "db/migrate/create_pgbus_tables.rb"
-        end
+        migration_template "migration.rb.erb",
+                           File.join(pgbus_migrate_path, "create_pgbus_tables.rb")
       end
 
       def create_config_file
@@ -121,10 +118,6 @@ module Pgbus
       def database_name
         options[:database]
       end
-
-      def separate_database?
-        database_name.present?
-      end
     end
   end
 end

data/lib/generators/pgbus/migrate_job_locks_generator.rb

@@ -2,11 +2,13 @@
 
 require "rails/generators"
 require "rails/generators/active_record"
+require_relative "migration_path"
 
 module Pgbus
   module Generators
     class MigrateJobLocksGenerator < Rails::Generators::Base
       include ActiveRecord::Generators::Migration
+      include MigrationPath
 
       source_root File.expand_path("templates", __dir__)
 
@@ -18,13 +20,8 @@ module Pgbus
                    desc: "Use a separate database for pgbus tables (e.g. --database=pgbus)"
 
       def create_migration_file
-        if separate_database?
-          migration_template "migrate_job_locks_to_uniqueness_keys.rb.erb",
-                             "db/pgbus_migrate/migrate_pgbus_job_locks_to_uniqueness_keys.rb"
-        else
-          migration_template "migrate_job_locks_to_uniqueness_keys.rb.erb",
-                             "db/migrate/migrate_pgbus_job_locks_to_uniqueness_keys.rb"
-        end
+        migration_template "migrate_job_locks_to_uniqueness_keys.rb.erb",
+                           File.join(pgbus_migrate_path, "migrate_pgbus_job_locks_to_uniqueness_keys.rb")
       end
 
       def display_post_install
@@ -47,10 +44,6 @@ module Pgbus
       def migration_version
         "[#{ActiveRecord::Migration.current_version}]"
       end
-
-      def separate_database?
-        options[:database].present?
-      end
     end
   end
 end

data/lib/generators/pgbus/migration_path.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module Generators
+    # Shared migration path logic for all pgbus generators.
+    #
+    # When --database is passed, uses Rails' built-in db_migrate_path which
+    # reads migrations_paths from database.yml. This is the standard Rails
+    # multi-database mechanism and respects custom paths like db/pgbus_migrate/.
+    #
+    # Falls back to db/migrate/ when no --database is set (single-database mode).
+    module MigrationPath
+      private
+
+      def pgbus_migrate_path
+        if separate_database?
+          db_migrate_path
+        else
+          "db/migrate"
+        end
+      end
+
+      def separate_database?
+        options[:database].present?
+      end
+    end
+  end
+end

data/lib/generators/pgbus/templates/migration.rb.erb

@@ -150,6 +150,12 @@ class CreatePgbusTables < ActiveRecord::Migration<%= migration_version %>
     # Create default queues via PGMQ
     execute "SELECT pgmq.create('pgbus_default')"
     execute "SELECT pgmq.create('pgbus_default_dlq')"
+
+    # Tune autovacuum for queue/archive tables and high-churn pgbus tables.
+    # Default settings are too conservative for the insert/delete churn of
+    # queue processing and concurrency lock management.
+    execute Pgbus::AutovacuumTuning.sql_for_all_queues
+    execute Pgbus::AutovacuumTuning.sql_for_high_churn_tables
   end
 
   def down

data/lib/generators/pgbus/templates/tune_autovacuum.rb.erb

@@ -0,0 +1,38 @@
+class TunePgbusAutovacuum < ActiveRecord::Migration<%= migration_version %>
+  def up
+    # Apply aggressive autovacuum settings to all existing PGMQ queue and
+    # archive tables. Queue tables have very high insert/delete churn from
+    # the read→process→archive cycle; default autovacuum settings (vacuum
+    # at 20% dead tuples) allow dead tuple accumulation that bloats indexes
+    # and degrades lock acquisition times.
+    #
+    # New queues created after this migration automatically receive these
+    # settings via Pgbus::Client at queue creation time.
+    execute Pgbus::AutovacuumTuning.sql_for_all_queues
+
+    # Also tune pgbus-owned tables with high write churn:
+    # - pgbus_semaphores: rapid upsert+increment per job, periodic expiry
+    # - pgbus_uniqueness_keys: INSERT on enqueue, DELETE on completion
+    # - pgbus_processed_events: INSERT per event, bulk DELETE on TTL expiry
+    execute Pgbus::AutovacuumTuning.sql_for_high_churn_tables
+  end
+
+  def down
+    # Reset to PostgreSQL defaults
+    execute <<~SQL
+      DO $$
+      DECLARE
+        q RECORD;
+      BEGIN
+        FOR q IN SELECT queue_name FROM pgmq.meta LOOP
+          EXECUTE format('ALTER TABLE pgmq.q_%I RESET (autovacuum_vacuum_scale_factor, autovacuum_vacuum_cost_delay, autovacuum_analyze_scale_factor)', q.queue_name);
+          EXECUTE format('ALTER TABLE pgmq.a_%I RESET (autovacuum_vacuum_scale_factor, autovacuum_vacuum_cost_delay, autovacuum_analyze_scale_factor)', q.queue_name);
+        END LOOP;
+      END $$;
+    SQL
+
+    Pgbus::AutovacuumTuning::HIGH_CHURN_TABLES.each do |table|
+      execute "ALTER TABLE #{table} RESET (autovacuum_vacuum_scale_factor, autovacuum_vacuum_cost_delay, autovacuum_analyze_scale_factor)"
+    end
+  end
+end

data/lib/generators/pgbus/tune_autovacuum_generator.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+require_relative "migration_path"
+
+module Pgbus
+  module Generators
+    class TuneAutovacuumGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+      include MigrationPath
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Tune autovacuum settings on PGMQ queue and archive tables for optimal queue health"
+
+      class_option :database,
+                   type: :string,
+                   default: nil,
+                   desc: "Use a separate database for pgbus tables (e.g. --database=pgbus)"
+
+      def create_migration_file
+        migration_template "tune_autovacuum.rb.erb",
+                           File.join(pgbus_migrate_path, "tune_pgbus_autovacuum.rb")
+      end
+
+      def display_post_install
+        say ""
+        say "Pgbus autovacuum tuning migration created!", :green
+        say ""
+        say "This migration applies aggressive autovacuum settings to all existing"
+        say "PGMQ queue and archive tables. New queues created at runtime will"
+        say "automatically receive these settings."
+        say ""
+        say "Next steps:"
+        say "  1. Run: rails db:migrate#{":#{options[:database]}" if separate_database?}"
+        say "  2. Restart pgbus: bin/pgbus start"
+        say ""
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::Migration.current_version}]"
+      end
+    end
+  end
+end

data/lib/generators/pgbus/upgrade_pgmq_generator.rb

@@ -2,11 +2,13 @@
 
 require "rails/generators"
 require "rails/generators/active_record"
+require_relative "migration_path"
 
 module Pgbus
   module Generators
     class UpgradePgmqGenerator < Rails::Generators::Base
       include ActiveRecord::Generators::Migration
+      include MigrationPath
 
       source_root File.expand_path("templates", __dir__)
 
@@ -18,13 +20,8 @@ module Pgbus
                    desc: "Use a separate database for pgbus tables (e.g. --database=pgbus)"
 
       def create_migration_file
-        if separate_database?
-          migration_template "upgrade_pgmq.rb.erb",
-                             "db/pgbus_migrate/upgrade_pgmq_to_v#{target_version_slug}.rb"
-        else
-          migration_template "upgrade_pgmq.rb.erb",
-                             "db/migrate/upgrade_pgmq_to_v#{target_version_slug}.rb"
-        end
+        migration_template "upgrade_pgmq.rb.erb",
+                           File.join(pgbus_migrate_path, "upgrade_pgmq_to_v#{target_version_slug}.rb")
       end
 
       def display_post_upgrade
@@ -51,10 +48,6 @@ module Pgbus
       def target_version_slug
         target_version.tr(".", "_")
       end
-
-      def separate_database?
-        options[:database].present?
-      end
     end
   end
 end

data/lib/pgbus/autovacuum_tuning.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Pgbus
+  # Shared autovacuum storage parameters for tables with high write churn.
+  #
+  # Queue tables (q_*) have high insert/delete churn: every read + archive
+  # cycle deletes from q_ and inserts into a_. Default autovacuum settings
+  # (vacuum at 20% dead tuples) are far too conservative — dead tuples
+  # accumulate, bloat B-tree indexes, and eventually degrade lock acquisition
+  # times. See: https://planetscale.com/blog/keeping-a-postgres-queue-healthy
+  #
+  # Several pgbus-owned tables share similar churn patterns:
+  # - pgbus_semaphores: rapid upsert+increment per job, periodic expiry
+  # - pgbus_uniqueness_keys: INSERT on enqueue, DELETE on completion
+  # - pgbus_processed_events: INSERT per event, bulk DELETE on TTL expiry
+  #
+  # Used by:
+  # - Client#ensure_single_queue (runtime, on queue creation)
+  # - CreatePgbusTables migration (fresh install)
+  # - TunePgbusAutovacuum migration (upgrade for existing installations)
+  module AutovacuumTuning
+    # Queue tables: very aggressive — high delete rate from read+archive.
+    QUEUE_SETTINGS = {
+      "autovacuum_vacuum_scale_factor" => "0.01",
+      "autovacuum_vacuum_cost_delay" => "2",
+      "autovacuum_analyze_scale_factor" => "0.05"
+    }.freeze
+
+    # Archive tables: moderately aggressive — append-heavy with periodic purge.
+    ARCHIVE_SETTINGS = {
+      "autovacuum_vacuum_scale_factor" => "0.05",
+      "autovacuum_vacuum_cost_delay" => "5",
+      "autovacuum_analyze_scale_factor" => "0.05"
+    }.freeze
+
+    # High-churn pgbus tables: rapid INSERT/DELETE or upsert cycles.
+    # - semaphores: upsert + increment per job acquire, decrement on release, periodic expiry
+    # - uniqueness_keys: INSERT on enqueue, DELETE on job completion (fast lifecycle)
+    # - processed_events: INSERT per event handler, bulk DELETE on idempotency TTL expiry
+    HIGH_CHURN_SETTINGS = {
+      "autovacuum_vacuum_scale_factor" => "0.02",
+      "autovacuum_vacuum_cost_delay" => "2",
+      "autovacuum_analyze_scale_factor" => "0.05"
+    }.freeze
+
+    HIGH_CHURN_TABLES = %w[
+      pgbus_semaphores
+      pgbus_uniqueness_keys
+      pgbus_processed_events
+    ].freeze
+
+    class << self
+      # Generate ALTER TABLE SQL for a single queue's tables.
+      def sql_for_queue(queue_name)
+        [
+          alter_table_sql("pgmq.q_#{queue_name}", QUEUE_SETTINGS),
+          alter_table_sql("pgmq.a_#{queue_name}", ARCHIVE_SETTINGS)
+        ].join("\n")
+      end
+
+      # Generate ALTER TABLE SQL for all queues discovered via pgmq.meta.
+      def sql_for_all_queues
+        <<~SQL
+          DO $$
+          DECLARE
+            q RECORD;
+          BEGIN
+            FOR q IN SELECT queue_name FROM pgmq.meta LOOP
+              EXECUTE format('ALTER TABLE pgmq.q_%I SET (#{settings_clause(QUEUE_SETTINGS)})', q.queue_name);
+              EXECUTE format('ALTER TABLE pgmq.a_%I SET (#{settings_clause(ARCHIVE_SETTINGS)})', q.queue_name);
+            END LOOP;
+          END $$;
+        SQL
+      end
+
+      # Generate ALTER TABLE SQL for pgbus-owned high-churn tables.
+      def sql_for_high_churn_tables
+        HIGH_CHURN_TABLES.map { |table| alter_table_sql(table, HIGH_CHURN_SETTINGS, if_exists: true) }.join("\n")
+      end
+
+      private
+
+      def alter_table_sql(table, settings, if_exists: false)
+        prefix = if_exists ? "ALTER TABLE IF EXISTS" : "ALTER TABLE"
+        "#{prefix} #{table} SET (#{settings_clause(settings)});"
+      end
+
+      def settings_clause(settings)
+        settings.map { |k, v| "#{k} = #{v}" }.join(", ")
+      end
+    end
+  end
+end

data/lib/pgbus/client.rb

@@ -75,7 +75,10 @@ module Pgbus
       return if @queues_created[dlq_name]
 
       @queues_created.compute_if_absent(dlq_name) do
-        synchronized { @pgmq.create(dlq_name) }
+        synchronized do
+          @pgmq.create(dlq_name)
+          tune_autovacuum(dlq_name)
+        end
         true
       end
     end
@@ -446,12 +449,21 @@ module Pgbus
       @queues_created.compute_if_absent(full_name) do
         synchronized do
           @pgmq.create(full_name)
+          tune_autovacuum(full_name)
           @pgmq.enable_notify_insert(full_name, throttle_interval_ms: NOTIFY_THROTTLE_MS) if config.listen_notify
         end
         true
       end
     end
 
+    def tune_autovacuum(queue_name)
+      with_raw_connection do |conn|
+        conn.exec(AutovacuumTuning.sql_for_queue(queue_name))
+      end
+    rescue StandardError => e
+      Pgbus.logger.debug { "[Pgbus::Client] Autovacuum tuning failed for #{queue_name}: #{e.message}" }
+    end
+
     # Serialize PGMQ operations through a mutex when sharing a connection
     # with ActiveRecord (Proc path). When pgmq-ruby owns its own connections
     # (String/Hash path), the internal connection_pool handles concurrency.

data/lib/pgbus/engine.rb

@@ -47,6 +47,7 @@ module Pgbus
     rake_tasks do
       load File.expand_path("../tasks/pgbus_pgmq.rake", __dir__)
       load File.expand_path("../tasks/pgbus_streams.rake", __dir__)
+      load File.expand_path("../tasks/pgbus_autovacuum.rake", __dir__)
     end
 
     initializer "pgbus.i18n" do

data/lib/pgbus/generators/migration_detector.rb

@@ -73,7 +73,8 @@ module Pgbus
         add_queue_states: "pgbus:add_queue_states",
         add_outbox: "pgbus:add_outbox",
         add_recurring: "pgbus:add_recurring",
-        add_failed_events_index: "pgbus:add_failed_events_index"
+        add_failed_events_index: "pgbus:add_failed_events_index",
+        tune_autovacuum: "pgbus:tune_autovacuum"
       }.freeze
 
       # Human-friendly description of each migration for the generator
@@ -88,7 +89,8 @@ module Pgbus
         add_queue_states: "queue states table (pause/resume)",
         add_outbox: "outbox entries table (transactional outbox)",
         add_recurring: "recurring tasks + executions tables",
-        add_failed_events_index: "unique index on pgbus_failed_events (queue_name, msg_id)"
+        add_failed_events_index: "unique index on pgbus_failed_events (queue_name, msg_id)",
+        tune_autovacuum: "autovacuum tuning for PGMQ queue and archive tables"
       }.freeze
 
       def initialize(connection)
@@ -110,7 +112,8 @@ module Pgbus
           *queue_states_migrations,
           *outbox_migrations,
           *recurring_migrations,
-          *failed_events_index_migrations
+          *failed_events_index_migrations,
+          *autovacuum_migrations
         ]
       end
 
@@ -193,6 +196,15 @@ module Pgbus
         [:add_failed_events_index]
       end
 
+      # Autovacuum tuning: check if any PGMQ queue table already has
+      # custom autovacuum settings applied. If not, queue the migration.
+      def autovacuum_migrations
+        return [] unless pgmq_schema_exists?
+        return [] if autovacuum_already_tuned?
+
+        [:tune_autovacuum]
+      end
+
       # --- schema probes -------------------------------------------------
 
       def table_exists?(name)
@@ -212,6 +224,29 @@ module Pgbus
       rescue StandardError
         false
       end
+
+      def pgmq_schema_exists?
+        result = connection.select_value("SELECT 1 FROM information_schema.schemata WHERE schema_name = 'pgmq'")
+        result.present?
+      rescue StandardError
+        false
+      end
+
+      def autovacuum_already_tuned?
+        queue_name = connection.select_value("SELECT queue_name FROM pgmq.meta ORDER BY queue_name LIMIT 1")
+        return true unless queue_name # no queues = nothing to tune, skip
+
+        result = connection.select_value(<<~SQL)
+          SELECT reloptions::text LIKE '%autovacuum_vacuum_scale_factor%'
+          FROM pg_class
+          WHERE relname = 'q_#{queue_name}'
+            AND relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'pgmq')
+        SQL
+
+        [true, "t"].include?(result)
+      rescue StandardError
+        true # if we can't tell, assume already tuned (safe default)
+      end
     end
   end
 end

data/lib/pgbus/version.rb

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

data/lib/pgbus/web/data_source.rb

@@ -21,6 +21,8 @@ module Pgbus
 
         throughput = compute_throughput(queues)
 
+        health = queue_health_stats
+
         {
           total_queues: queues.size,
           total_depth: total_depth,
@@ -29,7 +31,10 @@ module Pgbus
           failed_count: failed_events_count,
           dlq_depth: dlq_depth,
           recurring_count: recurring_tasks_count,
-          throughput_rate: throughput
+          throughput_rate: throughput,
+          total_dead_tuples: health[:total_dead_tuples],
+          tables_needing_vacuum: health[:tables_needing_vacuum],
+          oldest_transaction_age_sec: health[:oldest_transaction_age_sec]
         }
       end
 
@@ -629,6 +634,50 @@ module Pgbus
         []
       end
 
+      # Queue health — vacuum stats, dead tuples, bloat, MVCC horizon.
+      # Returns aggregate health across all queue and archive tables, plus
+      # the oldest open transaction age (MVCC horizon pinning risk).
+      def queue_health_stats
+        tables = fetch_all_table_stats
+
+        total_dead = tables.sum { |t| t[:dead_tuples] }
+        total_live = tables.sum { |t| t[:live_tuples] }
+        worst_bloat = tables.map { |t| t[:bloat_ratio] }.max || 0.0
+        needs_vacuum = tables.count { |t| t[:bloat_ratio] > 0.1 }
+        oldest_vacuum = tables.filter_map { |t| t[:last_vacuum_ago_sec] }.max
+
+        {
+          total_dead_tuples: total_dead,
+          total_live_tuples: total_live,
+          worst_bloat_ratio: worst_bloat.round(4),
+          tables_needing_vacuum: needs_vacuum,
+          oldest_vacuum_ago_sec: oldest_vacuum,
+          oldest_transaction_age_sec: oldest_transaction_age,
+          tables: tables
+        }
+      rescue StandardError => e
+        Pgbus.logger.debug { "[Pgbus::Web] Error fetching queue health stats: #{e.class}: #{e.message}" }
+        {
+          total_dead_tuples: 0, total_live_tuples: 0, worst_bloat_ratio: 0.0,
+          tables_needing_vacuum: 0, oldest_vacuum_ago_sec: nil,
+          oldest_transaction_age_sec: nil, tables: []
+        }
+      end
+
+      # Per-queue health stats for the queue detail view.
+      def queue_health_detail(queue_name)
+        sanitized = sanitize_name(queue_name)
+        tables = [
+          fetch_table_stats("pgmq", "q_#{sanitized}", "queue"),
+          fetch_table_stats("pgmq", "a_#{sanitized}", "archive")
+        ].compact
+
+        { tables: tables, oldest_transaction_age_sec: oldest_transaction_age }
+      rescue StandardError => e
+        Pgbus.logger.debug { "[Pgbus::Web] Error fetching health detail for #{queue_name}: #{e.message}" }
+        { tables: [], oldest_transaction_age_sec: nil }
+      end
+
       # Stream stats — only populated when streams_stats_enabled is
       # true AND the migration has been run. Controllers should gate
       # rendering on `stream_stats_available?` to avoid showing empty
@@ -674,6 +723,89 @@ module Pgbus
         Pgbus::BusRecord.connection
       end
 
+      # Single query to fetch pg_stat_user_tables stats for all queue and
+      # archive tables. Avoids 2*N catalog queries on the dashboard.
+      def fetch_all_table_stats
+        rows = connection.select_all(<<~SQL, "Pgbus All Table Health")
+          WITH rels AS (
+            SELECT queue_name, 'q_' || queue_name AS relname, 'queue' AS kind FROM pgmq.meta
+            UNION ALL
+            SELECT queue_name, 'a_' || queue_name AS relname, 'archive' AS kind FROM pgmq.meta
+          )
+          SELECT
+            'pgmq.' || r.relname AS table_name,
+            r.kind,
+            s.n_live_tup,
+            s.n_dead_tup,
+            EXTRACT(epoch FROM (NOW() - COALESCE(s.last_vacuum, s.last_autovacuum)))::int AS last_vacuum_ago_sec,
+            s.last_vacuum,
+            s.last_autovacuum
+          FROM rels r
+          LEFT JOIN pg_stat_user_tables s
+            ON s.schemaname = 'pgmq' AND s.relname = r.relname
+          ORDER BY r.queue_name, r.kind
+        SQL
+
+        rows.to_a.filter_map { |row| build_table_health_row(row) }
+      end
+
+      # Fetch pg_stat_user_tables stats for a single table (used by queue_health_detail).
+      def fetch_table_stats(schema, table_name, kind)
+        row = connection.select_one(<<~SQL, "Pgbus Table Health", [schema, table_name])
+          SELECT
+            n_live_tup,
+            n_dead_tup,
+            EXTRACT(epoch FROM (NOW() - COALESCE(last_vacuum, last_autovacuum)))::int AS last_vacuum_ago_sec,
+            last_vacuum,
+            last_autovacuum
+          FROM pg_stat_user_tables
+          WHERE schemaname = $1 AND relname = $2
+        SQL
+
+        return nil unless row
+
+        build_table_health_row(row.merge("table_name" => "#{schema}.#{table_name}", "kind" => kind))
+      end
+
+      def build_table_health_row(row)
+        return nil unless row["n_live_tup"] || row["n_dead_tup"]
+
+        live = row["n_live_tup"].to_i
+        dead = row["n_dead_tup"].to_i
+        total = live + dead
+        bloat = total.positive? ? (dead.to_f / total) : 0.0
+
+        {
+          table: row["table_name"],
+          kind: row["kind"],
+          live_tuples: live,
+          dead_tuples: dead,
+          bloat_ratio: bloat.round(4),
+          last_vacuum_ago_sec: row["last_vacuum_ago_sec"]&.to_i,
+          last_vacuum: row["last_vacuum"],
+          last_autovacuum: row["last_autovacuum"]
+        }
+      end
+
+      # Age of the oldest open transaction in seconds — indicates MVCC
+      # horizon pinning risk. Returns nil if no active transactions.
+      def oldest_transaction_age
+        row = connection.select_one(<<~SQL, "Pgbus Oldest Transaction")
+          SELECT EXTRACT(epoch FROM (NOW() - xact_start))::int AS age_sec
+          FROM pg_stat_activity
+          WHERE state != 'idle'
+            AND xact_start IS NOT NULL
+            AND pid != pg_backend_pid()
+          ORDER BY xact_start ASC
+          LIMIT 1
+        SQL
+
+        row&.dig("age_sec")&.to_i
+      rescue StandardError => e
+        Pgbus.logger.debug { "[Pgbus::Web] Error fetching oldest transaction age: #{e.class}: #{e.message}" }
+        nil
+      end
+
       # name is the full PGMQ queue name (already prefixed)
       def query_queue_messages(name, limit, offset)
         query_queue_messages_raw(name, limit, offset).map { |m| m.merge(queue: name) }