pgbus 0.18.2 → 0.19.1

data/lib/pgbus/integrations/appsignal/probe.rb

@@ -24,23 +24,31 @@ module Pgbus
         METRIC_PREFIX = "pgbus_"
         private_constant :METRIC_PREFIX
 
+        # Registered once at boot; @install_lock makes the check-then-register
+        # atomic so the probe is never registered twice (issue #527).
+        @install_lock = Mutex.new
+        @installed = false
+
         class << self
-          def install! # rubocop:disable Naming/PredicateMethod
-            return false if @installed
+          def install!
+            @install_lock.synchronize do
+              next false if @installed
 
-            ::Appsignal::Probes.register :pgbus, new_probe_instance
-            @installed = true
-            true
+              ::Appsignal::Probes.register :pgbus, new_probe_instance
+              @installed = true
+            end
           end
 
           def installed?
-            @installed == true
+            @install_lock.synchronize { @installed }
           end
 
           def reset!
-            ::Appsignal::Probes.unregister(:pgbus) if defined?(::Appsignal::Probes) &&
-                                                      ::Appsignal::Probes.respond_to?(:unregister)
-            @installed = false
+            @install_lock.synchronize do
+              ::Appsignal::Probes.unregister(:pgbus) if defined?(::Appsignal::Probes) &&
+                                                        ::Appsignal::Probes.respond_to?(:unregister)
+              @installed = false
+            end
           end
 
           # Visible for testing — returns a fresh runnable probe.

data/lib/pgbus/integrations/appsignal/subscriber.rb

@@ -21,14 +21,39 @@ module Pgbus
         METRIC_PREFIX = "pgbus_"
         private_constant :BACKGROUND_JOB, :METRIC_PREFIX
 
-        # Tracked so we can detach in reset! (used by specs).
-        @subscriptions = []
+        # Tracked so we can detach in reset! (used by specs). Installed once
+        # at boot (the engine's after_initialize); @install_lock makes the
+        # check-then-install atomic so nothing subscribes twice (issue #527).
+        @install_lock = Mutex.new
+        @subscriptions = [].freeze
+        @installed = false
 
         class << self
           def install!
-            return false if @installed
+            @install_lock.synchronize do
+              next false if @installed
 
-            @subscriptions = [
+              @subscriptions = subscribe_all
+              @installed = true
+            end
+          end
+
+          def installed?
+            @install_lock.synchronize { @installed }
+          end
+
+          def reset!
+            @install_lock.synchronize do
+              @subscriptions.each { |s| ActiveSupport::Notifications.unsubscribe(s) }
+              @subscriptions = [].freeze
+              @installed = false
+            end
+          end
+
+          private
+
+          def subscribe_all
+            [
               subscribe("pgbus.executor.execute") { |event| on_executor_execute(event) },
               subscribe("pgbus.job_completed") { |event| on_job_completed(event) },
               subscribe("pgbus.job_failed") { |event| on_job_failed(event) },
@@ -48,22 +73,9 @@ module Pgbus
               # pgbus_pool_available gauges for AppSignal (see probe.rb).
               # Subscribing here too would double-report on every heartbeat
               # and skew the gauges.
-            ]
-            @installed = true
-          end
-
-          def installed?
-            @installed == true
+            ].freeze
           end
 
-          def reset!
-            @subscriptions&.each { |s| ActiveSupport::Notifications.unsubscribe(s) }
-            @subscriptions = []
-            @installed = false
-          end
-
-          private
-
           def subscribe(name, &block)
             # silence rubocop unused
             ActiveSupport::Notifications.subscribe(name) do |*args|

data/lib/pgbus/integrations/appsignal.rb

@@ -28,41 +28,51 @@ module Pgbus
       DASHBOARD_PATH = File.expand_path("appsignal/dashboard.json", __dir__).freeze
       DASHBOARDS_DIR = File.expand_path("appsignal/dashboards", __dir__).freeze
 
+      # Installed once at boot (the engine's after_initialize); @lock makes
+      # the check-then-install atomic and guards the parsed-dashboard memos
+      # (issue #527).
+      @lock = Mutex.new
+      @installed = false
+
       module_function
 
-      def install! # rubocop:disable Naming/PredicateMethod
+      def install!
         return false unless defined?(::Appsignal)
-        return false if @installed
 
