pgbus 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dca12989cdb8d34cd026facd0ecb71cc9df51fb966135806a858e1c4bdb0f7cc
-  data.tar.gz: 4f94274ec1bda644087f5711f2a75f8b1c70f5840f5e0d1d9a1b7ea137f6e3ea
+  metadata.gz: c45dd364f341b6819b7901f583e058dbe761b375210e4162f19faf75917e3043
+  data.tar.gz: ed5ee189a3ff3d7fe0610deada3b2daba3726a2647d7762c58735e0771c9e0eb
 SHA512:
-  metadata.gz: decefd5c55ee2f4ca0c1aa6d52e1e1732f89ba3e789a0ae64c6b0bbd1cf60fe0d0c138dc87398f0a80b5e28d7e5cd7cd09eb44e2265265265adcfd9c0ee829f5
-  data.tar.gz: ad140f317e5de14558842881f2dd428281a8fb141986e7d8099976969a2d85b87dd08e7d01f64ebf5128f5b3174dd485b7af5c1f8d00b07bb4037ec095256c8c
+  metadata.gz: e28c032dc7b4f2cba37bd709c4a45030bcedd90274b86a1499d55dd4f4e255769e580983023602a42267b8728068a7eb11f7fdcbc8d12bd3efd83f35a50f241b
+  data.tar.gz: dc6d8d5d2e4feebbf7d940c173f53700549b5364c0e15df3f6afac1d72ecc6b1222127d85649016e9c6590e3c184eb9365da95c424a21a98be683862f4a24e67

data/lib/pgbus/active_job/executor.rb

@@ -13,6 +13,10 @@ module Pgbus
         @stat_buffer = stat_buffer
       end
 
+      # Exceptions we never want to swallow — let the process die/signal propagate.
+      FATAL_EXCEPTIONS = [SystemExit, Interrupt, SignalException, NoMemoryError, SystemStackError].freeze
+      private_constant :FATAL_EXCEPTIONS
+
       def execute(message, queue_name, source_queue: nil)
         execution_start = monotonic_now
         payload = JSON.parse(message.message)
@@ -51,18 +55,36 @@ module Pgbus
 
         job_succeeded = false
 
+        # Debug-level phase markers. Silent at INFO+, but invaluable when a
+        # fiber interrupt or connection issue loses control flow between phases
+        # (issue #126). Each line identifies msg_id + phase so the gap is
+        # visible in logs: "deserialized" without "archived" means the job
+        # ran but its message was never archived.
+        msg_id = message.msg_id.to_i
         Instrumentation.instrument("pgbus.executor.execute", queue: queue_name, job_class: job_class) do
+          Pgbus.logger.debug { "[Pgbus] Executor phase=deserialize msg_id=#{msg_id} job=#{job_class}" }
           job = ::ActiveJob::Base.deserialize(payload)
+          Pgbus.logger.debug { "[Pgbus] Executor phase=perform msg_id=#{msg_id} job=#{job_class}" }
           execute_job(job)
-          archive_from(queue_name, message.msg_id.to_i, source_queue: source_queue)
-          FailedEventRecorder.clear!(queue_name: queue_name, msg_id: message.msg_id.to_i)
+          Pgbus.logger.debug { "[Pgbus] Executor phase=archive msg_id=#{msg_id} job=#{job_class}" }
+          archive_from(queue_name, msg_id, source_queue: source_queue)
+          FailedEventRecorder.clear!(queue_name: queue_name, msg_id: msg_id)
           job_succeeded = true
+          Pgbus.logger.debug { "[Pgbus] Executor phase=succeeded msg_id=#{msg_id} job=#{job_class}" }
         end
 
         instrument("pgbus.job_completed", queue: queue_name, job_class: job_class)
         record_stat(payload, queue_name, "success", execution_start, message: message)
         :success
-      rescue StandardError => e
+      rescue *FATAL_EXCEPTIONS
+        # Process-fatal: propagate so the supervisor/OS can react.
+        raise
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        # Widened from StandardError to catch Async::Stop / Async::Cancel
+        # (both inherit from Exception, not StandardError) under execution_mode: :async.
+        # Before this, a fiber interruption between perform_now and archive_from
+        # silently lost control flow — no failed event row, no job_failed
+        # notification, uniqueness lock held until VT expired. See issue #126.
         handle_failure(message, queue_name, e, payload: payload)
         instrument("pgbus.job_failed", queue: queue_name, job_class: payload&.dig("job_class"), error: e.class.name)
         record_stat(payload, queue_name, "failed", execution_start, message: message)

