pgbus 0.13.9 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03f5f0c1044bc23fb429b3e24e13e3df5bfe6bffe5452ea3c746b24de081f822
-  data.tar.gz: bf1c7f3f71811469fef78fb8d93a66a77668229e0293d2e3442f62abedf6badf
+  metadata.gz: c7a7416041503b893fcd514bb1a81509d6ca3b1b6dbd31b800237b782ecad5e2
+  data.tar.gz: 831aa16289605abb51cd5e6ab9cdaa195497a3cbd58e68afe896813746fe4fb9
 SHA512:
-  metadata.gz: 0f82fba75de8a30b79887b4535cf47865d624126dc7f81cdbba190490be2b57ad1ea69c5d6a1d8ea902b4d48bb85c7b19920326d18cbc9c411201f30ac5ee571
-  data.tar.gz: '039f1c2bcc8e4c65188f03794f42ca5e31aebc67ed4a9de869ed885306e7052ea370af331e57f9f104ca9ae65ae51ef4caf690516993966c92a4d117c91f7bd0'
+  metadata.gz: b0734dc2d6f529c0560290a31d418165e2e2bba4b3ac175b379e9418596c304f0534adef23a390cb60ef3f8d6294b2bd2589016c9de638a3c49ada7112d1af46
+  data.tar.gz: 610918036f7585086d6bd2c2bd71df8cd8c3035f1e47919e47853f37bc76ce218487faaa106d71327c03c7ac080eac83eb974be83f3f16995a2b6ced71bfa145

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ### Fixed
 
