pgbus 0.18.2 → 0.19.0

data/lib/pgbus/web/authentication.rb

@@ -9,8 +9,25 @@ module Pgbus
         before_action :authenticate_pgbus!
       end
 
+      # The "dashboard has no authentication" warning is logged once per
+      # process. Request threads check and set the flag under @warn_lock, so
+      # concurrent first requests cannot both log it (issue #527).
+      @warn_lock = Mutex.new
+      @auth_warned = false
+
       class << self
-        attr_accessor :auth_warned
+        def auth_warned
+          @warn_lock.synchronize { @auth_warned }
+        end
+
+        def auth_warned=(value)
+          @warn_lock.synchronize { @auth_warned = value }
+        end
+
+        # True for the one caller that flips the flag from false to true.
+        def claim_auth_warning!
+          @warn_lock.synchronize { @auth_warned ? false : (@auth_warned = true) }
+        end
       end
 
       # Default base controller — anything else means the app deliberately
@@ -40,13 +57,13 @@ module Pgbus
         # place; don't nag apps that gate the dashboard via a custom controller
         # (they had to set a redundant web_auth lambda just to silence us — #334).
         return unless default_base_controller?
+        return unless Pgbus::Web::Authentication.claim_auth_warning!
 
         Pgbus.logger.warn do
           "[Pgbus] Dashboard is accessible without authentication. " \
             "Configure Pgbus.configuration.web_auth to restrict access. " \
             "See: https://github.com/zoolutions/pgbus#dashboard-authentication"
         end
-        Pgbus::Web::Authentication.auth_warned = true
       end
 
       # True when base_controller_class is (still) the default ActionController::Base.

data/lib/pgbus/web/data_source/list_counts.rb

@@ -30,12 +30,14 @@ module Pgbus
           ) b ON s.key = b.concurrency_key
         SQL
 
+        # Model names, resolved when counted (the models autoload lazily):
+        # names rather than lambdas, so the constant is plain frozen data.
         LIST_MODELS = {
-          batches: -> { BatchEntry },
-          job_locks: -> { UniquenessKey },
-          outbox: -> { OutboxEntry },
-          processed_events: -> { ProcessedEvent },
-          recurring_tasks: -> { RecurringTask }
+          batches: :BatchEntry,
+          job_locks: :UniquenessKey,
+          outbox: :OutboxEntry,
+          processed_events: :ProcessedEvent,
+          recurring_tasks: :RecurringTask
         }.freeze
 
         # list – :batches, :job_locks, :concurrency_keys, :outbox, :processed_events or :recurring_tasks.
@@ -62,7 +64,7 @@ module Pgbus
         private
 
         def bounded_count(list)
-          rows = list == :concurrency_keys ? concurrency_keys_probe : LIST_MODELS.fetch(list).call.limit(COUNT_CAP + 1).count
+          rows = list == :concurrency_keys ? concurrency_keys_probe : Pgbus.const_get(LIST_MODELS.fetch(list)).limit(COUNT_CAP + 1).count
           Count.new(total: [rows.to_i, COUNT_CAP].min, capped: rows.to_i > COUNT_CAP)
         rescue StandardError => e
           Pgbus.logger.debug { "[Pgbus::Web] Error counting #{list}: #{e.message}" }

data/lib/pgbus/web/health_server.rb

@@ -65,7 +65,10 @@ module Pgbus
 
         @server = TCPServer.new(@bind, @configured_port)
         @port = @server.addr[1]
-        @thread = Thread.new { accept_loop }
+        # The accept loop, owned by this server: started once (the @server
+        # check above) by the supervisor, joined (then killed if it hangs) by
+        # #stop.
+        @thread = Thread.new { accept_loop } # rubocop:disable ThreadSafety/NewThread
         logger.info { "[Pgbus::Web::HealthServer] listening on #{@bind}:#{@port} (/livez, /readyz)" }
       end
 

