pgbus 0.23.1 → 0.23.2

data/lib/pgbus/concurrency/blocked_execution.rb

@@ -58,28 +58,30 @@ module Pgbus
         def promote_next(concurrency_key, client:, delay: 0)
           released = nil
           msg_id = nil
-          Pgbus::BlockedExecution.transaction(requires_new: true) do
-            released = release_next(concurrency_key)
-            raise ActiveRecord::Rollback unless released
-
-            # Resolve the delay first: a parked scheduled job goes back into
-            # PGMQ invisible, and nothing renews its lease until a worker
-            # picks it up, so the wait has to be part of the lease.
-            actual_delay = resolve_delay(released[:payload], delay)
-            raise ActiveRecord::Rollback unless slot_taken?(concurrency_key, released[:payload], actual_delay)
-
-            # Carry the enqueuer's priority through: under priority routing it
-            # picks the _pN sub-queue, not just the release order (issue #423).
-            headers = released[:payload].is_a?(Hash) ? released[:payload].delete(HEADERS_KEY) : nil
-            msg_id = client.send_message(released[:queue_name], released[:payload],
-                                         delay: actual_delay, priority: released[:priority],
-                                         **(headers ? { headers: headers } : {}))
+          Pgbus::BlockedExecution.connection_pool.with_connection do
+            Pgbus::BlockedExecution.transaction(requires_new: true) do
+              released = release_next(concurrency_key)
+              raise ActiveRecord::Rollback unless released
+
+              # Resolve the delay first: a parked scheduled job goes back into
+              # PGMQ invisible, and nothing renews its lease until a worker
+              # picks it up, so the wait has to be part of the lease.
+              actual_delay = resolve_delay(released[:payload], delay)
+              raise ActiveRecord::Rollback unless slot_taken?(concurrency_key, released[:payload], actual_delay)
+
+              # Carry the enqueuer's priority through: under priority routing it
+              # picks the _pN sub-queue, not just the release order (issue #423).
+              headers = released[:payload].is_a?(Hash) ? released[:payload].delete(HEADERS_KEY) : nil
+              msg_id = client.send_message(released[:queue_name], released[:payload],
+                                           delay: actual_delay, priority: released[:priority],
+                                           **(headers ? { headers: headers } : {}))
+            end
+
+            next false unless released && msg_id
+
+            backfill(released, msg_id, client)
+            true
           end
-
-          return false unless released && msg_id
-
-          backfill(released, msg_id, client)
-          true
         rescue StandardError => e
           Pgbus.logger.warn { "[Pgbus] Promote blocked execution failed for #{concurrency_key}: #{e.message}" }
           false
@@ -112,9 +114,11 @@ module Pgbus
         # un-taking the slot while the message is already live, so the job
         # runs a second time.
         def backfill(released, msg_id, client)
-          Pgbus::BlockedExecution.transaction(requires_new: true) do
-            Batch.backfill_execution(released[:payload], msg_id,
-                                     client.target_queue(released[:queue_name], released[:priority]))
+          Pgbus::BlockedExecution.connection_pool.with_connection do
+            Pgbus::BlockedExecution.transaction(requires_new: true) do
+              Batch.backfill_execution(released[:payload], msg_id,
+                                       client.target_queue(released[:queue_name], released[:priority]))
+            end
           end
         rescue StandardError => e
           Pgbus.logger.warn { "[Pgbus] Batch execution backfill failed after promote: #{e.message}" }

data/lib/pgbus/concurrency/semaphore.rb

@@ -19,17 +19,23 @@ module Pgbus
 
         # Release one slot in the semaphore. Called after a job completes.
         def release(key)
-          Pgbus::Semaphore.where(key: key).update_all("value = GREATEST(value - 1, 0)")
+          Pgbus::Semaphore.connection_pool.with_connection do
+            Pgbus::Semaphore.where(key: key).update_all("value = GREATEST(value - 1, 0)")
+          end
         end
 
         # A job holding a slot is done: give the slot back and hand it to the
         # next parked job for this key, in one transaction. The decrement locks
         # the semaphore row first, so an enqueue that is parking a job right
         # now commits before the promote looks for parked rows.
+        # The lease is the caller's when it holds one, else taken for the
+        # signal and returned at its end (issue #649).
         def signal(key, client:)
-          Pgbus::Semaphore.transaction do
-            release(key)
-            BlockedExecution.promote_next(key, client: client)
+          Pgbus::Semaphore.connection_pool.with_connection do
+            Pgbus::Semaphore.transaction do
+              release(key)
+              BlockedExecution.promote_next(key, client: client)
+            end
           end
         end
 
@@ -54,11 +60,13 @@ module Pgbus
         # Returns an array of hashes with expired keys.
         # Uses DELETE ... RETURNING for atomicity (no race between pluck and delete).
         def expire_stale
-          result = Pgbus::Semaphore.connection.exec_query(
-            "DELETE FROM pgbus_semaphores WHERE expires_at < $1 RETURNING key",
-            "Pgbus Semaphore Expire",
-            [Time.current]
-          )
+          result = Pgbus::Semaphore.connection_pool.with_connection do |conn|
+            conn.exec_query(
+              "DELETE FROM pgbus_semaphores WHERE expires_at < $1 RETURNING key",
+              "Pgbus Semaphore Expire",
+              [Time.current]
+            )
+          end
           result.rows.map { |row| { "key" => row[0] } }
         end
 

