pgbus 0.8.1 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4ffab2bc9e16f1f6dd6c268a1e1019d768c916ea397064fc66c0f4938ce6e5a
-  data.tar.gz: ea2bfeb2bccc34b532facace227159cd0fa550d7ceb8c2ab57e48fa6a9a9020c
+  metadata.gz: a68e87de88b53f6f1b421479e766cbb82b7e6a9fc7a4257cd11cd52ef560f1a7
+  data.tar.gz: d8b0f9aeb5f7cd9ff4f14db915d27066918b8fb66e8be80f1710ca07edff02ce
 SHA512:
-  metadata.gz: cbce8e9eb0243c5875f4d39ce55dd47b9eda9043959dbc833bd3a2ac7e1470bdb299d042e2394b747c59be45177ff9fdb349f1126f360e70a78b1c03dd2db90f
-  data.tar.gz: 6d46db3bd53e2f230a43fb89496f744976910a2f64540fbfde956e0d5661a808fcfc586a6a552fe114e6b716ff288e7d310651eb2f05ef381ee058e9d0180e60
+  metadata.gz: 77afe26722276232120c9e0d0b41a3c3e849ac0f86c874500594db675a96b5571a7ec6a9edc30896883162d985f7081236c602f232896a04eafd660b20970b25
+  data.tar.gz: 8bd975ab73750cf7d22e99fcc672b86a85f125bf869f35672eb5675257d899a1526c196953f7ab4fe76c1b2a34383524ff105f63ad4bc82f79ccaf8f24c40e2e

data/app/controllers/pgbus/api/insights_controller.rb

@@ -15,6 +15,7 @@ module Pgbus
           payload[:latency_trend] = data_source.latency_trend(minutes: minutes)
           payload[:latency_by_queue] = data_source.latency_by_queue(minutes: minutes)
         end
+        payload[:live_streams] = data_source.live_stream_metrics
         render json: payload
       end
     end

data/app/controllers/pgbus/insights_controller.rb

@@ -9,6 +9,8 @@ module Pgbus
       @latency_by_queue = data_source.latency_by_queue(minutes: @minutes)
       @latency_available = Pgbus::JobStat.latency_columns?
 
+      @live_stream_metrics = data_source.live_stream_metrics
+
       @stream_stats_available = data_source.stream_stats_available?
       return unless @stream_stats_available
 

data/app/views/pgbus/insights/show.html.erb

@@ -159,6 +159,61 @@
   </table>
 </div>
 
