pgbus 0.11.4 → 0.12.1

data/lib/pgbus/pgmq_schema.rb

@@ -135,6 +135,46 @@ module Pgbus
         SQL
       end
 
+      # SQL to re-install the per-queue NOTIFY insert triggers that
+      # drop_pgmq_functions_sql cascades away (issue #360). Dropping
+      # pgmq.notify_queue_listeners() with CASCADE also drops the
+      # trigger_notify_queue_insert_listeners trigger from every queue table;
+      # install_sql re-creates the function but nothing re-creates the
+      # triggers, so NOTIFY-gated wakeups silently die fleet-wide until each
+      # queue happens to be re-ensured by a process restart.
+      #
+      # The dropped state is fully recoverable: pgmq.notify_insert_throttle is
+      # a TABLE (preserved by the upgrade — its rows record exactly which
+      # queues had notify enabled and at what throttle, FK-bound to pgmq.meta
+      # so it can't reference a dropped queue), and pgmq.enable_notify_insert
+      # is idempotent. Replaying it per recorded row restores every trigger at
+      # its original interval. No-ops when the throttle table or the enable
+      # function is absent (a vendored version without the notify feature).
+      def reinstall_notify_triggers_sql
+        <<~SQL
+          DO $$
+          DECLARE
+            r RECORD;
+          BEGIN
+            IF to_regclass('pgmq.notify_insert_throttle') IS NULL THEN
+              RETURN;
+            END IF;
+            IF to_regprocedure('pgmq.enable_notify_insert(text, integer)') IS NULL THEN
+              RETURN;
+            END IF;
+
+            -- The FOR loop iterates a snapshot, so enable_notify_insert's
+            -- internal DELETE + re-INSERT of the same throttle row is safe.
+            FOR r IN
+              SELECT queue_name, throttle_interval_ms
+              FROM pgmq.notify_insert_throttle
+            LOOP
+              PERFORM pgmq.enable_notify_insert(r.queue_name, r.throttle_interval_ms);
+            END LOOP;
+          END $$;
+        SQL
+      end
+
       private
 
       # Strips extension-specific blocks (pg_extension_config_dump, pg_depend checks)

data/lib/pgbus/recurring/schedule.rb

@@ -139,7 +139,7 @@ module Pgbus
         return nil unless config
         return nil unless config[:strategy] == :until_executed
 
-        key = resolve_uniqueness_key(config, task)
+        key = resolve_uniqueness_key(job_class, config, task)
         return nil unless key
 
         acquired = UniquenessKey.acquire!(key, queue_name: resolve_queue(task), msg_id: 0)
@@ -155,6 +155,7 @@ module Pgbus
           "[Pgbus] Uniqueness lock check failed for #{task.key}: #{e.class}: #{e.message} — " \
             "skipping enqueue to prevent duplicates"
         end
+        ErrorReporter.report(e, { action: "recurring_uniqueness_lock", task: task.key })
         :already_locked # Fail closed — skip enqueue when lock check errors
       end
 
@@ -168,19 +169,39 @@ module Pgbus
       end
 
       # Resolve the uniqueness key for a recurring task.
-      # For no-argument recurring jobs, the key defaults to the class name.
-      def resolve_uniqueness_key(config, task)
+      # With no explicit key: the key is the SCHEDULED job class's name —
+      # resolved here, not via a stored proc, so a declaration inherited from
+      # a base class keys each subclass separately (issue #357) — qualified
+      # with the task's arguments so two recurring tasks pointing at the same
+      # job class with different args: don't share one lock (the scheduler
+      # can't use #333's raise-at-enqueue guard, so it disambiguates instead).
+      #
+      # Every failure here — default path or user-supplied key proc — must
+      # propagate to acquire_uniqueness_lock's fail-closed rescue (skip this
+      # tick, log, report). Returning nil instead would mean "no key
+      # configured", and the task would be enqueued WITHOUT a lock: a broken
+      # key proc silently disabling the very protection it configures. The
+      # warn adds the failing-proc context before re-raising.
+      def resolve_uniqueness_key(job_class, config, task)
         key_proc = config[:key]
         args = task.arguments || []
+        return default_uniqueness_key(job_class, args) unless key_proc
 
-        if args.empty?
-          key_proc.call
-        else
-          key_proc.call(*args)
+        begin
+          args.empty? ? key_proc.call : key_proc.call(*args)
+        rescue StandardError => e
+          Pgbus.logger.warn { "[Pgbus] Could not resolve uniqueness key for #{task.key}: #{e.message}" }
+          raise
         end
-      rescue StandardError => e
-        Pgbus.logger.warn { "[Pgbus] Could not resolve uniqueness key for #{task.key}: #{e.message}" }
-        nil
+      end
+
+      # Class-name default for the scheduler path, args-qualified so distinct
+      # argument sets get distinct locks. JSON keeps the key deterministic
+      # and readable in the dashboard/locks table.
+      def default_uniqueness_key(job_class, args)
+        return job_class.name if args.empty?
+
+        "#{job_class.name}:#{JSON.generate(args)}"
       end
 
       # Inject uniqueness metadata into the payload so the executor releases
@@ -197,7 +218,7 @@ module Pgbus
         return payload unless config
         return payload unless config[:strategy] == :until_executed
 
