pgbus 0.1.5 → 0.1.7

data/lib/generators/pgbus/add_job_stats_generator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Pgbus
+  module Generators
+    class AddJobStatsGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Add job stats table for dashboard insights and performance tracking"
+
+      class_option :database,
+                   type: :string,
+                   default: nil,
+                   desc: "Use a separate database for pgbus tables (e.g. --database=pgbus)"
+
+      def create_migration_file
+        if separate_database?
+          migration_template "add_job_stats.rb.erb",
+                             "db/pgbus_migrate/add_pgbus_job_stats.rb"
+        else
+          migration_template "add_job_stats.rb.erb",
+                             "db/migrate/add_pgbus_job_stats.rb"
+        end
+      end
+
+      def display_post_install
+        say ""
+        say "Pgbus job stats table installed!", :green
+        say ""
+        say "Next steps:"
+        say "  1. Run: rails db:migrate#{":#{options[:database]}" if separate_database?}"
+        say "  2. Stats collection is enabled by default"
+        say "  3. View insights at /pgbus/insights"
+        say ""
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::Migration.current_version}]"
+      end
+
+      def separate_database?
+        options[:database].present?
+      end
+    end
+  end
+end

data/lib/generators/pgbus/add_outbox_generator.rb

@@ -17,7 +17,7 @@ module Pgbus
                    default: nil,
                    desc: "Use a separate database for pgbus tables (e.g. --database=pgbus)"
 
-      def create_migration
+      def create_migration_file
         if separate_database?
           migration_template "add_outbox.rb.erb",
                              "db/pgbus_migrate/add_pgbus_outbox.rb"

data/lib/generators/pgbus/add_queue_states_generator.rb

@@ -17,7 +17,7 @@ module Pgbus
                    default: nil,
                    desc: "Use a separate database for pgbus tables (e.g. --database=pgbus)"
 
-      def create_migration
+      def create_migration_file
         if separate_database?
           migration_template "add_queue_states.rb.erb",
                              "db/pgbus_migrate/add_pgbus_queue_states.rb"

data/lib/generators/pgbus/add_recurring_generator.rb

@@ -17,7 +17,7 @@ module Pgbus
                    default: nil,
                    desc: "Use a separate database for pgbus tables (e.g. --database=pgbus)"
 
-      def create_migration
+      def create_migration_file
         if separate_database?
           migration_template "add_recurring_tables.rb.erb",
                              "db/pgbus_migrate/add_pgbus_recurring_tables.rb"

data/lib/generators/pgbus/install_generator.rb

@@ -24,7 +24,7 @@ module Pgbus
                    desc: "Use a separate database for pgbus tables (e.g. --database=pgbus). " \
                          "Migrations go to db/pgbus_migrate/ and schema to db/pgbus_schema.rb"
 
-      def create_migration
+      def create_migration_file
         if separate_database?
           migration_template "migration.rb.erb",
                              "db/pgbus_migrate/create_pgbus_tables.rb"

data/lib/generators/pgbus/templates/add_job_locks.rb.erb

@@ -0,0 +1,21 @@
+class AddPgbusJobLocks < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :pgbus_job_locks do |t|
+      t.string :lock_key, null: false
+      t.string :job_class, null: false
+      t.string :job_id
+      t.string :state, null: false, default: "queued"
+      t.integer :owner_pid
+      t.string :owner_hostname
+      t.datetime :locked_at, null: false, default: -> { "CURRENT_TIMESTAMP" }
+      t.datetime :expires_at, null: false
+    end
+
+    add_index :pgbus_job_locks, :lock_key,
+      unique: true, name: "idx_pgbus_job_locks_key"
+    add_index :pgbus_job_locks, :expires_at,
+      name: "idx_pgbus_job_locks_expires"
+    add_index :pgbus_job_locks, [:state, :owner_pid],
+      name: "idx_pgbus_job_locks_reaper"
+  end
+end

data/lib/generators/pgbus/templates/add_job_stats.rb.erb