data/lib/pgbus/web/process_activity.rb

@@ -11,7 +11,7 @@ module Pgbus
     # :uptime and :limit (lifetime), Strings for queue and topic lists.
     module ProcessActivity
       KIND_ORDER = %w[worker consumer dispatcher scheduler outbox_poller].freeze
-      RECYCLE_LIMITS = [%w[jobs max_jobs jobs_processed done], %w[memory max_memory_mb memory_mb used]].freeze
+      RECYCLE_LIMITS = [%w[jobs max_jobs jobs_processed done].freeze, %w[memory max_memory_mb memory_mb used].freeze].freeze
 
       module_function
 

data/lib/pgbus/web/streamer/heartbeat.rb

@@ -48,7 +48,10 @@ module Pgbus
           return if @running
 
           @running = true
-          @thread = Thread.new { run_loop }
+          # The heartbeat's one thread, owned by this object: Instance#start
+          # starts it once (under Streamer's @current_mutex); #stop signals
+          # and joins it.
+          @thread = Thread.new { run_loop } # rubocop:disable ThreadSafety/NewThread
           self
         end
 

data/lib/pgbus/web/streamer/hub_client.rb

@@ -43,7 +43,10 @@ module Pgbus
 
         def connect
           @sock = UNIXSocket.new(@socket_path)
-          @reader = Thread.new { reader_loop }
+          # The client's reader thread, owned by this object: #connect starts
+          # it once per socket; it ends when the socket closes, and #stop
+          # closes the socket and joins it.
+          @reader = Thread.new { reader_loop } # rubocop:disable ThreadSafety/NewThread
           self
         rescue SystemCallError, IOError, ArgumentError, ThreadError => e
           # ArgumentError: a socket path over the platform sun_path limit;

data/lib/pgbus/web/streamer/listener.rb

@@ -35,8 +35,14 @@ module Pgbus
       # For a queue named `pgbus_stream_chat` the trigger table is
       # `q_pgbus_stream_chat`, so the channel is `pgmq.q_pgbus_stream_chat.INSERT`.
       class Listener
+        # Kept Ractor-shareable (issue #527): the hand-off to the dispatcher
+        # is the seam a Ractor dispatcher would pass by reference. The Strings
+        # are frozen in place: they are the sender's own (the NOTIFY's, or the
+        # hub frame's).
         WakeMessage = Data.define(:queue_name, :payload) do
           def initialize(queue_name:, payload: nil)
+            queue_name.freeze
+            payload&.freeze
             super
           end
         end
@@ -101,7 +107,10 @@ module Pgbus
           return if @running
 
           @running = true
-          @thread = Thread.new { run_loop }
+          # The LISTEN thread, owned by this object: Instance#start starts it
+          # once (under Streamer's @current_mutex); #stop clears @running and
+          # joins it.
+          @thread = Thread.new { run_loop } # rubocop:disable ThreadSafety/NewThread
           self
         end
 

data/lib/pgbus/web/streamer/master_hub.rb

@@ -124,9 +124,12 @@ module Pgbus
             File.umask(old_umask)
           end
           File.chmod(0o600, @socket_path)
-          @accept_thread = Thread.new { accept_loop }
-          @fanout_thread = Thread.new { fanout_loop }
-          @status_thread = Thread.new { status_loop }
+          # The hub's three loops, owned by this hub: #start runs once at hub
+          # start in the Puma master, under @lifecycle_mutex; #stop signals
+          # each loop and joins all three.
+          @accept_thread = Thread.new { accept_loop } # rubocop:disable ThreadSafety/NewThread
+          @fanout_thread = Thread.new { fanout_loop } # rubocop:disable ThreadSafety/NewThread
+          @status_thread = Thread.new { status_loop } # rubocop:disable ThreadSafety/NewThread
           self
         rescue StandardError
           @table_mutex.synchronize { @running = false }
@@ -201,8 +204,11 @@ module Pgbus
             @workers[@next_id] = entry
             @next_id
           end