data/lib/pgbus/client/ensure_stream_queue.rb

@@ -27,7 +27,9 @@ module Pgbus
         # 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.
-        synchronized { @pgmq.enable_notify_insert(full_name, throttle_interval_ms: 0) } if config.listen_notify
+        # 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) }
 
         # 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

@@ -457,12 +457,48 @@ module Pgbus
         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
+          enable_notify_if_needed(full_name, NOTIFY_THROTTLE_MS)
         end
         true
       end
     end
 
+    def enable_notify_if_needed(full_name, throttle_ms)
+      return unless config.listen_notify
+      return if notify_trigger_current?(full_name, throttle_ms)
+
+      @pgmq.enable_notify_insert(full_name, throttle_interval_ms: throttle_ms)
+    end
+
+    # Check whether the NOTIFY trigger already exists on this queue with the
+    # expected throttle interval. When it does, we can skip the destructive
+    # DROP TRIGGER + CREATE TRIGGER cycle that causes deadlocks when multiple
+    # forked processes race during bootstrap.
+    def notify_trigger_current?(full_name, throttle_ms)
+      with_raw_connection do |conn|
+        result = conn.exec_params(<<~SQL, [full_name, throttle_ms])
+          SELECT 1
+          FROM pg_trigger t
+          JOIN pg_class c ON t.tgrelid = c.oid
+          JOIN pg_namespace n ON c.relnamespace = n.oid
+          WHERE n.nspname = 'pgmq'
+            AND c.relname = pgmq.format_table_name($1, 'q')
+            AND t.tgname = 'trigger_notify_queue_insert_listeners'
+            AND EXISTS (
+              SELECT 1 FROM pgmq.notify_insert_throttle
+              WHERE queue_name = $1
+                AND throttle_interval_ms = $2
+            )
+          LIMIT 1
+        SQL
+        result.ntuples.positive?
+      end
+    rescue StandardError
+      # If we can't check (e.g. pgmq schema not fully ready), fall back to
+      # the unconditional path — same behavior as before this fix.
+      false
+    end
+
     def tune_autovacuum(queue_name)
       with_raw_connection do |conn|
         conn.exec(AutovacuumTuning.sql_for_queue(queue_name))

data/lib/pgbus/execution_pools/async_pool.rb

@@ -128,9 +128,20 @@ module Pgbus
         nil
       end
 
+      # Supervisor-level rescue: catch any Exception raised from the user
+      # block so capacity is always restored and the failure is logged.
+      # The `async` gem uses Async::Stop / Async::Cancel (Exception subclasses,
+      # NOT StandardError) to cancel tasks, and prior to issue #126 those
+      # would leak past `rescue StandardError` and silently vanish.
+      # Process-fatal signals still propagate so the supervisor can react.
+      FATAL_EXCEPTIONS = [SystemExit, Interrupt, SignalException, NoMemoryError, SystemStackError].freeze
+      private_constant :FATAL_EXCEPTIONS
+
       def perform(block)
         block.call
-      rescue StandardError => e
+      rescue *FATAL_EXCEPTIONS
+        raise
+      rescue Exception => e # rubocop:disable Lint/RescueException
         Pgbus.logger.error { "[Pgbus] Async pool fiber error: #{e.class}: #{e.message}" }
       ensure
         restore_capacity

data/lib/pgbus/process/supervisor.rb

@@ -21,6 +21,14 @@ module Pgbus
 
         Pgbus.logger.info { "[Pgbus] Supervisor starting pid=#{::Process.pid}" }
 
+        # Bootstrap queues once in the parent process before forking children.
+        # This avoids the deadlock that occurs when multiple forked children
+        # race to call enable_notify_insert (DROP TRIGGER + CREATE TRIGGER)
+        # concurrently on the same queue tables. Children still call
+        # bootstrap_queues post-fork but the idempotent check in
+        # notify_trigger_current? makes those calls cheap no-ops.
+        bootstrap_queues
+
         boot_processes
         monitor_loop
       ensure

data/lib/pgbus/version.rb

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

metadata

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