-        Subscriber.install!
-        Probe.install! if Pgbus.configuration.appsignal_probe_enabled
-        @installed = true
-        Pgbus.logger.info { "[Pgbus] AppSignal integration installed" }
-        true
+        installed_now = @lock.synchronize do
+          next false if @installed
+
+          Subscriber.install!
+          Probe.install! if Pgbus.configuration.appsignal_probe_enabled
+          @installed = true
+        end
+        Pgbus.logger.info { "[Pgbus] AppSignal integration installed" } if installed_now
+        installed_now
       end
 
       def installed?
-        @installed == true
+        @lock.synchronize { @installed }
       end
 
       def dashboard_definition
-        @dashboard_definition ||= JSON.parse(File.read(DASHBOARD_PATH))
+        @lock.synchronize { @dashboard_definition ||= JSON.parse(File.read(DASHBOARD_PATH)) }
       end
 
       def dashboard_definitions
-        @dashboard_definitions ||=
-          Dir[File.join(DASHBOARDS_DIR, "*.json")].map do |path|
-            JSON.parse(File.read(path))
-          end
+        @lock.synchronize do
+          @dashboard_definitions ||= Dir[File.join(DASHBOARDS_DIR, "*.json")].map { |path| JSON.parse(File.read(path)) }
+        end
       end
 
       # Test hook: tear everything down so a fresh install! can run.
       def reset!
         Subscriber.reset! if defined?(Subscriber)
         Probe.reset! if defined?(Probe)
-        @installed = false
-        @dashboard_definition = nil
-        @dashboard_definitions = nil
+        @lock.synchronize do
+          @installed = false
+          @dashboard_definition = nil
+          @dashboard_definitions = nil
+        end
       end
     end
   end

data/lib/pgbus/mcp/rack_app.rb

@@ -37,7 +37,7 @@ module Pgbus
       # First mcp release with the transport's allowed_hosts / allowed_origins /
       # dns_rebinding_protection options. Older gems would raise ArgumentError
       # on the pass-through; fail with the fix spelled out instead.
-      MIN_MCP_VERSION = Gem::Version.new("0.23.0")
+      MIN_MCP_VERSION = Gem::Version.new("0.23.0").freeze
       # Only the JSON body string is frozen and reused. The outer response triple
       # and its headers hash MUST be built fresh per call (#unauthorized) so
       # downstream Rack middleware can mutate them — Rack::TempfileReaper assigns

data/lib/pgbus/mcp/server.rb

@@ -26,7 +26,8 @@ module Pgbus
         Tools::ConcurrencyTool,
         Tools::ThroughputTool,
         Tools::StatsTool,
-        Tools::RecurringTool
+        Tools::RecurringTool,
+        Tools::DeployTasksTool
       ].freeze
 
       INSTRUCTIONS = <<~TEXT