@@ -0,0 +1,18 @@
+class AddPgbusJobStats < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :pgbus_job_stats do |t|
+      t.string :job_class, null: false
+      t.string :queue_name, null: false
+      t.string :status, null: false
+      t.integer :duration_ms, null: false, default: 0
+      t.datetime :created_at, null: false, default: -> { "CURRENT_TIMESTAMP" }
+    end
+
+    add_index :pgbus_job_stats, :created_at,
+      name: "idx_pgbus_job_stats_time"
+    add_index :pgbus_job_stats, [:job_class, :created_at],
+      name: "idx_pgbus_job_stats_class_time"
+    add_index :pgbus_job_stats, [:status, :created_at],
+      name: "idx_pgbus_job_stats_status_time"
+  end
+end

data/lib/generators/pgbus/upgrade_pgmq_generator.rb

@@ -17,7 +17,7 @@ module Pgbus
                    default: nil,
                    desc: "Use a separate database for pgbus tables (e.g. --database=pgbus)"
 
-      def create_migration
+      def create_migration_file
         if separate_database?
           migration_template "upgrade_pgmq.rb.erb",
                              "db/pgbus_migrate/upgrade_pgmq_to_v#{target_version_slug}.rb"

data/lib/pgbus/active_job/adapter.rb

@@ -9,8 +9,11 @@ module Pgbus
         queue = active_job.queue_name || Pgbus.configuration.default_queue
         payload_hash = Serializer.serialize_job_hash(active_job)
         payload_hash = Concurrency.inject_metadata(active_job, payload_hash)
+        payload_hash = Uniqueness.inject_metadata(active_job, payload_hash)
         payload_hash = inject_batch_metadata(payload_hash)
 
+        return active_job if uniqueness_rejected?(active_job, payload_hash)
+
         enqueue_with_concurrency(active_job, queue, payload_hash)
       end
 
@@ -18,14 +21,27 @@ module Pgbus
         queue = active_job.queue_name || Pgbus.configuration.default_queue
         payload_hash = Serializer.serialize_job_hash(active_job)
         payload_hash = Concurrency.inject_metadata(active_job, payload_hash)
+        payload_hash = Uniqueness.inject_metadata(active_job, payload_hash)
         payload_hash = inject_batch_metadata(payload_hash)
         delay = [(timestamp - Time.now.to_f).ceil, 0].max
 
+        return active_job if uniqueness_rejected?(active_job, payload_hash)
+
         enqueue_with_concurrency(active_job, queue, payload_hash, delay: delay)
       end
 
       def enqueue_all(active_jobs)
-        active_jobs.group_by { |j| j.queue_name || Pgbus.configuration.default_queue }.each do |queue, jobs|
+        # Jobs with uniqueness must go through individual enqueue to acquire locks
+        unique, bulk = active_jobs.partition { |j| Uniqueness.uniqueness_config(j) }
+        unique.each do |j|
+          if j.scheduled_at && j.scheduled_at > Time.now
+            enqueue_at(j, j.scheduled_at.to_f)
+          else
+            enqueue(j)
+          end
+        end
+
+        bulk.group_by { |j| j.queue_name || Pgbus.configuration.default_queue }.each do |queue, jobs|
           enqueue_immediate(queue, jobs.reject { |j| j.scheduled_at && j.scheduled_at > Time.now })
           jobs.select { |j| j.scheduled_at && j.scheduled_at > Time.now }.each { |j| enqueue_at(j, j.scheduled_at.to_f) }
         end
@@ -54,10 +70,20 @@ module Pgbus
           active_job.provider_job_id = msg_id
         end
 
+        Thread.current[:pgbus_acquired_uniqueness_key] = nil
         active_job
-      rescue Pgbus::SchemaNotReady => e
-        Pgbus.logger.error { "[Pgbus] #{e.message}" }
-        raise
+      rescue StandardError => e
+        # Roll back the uniqueness lock if enqueue failed
+        rollback_key = Thread.current[:pgbus_acquired_uniqueness_key]
+        if rollback_key
+          begin
+            Uniqueness.release_lock(rollback_key)
+          rescue StandardError => rollback_error
+            Pgbus.logger.warn { "[Pgbus] Lock rollback failed: #{rollback_error.message}" }
+          end
+          Thread.current[:pgbus_acquired_uniqueness_key] = nil
+        end
+        raise e
       end
 
       def concurrency_config(active_job)
@@ -81,6 +107,34 @@ module Pgbus
         end
       end
 
