pgbus 0.7.5 → 0.7.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d2034c37f18f53d3a55df8381e7d37581905b622487f9ae4beb0c1e0f35c964
-  data.tar.gz: 419c3c7c6b62276903579ca53e39baf06ed1c0e818817e6139ceb004ad6026b3
+  metadata.gz: a28025e2b7af463cb6ff57d12e516d461b9b968ed7bb4eb4568be18d77ff2678
+  data.tar.gz: fd39f5774df158b0cf06e85a6ef52f0114d649008f56b4736a782ce895baae0b
 SHA512:
-  metadata.gz: 40bf9610792cef84a8792035b513c660312ff91d0642432a088f544b84846996856d7bd318b7c06d530b8cd573a2dbb78f20ee132f53540a937a075625a54afc
-  data.tar.gz: 50ddee092a20af26d348c13ae61f48a8566ec0e46687a958012dbdb508e35e2fde217ee277ddaf47333c9c5b20ad51197c0b7950c358b519c8590573433206aa
+  metadata.gz: 19ced25de78f93ccbf307e2bdd72a5dbc46050657c6e394bc9e6a16d8665fa19bc2a29cebf2fcbda8c31eb07e07d94545322eec80c5d61915ddd6bfc924de105
+  data.tar.gz: 9d8e2a9255ce011edf6bc2647fbd4d604db65b8fb2470c17735149599072f2824e510db4e97c4d241cdd4d6a9fef2ff7c23638738cd40de581ee56a07b783f6b

data/lib/pgbus/client/ensure_stream_queue.rb

@@ -19,17 +19,20 @@ module Pgbus
     # stream and from the streamer on first subscription per stream.
     module EnsureStreamQueue
       def ensure_stream_queue(stream_name)
-        ensure_queue(stream_name)
         full_name = config.queue_name(stream_name)
 
-        # PGMQ's default NOTIFY throttle is 250ms — meant to coalesce
-        # high-frequency worker queue inserts. Streams are latency-
-        # sensitive and need every broadcast to fire a NOTIFY, even
-        # when several are batched within a single millisecond.
-        # Override the throttle to 0 specifically for stream queues.
-        # Use the idempotent path to avoid deadlocks when multiple
-        # processes race to set up the same stream queue.
-        synchronized { enable_notify_if_needed(full_name, 0) }
+        with_stale_connection_retry do
+          ensure_queue(stream_name)
+
+          # PGMQ's default NOTIFY throttle is 250ms — meant to coalesce
+          # high-frequency worker queue inserts. Streams are latency-
+          # sensitive and need every broadcast to fire a NOTIFY, even
+          # when several are batched within a single millisecond.
+          # Override the throttle to 0 specifically for stream queues.
+          # Use the idempotent path to avoid deadlocks when multiple
+          # processes race to set up the same stream queue.
+          synchronized { enable_notify_if_needed(full_name, 0) }
+        end
 
         # CREATE INDEX IF NOT EXISTS is idempotent in Postgres but still
         # requires a roundtrip and a brief ACCESS SHARE lock on the archive

data/lib/pgbus/client.rb

@@ -85,9 +85,9 @@ module Pgbus
 
     def send_message(queue_name, payload, headers: nil, delay: 0, priority: nil)
       target = @queue_strategy.target_queue(queue_name, priority)
-      ensure_queue(queue_name)
       Instrumentation.instrument("pgbus.client.send_message", queue: target) do
         with_stale_connection_retry do
+          ensure_queue(queue_name)
           synchronized { @pgmq.produce(target, serialize(payload), headers: headers && serialize(headers), delay: delay) }
         end
       end
@@ -95,10 +95,10 @@ module Pgbus
 
     def send_batch(queue_name, payloads, headers: nil, delay: 0)
       full_name = config.queue_name(queue_name)
-      ensure_queue(queue_name)
       serialized, serialized_headers = serialize_batch(payloads, headers)
       Instrumentation.instrument("pgbus.client.send_batch", queue: full_name, size: payloads.size) do
         with_stale_connection_retry do
+          ensure_queue(queue_name)
           synchronized { @pgmq.produce_batch(full_name, serialized, headers: serialized_headers, delay: delay) }
         end
       end
@@ -107,14 +107,18 @@ module Pgbus
     def read_message(queue_name, vt: nil)
       full_name = config.queue_name(queue_name)
       Instrumentation.instrument("pgbus.client.read_message", queue: full_name) do
-        synchronized { @pgmq.read(full_name, vt: vt || config.visibility_timeout) }
+        with_stale_connection_retry do
+          synchronized { @pgmq.read(full_name, vt: vt || config.visibility_timeout) }
+        end
       end
     end
 
     def read_batch(queue_name, qty:, vt: nil)
       full_name = config.queue_name(queue_name)
       Instrumentation.instrument("pgbus.client.read_batch", queue: full_name, qty: qty) do