-          entry[:writer] = Thread.new { writer_loop(id, entry) }
-          entry[:reader] = Thread.new { reader_loop(id, entry) }
+          # One writer and one reader per connected Puma worker, owned by its
+          # @workers entry: both end when cleanup_worker closes the entry's
+          # socket (a worker hangs up, or #stop cleans up every worker).
+          entry[:writer] = Thread.new { writer_loop(id, entry) } # rubocop:disable ThreadSafety/NewThread
+          entry[:reader] = Thread.new { reader_loop(id, entry) } # rubocop:disable ThreadSafety/NewThread
           id
         end
 

data/lib/pgbus/web/streamer/master_hub_boot.rb

@@ -50,7 +50,9 @@ module Pgbus
         def start
           ENV["PGBUS_STREAMS_HUB_SOCKET"] = @socket_path
           @state_mutex.synchronize { @running = true }
-          @thread = Thread.new { wait_and_start }
+          # The boot thread, owned by this object: the Puma plugin starts it
+          # once in the master; #stop clears @running and joins it.
+          @thread = Thread.new { wait_and_start } # rubocop:disable ThreadSafety/NewThread
           self
         end
 

data/lib/pgbus/web/streamer/outbound_pump.rb

@@ -62,7 +62,10 @@ module Pgbus
 
           @started = true
           @partitions.each do |partition|
-            @threads << Thread.new { run_worker(partition) }
+            # One writer per partition, owned by this pump: Instance#start
+            # starts them once (the @started check above); #stop signals each
+            # partition and joins every thread.
+            @threads << Thread.new { run_worker(partition) } # rubocop:disable ThreadSafety/NewThread
           end
           self
         end

data/lib/pgbus/web/streamer/peer_close_watcher.rb

@@ -57,7 +57,10 @@ module Pgbus
 
           @wake_reader, @wake_writer = IO.pipe if @wake_reader.closed?
           @running = true
-          @thread = Thread.new { run_loop }
+          # The watcher's one thread, owned by this object: Instance#start
+          # starts it once (under Streamer's @current_mutex); #stop wakes it
+          # through the pipe and joins it.
+          @thread = Thread.new { run_loop } # rubocop:disable ThreadSafety/NewThread
           self
         end
 

data/lib/pgbus/web/streamer/stream_event_dispatcher.rb

@@ -62,8 +62,17 @@ module Pgbus
         #                    nil means the default (turbo-stream); a typed
         #                    name (e.g. "presence", "reactive") lets clients
         #                    route without sniffing the HTML (issue #170).
+        #
+        # Kept Ractor-shareable, like WakeMessage (issue #527): its Strings are
+        # frozen in place (the dispatcher's own, from JSON.parse or the read),
+        # and `exclude` is normalized to the String it is compared as.
         StreamEnvelope = Data.define(:msg_id, :enqueued_at, :payload, :source, :visible_to, :exclude, :event) do
           def initialize(msg_id:, enqueued_at:, payload:, source:, visible_to: nil, exclude: nil, event: nil)
+            enqueued_at&.freeze
+            payload&.freeze
+            source&.freeze
+            event&.freeze
+            exclude = exclude&.to_s&.freeze
             super
           end
         end
@@ -147,7 +156,10 @@ module Pgbus
           return if @running
 
           @running = true
-          @thread = Thread.new { run_loop }
+          # The dispatcher's one thread, owned by this object: Instance#start
+          # starts it once (under Streamer's @current_mutex); #stop sends the
+          # sentinel and joins it.
+          @thread = Thread.new { run_loop } # rubocop:disable ThreadSafety/NewThread
           self
         end
 

data/lib/pgbus.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "concurrent/map"
 require "zeitwerk"
 
 module Pgbus
@@ -83,17 +84,37 @@ module Pgbus
   end
 
   class << self