+<% if @live_stream_metrics[:totals][:streams] > 0 %>
+<!-- Live stream counters (in-memory, always-on) -->
+<div class="mt-8">
+  <h2 class="text-lg font-semibold text-gray-900 dark:text-white mb-4"><%= t("pgbus.insights.show.live_streams.title") %></h2>
+
+  <div class="grid grid-cols-2 gap-4 sm:grid-cols-3 lg:grid-cols-4 mb-6">
+    <div class="rounded-lg bg-white dark:bg-gray-800 p-4 shadow ring-1 ring-gray-200 dark:ring-gray-700">
+      <dt class="text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.live_streams.broadcasts") %></dt>
+      <dd class="mt-1 text-2xl font-semibold text-gray-900 dark:text-white"><%= pgbus_number(@live_stream_metrics[:totals][:broadcasts]) %></dd>
+    </div>
+    <div class="rounded-lg bg-white dark:bg-gray-800 p-4 shadow ring-1 ring-gray-200 dark:ring-gray-700">
+      <dt class="text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.live_streams.active_connections") %></dt>
+      <dd class="mt-1 text-2xl font-semibold text-green-600 dark:text-green-400"><%= pgbus_number(@live_stream_metrics[:totals][:active_connections]) %></dd>
+    </div>
+    <div class="rounded-lg bg-white dark:bg-gray-800 p-4 shadow ring-1 ring-gray-200 dark:ring-gray-700">
+      <dt class="text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.live_streams.total_connections") %></dt>
+      <dd class="mt-1 text-2xl font-semibold text-gray-900 dark:text-white"><%= pgbus_number(@live_stream_metrics[:totals][:total_connections]) %></dd>
+    </div>
+    <div class="rounded-lg bg-white dark:bg-gray-800 p-4 shadow ring-1 ring-gray-200 dark:ring-gray-700">
+      <dt class="text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.live_streams.streams") %></dt>
+      <dd class="mt-1 text-2xl font-semibold text-gray-900 dark:text-white"><%= pgbus_number(@live_stream_metrics[:totals][:streams]) %></dd>
+    </div>
+  </div>
+
+  <div class="rounded-lg bg-white dark:bg-gray-800 shadow ring-1 ring-gray-200 dark:ring-gray-700">
+    <div class="px-5 py-4 border-b border-gray-200 dark:border-gray-700">
+      <h3 class="text-sm font-medium text-gray-700 dark:text-gray-300"><%= t("pgbus.insights.show.live_streams.per_stream_title") %></h3>
+    </div>
+    <table class="pgbus-table min-w-full divide-y divide-gray-200 dark:divide-gray-700">
+      <thead class="bg-gray-50 dark:bg-gray-900">
+        <tr>
+          <th class="px-4 py-3 text-left text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.live_streams.stream") %></th>
+          <th class="px-4 py-3 text-right text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.live_streams.broadcasts") %></th>
+          <th class="px-4 py-3 text-right text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.live_streams.active_connections") %></th>
+          <th class="px-4 py-3 text-right text-xs font-medium uppercase text-gray-500 dark:text-gray-400"><%= t("pgbus.insights.show.live_streams.total_connections") %></th>
+        </tr>
+      </thead>
+      <tbody class="divide-y divide-gray-100 dark:divide-gray-700">
+        <% @live_stream_metrics[:streams].sort_by { |_name, data| -data[:broadcasts] }.each do |name, data| %>
+          <tr class="hover:bg-gray-50 dark:hover:bg-gray-700/50">
+            <td data-label="Stream" class="px-4 py-3 text-sm font-medium text-gray-700 dark:text-gray-300"><%= name %></td>
+            <td data-label="Broadcasts" class="px-4 py-3 text-sm text-right font-mono text-gray-700 dark:text-gray-300"><%= pgbus_number(data[:broadcasts]) %></td>
+            <td data-label="Active" class="px-4 py-3 text-sm text-right font-mono text-gray-700 dark:text-gray-300"><%= pgbus_number(data[:active_connections]) %></td>
+            <td data-label="Total" class="px-4 py-3 text-sm text-right font-mono text-gray-700 dark:text-gray-300"><%= pgbus_number(data[:total_connections]) %></td>
+          </tr>
+        <% end %>
+        <% if @live_stream_metrics[:streams].empty? %>
+          <tr><td colspan="4" class="px-4 py-8 text-center text-sm text-gray-400 dark:text-gray-500"><%= t("pgbus.insights.show.live_streams.empty") %></td></tr>
+        <% end %>
+      </tbody>
+    </table>
+  </div>
+</div>
+<% end %>
+
 <% if @stream_stats_available %>
 <!-- Stream stats -->
 <div class="mt-8">

data/config/locales/da.yml

@@ -222,6 +222,15 @@ da:
             p95: P95 (ms)
             queue: Kø
           title: Forsinkelse efter kø
+        live_streams:
+          active_connections: Aktive forbindelser
+          broadcasts: Samlede udsendelser
+          empty: Ingen aktive streams i denne proces
+          per_stream_title: Per-stream tællere
+          stream: Stream
+          streams: Streams
+          title: Live stream-tællere
+          total_connections: Samlede forbindelser
         slowest:
           empty: Ingen jobstatistikker endnu
           headers:

data/config/locales/de.yml

@@ -222,6 +222,15 @@ de:
             p95: P95 (ms)
             queue: Warteschlange
           title: Latenz nach Warteschlange
+        live_streams:
+          active_connections: Aktive Verbindungen
+          broadcasts: Gesamt-Broadcasts
+          empty: Keine aktiven Streams in diesem Prozess
+          per_stream_title: Pro-Stream-Zähler
+          stream: Stream
+          streams: Streams
+          title: Live-Stream-Zähler
+          total_connections: Gesamtverbindungen
         slowest:
           empty: Noch keine Auftragsstatistiken
           headers:

data/config/locales/en.yml