data/lib/pgbus/mcp/tools/deploy_tasks_tool.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module MCP
+    module Tools
+      # Deploy tasks with their state and the rollover the scheduler waits on.
+      # Maps to DataSource#deploy_tasks and #deploy_rollover. Job arguments are
+      # not part of the list payload (and are dropped here if a data source
+      # ever adds them), so the tool never carries them.
+      class DeployTasksTool < BaseTool
+        tool_name "pgbus_deploy_tasks"
+        title "Pgbus Deploy Tasks"
+        description <<~DESC
+          Deploy tasks: one-time jobs the scheduler enqueues once every live pgbus process runs the new app revision. Lists each task's state (disabled, waiting, due, ran, never) and the rollover status the scheduler waits on.
+          Returns every task unless page or per_page is given; then it is
+          paginated (per_page defaults to 100, capped at 100). The response
+          carries page, per_page, total (capped at 10000 when paginated; the
+          exact row count when not) and has_more; per_page is null when
+          unpaginated.
+        DESC
+
+        MAX_PER_PAGE = 100
+        MAX_PAGE = 1_000
+
+        input_schema(
+          properties: {
+            page: { type: "integer", description: "1-based page number (default 1, max 1000).", minimum: 1 },
+            per_page: { type: "integer", description: "Rows per page (default 100 once paginating, max 100).", minimum: 1 }
+          },
+          required: []
+        )
+
+        def self.call(page: nil, per_page: nil, server_context: nil)
+          data_source = data_source_from(server_context)
+          return unpaged(data_source) if page.nil? && per_page.nil?
+
+          per_page = (per_page || MAX_PER_PAGE).to_i.clamp(1, MAX_PER_PAGE)
+          page = (page || 1).to_i.clamp(1, MAX_PAGE)
+          tasks = data_source.deploy_tasks(page: page, per_page: per_page)
+          count = data_source.list_count(:deploy_tasks)
+
+          json_response(
+            payload(data_source, tasks).merge(
+              page: page, per_page: per_page, total: count.total,
+              has_more: more_pages?(count, page: page, per_page: per_page, shown: tasks.size)
+            )
+          )
+        end
+
+        def self.unpaged(data_source)
+          tasks = data_source.deploy_tasks
+          json_response(
+            payload(data_source, tasks).merge(page: 1, per_page: nil, total: tasks.size, has_more: false)
+          )
+        end
+        private_class_method :unpaged
+
+        def self.payload(data_source, tasks)
+          rollover = data_source.deploy_rollover
+          { rollover: serialize(rollover), tasks: tasks.map { |row| task_hash(row, rollover) } }
+        end
+        private_class_method :payload
+
+        def self.task_hash(row, rollover)
+          state = Pgbus::Web::DeployTaskState.present(row, rollover)
+          serialize(row.except(:arguments)).merge(
+            "state" => state.state, "reason" => state.reason_key, "reason_args" => serialize(state.reason_args)
+          )
+        end
+        private_class_method :task_hash
+
+        # Times as ISO 8601 UTC, symbols as strings, string keys throughout.
+        def self.serialize(value)
+          case value
+          when Hash then value.to_h { |key, val| [key.to_s, serialize(val)] }
+          when Array then value.map { |val| serialize(val) }
+          when Symbol then value.to_s
+          when Time, DateTime, ActiveSupport::TimeWithZone then value.utc.iso8601
+          else value
+          end
+        end
+        private_class_method :serialize
+      end
+    end
+  end
+end

data/lib/pgbus/mcp.rb

@@ -28,6 +28,7 @@ module Pgbus
       pgbus/mcp/tools/throughput_tool
       pgbus/mcp/tools/stats_tool
       pgbus/mcp/tools/recurring_tool
+      pgbus/mcp/tools/deploy_tasks_tool
       pgbus/mcp/server
       pgbus/mcp/runner
       pgbus/mcp/rack_app

data/lib/pgbus/metrics/subscriber.rb

@@ -17,15 +17,45 @@ module Pgbus
       METRIC_PREFIX = "pgbus_"
       private_constant :METRIC_PREFIX
 
-      @subscriptions = []
+      # Installed once at boot (the engine's after_initialize) and torn down by
+      # reset! in specs; @install_lock makes the check-then-install atomic so
+      # two callers can never subscribe twice (issue #527). Handlers read
+      # @backend through the private reader: a reference swapped whole.
+      @install_lock = Mutex.new
+      @subscriptions = [].freeze
       @backend = nil
+      @installed = false
 
       class << self
         def install!(backend:)
-          return false if @installed
+          @install_lock.synchronize do
+            next false if @installed
 
-          @backend = backend
-          @subscriptions = [
+            @backend = backend
+            @subscriptions = subscribe_all
+            @installed = true
+          end
+        end
+
+        def installed?
+          @install_lock.synchronize { @installed }
+        end
+
+        def reset!
+          @install_lock.synchronize do
+            @subscriptions.each { |s| ActiveSupport::Notifications.unsubscribe(s) }
+            @subscriptions = [].freeze
+            @backend = nil
+            @installed = false
+          end
+        end
+
+        private
+
+        attr_reader :backend
+
+        def subscribe_all
+          [
             subscribe("pgbus.executor.execute") { |event| on_executor_execute(event) },
             subscribe("pgbus.job_completed") { |event| on_job_completed(event) },
             subscribe("pgbus.job_failed") { |event| on_job_failed(event) },
@@ -43,25 +73,9 @@ module Pgbus
             subscribe("pgbus.worker.recycle") { |event| on_worker_recycle(event) },
             subscribe("pgbus.consumer.recycle") { |event| on_consumer_recycle(event) },
             subscribe("pgbus.client.pool") { |event| on_client_pool(event) }
-          ]
-          @installed = true
-        end
-
-        def installed?
-          @installed == true
-        end
-
-        def reset!
-          @subscriptions&.each { |s| ActiveSupport::Notifications.unsubscribe(s) }
-          @subscriptions = []
-          @backend = nil
-          @installed = false
+          ].freeze
         end
 