-        synchronized { @pgmq.read_batch(full_name, vt: vt || config.visibility_timeout, qty: qty) }
+        with_stale_connection_retry do
+          synchronized { @pgmq.read_batch(full_name, vt: vt || config.visibility_timeout, qty: qty) }
+        end
       end
     end
 
@@ -134,7 +138,9 @@ module Pgbus
         break if remaining <= 0
 
         msgs = Instrumentation.instrument("pgbus.client.read_batch", queue: pq_name, qty: remaining) do
-          synchronized { @pgmq.read_batch(pq_name, vt: vt || config.visibility_timeout, qty: remaining) }
+          with_stale_connection_retry do
+            synchronized { @pgmq.read_batch(pq_name, vt: vt || config.visibility_timeout, qty: remaining) }
+          end
         end || []
 
         msgs.each { |m| results << [pq_name, m] }
@@ -146,14 +152,16 @@ module Pgbus
 
     def read_with_poll(queue_name, qty:, vt: nil, max_poll_seconds: 5, poll_interval_ms: 100)
       full_name = config.queue_name(queue_name)
-      synchronized do
-        @pgmq.read_with_poll(
-          full_name,
-          vt: vt || config.visibility_timeout,
-          qty: qty,
-          max_poll_seconds: max_poll_seconds,
-          poll_interval_ms: poll_interval_ms
-        )
+      with_stale_connection_retry do
+        synchronized do
+          @pgmq.read_with_poll(
+            full_name,
+            vt: vt || config.visibility_timeout,
+            qty: qty,
+            max_poll_seconds: max_poll_seconds,
+            poll_interval_ms: poll_interval_ms
+          )
+        end
       end
     end
 
@@ -168,8 +176,10 @@ module Pgbus
     def read_multi(queue_names, qty:, vt: nil, limit: nil)
       full_names = queue_names.map { |q| config.queue_name(q) }
       Instrumentation.instrument("pgbus.client.read_multi", queues: full_names, qty: qty, limit: limit) do
-        synchronized do
-          @pgmq.read_multi(full_names, vt: vt || config.visibility_timeout, qty: qty, limit: limit)
+        with_stale_connection_retry do
+          synchronized do
+            @pgmq.read_multi(full_names, vt: vt || config.visibility_timeout, qty: qty, limit: limit)
+          end
         end
       end
     end
@@ -178,74 +188,99 @@ module Pgbus
     # the full PGMQ queue name (e.g. from priority sub-queues or dashboard).
     def delete_message(queue_name, msg_id, prefixed: true)
       name = prefixed ? config.queue_name(queue_name) : queue_name
-      synchronized { @pgmq.delete(name, msg_id) }
+      with_stale_connection_retry do
+        synchronized { @pgmq.delete(name, msg_id) }
+      end
     end
 
     # Archive a message. Pass prefixed: false when queue_name is already
     # the full PGMQ queue name.
     def archive_message(queue_name, msg_id, prefixed: true)
       name = prefixed ? config.queue_name(queue_name) : queue_name
-      synchronized { @pgmq.archive(name, msg_id) }
+      with_stale_connection_retry do
+        synchronized { @pgmq.archive(name, msg_id) }
+      end
     end
 
     # Batch archive — moves multiple messages to the archive table in one call.
     def archive_batch(queue_name, msg_ids, prefixed: true)
       name = prefixed ? config.queue_name(queue_name) : queue_name
-      synchronized { @pgmq.archive_batch(name, msg_ids) }
+      with_stale_connection_retry do
+        synchronized { @pgmq.archive_batch(name, msg_ids) }
+      end
     end
 
     # Batch delete — permanently removes multiple messages in one call.
     def delete_batch(queue_name, msg_ids, prefixed: true)
       name = prefixed ? config.queue_name(queue_name) : queue_name
-      synchronized { @pgmq.delete_batch(name, msg_ids) }
+      with_stale_connection_retry do
+        synchronized { @pgmq.delete_batch(name, msg_ids) }
+      end
     end
 
     # Set visibility timeout. Pass prefixed: false when queue_name is already
     # the full PGMQ queue name.
     def set_visibility_timeout(queue_name, msg_id, vt:, prefixed: true)
       name = prefixed ? config.queue_name(queue_name) : queue_name
-      synchronized { @pgmq.set_vt(name, msg_id, vt: vt) }
+      with_stale_connection_retry do
+        synchronized { @pgmq.set_vt(name, msg_id, vt: vt) }
+      end
     end
 