@@ -222,6 +222,15 @@ en:
             p95: P95 (ms)
             queue: Queue
           title: Latency by Queue
+        live_streams:
+          active_connections: Active Connections
+          broadcasts: Total Broadcasts
+          empty: No streams active in this process
+          per_stream_title: Per-Stream Counters
+          stream: Stream
+          streams: Streams
+          title: Live Stream Counters
+          total_connections: Total Connections
         slowest:
           empty: No job stats yet
           headers:

data/config/locales/es.yml

@@ -222,6 +222,15 @@ es:
             p95: P95 (ms)
             queue: Cola
           title: Latencia por Cola
+        live_streams:
+          active_connections: Conexiones activas
+          broadcasts: Emisiones totales
+          empty: No hay streams activos en este proceso
+          per_stream_title: Contadores por stream
+          stream: Stream
+          streams: Streams
+          title: Contadores de streams en vivo
+          total_connections: Conexiones totales
         slowest:
           empty: Aún no hay estadísticas de trabajos
           headers:

data/config/locales/fi.yml

@@ -222,6 +222,15 @@ fi:
             p95: P95 (ms)
             queue: Jono
           title: Viive jonon mukaan
+        live_streams:
+          active_connections: Aktiiviset yhteydet
+          broadcasts: Lähetykset yhteensä
+          empty: Ei aktiivisia striimejä tässä prosessissa
+          per_stream_title: Striimikohtaiset laskurit
+          stream: Striimi
+          streams: Striimit
+          title: Reaaliaikaiset striimilaskurit
+          total_connections: Yhteydet yhteensä
         slowest:
           empty: Ei vielä tehtävätilastoja
           headers:

data/config/locales/fr.yml

@@ -222,6 +222,15 @@ fr:
             p95: P95 (ms)
             queue: File d'attente
           title: Latence par file d'attente
+        live_streams:
+          active_connections: Connexions actives
+          broadcasts: Diffusions totales
+          empty: Aucun flux actif dans ce processus
+          per_stream_title: Compteurs par flux
+          stream: Flux
+          streams: Flux
+          title: Compteurs de flux en direct
+          total_connections: Connexions totales
         slowest:
           empty: Pas encore de statistiques de tâches
           headers:

data/config/locales/it.yml

@@ -222,6 +222,15 @@ it:
             p95: P95 (ms)
             queue: Coda
           title: Latenza per coda
+        live_streams:
+          active_connections: Connessioni attive
+          broadcasts: Trasmissioni totali
+          empty: Nessuno stream attivo in questo processo
+          per_stream_title: Contatori per stream
+          stream: Stream
+          streams: Stream
+          title: Contatori stream in tempo reale
+          total_connections: Connessioni totali
         slowest:
           empty: Nessuna statistica lavori ancora
           headers:

data/config/locales/ja.yml

@@ -222,6 +222,15 @@ ja:
             p95: P95 (ms)
             queue: キュー
           title: キュー別遅延
+        live_streams:
+          active_connections: アクティブ接続
+          broadcasts: 総ブロードキャスト
+          empty: このプロセスにアクティブなストリームはありません
+          per_stream_title: ストリーム別カウンター
+          stream: ストリーム
+          streams: ストリーム
+          title: ライブストリームカウンター
+          total_connections: 総接続数
         slowest:
           empty: まだジョブ統計がありません
           headers:

data/config/locales/nb.yml

@@ -222,6 +222,15 @@ nb:
             p95: P95 (ms)
             queue: Kø
           title: Forsinkelse per kø
+        live_streams:
+          active_connections: Aktive tilkoblinger
+          broadcasts: Totale kringkastinger
+          empty: Ingen aktive strømmer i denne prosessen
+          per_stream_title: Per-strøm tellere
+          stream: Strøm
+          streams: Strømmer
+          title: Sanntids strømtellere
+          total_connections: Totale tilkoblinger
         slowest:
           empty: Ingen jobbstatistikk ennå
           headers:

data/config/locales/nl.yml

@@ -222,6 +222,15 @@ nl:
             p95: P95 (ms)
             queue: Wachtrij
           title: Vertraging per wachtrij