+      def uniqueness_rejected?(active_job, payload_hash)
+        uniqueness_key = Uniqueness.extract_key(payload_hash)
+        return false unless uniqueness_key
+
+        result = Uniqueness.acquire_enqueue_lock(uniqueness_key, active_job)
+
+        # :no_lock means no enqueue-time lock needed (e.g. :while_executing strategy)
+        return false if result == :no_lock
+
+        # Store the acquired key so we can release it if enqueue fails
+        Thread.current[:pgbus_acquired_uniqueness_key] = uniqueness_key if result == :acquired
+        return false if result == :acquired
+
+        config = Uniqueness.uniqueness_config(active_job)
+        case config[:on_conflict]
+        when :reject
+          raise JobNotUnique, "Job #{active_job.class.name} is already locked"
+        when :discard
+          Pgbus.logger.info { "[Pgbus] Discarding duplicate job #{active_job.class.name}" }
+          true
+        when :log
+          Pgbus.logger.warn { "[Pgbus] Duplicate job #{active_job.class.name} detected" }
+          true
+        else
+          true
+        end
+      end
+
       def inject_batch_metadata(payload_hash)
         batch_id = Thread.current[:pgbus_batch_id]
         return payload_hash unless batch_id

data/lib/pgbus/active_job/executor.rb

@@ -11,6 +11,7 @@ module Pgbus
       end
 
       def execute(message, queue_name, source_queue: nil)
+        execution_start = monotonic_now
         payload = JSON.parse(message.message)
         read_count = message.read_ct.to_i
 
@@ -18,10 +19,32 @@ module Pgbus
           handle_dead_letter(message, queue_name, payload, source_queue: source_queue)
           signal_concurrency(payload)
           signal_batch_discarded(payload)
+          Uniqueness.release_lock(Uniqueness.extract_key(payload))
+          record_stat(payload, queue_name, "dead_lettered", execution_start)
           return :dead_lettered
         end
 
         job_class = payload["job_class"]
+        uniqueness_key = Uniqueness.extract_key(payload)
+        uniqueness_strategy = Uniqueness.extract_strategy(payload)
+        uniqueness_ttl = payload[Uniqueness::TTL_KEY] || Uniqueness::DEFAULT_LOCK_TTL
+
+        if uniqueness_key
+          case uniqueness_strategy
+          when :until_executed
+            # Transition the queued lock to executing state with our PID.
+            # The lock was acquired at enqueue time — now we claim ownership
+            # so the reaper can correlate it with our heartbeat.
+            Uniqueness.claim_for_execution!(uniqueness_key, ttl: uniqueness_ttl)
+          when :while_executing
+            # Acquire the lock now. If another worker is already executing
+            # this job, skip it — VT will expire and it'll be retried.
+            unless Uniqueness.acquire_execution_lock(uniqueness_key, payload)
+              Pgbus.logger.info { "[Pgbus] Skipping duplicate execution for #{job_class}" }
+              return :skipped
+            end
+          end
+        end
 
         job_succeeded = false
 
@@ -33,10 +56,12 @@ module Pgbus
         end
 
         instrument("pgbus.job_completed", queue: queue_name, job_class: job_class)
+        record_stat(payload, queue_name, "success", execution_start)
         :success
       rescue StandardError => e
         handle_failure(message, queue_name, e)
         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)
         # Don't signal concurrency on transient failure — the job will be retried.
         # Semaphore is released only on success or dead-lettering.
         :failed
@@ -47,6 +72,8 @@ module Pgbus
         if job_succeeded
           signal_concurrency(payload)
           signal_batch_completed(payload)
+          # Release uniqueness lock on successful completion (both strategies)
+          Uniqueness.release_lock(uniqueness_key) if uniqueness_key
         end
       end
 
@@ -60,6 +87,24 @@ module Pgbus
         end
       end
 
+      def monotonic_now
+        ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      end
+
+      def record_stat(payload, queue_name, status, start_time)
+        return unless config.stats_enabled
+
+        duration_ms = ((monotonic_now - start_time) * 1000).round
+        JobStat.record!(
+          job_class: payload&.dig("job_class") || "unknown",
+          queue_name: queue_name,
+          status: status,
+          duration_ms: duration_ms
+        )
+      rescue StandardError => e
+        Pgbus.logger.debug { "[Pgbus] Stat recording failed: #{e.message}" }
+      end
+
       def handle_failure(_message, _queue_name, error)
         Pgbus.logger.error { "[Pgbus] Job failed: #{error.class}: #{error.message}" }
         Pgbus.logger.debug { error.backtrace&.join("\n") }