+    # Open a PGMQ transaction. The caller block may run twice if the first
+    # attempt hits a pre-flight stale-connection error — safe because no SQL
+    # was sent on the first attempt (the connection was dead before the BEGIN).
     def transaction(&block)
-      synchronized { @pgmq.transaction(&block) }
+      with_stale_connection_retry do
+        synchronized { @pgmq.transaction(&block) }
+      end
     end
 
     def move_to_dead_letter(queue_name, message)
-      ensure_dead_letter_queue(queue_name)
       dlq_name = config.dead_letter_queue_name(queue_name)
       full_queue = config.queue_name(queue_name)
 
-      synchronized do
-        @pgmq.transaction do |txn|
-          txn.produce(dlq_name, message.message, headers: message.headers)
-          txn.delete(full_queue, message.msg_id.to_i)
+      with_stale_connection_retry do
+        ensure_dead_letter_queue(queue_name)
+        synchronized do
+          @pgmq.transaction do |txn|
+            txn.produce(dlq_name, message.message, headers: message.headers)
+            txn.delete(full_queue, message.msg_id.to_i)
+          end
         end
       end
     end
 
     def metrics(queue_name = nil)
-      synchronized do
-        if queue_name
-          @pgmq.metrics(config.queue_name(queue_name))
-        else
-          @pgmq.metrics_all
+      with_stale_connection_retry do
+        synchronized do
+          if queue_name
+            @pgmq.metrics(config.queue_name(queue_name))
+          else
+            @pgmq.metrics_all
+          end
         end
       end
     end
 
     def list_queues
-      synchronized { @pgmq.list_queues }
+      with_stale_connection_retry do
+        synchronized { @pgmq.list_queues }
+      end
     end
 
     def purge_queue(queue_name, prefixed: true)
       name = prefixed ? config.queue_name(queue_name) : queue_name
-      synchronized { @pgmq.purge_queue(name) }
+      with_stale_connection_retry do
+        synchronized { @pgmq.purge_queue(name) }
+      end
     end
 
     def drop_queue(queue_name, prefixed: true)
       name = prefixed ? config.queue_name(queue_name) : queue_name
-      result = synchronized { @pgmq.drop_queue(name) }
+      result = with_stale_connection_retry do
+        synchronized { @pgmq.drop_queue(name) }
+      end
       @queues_created.delete(name)
       result
     end
@@ -317,8 +352,10 @@ module Pgbus
     # Topic routing
     def bind_topic(pattern, queue_name)
       full_name = config.queue_name(queue_name)
-      ensure_queue(queue_name)
-      synchronized { @pgmq.bind_topic(pattern, full_name) }
+      with_stale_connection_retry do
+        ensure_queue(queue_name)
+        synchronized { @pgmq.bind_topic(pattern, full_name) }
+      end
     end
 
     def publish_to_topic(routing_key, payload, headers: nil, delay: 0)
@@ -541,15 +578,24 @@ module Pgbus
       "connection is closed",
       "connection has been closed",
       "connection not open",
-      "no connection to the server"
+      "no connection to the server",
+      "ssl error: unexpected eof",
+      "ssl syscall error"
     ].freeze
     private_constant :STALE_CONNECTION_PATTERNS
 
-    # Enqueue path guard: rescue PGMQ::Errors::ConnectionError once if its
-    # message matches a known stale-socket pattern. pgmq-ruby's
-    # auto_reconnect + verify_connection! already recovers on the *next*
-    # checkout, so a single retry is sufficient. Other connection errors
-    # (pool timeout, misconfiguration, truly unreachable DB) propagate.
+    # Rescue PGMQ::Errors::ConnectionError once if its message matches a
+    # known stale-socket pattern. pgmq-ruby's auto_reconnect + verify_connection!
+    # already recovers on the *next* checkout, so a single retry is sufficient.
+    # Other connection errors (pool timeout, misconfiguration, truly unreachable
+    # DB) propagate.
+    #
+    # Wraps every @pgmq.* call site. Pattern matching is intentionally narrow
+    # (pre-flight / idle-socket signals only), so retry is safe even for
+    # non-idempotent ops like delete/archive — a matched error means the
+    # connection was dead *before* pgmq-ruby tried to use it, so no SQL was
+    # ever sent. Mid-flight errors like "server closed the connection" are
+    # excluded from the pattern list for this reason.
     def with_stale_connection_retry
       attempts = 0
       begin
@@ -559,7 +605,7 @@ module Pgbus
         raise unless attempts == 1 && stale_connection_error?(e)
 
         Pgbus.logger.warn do
-          "[Pgbus::Client] Retrying produce after stale pgmq connection: #{e.message}"
+          "[Pgbus::Client] Retrying after stale pgmq connection: #{e.message}"
         end
         retry
       end

data/lib/pgbus/version.rb

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

metadata

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