+    # The gem's Zeitwerk loader, the app/models loader used outside Rails, and
+    # the configuration: built once when this file loads (see the bottom of
+    # the module body) and replaced only by reset!/teardown under @state_lock.
+    # Readers need no lock: a reference is published whole.
+    attr_reader :loader, :models_loader, :configuration
+
     # Process-global flag set by Worker#graceful_shutdown so the adapter
     # can report stopping? to ActiveJob::Continuation (Rails 8.1+).
-    attr_writer :stopping
-
     def stopping
-      @stopping || false
+      @state_lock.synchronize { @stopping }
+    end
+
+    def stopping=(value)
+      @state_lock.synchronize { @stopping = value ? true : false }
     end
 
-    def loader
-      @loader ||= begin
-        loader = Zeitwerk::Loader.for_gem
+    private
+
+    # True while a Rails app boots (its initializers and after_initialize
+    # blocks run): the engine finalizes at the end of that.
+    def rails_booting?
+      return false unless defined?(::Rails::Application) && ::Rails.respond_to?(:application)
+
+      app = ::Rails.application
+      !app.nil? && !app.initialized?
+    end
+
+    # Zeitwerk::Loader.for_gem works out the gem root from its caller, so this
+    # must stay in lib/pgbus.rb.
+    def build_loader
+      Zeitwerk::Loader.for_gem.tap do |loader|
         loader.inflector.inflect(
           "pgbus" => "Pgbus",
           "cli" => "CLI",
@@ -127,35 +148,32 @@ module Pgbus
         # root and tries to autoload Puma::Plugin, which collides with the real
         # Puma::Plugin class defined by the puma gem itself.
         loader.ignore("#{__dir__}/puma")
-        loader
       end
     end
 
     # Separate loader for app/models used only in non-Rails contexts (specs,
     # standalone scripts). When the Engine boots, Rails' autoloader takes over
     # app/models and this loader is torn down to avoid conflicts.
-    def models_loader
+    def build_models_loader
       models_dir = File.expand_path("../app/models", __dir__)
       return nil unless File.directory?(models_dir)
 
-      @models_loader ||= begin
-        loader = Zeitwerk::Loader.new
+      Zeitwerk::Loader.new.tap do |loader|
         loader.tag = "pgbus-models"
         loader.push_dir(models_dir)
         loader.setup
-        loader
       end
     end
 
-    def teardown_models_loader!
-      return unless @models_loader
-
-      @models_loader.unregister
-      @models_loader = nil
-    end
+    public
 
-    def configuration
-      @configuration ||= Configuration.new
+    def teardown_models_loader!
+      loader = @state_lock.synchronize do
+        current = @models_loader
+        @models_loader = nil
+        current
+      end
+      loader&.unregister
     end
 
     # True when the current process is running a rake task (db:*, assets:*, …
@@ -188,11 +206,32 @@ module Pgbus
       # until a worker path consumes it. Checking the flag after the yield
       # lets a block opt out for itself via `c.eager_validation = false`.
       configuration.validate! if configuration.eager_validation
+      # Without Rails this is the end of boot, so it finalizes; so does any
+      # configure once a Rails app has booted. While a Rails app boots, the
+      # engine's after_initialize finalizes instead, after every initializer
+      # and after_initialize block has had its say.
+      configuration.finalize! if configuration.finalized? || !rails_booting?
       configuration
     end
 
+    # The end of boot: validates the configuration (unless eager_validation
+    # is off) and freezes its plain-data settings into Ractor-shareable values
+    # (Configuration#finalize!). Callables and the logger stay as they are, on
+    # the main Ractor. Runs on its own: from the engine's after_initialize in a
+    # Rails app, at the end of each Pgbus.configure without Rails, and in
+    # `pgbus start` after its flags. Call it yourself only when you configure
+    # pgbus through setters alone, without Rails.
+    def finalize!
+      configuration.validate! if configuration.eager_validation
+      configuration.finalize!
+    end
+
+    # Built on first use, under @state_lock: two threads making the first
+    # call at once must not each build a Client (the loser's pool would be
+    # orphaned, its connections never closed). Not built at boot: a Client
+    # resolves connection options, which a rake db: task must not need.
     def client
-      @client ||= Client.new(configuration)
+      @state_lock.synchronize { @client ||= Client.new(configuration) }
     end
 
     # Entry point for the streams subsystem — `Pgbus.stream(name).broadcast(html)`
@@ -218,8 +257,7 @@ module Pgbus
       name = Streams::Stream.name_from(streamables)
       resolved = durable.nil? ? configuration.stream_durable?(name) : durable
       cache_key = "#{name}:#{resolved ? "d" : "e"}"
-      @stream_cache ||= Concurrent::Map.new
-      @stream_cache.compute_if_absent(cache_key) { Streams::Stream.new(streamables, durable: resolved) }
+      stream_cache.compute_if_absent(cache_key) { Streams::Stream.new(streamables, durable: resolved) }
     end
 
     # Compose a short, pgbus-safe stream identifier from any mix of
@@ -278,11 +316,14 @@ module Pgbus
       EventBus::Publisher.publish_later(routing_key, payload, delay: delay, headers: headers)
     end
 
+    # A fresh configuration (never nil, so readers need no lock) and no client.
     def reset!
-      @client&.close
-      @client = nil
-      @configuration = nil
-      @stream_cache = nil
+      @state_lock.synchronize do
+        @client&.close
+        @client = nil
+        @configuration = Configuration.new
+        @stream_cache = Concurrent::Map.new
+      end
     end
 
     # Discard the inherited PGMQ client after fork.
@@ -290,9 +331,13 @@ module Pgbus
     # state post-fork and attempting to acquire it can deadlock.
     # The next call to Pgbus.client will lazily create a fresh one.
     # Cached streams hold the client they were built with, so they go too.
+    # (@state_lock itself is safe to take in the child: Ruby abandons a Mutex
+    # whose owning thread did not survive the fork.)
     def reset_client!
-      @client = nil
-      @stream_cache = nil
+      @state_lock.synchronize do
+        @client = nil
+        @stream_cache = Concurrent::Map.new
+      end
     end
 
     def logger
@@ -302,13 +347,30 @@ module Pgbus
     def logger=(value)
       configuration.logger = value
     end
+
+    private
+
+    # Process-local, like the client it holds; replaced (never mutated in
+    # place) by reset!/reset_client!.
+    attr_reader :stream_cache
   end
 
-  loader.setup
+  # Module state, built here at load rather than by `||=` on first use, so no
+  # two threads can each build their own (issue #527). @state_lock guards every
+  # later write: the client memo, reset!/reset_client!, the stopping flag.
+  @state_lock = Mutex.new
+  @stopping = false
+  @client = nil
+  @stream_cache = Concurrent::Map.new
+  @loader = build_loader
+  @loader.setup
+
+  # After loader.setup: Configuration is Zeitwerk-managed.
+  @configuration = Configuration.new
 
   # In non-Rails contexts, set up model autoloading via a separate loader.
   # This is torn down by the Engine initializer when Rails boots.
-  models_loader unless defined?(Rails::Engine)
+  @models_loader = defined?(Rails::Engine) ? nil : build_models_loader
 end
 
 require "active_job/queue_adapters/pgbus_adapter" if defined?(ActiveJob)

data/sig/pgbus/active_job/adapter.rbs

@@ -0,0 +1,57 @@
+module Pgbus
+  module ActiveJob
+    # What the queue adapter delegates to.
+    class Adapter
+      def enqueue: (untyped active_job) -> untyped
+      def enqueue_at: (untyped active_job, Numeric timestamp) -> untyped
+      def enqueue_all: (Array[untyped] active_jobs) -> Integer
+    end
+  end
+
+  # The job-class options, included on ActiveJob::Base by the engine.
+  module Concurrency
+    module ClassMethods
+      def limits_concurrency: (to: Integer, ?key: untyped, ?duration: Numeric, ?on_conflict: :block | :discard | :raise) -> untyped
+      def pgbus_concurrency: () -> Hash[Symbol, untyped]?
+    end
+  end
+
+  module Uniqueness
+    module ClassMethods
+      # Any other keyword raises ArgumentError (lock_ttl: with a pointer to 1.0's removal).
+      def ensures_uniqueness: (?strategy: :until_executed | :while_executing, ?key: untyped,
+                               ?on_conflict: :reject | :discard | :log) -> untyped
+      def pgbus_uniqueness: () -> Hash[Symbol, untyped]?
+    end
+  end
+
+  module RetryBackoff
+    module JobMixin
+      module ClassMethods
+        def pgbus_retry_backoff: (?base: Numeric?, ?max: Numeric?, ?jitter: Numeric?) -> untyped
+        def pgbus_retry_backoff_config: () -> Hash[Symbol, Numeric]?
+      end
+    end
+  end
+
+  module VisibilityHeartbeat
+    module JobMixin
+      module ClassMethods
+        def pgbus_visibility_heartbeat: (?boolish enabled) -> bool
+      end
+    end
+  end
+end
+
+module ActiveJob
+  module QueueAdapters
+    # `config.active_job.queue_adapter = :pgbus`
+    class PgbusAdapter
+      def enqueue: (untyped active_job) -> untyped
+      def enqueue_at: (untyped active_job, Numeric timestamp) -> untyped
+      def enqueue_all: (Array[untyped] active_jobs) -> Integer
+      def enqueue_after_transaction_commit?: () -> bool
+      def stopping?: () -> bool
+    end
+  end
+end

data/sig/pgbus/client.rbs

@@ -0,0 +1,78 @@
+# The PGMQ client (Pgbus.client). Generated from reflection, untyped; always go
+# through it rather than PGMQ directly. spec/pgbus/rbs_spec.rb fails when a
+# public method is missing here.
+module Pgbus
+  class Client
+    def archive_batch: (untyped queue_name, untyped msg_ids, ?prefixed: untyped) -> untyped
+    def archive_message: (untyped queue_name, untyped msg_id, ?prefixed: untyped) -> untyped
+    def bind_topic: (untyped pattern, untyped queue_name) -> untyped
+    def close: () -> untyped
+    def config: () -> untyped
+    def configured_queues: () -> untyped
+    def connection_health: () -> untyped
+    def convert_archive_partitioned: (untyped queue_name, ?partition_interval: untyped, ?retention_interval: untyped, ?leading_partition: untyped) -> untyped
+    def create_fifo_index: (untyped queue_name) -> untyped
+    def create_fifo_indexes_all: () -> untyped
+    def dead_letter_physical_name: (untyped queue_name) -> untyped
+    def delete_batch: (untyped queue_name, untyped msg_ids, ?prefixed: untyped) -> untyped
+    def delete_message: (untyped queue_name, untyped msg_id, ?prefixed: untyped) -> untyped
+    def drop_queue: (untyped queue_name, ?prefixed: untyped) -> untyped
+    def ensure_all_queues: () -> untyped
+    def ensure_dead_letter_queue: (untyped name) -> untyped
+    def ensure_fair_index: (untyped queue_name) -> untyped
+    def ensure_queue: (untyped name) -> untyped
+    def ensure_stream_queue: (untyped stream_name) -> untyped
+    def in_recovery?: () -> bool
+    def list_notify_insert_throttles: () -> untyped
+    def list_queues: () -> untyped
+    def message_archived?: (untyped queue_name, msg_id: untyped) -> bool
+    def message_exists?: (untyped queue_name, ?msg_id: untyped, ?uniqueness_key: untyped) -> bool
+    def message_in_queue?: (untyped queue_name, msg_id: untyped) -> bool
+    def message_with_job_id?: (untyped queue_name, job_id: untyped) -> bool
+    def metrics: (?untyped queue_name) -> untyped
+    def move_to_dead_letter: (untyped queue_name, untyped message, ?headers: untyped) -> untyped
+    def notify_enabled?: (untyped queue_name) -> bool
+    def notify_stream: (untyped stream_name, untyped payload) -> untyped
+    def oldest_claimable_ages: (?untyped queue_name) -> untyped
+    def pgmq: () -> untyped
+    def pgmq_installed?: () -> bool
+    def pgmq_schema_version: () -> untyped
+    def physical_queue_names: (untyped logical_name) -> untyped
+    def ping: () -> untyped
+    def pool_stats: () -> untyped
+    def publish_to_topic: (untyped routing_key, untyped payload, ?headers: untyped, ?delay: untyped) -> untyped
+    def purge_archive: (untyped queue_name, older_than: untyped, ?batch_size: untyped) -> untyped
+    def purge_queue: (untyped queue_name, ?prefixed: untyped) -> untyped
+    def read_after: (untyped stream_name, after_id: untyped, ?limit: untyped) -> untyped
+    def read_batch: (untyped queue_name, qty: untyped, ?vt: untyped) -> untyped
+    def read_batch_fair: (untyped queue_name, qty: untyped, ?vt: untyped) -> untyped
+    def read_batch_prioritized: (untyped queue_name, qty: untyped, ?vt: untyped) -> untyped
+    def read_batch_prioritized_fair: (untyped queue_name, qty: untyped, ?vt: untyped) -> untyped
+    def read_grouped: (untyped queue_name, qty: untyped, ?vt: untyped) -> untyped
+    def read_grouped_head: (untyped queue_name, qty: untyped, ?vt: untyped) -> untyped
+    def read_grouped_rr: (untyped queue_name, qty: untyped, ?vt: untyped) -> untyped
+    def read_message: (untyped queue_name, ?vt: untyped) -> untyped
+    def read_multi: (untyped queue_names, qty: untyped, ?vt: untyped, ?limit: untyped) -> untyped
+    def read_with_poll: (untyped queue_name, qty: untyped, ?vt: untyped, ?max_poll_seconds: untyped, ?poll_interval_ms: untyped) -> untyped
+    def reload: () -> untyped
+    def resize_streams_pool: (untyped new_size) -> untyped
+    def send_batch: (untyped queue_name, untyped payloads, ?headers: untyped, ?delay: untyped, ?priority: untyped) -> untyped
+    def send_message: (untyped queue_name, untyped payload, ?headers: untyped, ?delay: untyped, ?priority: untyped) -> untyped
+    def send_stream_message: (untyped stream_name, untyped payload, ?headers: untyped, ?delay: untyped) -> untyped
+    def set_visibility_timeout: (untyped queue_name, untyped msg_id, vt: untyped, ?prefixed: untyped) -> untyped
+    def shared_connection?: () -> bool
+    def stream_current_msg_id: (untyped stream_name) -> untyped
+    def stream_oldest_msg_id: (untyped stream_name) -> untyped
+    def streams_pool_stats: () -> untyped
+    def streams_swap_stats: () -> untyped
+    def synchronizing?: () -> bool
+    def target_queue: (untyped queue_name, ?untyped priority) -> untyped
+    def transaction: () ?{ (*untyped) -> untyped } -> untyped
+    def uniqueness_keys_present: (untyped lock_keys) -> untyped
+    def update_notify_insert: (untyped queue_name, throttle_interval_ms: untyped) -> untyped
+    def verify_connection!: () -> untyped
+    def wait_for_notify: (untyped queue_name, ?timeout: untyped) ?{ (*untyped) -> untyped } -> untyped
+    def self.load_pgmq_gem!: () -> untyped
+    def self.pgmq_install_mutex: () -> untyped
+  end
+end