data/lib/pgbus/client.rb

@@ -32,14 +32,11 @@ module Pgbus
       )
       @pgmq_mutex = Mutex.new
       @queues_created = Concurrent::Map.new
+      @queue_strategy = QueueFactory.for(config)
     end
 
     def ensure_queue(name)
-      if priority_enabled?
-        config.priority_queue_names(name).each { |pq| ensure_single_queue(pq) }
-      else
-        ensure_single_queue(config.queue_name(name))
-      end
+      @queue_strategy.physical_queue_names(name).each { |pq| ensure_single_queue(pq) }
     rescue PGMQ::Errors::ConnectionError => e
       raise Pgbus::SchemaNotReady,
             "PGMQ schema is not available (#{e.message}). Run `rails db:migrate` for the pgbus database."
@@ -56,7 +53,7 @@ module Pgbus
     end
 
     def send_message(queue_name, payload, headers: nil, delay: 0, priority: nil)
-      target = resolve_target_queue(queue_name, priority)
+      target = @queue_strategy.target_queue(queue_name, priority)
       ensure_queue(queue_name)
       Instrumentation.instrument("pgbus.client.send_message", queue: target) do
         synchronized { @pgmq.produce(target, serialize(payload), headers: headers && serialize(headers), delay: delay) }
@@ -90,7 +87,11 @@ module Pgbus
     # Read from priority sub-queues, highest priority (p0) first.
     # Returns [priority_queue_name, messages] pairs.
     def read_batch_prioritized(queue_name, qty:, vt: nil)
-      return (read_batch(queue_name, qty: qty, vt: vt) || []).map { |m| [config.queue_name(queue_name), m] } unless priority_enabled?
+      unless @queue_strategy.priority?
+        return (read_batch(queue_name, qty: qty, vt: vt) || []).map do |m|
+          [config.queue_name(queue_name), m]
+        end
+      end
 
       remaining = qty
       results = []
@@ -239,21 +240,6 @@ module Pgbus
       end
     end
 
-    def priority_enabled?
-      config.priority_levels && config.priority_levels > 1
-    end
-
-    def resolve_target_queue(queue_name, priority)
-      if priority_enabled? && priority
-        clamped = priority.clamp(0, config.priority_levels - 1)
-        config.priority_queue_name(queue_name, clamped)
-      elsif priority_enabled?
-        config.priority_queue_name(queue_name, config.default_priority.clamp(0, config.priority_levels - 1))
-      else
-        config.queue_name(queue_name)
-      end
-    end
-
     # Serialize all PGMQ operations through a single mutex.
     # PG::Connection is not thread-safe — concurrent access from worker
     # threads causes segfaults and result corruption.

data/lib/pgbus/configuration.rb

@@ -59,6 +59,9 @@ module Pgbus
     # Requires a matching entry in config/database.yml under the "pgbus" key.
     attr_accessor :connects_to
 
+    # Job stats
+    attr_accessor :stats_retention, :stats_enabled
+
     # Web dashboard
     attr_accessor :web_auth, :web_refresh_interval, :web_per_page, :web_live_updates, :web_data_source
 
@@ -120,6 +123,9 @@ module Pgbus
       @skip_recurring = false
       @recurring_execution_retention = 7 * 24 * 3600 # 7 days
 
+      @stats_enabled = true
+      @stats_retention = 7 * 24 * 3600 # 7 days
+
       @connects_to = nil
 
       @web_auth = nil

data/lib/pgbus/engine.rb

@@ -34,6 +34,7 @@ module Pgbus
     initializer "pgbus.active_job" do
       ActiveSupport.on_load(:active_job) do
         include Pgbus::Concurrency
+        include Pgbus::Uniqueness
       end
     end
 