+- **The 0.14.0 purge/drop guard no longer crashes on Rails 8.0/8.1 — pool ownership is resolved version-tolerantly (issue #411).** `Pgbus::BusRecord.disconnect_all_pools!` (added in #410 for the #409 wedge) identified its own pools via `pool.connection_class` — an API that exists on Rails 7.1/7.2 but was replaced in Rails 8.0 by `ConnectionPool#connection_descriptor` (a `ConnectionDescriptor` whose `#name` is the owning class name; 8.x `PoolConfig` has no `connection_class` either, so the obvious fallback route doesn't exist). Since the guard is prepended onto every purge/drop path, the `NoMethodError` aborted **every** `db:test:purge` / `db:prepare` on current stable Rails, forcing consumers to cap at `< 0.14`. Ownership is now resolved against whichever API the running Rails exposes — `connection_descriptor&.name == name` on 8.0+ (a nil descriptor, e.g. a null pool, never matches), `connection_class == self` on 7.x — with identical semantics: only `connects_to`-created BusRecord pools are disconnected, `ActiveRecord::Base`'s pool is never touched. The reason CI missed this: the spec stubbed `connection_class` on plain RSpec doubles, which happily fake methods the running Rails doesn't define. The spec now also exercises verifying doubles (`instance_double`) against the real `ConnectionPool`, so both existing matrix legs (7.1 and latest 8.x) fail on any future drift in the ownership API. Refs #411.
+
+- **Boot-time BusRecord connections no longer wedge `db:test:purge` — pgbus disconnects its own pools before every database purge/drop (issue #409).** With pgbus on a dedicated database (`config.connects_to`), any boot-time touch of a pgbus model left an idle session on that database for the life of the process. Rails' purge/drop only disconnects the connection it establishes for the target db_config — it knows nothing about gem-owned pools — so the rake process's own idle session blocked its own `DROP DATABASE`: a hang without a `statement_timeout`, a fast `ActiveRecord::QueryCanceled` with one, and either way `db:test:prepare` / `maintain_test_schema!` permanently broken on that machine (every retry re-boots, re-opens the connection, and re-blocks; terminating sessions externally can't help). Three changes: **(1)** `Pgbus::DatabaseTasksGuard` is prepended onto `ActiveRecord::Tasks::DatabaseTasks` at boot, so every route to a purge/drop — `db:test:purge` / `db:purge` / `db:drop` and their per-database variants, `maintain_test_schema!`'s in-process purge, parallel-testing's `TestDatabases` — first runs `Pgbus::BusRecord.disconnect_all_pools!` (all roles; a no-op on primary-database installs, `ActiveRecord::Base`'s pool is never touched). **(2)** The task-aware guard the event-bus registry already used internally is now public as **`Pgbus.database_task?`** — true while the process runs a `db:*` / `assets:*`-family rake task — so apps can skip their own boot-time warm-ups in the contexts where a database may legitimately not exist. **(3)** `pgbus:tune_autovacuum` (enhanced onto `db:schema:load`) no longer holds a permanent connection lease from `BusRecord.connection`: it checks out via `connection_pool.with_connection` and disconnects the pool afterward, leaving no idle session behind inside longer rake chains. Refs #409.
+
 - **Concurrent queue creation no longer kills the loser with `PG::UniqueViolation` on `pg_class` (issue #404).** The sibling of the #403 trigger race, one DDL step earlier: `CREATE TABLE IF NOT EXISTS` is not race-safe — two backends creating a not-yet-existing queue both pass the existence check (READ COMMITTED; neither sees the other's uncommitted catalog rows), both insert into `pg_class`, and the loser raises `unique_violation` on `pg_class_relname_nsp_index` instead of the friendly `duplicate_table`. All the dedup guards (`@queues_created`, `Stream#@ensured`, `synchronized`) are process-local, so with lazily-created per-record durable stream queues two processes first-touching the same brand-new stream hit `pgmq.create` simultaneously — and via `send_message`'s `ensure_queue` the same window applies to plain job queues on cold post-deploy herds (production: AppSignal incident #963, an unrescued `PG::UniqueViolation` out of an unrelated `after_commit`). Three DDL steps now rescue the duplicate as success, mirroring the #397/#403 shape: **(1)** `create_queue_table` — `pgmq.create` is a single statement and therefore atomic, so when the loser unblocks the winner has committed the whole queue; the loser re-checks `pgmq.meta` and returns, retrying `pgmq.create` once when the re-check can't confirm (e.g. a leftover physical table without a meta row) with a second failure propagating (the retry's own error — the original duplicate is preserved deeper in its cause chain via Ruby's implicit `$!` chaining); **(2)** `create_fifo_index_if_needed` under group_mode — the duplicate proves the index exists; **(3)** the stream archive `msg_id` index in `ensure_stream_queue` — a raw `CREATE INDEX IF NOT EXISTS` with the same catalog race, where the loser now proceeds to register and memoize the stream instead of dropping the first broadcast. Duplicate detection reuses `DUPLICATE_INSTALL_ERROR_CLASSES`, matched directly (raw `conn.exec` paths) or as the `cause` of pgmq-ruby's `ConnectionError` wrapper. No locking added, no happy-path cost. Refs #404.
 
 - **Concurrent lazy stream-queue ensures no longer drop the loser's broadcast with `PG::DuplicateObject` on the NOTIFY trigger (issue #403).** `Client#enable_notify_if_needed` is check-then-act — `notify_trigger_current?` is a plain SELECT and the surrounding `synchronized` is a process-local mutex — so after a deploy, when every process's `@queues_created` memo is cold, two processes handling the first broadcast for the same stream both see "trigger not current" and both run PGMQ's `DROP TRIGGER IF EXISTS` + `CREATE CONSTRAINT TRIGGER` cycle. The loser's CREATE blocks on the winner's table lock and fails with `duplicate_object` once the winner commits — surfaced as `PGMQ::Errors::ConnectionError`, killing that broadcast (in production: a deploy-time thundering herd turning unrelated `after_commit` writes into 500s, AppSignal incident #546). The existing mitigations all miss this window: the 0.12.x `notify_trigger_current?` check made repeat ensures cheap but left the TOCTOU race, the #397 advisory lock serializes schema install only, and the supervisor's pre-fork bootstrap covers job-container children but not web processes. The loser now treats the duplicate as success — the trigger provably exists because a concurrent caller just created it (same shape as the #397 duplicate-object rescue on schema install; matched on the trigger identifier, which survives message localization, plus the `PG::DuplicateObject` cause or the "already exists" text). Before returning, it re-checks `notify_trigger_current?`: racing ensures pass the same throttle so the check normally confirms and returns, but a job-queue ensure (250ms) racing the stream override (0ms) can leave the wrong interval installed — that mismatch retries `enable_notify_insert` once to converge; a second loss propagates. No locking added, no happy-path cost. Refs #403.

data/lib/pgbus/bus_record.rb

@@ -12,5 +12,34 @@ module Pgbus
   # and the engine's app/models path isn't registered yet.
   class BusRecord < ActiveRecord::Base
     self.abstract_class = true
+
+    # Disconnects every pool owned by this class — the pools `connects_to`
+    # creates when pgbus runs on a dedicated database — across all roles.
+    # When pgbus runs in the primary database there is no BusRecord-owned
+    # pool and this is a no-op; ActiveRecord::Base's pool is never touched.
+    #
+    # Called by Pgbus::DatabaseTasksGuard before every database purge/drop so
+    # an idle boot-time session on the pgbus database can never block that
+    # same process's DROP DATABASE (issue #409). Safe to call at any time:
+    # the next checkout after a disconnect reconnects transparently.
+    def self.disconnect_all_pools!
+      connection_handler.connection_pool_list(:all).each do |pool|
+        pool.disconnect! if owns_pool?(pool)
+      end
+    end
+
+    # Rails 8.0 replaced ConnectionPool#connection_class with
+    # #connection_descriptor — a ConnectionDescriptor whose #name is the
+    # owning class name (issue #411). Pools `connects_to` creates register
+    # under the class name, so the name comparison is equivalent to the
+    # class-identity check on 7.x. A nil descriptor (null pool) never matches.
+    def self.owns_pool?(pool)
+      if pool.respond_to?(:connection_descriptor)
+        pool.connection_descriptor&.name == name
+      else
+        pool.connection_class == self
+      end
+    end
+    private_class_method :owns_pool?
   end
 end

data/lib/pgbus/database_tasks_guard.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pgbus
+  # Prepended onto ActiveRecord::Tasks::DatabaseTasks' singleton class by the
+  # engine (initializer "pgbus.db") so every database purge/drop first
+  # disconnects the gem's own BusRecord pools.
+  #
+  # Why: with pgbus on a dedicated database (config.connects_to), any
+  # boot-time touch of a Pgbus model leaves an idle session on that database
+  # for the life of the process. Rails' purge/drop only disconnects the
+  # connection it establishes for the target db_config — it knows nothing
+  # about gem-owned pools — so the process's own idle session blocks its own
+  # DROP DATABASE (or kills it via statement_timeout), permanently wedging
+  # db:test:prepare (issue #409).
+  #
+  # Intercepting DatabaseTasks (rather than enhancing the rake tasks) covers
+  # every route to a purge/drop: db:test:purge / db:purge / db:drop and their
+  # per-database variants, maintain_test_schema!'s in-process purge, and
+  # parallel-testing's TestDatabases — they all funnel through these methods.
+  #
+  # Installed only in processes that booted the app; a bare `db:drop` process
+  # that never ran initializers has no BusRecord pool to block on anyway.
+  module DatabaseTasksGuard
+    def purge(...)
+      Pgbus::BusRecord.disconnect_all_pools!
+      super
+    end
+
+    def drop(...)
+      Pgbus::BusRecord.disconnect_all_pools!
+      super
+    end
+  end
+end

data/lib/pgbus/engine.rb

@@ -61,6 +61,12 @@ module Pgbus
     initializer "pgbus.db" do
       ActiveSupport.on_load(:active_record) do
         Pgbus::BusRecord.connects_to(**Pgbus.configuration.connects_to) if Pgbus.configuration.connects_to
+
+        # Disconnect the gem's own pools before any database purge/drop, so an
+        # idle boot-time BusRecord session on a dedicated pgbus database can
+        # never block that same process's DROP DATABASE (issue #409). No-op
+        # when pgbus runs in the primary database (no BusRecord-owned pool).
+        ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(Pgbus::DatabaseTasksGuard)
       end
     end
 

data/lib/pgbus/event_bus/registry.rb

@@ -104,23 +104,11 @@ module Pgbus
 
       private
 
-      # Rake task-name prefixes during which pgbus must NOT open a PGMQ
-      # connection: creating/dropping/migrating/loading the schema (a live
-      # connection blocks DROP DATABASE) and asset precompile (no DB expected).
-      SCHEMA_TASK_PREFIXES = %w[db: db_test: assets: webpacker: yarn:].freeze
-      private_constant :SCHEMA_TASK_PREFIXES
-
       # True when running inside a rake schema/asset task, where setup_all!(safe:)
-      # should skip rather than open a connection. Detected from the invoked rake
-      # task names; false outside a Rake run.
+      # should skip rather than open a connection. Delegates to the shared,
+      # public detector (issue #409) so there is a single implementation.
       def schema_task_context?
-        return false unless defined?(::Rake) && ::Rake.respond_to?(:application)
-
-        tasks = ::Rake.application.top_level_tasks
-        tasks.any? { |t| SCHEMA_TASK_PREFIXES.any? { |prefix| t.to_s.start_with?(prefix) } }
-      rescue StandardError => e
-        Pgbus.logger.debug { "[Pgbus] schema_task_context? detection failed, assuming non-schema: #{e.class}: #{e.message}" }
-        false
+        Pgbus.database_task?
       end
 
       def matches?(pattern, routing_key)

data/lib/pgbus/version.rb

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

data/lib/pgbus.rb

@@ -10,6 +10,13 @@ module Pgbus
   # this to be configurable.
   DEAD_LETTER_SUFFIX = "_dlq"
 
+  # Rake task-name prefixes during which pgbus must NOT open a database
+  # connection: schema management (an idle session on a dedicated pgbus
+  # database blocks that same process's DROP DATABASE during db:test:purge —
+  # issue #409) and asset precompile (where a database may legitimately not
+  # exist). Consulted by Pgbus.database_task?.
+  DATABASE_TASK_PREFIXES = %w[db: db_test: assets: webpacker: yarn:].freeze
+
   # Error-hierarchy policy (the 1.0 contract, issue #282):
   #
   #   * OPERATIONAL errors — a pgbus subsystem failed to do its job at runtime
@@ -149,6 +156,30 @@ module Pgbus
       @configuration ||= Configuration.new
     end
 
+    # True when the current process is running a rake task (db:*, assets:*, …
+    # — see DATABASE_TASK_PREFIXES) during which pgbus must not touch the
+    # database: the database may not exist yet, and an idle connection on a
+    # dedicated pgbus database blocks that same process's DROP DATABASE
+    # during db:test:purge (issue #409). Use it to guard boot-time database
+    # touches in an initializer:
+    #
+    #   Rails.application.config.after_initialize do
+    #     Pgbus::StreamQueue.table_exists? unless Pgbus.database_task?
+    #   end
+    #
+    # False outside a Rake run, and false (never raise into boot) when
+    # detection itself fails.
+    def database_task?
+      return false unless defined?(::Rake) && ::Rake.respond_to?(:application)
+
+      ::Rake.application.top_level_tasks.any? do |task|
+        DATABASE_TASK_PREFIXES.any? { |prefix| task.to_s.start_with?(prefix) }
+      end
+    rescue StandardError => e
+      logger.debug { "[Pgbus] database_task? detection failed, assuming non-schema: #{e.class}: #{e.message}" }
+      false
+    end
+
     def configure
       yield configuration
       # Fail loud at boot on an invalid value rather than leaving it dormant

data/lib/tasks/pgbus_autovacuum.rake

@@ -5,26 +5,42 @@ namespace :pgbus do
   task tune_autovacuum: :environment do
     require "pgbus/autovacuum_tuning"
 
-    conn = Pgbus.configuration.connects_to ? Pgbus::BusRecord.connection : ActiveRecord::Base.connection
+    apply_tuning = lambda do |conn|
+      # Only run if pgmq schema exists (tables may not be created yet during
+      # initial setup — the install migration handles tuning itself).
+      pgmq_exists = conn.select_value(
+        "SELECT 1 FROM information_schema.schemata WHERE schema_name = 'pgmq'"
+      )
 
-    # Only run if pgmq schema exists (tables may not be created yet during
-    # initial setup — the install migration handles tuning itself).
-    pgmq_exists = conn.select_value(
-      "SELECT 1 FROM information_schema.schemata WHERE schema_name = 'pgmq'"
-    )
+      unless pgmq_exists
+        puts "[pgbus] PGMQ schema not found — skipping autovacuum tuning."
+        next
+      end
 
-    unless pgmq_exists
-      puts "[pgbus] PGMQ schema not found — skipping autovacuum tuning."
-      next
-    end
+      puts "[pgbus] Applying autovacuum tuning to PGMQ queue/archive tables..."
+      conn.execute(Pgbus::AutovacuumTuning.sql_for_all_queues)
 
-    puts "[pgbus] Applying autovacuum tuning to PGMQ queue/archive tables..."
-    conn.execute(Pgbus::AutovacuumTuning.sql_for_all_queues)
+      puts "[pgbus] Applying autovacuum tuning to high-churn pgbus tables..."
+      conn.execute(Pgbus::AutovacuumTuning.sql_for_high_churn_tables)
 
-    puts "[pgbus] Applying autovacuum tuning to high-churn pgbus tables..."
-    conn.execute(Pgbus::AutovacuumTuning.sql_for_high_churn_tables)
+      puts "[pgbus] Autovacuum tuning complete."
+    end
 
-    puts "[pgbus] Autovacuum tuning complete."
+    if Pgbus.configuration.connects_to
+      # Scoped checkout + disconnect: this task is enhanced onto
+      # db:schema:load, so a permanent `.connection` lease on the dedicated
+      # pgbus database would leave an idle session that blocks a later
+      # DROP DATABASE in the same rake process (issue #409).
+      begin
+        Pgbus::BusRecord.connection_pool.with_connection { |conn| apply_tuning.call(conn) }
+      ensure
+        # Disconnect even when tuning raises — the session must not outlive
+        # the task either way.
+        Pgbus::BusRecord.connection_pool.disconnect!
+      end
+    else
+      apply_tuning.call(ActiveRecord::Base.connection)
+    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgbus
 version: !ruby/object:Gem::Version
-  version: 0.13.9
+  version: 0.14.1
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -270,6 +270,7 @@ files:
 - lib/pgbus/concurrency/semaphore.rb
 - lib/pgbus/configuration.rb
 - lib/pgbus/configuration/capsule_dsl.rb
+- lib/pgbus/database_tasks_guard.rb
 - lib/pgbus/dedicated_connection.rb
 - lib/pgbus/dedup_cache.rb
 - lib/pgbus/doctor.rb