data/lib/pgbus/failed_event_recorder.rb

@@ -32,11 +32,12 @@ module Pgbus
           retry_count
         ]
         legacy = !source_queue_column?
-        if legacy
-          connection.exec_query(LEGACY_RECORD_SQL, "FailedEvent Record", [queue_name, msg_id.to_i, *details])
-        else
-          connection.exec_query(RECORD_SQL, "FailedEvent Record", [queue_name, source_queue, msg_id.to_i, *details])
-        end
+        sql, binds = if legacy
+                       [LEGACY_RECORD_SQL, [queue_name, msg_id.to_i, *details]]
+                     else
+                       [RECORD_SQL, [queue_name, source_queue, msg_id.to_i, *details]]
+                     end
+        with_connection { |conn| conn.exec_query(sql, "FailedEvent Record", binds) }
       rescue StandardError => e
         # A process started before the migration would keep sending the old
         # ON CONFLICT target, whose index the migration drops: probe again.
@@ -46,7 +47,9 @@ module Pgbus
 
       def exists?(queue_name:, msg_id:, source_queue:)
         sql, binds = message_scope(queue_name, msg_id, source_queue)
-        result = connection.select_value("SELECT 1 FROM pgbus_failed_events WHERE #{sql} LIMIT 1", "FailedEvent Exists", binds)
+        result = with_connection do |conn|
+          conn.select_value("SELECT 1 FROM pgbus_failed_events WHERE #{sql} LIMIT 1", "FailedEvent Exists", binds)
+        end
         !result.nil?
       rescue StandardError => e
         Pgbus.logger.debug { "[Pgbus] FailedEvent exists? check failed: #{e.class}: #{e.message}" }
@@ -61,12 +64,14 @@ module Pgbus
       def last_error(queue_name:, msg_id:, source_queue:)
         sql, binds = message_scope(queue_name, msg_id, source_queue)
         order = binds.size > 2 ? " ORDER BY source_queue IS NULL, failed_at DESC" : ""
-        row = connection.select_one(
-          "SELECT error_class, error_message, backtrace, retry_count, failed_at " \
-          "FROM pgbus_failed_events WHERE #{sql}#{order} LIMIT 1",
-          "FailedEvent Last Error",
-          binds
-        )
+        row = with_connection do |conn|
+          conn.select_one(
+            "SELECT error_class, error_message, backtrace, retry_count, failed_at " \
+            "FROM pgbus_failed_events WHERE #{sql}#{order} LIMIT 1",
+            "FailedEvent Last Error",
+            binds
+          )
+        end
         return unless row
 
         {
@@ -89,11 +94,13 @@ module Pgbus
       # case, while a row may carry the executor's configured spelling
       # ("Critical") or a physical name from before #633.
       def clear_queue!(queue_names)
-        connection.exec_delete(
-          "DELETE FROM pgbus_failed_events WHERE lower(queue_name) = ANY($1::text[])",
-          "FailedEvent Clear Queue",
-          ["{#{queue_names.map(&:downcase).join(",")}}"]
-        )
+        with_connection do |conn|
+          conn.exec_delete(
+            "DELETE FROM pgbus_failed_events WHERE lower(queue_name) = ANY($1::text[])",
+            "FailedEvent Clear Queue",
+            ["{#{queue_names.map(&:downcase).join(",")}}"]
+          )
+        end
       rescue StandardError => e
         Pgbus.logger.error do
           "[Pgbus] Failed to clear failed events for dropped queue(s) #{queue_names.join(", ")}: " \
@@ -105,7 +112,7 @@ module Pgbus
       # existed: a sibling sub-queue's row with the same msg_id stays.
       def clear!(queue_name:, msg_id:, source_queue:)
         sql, binds = message_scope(queue_name, msg_id, source_queue)
-        connection.exec_delete("DELETE FROM pgbus_failed_events WHERE #{sql}", "FailedEvent Clear", binds)
+        with_connection { |conn| conn.exec_delete("DELETE FROM pgbus_failed_events WHERE #{sql}", "FailedEvent Clear", binds) }
       rescue StandardError => e
         # ERROR-level: a failed clear leaves a stale row in the dashboard
         # AFTER the job actually succeeded — confusing and load-bearing
@@ -168,7 +175,7 @@ module Pgbus
       end
 
       def detect_source_queue_column(warn:)
-        supported = connection.column_exists?(:pgbus_failed_events, :source_queue)
+        supported = with_connection { |conn| conn.column_exists?(:pgbus_failed_events, :source_queue) }
         if warn && !supported
           Pgbus.logger.warn do
             "[Pgbus] pgbus_failed_events is missing the source_queue column; under priority routing two " \
@@ -186,12 +193,14 @@ module Pgbus
         value.to_s
       end
 
-      def connection
-        if defined?(BusRecord) && BusRecord.connected?
-          BusRecord.connection
-        else
-          ActiveRecord::Base.connection
-        end
+      # A lease the caller already holds is reused and kept; otherwise one is
+      # taken for the block and returned at its end (issue #649), so the
+      # executor's bookkeeping leaves no connection pinned to the job's
+      # thread or fiber. BusRecord's pool is the pgbus database's under
+      # connects_to and the primary's otherwise; asking first whether it had
+      # connected sent a cold process's first failure to the primary.
+      def with_connection(&)
+        BusRecord.connection_pool.with_connection(&)
       end
     end
 

data/lib/pgbus/version.rb

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

metadata

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