+        live_streams:
+          active_connections: Actieve verbindingen
+          broadcasts: Totaal uitzendingen
+          empty: Geen actieve streams in dit proces
+          per_stream_title: Per-stream tellers
+          stream: Stream
+          streams: Streams
+          title: Live stream-tellers
+          total_connections: Totale verbindingen
         slowest:
           empty: Nog geen taakstatistieken
           headers:

data/config/locales/pt.yml

@@ -222,6 +222,15 @@ pt:
             p95: P95 (ms)
             queue: Fila
           title: Latência por Fila
+        live_streams:
+          active_connections: Conexões ativas
+          broadcasts: Transmissões totais
+          empty: Nenhum stream ativo neste processo
+          per_stream_title: Contadores por stream
+          stream: Stream
+          streams: Streams
+          title: Contadores de stream ao vivo
+          total_connections: Conexões totais
         slowest:
           empty: Nenhuma estatística de tarefa ainda
           headers:

data/config/locales/sv.yml

@@ -222,6 +222,15 @@ sv:
             p95: P95 (ms)
             queue: Kö
           title: Fördröjning per kö
+        live_streams:
+          active_connections: Aktiva anslutningar
+          broadcasts: Totala sändningar
+          empty: Inga aktiva strömmar i denna process
+          per_stream_title: Per-ström mätare
+          stream: Ström
+          streams: Strömmar
+          title: Realtids strömmätare
+          total_connections: Totala anslutningar
         slowest:
           empty: Inga jobbstatistik än
           headers:

data/lib/pgbus/client/notify_stream.rb

@@ -25,9 +25,11 @@ module Pgbus
         json = payload.is_a?(String) ? payload : JSON.generate(payload)
 
         Instrumentation.instrument("pgbus.stream.notify", stream: stream_name, bytes: json.bytesize) do
-          synchronized do
-            @pgmq.__send__(:with_connection) do |conn|
-              conn.exec_params("SELECT pg_notify($1, $2)", [channel, json])
+          with_stale_connection_retry do
+            synchronized do
+              @pgmq.__send__(:with_connection) do |conn|
+                conn.exec_params("SELECT pg_notify($1, $2)", [channel, json])
+              end
             end
           end
         end

data/lib/pgbus/engine.rb

@@ -136,6 +136,11 @@ module Pgbus
           _autoload_trigger = Pgbus::Streams::TurboBroadcastable
           Pgbus::Streams.install_turbo_broadcastable_patch!
 
+          if defined?(::Turbo::Broadcastable)
+            _autoload_trigger_broadcastable = Pgbus::Streams::BroadcastableOverride
+            Pgbus::Streams::BroadcastableOverride.install!(::Turbo::Broadcastable)
+          end
+
           # Subscribe-side patch: override turbo_stream_from to render
           # <pgbus-stream-source> (SSE) instead of <turbo-cable-stream-source>
           # (ActionCable). Without this, third-party gems like