data/lib/pgbus/process/consumer_priority.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module Process
+    # Implements consumer priority by checking whether higher-priority
+    # workers are active for the same queues. When a higher-priority
+    # worker is healthy and not at its prefetch limit, lower-priority
+    # workers yield by using a longer polling interval.
+    #
+    # Inspired by LavinMQ's consumer priority where higher-priority
+    # consumers are served first and lower-priority consumers wait
+    # until all higher-priority consumers are at their prefetch limit.
+    module ConsumerPriority
+      # Check if this worker should yield to a higher-priority worker.
+      # Returns true if a higher-priority healthy worker exists for
+      # any of the given queues.
+      def self.should_yield?(queues:, my_priority:, my_pid:)
+        return false if my_priority >= max_active_priority(queues, my_pid)
+
+        true
+      rescue StandardError => e
+        Pgbus.logger.debug { "[Pgbus] Consumer priority check failed: #{e.message}" }
+        false
+      end
+
+      # Returns the highest consumer_priority among healthy workers
+      # that share at least one queue with the given queue list,
+      # excluding the current worker (by PID).
+      def self.max_active_priority(queues, my_pid)
+        conn = Pgbus.configuration.connects_to ? Pgbus::ApplicationRecord.connection : ActiveRecord::Base.connection
+        rows = conn.select_all(
+          "SELECT metadata FROM pgbus_processes WHERE kind = 'worker' AND pid != $1 AND last_heartbeat_at > $2",
+          "Pgbus ConsumerPriority",
+          [my_pid, Time.now.utc - Heartbeat::ALIVE_THRESHOLD]
+        )
+
+        max_priority = 0
+        rows.each do |row|
+          metadata = row["metadata"]
+          metadata = JSON.parse(metadata) if metadata.is_a?(String)
+          next unless metadata
+
+          other_queues = metadata["queues"] || []
+          next unless queues.intersect?(other_queues)
+
+          other_priority = metadata["consumer_priority"] || 0
+          max_priority = other_priority if other_priority > max_priority
+        end
+
+        max_priority
+      end
+
+      # Calculate the effective polling interval for this worker.
+      # Higher-priority workers use the base interval.
+      # Lower-priority workers multiply by a backoff factor.
+      def self.effective_polling_interval(base_interval:, my_priority:, max_priority:)
+        return base_interval if my_priority >= max_priority
+
+        # Lower-priority workers back off: 3x the base interval
+        base_interval * 3
+      end
+    end
+  end
+end

data/lib/pgbus/process/dispatcher.rb

@@ -13,6 +13,8 @@ module Pgbus
       RECURRING_CLEANUP_INTERVAL = 3600     # Run recurring execution cleanup every hour
       ARCHIVE_COMPACTION_INTERVAL = 3600    # Run archive compaction every hour
       OUTBOX_CLEANUP_INTERVAL = 3600 # Run outbox cleanup every hour
+      JOB_LOCK_CLEANUP_INTERVAL = 300 # Run job lock cleanup every 5 minutes
+      STATS_CLEANUP_INTERVAL = 3600 # Run stats cleanup every hour
 
       attr_reader :config
 
@@ -26,6 +28,8 @@ module Pgbus
         @last_recurring_cleanup_at = Time.now
         @last_archive_compaction_at = Time.now
         @last_outbox_cleanup_at = Time.now
+        @last_job_lock_cleanup_at = Time.now
+        @last_stats_cleanup_at = Time.now
       end
 
       def run
@@ -70,6 +74,8 @@ module Pgbus
         run_if_due(now, :@last_recurring_cleanup_at, RECURRING_CLEANUP_INTERVAL) { cleanup_recurring_executions }
         run_if_due(now, :@last_archive_compaction_at, archive_compaction_interval) { compact_archives }
         run_if_due(now, :@last_outbox_cleanup_at, OUTBOX_CLEANUP_INTERVAL) { cleanup_outbox }
+        run_if_due(now, :@last_job_lock_cleanup_at, JOB_LOCK_CLEANUP_INTERVAL) { cleanup_job_locks }
+        run_if_due(now, :@last_stats_cleanup_at, STATS_CLEANUP_INTERVAL) { cleanup_stats }
       end
 
       # Only update the timestamp when the block succeeds.
@@ -127,6 +133,29 @@ module Pgbus
         Pgbus.logger.warn { "[Pgbus] Batch cleanup failed: #{e.message}" }
       end
 