-        private
-
-        attr_reader :backend
-
         def subscribe(name, &block)
           ActiveSupport::Notifications.subscribe(name) do |*args|
             event = ActiveSupport::Notifications::Event.new(*args)

data/lib/pgbus/outbox/poller.rb

@@ -139,6 +139,7 @@ module Pgbus
       def start_heartbeat
         @heartbeat = Process::Heartbeat.new(
           kind: "outbox_poller",
+          config: @config,
           metadata: { pid: ::Process.pid, started_at: Time.now.to_f, supervisor_pid: ::Process.ppid }
         )
         @heartbeat.start

data/lib/pgbus/process/consumer.rb

@@ -170,7 +170,7 @@ module Pgbus
       def immediate_shutdown
         @shutting_down = true
         @wake_signal.notify!
-        @pool.kill
+        ExecutionPools.terminate(@pool, grace: config.immediate_shutdown_grace)
       end
 
       private
@@ -615,6 +615,7 @@ module Pgbus
       def start_heartbeat
         @heartbeat = Heartbeat.new(
           kind: "consumer",
+          config: @config,
           metadata: {
             topics: topics, threads: threads, pid: ::Process.pid, execution_mode: @execution_mode,
             started_at: @started_at.to_f, supervisor_pid: ::Process.ppid

data/lib/pgbus/process/consumer_priority.rb

@@ -17,8 +17,8 @@ module Pgbus
       # 0.1s polling interval.
       CACHE_TTL = 5
 
-      @cache = {}
       @cache_mutex = Mutex.new
+      @cache = {} # rubocop:disable ThreadSafety/MutableClassInstanceVariable -- only read or written under @cache_mutex
 
       # Check if this worker should yield to a higher-priority worker.
       # Returns true if a higher-priority healthy worker exists for

data/lib/pgbus/process/dispatcher.rb

@@ -13,6 +13,7 @@ module Pgbus
       CONCURRENCY_INTERVAL = 300            # Run concurrency cleanup every 5 minutes
       BATCH_CLEANUP_INTERVAL = 3600         # Run batch cleanup every hour
       RECURRING_CLEANUP_INTERVAL = 3600     # Run recurring execution cleanup every hour
+      DEPLOY_RUN_CLEANUP_INTERVAL = 3600    # Run deploy task run 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
@@ -52,7 +53,8 @@ module Pgbus
       MAINTENANCE_TIMESTAMPS = %i[
         @last_cleanup_at @last_reap_at @last_concurrency_at @last_batch_cleanup_at
         @last_batch_sweep_at
-        @last_recurring_cleanup_at @last_archive_compaction_at @last_stream_archive_compaction_at
+        @last_recurring_cleanup_at @last_deploy_run_cleanup_at @last_archive_compaction_at
+        @last_stream_archive_compaction_at
         @last_outbox_cleanup_at @last_job_lock_cleanup_at @last_stats_cleanup_at
         @last_orphan_stream_sweep_at @last_table_maintenance_at
       ].freeze
@@ -236,6 +238,7 @@ module Pgbus
         results << run_if_due(now, :@last_batch_cleanup_at, BATCH_CLEANUP_INTERVAL) { cleanup_batches }
         results << run_if_due(now, :@last_batch_sweep_at, config.batch_sweep_interval) { sweep_stalled_batches }
         results << run_if_due(now, :@last_recurring_cleanup_at, RECURRING_CLEANUP_INTERVAL) { cleanup_recurring_executions }
+        results << run_if_due(now, :@last_deploy_run_cleanup_at, DEPLOY_RUN_CLEANUP_INTERVAL) { cleanup_deploy_task_runs }
         results << run_if_due(now, :@last_archive_compaction_at, ARCHIVE_COMPACTION_INTERVAL) { compact_archives }
         results << run_if_due(now, :@last_stream_archive_compaction_at, ARCHIVE_COMPACTION_INTERVAL) { prune_stream_archives }
         results << run_if_due(now, :@last_outbox_cleanup_at, OUTBOX_CLEANUP_INTERVAL) { cleanup_outbox }
@@ -681,6 +684,19 @@ module Pgbus
         e
       end
 
+      # Guarded on the table: deploy tasks default on, and an install that has
+      # not run pgbus:add_deploy_tasks must not warn every hour.
+      def cleanup_deploy_task_runs
+        retention = config.deploy_task_run_retention
+        return unless retention&.positive? && DeployTaskRun.table_exists?
+
+        deleted = DeployTaskRun.prunable_before(Time.current - retention).delete_all
+        Pgbus.logger.debug { "[Pgbus] Cleaned up #{deleted} old deploy task runs" } if deleted.positive?
+      rescue StandardError => e
+        log_maintenance_failure("Deploy task run cleanup", e)
+        e
+      end
+
       def monotonic_now
         ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       end
@@ -697,6 +713,7 @@ module Pgbus
       def start_heartbeat
         @heartbeat = Heartbeat.new(
           kind: "dispatcher",
+          config: @config,
           metadata: { pid: ::Process.pid, started_at: Time.now.to_f, supervisor_pid: ::Process.ppid },
           loop_tick_supplier: -> { @loop_tick_at.get }
         )

data/lib/pgbus/process/heartbeat.rb

@@ -11,9 +11,14 @@ module Pgbus
 
       attr_reader :process_entry
 
-      def initialize(kind:, metadata: {}, on_beat: nil, loop_tick_supplier: nil, metadata_supplier: nil)
+      # config: the owning process's configuration, for the app revision.
+      def initialize(kind:, metadata: {}, on_beat: nil, loop_tick_supplier: nil, metadata_supplier: nil,
+                     config: Pgbus.configuration)
         @kind = kind
-        @metadata = metadata
+        # Every kind's row carries the app revision from its first
+        # registration on, nil included: the deploy-task rollover gate reads
+        # it (issue #536), and beat_metadata dups this hash so it survives.
+        @metadata = metadata.merge(revision: Deploy::Revision.current(config))
         @on_beat = on_beat
         @loop_tick_supplier = loop_tick_supplier
         @metadata_supplier = metadata_supplier

data/lib/pgbus/process/lifecycle.rb

@@ -22,11 +22,11 @@ module Pgbus
       STATES = %i[starting running paused draining stopped].freeze
 
       TRANSITIONS = {
-        starting: %i[running stopped],
-        running: %i[paused draining stopped],
-        paused: %i[running draining stopped],
-        draining: %i[stopped],
-        stopped: []
+        starting: %i[running stopped].freeze,
+        running: %i[paused draining stopped].freeze,
+        paused: %i[running draining stopped].freeze,
+        draining: %i[stopped].freeze,
+        stopped: [].freeze
       }.freeze
 
       attr_reader :state

data/lib/pgbus/process/notify_listener.rb

@@ -64,6 +64,9 @@ module Pgbus
         @health_check_ms = health_check_ms
         @logger = logger
         @state_mutex = Mutex.new
+        # Serializes #start and #stop whole (see #start). Never taken by the
+        # listener thread, so #stop can join it while holding this.
+        @lifecycle_mutex = Mutex.new
         @listening_to = Set.new
         @commands = Queue.new
         @running = false
@@ -98,33 +101,44 @@ module Pgbus
         @state_mutex.synchronize { @delivering }
       end
 
+      # Under @lifecycle_mutex, like #stop: a stop that ran between the
+      # @running check and Thread.new found no thread to join, and the thread
+      # started after it was joined by nobody (and a restart could run a
+      # second run_loop beside it).
       def start
-        @state_mutex.synchronize do
-          return self if @running
+        @lifecycle_mutex.synchronize do
+          @state_mutex.synchronize do
+            return self if @running
 
-          @running = true
+            @running = true
+          end
+          @physical_queues.each { |q| @commands << [:listen, q] }
+          # The listener's one thread, owned by this object: started once (the
+          # @running check above, with #start and #stop serialized), the sole
+          # owner of @conn, and joined by #stop after it clears @running.
+          @thread = Thread.new { run_loop } # rubocop:disable ThreadSafety/NewThread
         end
-        @physical_queues.each { |q| @commands << [:listen, q] }
-        @thread = Thread.new { run_loop }
         self
       end
 
       def stop
-        @state_mutex.synchronize do
-          return self unless @running
+        @lifecycle_mutex.synchronize do
+          @state_mutex.synchronize do
+            return self unless @running
 
-          @running = false
+            @running = false
+          end
+          @commands << [:stop]
+          # Deliberately does NOT touch @conn. PG::Connection is not thread-safe
+          # and #close is PQfinish: it frees the PGconn and its OpenSSL objects
+          # out from under whatever libpq call the listener thread is making on
+          # the same connection. That is a use-after-free — a process-killing
+          # SEGV, not a rescuable PG::Error (issue #375). The listener thread is
+          # the sole owner of @conn for its entire life and closes it in
+          # run_loop's ensure; clearing @running above is the whole stop signal.
+          @thread&.join(stop_join_timeout)
+          @thread = nil
         end
-        @commands << [:stop]
-        # Deliberately does NOT touch @conn. PG::Connection is not thread-safe
-        # and #close is PQfinish: it frees the PGconn and its OpenSSL objects
-        # out from under whatever libpq call the listener thread is making on
-        # the same connection. That is a use-after-free — a process-killing
-        # SEGV, not a rescuable PG::Error (issue #375). The listener thread is
-        # the sole owner of @conn for its entire life and closes it in
-        # run_loop's ensure; clearing @running above is the whole stop signal.
-        @thread&.join(stop_join_timeout)
-        @thread = nil
         self
       end
 

data/lib/pgbus/process/supervisor.rb

@@ -425,9 +425,12 @@ module Pgbus
         ErrorReporter.report(e, { action: "fork_dispatcher" })
       end
 
+      # The scheduler runs recurring tasks and deploy tasks (issue #536);
+      # either one being enabled and configured forks it.
       def boot_scheduler
-        return unless config.recurring_enabled
-        return unless recurring_tasks_configured?
+        recurring = config.recurring_enabled && recurring_tasks_configured?
+        deploy = config.deploy_tasks_enabled && deploy_tasks_configured?
+        return unless recurring || deploy
 
         fork_scheduler
       end
@@ -438,7 +441,8 @@ module Pgbus
           restore_signals
           setup_child_process
           load_rails_app
-          load_recurring_config
+          load_recurring_config if config.recurring_enabled
+          load_deploy_tasks_config if config.deploy_tasks_enabled
           bootstrap_queues!
           scheduler = Recurring::Scheduler.new(config: config)
           scheduler.run
@@ -488,6 +492,33 @@ module Pgbus
         config.recurring_tasks = Recurring::ConfigLoader.load(path)
       end
 
+      def deploy_tasks_configured?
+        return true if config.deploy_tasks&.any?
+        # Explicit files replace the default file, as in load_deploy_tasks_config.
+        return config.deploy_tasks_files.any? { |f| File.exist?(f.to_s) } if config.deploy_tasks_files
+
+        path = default_deploy_tasks_path
+        path ? File.exist?(path.to_s) : false
+      end
+
+      # The engine initializer loads config/deploy_tasks.yml in a Rails boot;
+      # this covers a scheduler fork whose config was not loaded that way.
+      def load_deploy_tasks_config
+        return if config.deploy_tasks&.any?
+
+        files = config.deploy_tasks_files
+        tasks = if files
+                  Recurring::ConfigLoader.load_all(files)
+                elsif (path = default_deploy_tasks_path) && File.exist?(path.to_s)
+                  Recurring::ConfigLoader.load(path)
+                end
+        config.deploy_tasks = tasks if tasks&.any?
+      end
+
+      def default_deploy_tasks_path
+        Rails.root.join("config", "deploy_tasks.yml") if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+      end
+
       def boot_consumers
         return unless config.event_consumers
 
@@ -903,6 +934,7 @@ module Pgbus
       def start_heartbeat
         @heartbeat = Heartbeat.new(
           kind: "supervisor",
+          config: @config,
           metadata: { pid: ::Process.pid, hostname: Socket.gethostname, started_at: Time.now.to_f }
         )
         @heartbeat.start

data/lib/pgbus/process/wake_pipe.rb

@@ -53,7 +53,10 @@ module Pgbus
 
           @running = true
         end
-        @thread = Thread.new { run_loop }
+        # The pipe watcher's one thread, owned by this object: started once
+        # (the @running check above, under @state_mutex) and stopped by #stop,
+        # which closes the pipe under it and joins it.
+        @thread = Thread.new { run_loop } # rubocop:disable ThreadSafety/NewThread
         self
       end