data/lib/pgbus/streams/broadcastable_override.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module Streams
+    # Runtime patch for `Turbo::Broadcastable` that adds `durable:` kwarg
+    # support to synchronous broadcast helpers. Applied at Rails engine boot
+    # time when `defined?(::Turbo::Broadcastable)` — see `Pgbus::Engine`.
+    #
+    # Instance methods extract `durable:` from kwargs and set a thread-local
+    # (`Thread.current[:pgbus_broadcast_durable]`) that
+    # `TurboBroadcastable#broadcast_stream_to` reads. The thread-local is
+    # always cleaned up after the broadcast, even on error.
+    #
+    # The `_later_to` variants are NOT overridden because turbo-rails
+    # enqueues them as background jobs — the thread-local cannot survive
+    # into the job execution context. For async broadcasts, use
+    # `streams_durable_patterns` or `streams_default_broadcast_mode` config.
+    #
+    # Class methods (`broadcasts_to`, `broadcasts_refreshes_to`) accept
+    # `durable:` and store it so the generated callbacks set the thread-local
+    # before each broadcast.
+    module BroadcastableOverride
+      BROADCAST_METHODS = %i[
+        broadcast_after_to
+        broadcast_before_to
+        broadcast_replace_to
+        broadcast_append_to
+        broadcast_prepend_to
+        broadcast_update_to
+        broadcast_remove_to
+        broadcast_refresh_to
+        broadcast_render_to
+      ].freeze
+
+      BROADCAST_ACTION_METHODS = %i[
+        broadcast_action_to
+      ].freeze
+
+      BROADCAST_METHODS.each do |method_name|
+        define_method(method_name) do |*streamables, **kwargs|
+          durable = kwargs.delete(:durable)
+          with_pgbus_durable(durable) { super(*streamables, **kwargs) }
+        end
+      end
+
+      BROADCAST_ACTION_METHODS.each do |method_name|
+        define_method(method_name) do |*streamables, action:, **kwargs|
+          durable = kwargs.delete(:durable)
+          with_pgbus_durable(durable) { super(*streamables, action: action, **kwargs) }
+        end
+      end
+
+      module ClassMethods
+        def broadcasts_to(stream, durable: nil, inserts_by: :append, target: broadcast_target_default, **rendering)
+          if durable.nil?
+            after_create_commit lambda {
+              broadcast_action_later_to(
+                stream.try(:call, self) || send(stream),
+                action: inserts_by,
+                target: target.try(:call, self) || target,
+                **rendering
+              )
+            }
+            after_update_commit -> { broadcast_replace_later_to(stream.try(:call, self) || send(stream), **rendering) }
+            after_destroy_commit -> { broadcast_remove_to(stream.try(:call, self) || send(stream)) }
+          else
+            @pgbus_durable_streams ||= {}
+            @pgbus_durable_streams[stream] = durable
+
+            after_create_commit lambda {
+              broadcast_action_to(
+                stream.try(:call, self) || send(stream),
+                action: inserts_by,
+                target: target.try(:call, self) || target,
+                durable: durable,
+                **rendering
+              )
+            }
+            after_update_commit lambda {
+              broadcast_replace_to(stream.try(:call, self) || send(stream), durable: durable, **rendering)
+            }
+            after_destroy_commit lambda {
+              broadcast_remove_to(stream.try(:call, self) || send(stream), durable: durable)
+            }
+          end
+        end
+
+        def broadcasts_refreshes_to(stream, durable: nil)
+          if durable.nil?
+            after_commit -> { broadcast_refresh_later_to(stream.try(:call, self) || send(stream)) }
+          else
+            @pgbus_durable_streams ||= {}
+            @pgbus_durable_streams[stream] = durable
+
+            after_commit lambda {
+              broadcast_refresh_to(stream.try(:call, self) || send(stream), durable: durable)
+            }
+          end
+        end
+
+        def pgbus_durable_streams
+          @pgbus_durable_streams || {}
+        end
+      end
+
+      def self.install!(mod)
+        return if mod.ancestors.include?(self)
+
+        mod.prepend(self)
+
+        # Turbo::Broadcastable uses ActiveSupport::Concern, which extends
+        # each including class with Turbo::Broadcastable::ClassMethods.
+        # Prepending our ClassMethods onto that nested module ensures any
+        # class that includes Turbo::Broadcastable picks up our overrides
+        # (broadcasts_to, broadcasts_refreshes_to) automatically.
+        if defined?(::Turbo::Broadcastable::ClassMethods) &&
+           !::Turbo::Broadcastable::ClassMethods.ancestors.include?(ClassMethods)
+          ::Turbo::Broadcastable::ClassMethods.prepend(ClassMethods)
+        end
+      end
+
+      private
+
+      def with_pgbus_durable(value)
+        return yield if value.nil?
+
+        previous = Thread.current[:pgbus_broadcast_durable]
+        Thread.current[:pgbus_broadcast_durable] = value
+        yield
+      ensure
+        Thread.current[:pgbus_broadcast_durable] = previous unless value.nil?
+      end
+    end
+  end
+end

data/lib/pgbus/streams/turbo_broadcastable.rb

@@ -36,8 +36,13 @@ module Pgbus
     module TurboBroadcastable
       def broadcast_stream_to(*streamables, content:)
         name = stream_name_from(streamables)
-        mode = Pgbus.configuration.streams_default_broadcast_mode
-        Pgbus.stream(name, durable: mode == :durable).broadcast(content)
+        override = Thread.current[:pgbus_broadcast_durable]
+        durable = if override.nil?
+                    Pgbus.configuration.streams_default_broadcast_mode == :durable
+                  else
+                    override
+                  end
+        Pgbus.stream(name, durable: durable).broadcast(content)
       end
     end
 