-        key = resolve_uniqueness_key(config, task)
+        key = resolve_uniqueness_key(job_class, config, task)
         return payload unless key
 
         payload.merge(

data/lib/pgbus/support.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pgbus
+  # Shared internal helpers.
+  module Support
+    module_function
+
+    # Call a user-supplied key proc with a job's arguments, preserving
+    # ActiveJob's keyword-argument convention: a trailing Hash whose keys are
+    # all Symbols is splatted as keywords; everything else is positional.
+    # Single implementation for Uniqueness.resolve_key and
+    # Concurrency.resolve_key so the dispatch semantics cannot drift apart.
+    def call_key_proc(key_proc, args)
+      last = args.last
+      if last.is_a?(Hash) && last.each_key.all?(Symbol)
+        key_proc.call(*args[...-1], **last)
+      else
+        key_proc.call(*args)
+      end
+    end
+  end
+end

data/lib/pgbus/uniqueness.rb

@@ -60,7 +60,7 @@ module Pgbus
         raise ArgumentError, "unknown keyword: #{opts.keys.first.inspect}" if opts.any?
         raise ArgumentError, "strategy must be one of: #{VALID_STRATEGIES.join(", ")}" unless VALID_STRATEGIES.include?(strategy)
         raise ArgumentError, "on_conflict must be one of: #{VALID_CONFLICTS.join(", ")}" unless VALID_CONFLICTS.include?(on_conflict)
-        raise ArgumentError, "key must be callable (Proc or lambda)" if key && !key.respond_to?(:call)
+        raise ArgumentError, "key must be callable (Proc or lambda)" if !key.nil? && !key.respond_to?(:call)
 
         # Record whether an explicit key was given. With NO explicit key the key
         # defaults to the class name; that is safe for a no-argument job (one
@@ -70,16 +70,26 @@ module Pgbus
         # order into ONE per-class singleton. resolve_key raises at resolve time
         # when the class-name default meets non-empty arguments (see #333); the
         # no-arg case keeps working. explicit_key marks which is which.
+        #
+        # No proc is stored for the default — resolve_key derives it from the
+        # ENQUEUED job's class. A stored `->(*) { name }` would capture the
+        # DECLARING class, so a base-class declaration would collapse every
+        # subclass into one shared key once configs became inheritable (#357).
         @pgbus_uniqueness = {
           strategy: strategy,
-          key: key || ->(*) { name },
+          key: key,
           explicit_key: !key.nil?,
           on_conflict: on_conflict
         }.freeze
       end
 
+      # The nearest declaration in the ancestor chain wins: a class's own
+      # `ensures_uniqueness` beats an inherited one, and a base-class
+      # declaration reaches every subclass (issue #357 — class-level ivars
+      # don't inherit, so without the superclass walk a base declaration was
+      # silently inert for subclasses).
       def pgbus_uniqueness
-        @pgbus_uniqueness
+        @pgbus_uniqueness || (superclass.pgbus_uniqueness if superclass.respond_to?(:pgbus_uniqueness))
       end
     end
 
@@ -90,11 +100,12 @@ module Pgbus
 
         args = active_job.arguments
         guard_class_name_default!(active_job, config, args)
-        last = args.last
-        key = if last.is_a?(Hash) && last.each_key.all?(Symbol)
-                config[:key].call(*args[...-1], **last)
+        key = if config[:explicit_key]
+                Support.call_key_proc(config[:key], args)
               else
-                config[:key].call(*args)
+                # Class-name default, resolved from the ENQUEUED job's class so
+                # an inherited declaration keys each subclass separately (#357).
+                active_job.class.name
               end
 
         # Automatically serialize GlobalID-compatible objects (e.g. ActiveRecord models)

data/lib/pgbus/version.rb

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

data/lib/pgbus/web/data_source.rb

@@ -65,6 +65,19 @@ module Pgbus
       end
       private :fetch_queues_with_metrics
 
+      # Physical queue names registered as stream queues (the
+      # pgbus_stream_queues registry). Stream delivery is a non-consuming
+      # peek, so stream messages sit visible with read_ct=0 forever — health
+      # verdicts must not read that as a wedge (issue #359). Loaded fresh per
+      # call (reset + one query): verdicts run on coarse intervals and a
+      # long-lived process must see streams registered since the last check.
+      # Degrades to an empty Set when the registry table is absent
+      # (pre-migration installs) or unreadable — StreamQueue swallows both.
+      def stream_queue_names
+        StreamQueue.reset_cache!
+        StreamQueue.all_names
+      end
+
       # name is the full PGMQ queue name (e.g. "pgbus_default") as returned
       # by queues_with_metrics. No prefix is added.
       def queue_detail(name)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgbus
 version: !ruby/object:Gem::Version
-  version: 0.11.4
+  version: 0.12.1
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -63,14 +63,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.7.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.7.1
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -321,6 +321,7 @@ files:
 - lib/pgbus/pgmq_schema.rb
 - lib/pgbus/pgmq_schema/pgmq_v1.11.0.sql
 - lib/pgbus/pgmq_schema/pgmq_v1.11.1.sql
+- lib/pgbus/pgmq_schema/pgmq_v1.12.0.sql
 - lib/pgbus/process/consumer.rb
 - lib/pgbus/process/consumer_priority.rb
 - lib/pgbus/process/dispatcher.rb
@@ -364,6 +365,7 @@ files:
 - lib/pgbus/streams/turbo_broadcastable.rb
 - lib/pgbus/streams/turbo_stream_override.rb
 - lib/pgbus/streams/watermark_cache_middleware.rb
+- lib/pgbus/support.rb
 - lib/pgbus/table_maintenance.rb
 - lib/pgbus/testing.rb
 - lib/pgbus/testing/assertions.rb