+      def cleanup_stats
+        return unless config.stats_enabled
+
+        retention = config.stats_retention
+        return unless retention&.positive?
+
+        deleted = JobStat.cleanup!(older_than: Time.now.utc - retention)
+        Pgbus.logger.debug { "[Pgbus] Cleaned up #{deleted} old job stats" } if deleted.positive?
+      end
+
+      def cleanup_job_locks
+        # Primary: reap orphaned locks whose owner worker is no longer alive.
+        # Cross-references (owner_pid, owner_hostname) against pgbus_processes heartbeats.
+        reaped = JobLock.reap_orphaned!
+        Pgbus.logger.info { "[Pgbus] Reaped #{reaped} orphaned job locks" } if reaped.positive?
+
+        # Last resort: clean up locks with expired TTL (handles case where
+        # even the reaper/supervisor is dead and locks are truly abandoned).
+        expired = JobLock.cleanup_expired!
+        Pgbus.logger.debug { "[Pgbus] Cleaned up #{expired} expired job locks" } if expired.positive?
+        # No rescue here — let run_if_due handle the error and retry next tick
+      end
+
       def cleanup_outbox
         return unless config.outbox_enabled
 

data/lib/pgbus/process/queue_lock.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Pgbus
+  module Process
+    # Manages PostgreSQL advisory locks for single-active-consumer mode.
+    # Only one worker process can hold the lock for a given queue at a time.
+    # Other workers skip the queue and process other queues instead.
+    #
+    # Uses pg_try_advisory_lock (non-blocking) so workers never wait —
+    # they simply skip queues they can't lock and try again next cycle.
+    #
+    # Locks are session-level and automatically released when the connection
+    # closes (including on crash), so no manual cleanup is needed.
+    class QueueLock
+      # Use a fixed namespace to avoid collision with application advisory locks.
+      # CRC32 of "pgbus_queue_lock" = 0x5067_6275
+      LOCK_NAMESPACE = 0x5067_6275
+
+      def initialize
+        @held_locks = Concurrent::Map.new
+      end
+
+      # Try to acquire an advisory lock for the given queue name.
+      # Returns true if acquired (or already held), false if another process holds it.
+      def try_lock(queue_name)
+        return true if @held_locks[queue_name]
+
+        lock_id = lock_id_for(queue_name)
+        acquired = connection.select_value(
+          "SELECT pg_try_advisory_lock(#{LOCK_NAMESPACE}, #{lock_id})"
+        )
+
+        if acquired
+          @held_locks[queue_name] = lock_id
+          true
+        else
+          false
+        end
+      rescue StandardError => e
+        Pgbus.logger.warn { "[Pgbus] Advisory lock failed for #{queue_name}: #{e.message}" }
+        false
+      end
+
+      # Release the advisory lock for a queue. Called during shutdown.
+      def unlock(queue_name)
+        lock_id = @held_locks.delete(queue_name)
+        return unless lock_id
+
+        connection.select_value(
+          "SELECT pg_advisory_unlock(#{LOCK_NAMESPACE}, #{lock_id})"
+        )
+      rescue StandardError => e
+        Pgbus.logger.warn { "[Pgbus] Advisory unlock failed for #{queue_name}: #{e.message}" }
+      end
+
+      # Release all held locks.
+      def unlock_all
+        @held_locks.each_key { |q| unlock(q) }
+      end
+
+      def locked?(queue_name)
+        @held_locks.key?(queue_name)
+      end
+
+      def held_queues
+        @held_locks.keys
+      end
+
+      private
+
+      def lock_id_for(queue_name)
+        # Use a stable hash to convert queue name to a 32-bit integer
+        Zlib.crc32(queue_name.to_s) & 0x7FFFFFFF
+      end
+
+      def connection
+        if Pgbus.configuration.connects_to
+          Pgbus::ApplicationRecord.connection
+        else
+          ActiveRecord::Base.connection
+        end
+      end
+    end
+  end
+end

data/lib/pgbus/process/supervisor.rb

@@ -63,12 +63,17 @@ module Pgbus
       def fork_worker(worker_config)
         queues = worker_config[:queues] || worker_config["queues"] || [config.default_queue]
         threads = worker_config[:threads] || worker_config["threads"] || 5
+        single_active = worker_config[:single_active_consumer] || worker_config["single_active_consumer"] || false
+        priority = worker_config[:consumer_priority] || worker_config["consumer_priority"] || 0
 
         pid = fork do
           restore_signals
           setup_child_process
           load_rails_app
-          worker = Worker.new(queues: queues, threads: threads, config: config)
+          worker = Worker.new(
+            queues: queues, threads: threads, config: config,
+            single_active_consumer: single_active, consumer_priority: priority
+          )
           worker.run
         end