data/lib/pgbus/version.rb

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

data/lib/pgbus/web/data_source.rb

@@ -681,6 +681,19 @@ module Pgbus
       # true AND the migration has been run. Controllers should gate
       # rendering on `stream_stats_available?` to avoid showing empty
       # sections.
+      def live_stream_metrics
+        counter = Pgbus::Web::Streamer.stream_counter
+        unless counter
+          empty_totals = { broadcasts: 0, active_connections: 0, total_connections: 0, streams: 0 }
+          return { streams: {}, totals: empty_totals }
+        end
+
+        { streams: counter.snapshot, totals: counter.totals }
+      rescue StandardError => e
+        Pgbus.logger.debug { "[Pgbus::Web] Error fetching live stream metrics: #{e.message}" }
+        { streams: {}, totals: { broadcasts: 0, active_connections: 0, total_connections: 0, streams: 0 } }
+      end
+
       def stream_stats_available?
         Pgbus.configuration.streams_stats_enabled && StreamStat.table_exists?
       rescue StandardError => e

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

@@ -38,7 +38,8 @@ module Pgbus
         def enqueue(envelopes)
           written = []
           envelopes.each do |envelope|
-            next if envelope.msg_id <= @last_msg_id_sent
+            ephemeral = envelope.msg_id.negative?
+            next if !ephemeral && envelope.msg_id <= @last_msg_id_sent
 
             bytes = Pgbus::Streams::Envelope.message(
               id: envelope.msg_id,
@@ -48,7 +49,7 @@ module Pgbus
 
             result = @writer.write(self, bytes, deadline_ms: @write_deadline_ms)
             if result == :ok
-              @last_msg_id_sent = envelope.msg_id
+              @last_msg_id_sent = envelope.msg_id unless ephemeral
               @last_write_at = monotonic
               written << envelope
             else

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

@@ -20,7 +20,7 @@ module Pgbus
       # production the module-level Streamer.current(...) builds all of the
       # defaults from the configuration.
       class Instance
-        attr_reader :registry, :listener, :dispatcher, :heartbeat, :dispatch_queue
+        attr_reader :registry, :listener, :dispatcher, :heartbeat, :dispatch_queue, :stream_counter
 
         def initialize(
           client: Pgbus.client,
@@ -36,6 +36,7 @@ module Pgbus
           @registry = registry || Registry.new
           @dispatch_queue = dispatch_queue || Queue.new
 
+          @stream_counter = StreamCounter.new
           @pg_connection = pg_connection || build_pg_connection
           @listener = Listener.new(
             pg_connection: @pg_connection,
@@ -49,7 +50,8 @@ module Pgbus
             listener: @listener,
             dispatch_queue: @dispatch_queue,
             logger: @logger,
-            config: @config
+            config: @config,
+            stream_counter: @stream_counter
           )
           @heartbeat = Heartbeat.new(
             registry: @registry,

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

@@ -37,16 +37,23 @@ module Pgbus
           end
         end
 
+        # Returns true if a matching connection was removed, false if it
+        # was not registered. Callers (e.g. StreamEventDispatcher) use the
+        # return value to make per-connection bookkeeping idempotent on
+        # duplicate DisconnectMessages — prune_dead can enqueue a
+        # DisconnectMessage on every wake while the first one is still
+        # waiting in the queue.
         def unregister(connection)
           @mutex.synchronize do
             existing = @by_id.delete(connection.id)
-            return unless existing
+            return false unless existing
 
             set = @by_stream[existing.stream_name]
-            next unless set
-
-            set.delete(existing)
-            @by_stream.delete(existing.stream_name) if set.empty?
+            if set
+              set.delete(existing)
+              @by_stream.delete(existing.stream_name) if set.empty?
+            end
+            true
           end
         end
 

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module Pgbus
+  module Web
+    module Streamer
+      class StreamCounter
+        def initialize
+          @streams = Concurrent::Map.new
+        end
+
+        def increment_broadcasts(stream_name)
+          counters_for(stream_name)[:broadcasts].increment
+        end
+
+        def increment_connections(stream_name)
+          counters_for(stream_name)[:active_connections].increment
+        end
+
+        def decrement_connections(stream_name)
+          counters_for(stream_name)[:active_connections].decrement
+        end
+
+        def increment_total_connections(stream_name)
+          counters_for(stream_name)[:total_connections].increment
+        end
+
+        def broadcasts(stream_name)
+          entry = @streams[stream_name]
+          entry ? entry[:broadcasts].value : 0
+        end
+
+        def active_connections(stream_name)
+          entry = @streams[stream_name]
+          return 0 unless entry
+
+          [entry[:active_connections].value, 0].max
+        end
+
+        def total_connections(stream_name)
+          entry = @streams[stream_name]
+          entry ? entry[:total_connections].value : 0
+        end
+
+        def snapshot
+          result = {}
+          @streams.each_pair do |name, counters|
+            result[name] = {
+              broadcasts: counters[:broadcasts].value,
+              active_connections: [counters[:active_connections].value, 0].max,
+              total_connections: counters[:total_connections].value
+            }
+          end
+          result
+        end
+
+        def totals
+          total_broadcasts = 0
+          total_active = 0
+          total_conns = 0
+          stream_count = 0
+
+          @streams.each_pair do |_name, counters|
+            total_broadcasts += counters[:broadcasts].value
+            total_active += [counters[:active_connections].value, 0].max
+            total_conns += counters[:total_connections].value
+            stream_count += 1
+          end
+
+          {
+            broadcasts: total_broadcasts,
+            active_connections: total_active,
+            total_connections: total_conns,
+            streams: stream_count
+          }
+        end
+
+        private
+
+        def counters_for(stream_name)
+          @streams.compute_if_absent(stream_name) do
+            {
+              broadcasts: Concurrent::AtomicFixnum.new(0),
+              active_connections: Concurrent::AtomicFixnum.new(0),
+              total_connections: Concurrent::AtomicFixnum.new(0)
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -47,9 +47,11 @@ module Pgbus
 
         DEFAULT_READ_LIMIT = 500
 
+        attr_reader :stream_counter
+
         def initialize(client:, registry:, listener:, dispatch_queue:,
                        logger: Pgbus.logger, read_limit: DEFAULT_READ_LIMIT,
-                       filters: nil, config: nil)
+                       filters: nil, config: nil, stream_counter: nil)
           @client = client
           @registry = registry
           @listener = listener
@@ -67,6 +69,7 @@ module Pgbus
           # process-wide setting. Falls back to the global config
           # for production call sites that don't specify one.
           @config = config || Pgbus.configuration
+          @stream_counter = stream_counter || StreamCounter.new
           # stream_name → Array<[connection, Array<Envelope>]>
           @in_flight = Hash.new { |h, k| h[k] = [] }
           # PGMQ full table name (pgbus_<prefix>_<name>) → logical stream
@@ -128,21 +131,16 @@ module Pgbus
             msg = @queue.pop
             break if msg == :__stop__
 
-            # Wake coalescing: if a WakeMessage arrives, opportunistically
-            # drain consecutive same-stream wakes from the queue. Without
-            # this, N broadcasts in rapid succession produce N
-            # WakeMessages, each running its own read_after roundtrip
-            # even though one read_after with the lowest cursor would
-            # have pulled all N messages. The drain is bounded by the
-            # queue's current contents — once we hit a non-Wake or a
-            # different stream, we stop and let the regular path handle
-            # the rest.
-            if msg.is_a?(WakeMessage) && msg.payload.nil?
-              wakes, trailing = drain_wakes_for(msg)
-              wakes.each { |w| handle(w) }
-              handle(trailing) if trailing
-            else
-              handle(msg)
+            begin
+              if msg.is_a?(WakeMessage) && msg.payload.nil?
+                wakes, trailing = drain_wakes_for(msg)
+                wakes.each { |w| handle(w) }
+                handle(trailing) if trailing
+              else
+                handle(msg)
+              end
+            ensure
+              release_ar_connections
             end
           end
         rescue StandardError => e
@@ -224,6 +222,7 @@ module Pgbus
           end
 
           prune_dead(registered)
+          @stream_counter.increment_broadcasts(stream)
 
           record_stat(
             stream_name: stream,
@@ -258,12 +257,14 @@ module Pgbus
           end
 
           prune_dead(registered)
+          @stream_counter.increment_broadcasts(stream)
 
           record_stat(
             stream_name: stream,
             event_type: "broadcast",
             started_at: started_at,
-            fanout: registered.size + in_flight_pairs.size
+            fanout: registered.size + in_flight_pairs.size,
+            ephemeral: true
           )
         end
 
@@ -312,18 +313,15 @@ module Pgbus
           # here. Otherwise this stream's state is pinned for the
           # life of the worker.
           remove_in_flight(stream, connection)
+          @stream_counter.increment_total_connections(stream)
           if connection.dead?
             @scanned_cursor.delete(connection)
             cleanup_stream_if_unused(stream)
           else
+            @stream_counter.increment_connections(stream)
             @registry.register(connection)
           end
 
-          # Record the connect regardless of whether the connection
-          # survived the replay — a dead-before-register is still an
-          # operator-visible "connection attempt" and disconnects
-          # won't be recorded for it, so dropping it here would
-          # under-count.
           record_stat(
             stream_name: stream,
             event_type: "connect",
@@ -345,8 +343,9 @@ module Pgbus
           started_at = monotonic_ms
           connection = msg.connection
           stream = connection.stream_name
-          @registry.unregister(connection)
+          removed = @registry.unregister(connection)
           @scanned_cursor.delete(connection)
+          @stream_counter.decrement_connections(stream) if removed
           cleanup_stream_if_unused(stream)
 
           record_stat(
@@ -479,8 +478,21 @@ module Pgbus
         # if operators actually look at it. All failures are
         # swallowed by StreamStat.record! itself so a stats-table
         # outage cannot block the dispatcher.
-        def record_stat(stream_name:, event_type:, started_at:, fanout: nil)
-          return unless @config.streams_stats_enabled
+        # Release any AR connections the dispatcher fiber acquired during
+        # this iteration (typically from StreamStat.record! via BusRecord).
+        # Without this, the connection stays leased while the fiber parks
+        # on @queue.pop, blocking clear_reloadable_connections! on the
+        # next Rails code reload (10s wedge under rack-timeout).
+        def release_ar_connections
+          return unless defined?(::ActiveRecord::Base)
+
+          Pgbus::BusRecord.connection_handler.clear_active_connections!
+        rescue StandardError => e
+          @logger.debug { "[Pgbus::Streamer::StreamEventDispatcher] AR connection release failed: #{e.class}: #{e.message}" }
+        end
+
+        def record_stat(stream_name:, event_type:, started_at:, fanout: nil, ephemeral: false)
+          return unless ephemeral || @config.streams_stats_enabled
 
           Pgbus::StreamStat.record!(
             stream_name: stream_name,

data/lib/pgbus/web/streamer.rb

@@ -37,8 +37,10 @@ module Pgbus
           @current_mutex.synchronize { @current = instance }
         end
 
-        # Tear down the current instance and clear the slot. Called by the
-        # Puma shutdown hook (Phase 4.4) and by tests between examples.
+        def stream_counter
+          @current_mutex.synchronize { @current&.stream_counter }
+        end
+
         def reset!
           instance = nil
           @current_mutex.synchronize do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgbus
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.3
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -308,6 +308,7 @@ files:
 - lib/pgbus/serializer.rb
 - lib/pgbus/stat_buffer.rb
 - lib/pgbus/streams.rb
+- lib/pgbus/streams/broadcastable_override.rb
 - lib/pgbus/streams/cursor.rb
 - lib/pgbus/streams/envelope.rb
 - lib/pgbus/streams/filters.rb
@@ -337,6 +338,7 @@ files:
 - lib/pgbus/web/streamer/io_writer.rb
 - lib/pgbus/web/streamer/listener.rb
 - lib/pgbus/web/streamer/registry.rb
+- lib/pgbus/web/streamer/stream_counter.rb
 - lib/pgbus/web/streamer/stream_event_dispatcher.rb
 - lib/puma/plugin/pgbus_streams.rb
 - lib/tasks/pgbus_autovacuum.rake