pgbus 0.5.1 → 0.6.1

data/lib/pgbus/generators/database_target_detector.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module Generators
+    # Detects whether the host application has configured pgbus to use
+    # a separate database via connects_to, and returns the database name
+    # that --database flags should be set to for sub-generators.
+    #
+    # Detection sources, in priority order:
+    #
+    #   1. Pgbus.configuration.connects_to (runtime — authoritative if
+    #      the initializer has already booted)
+    #   2. config/initializers/pgbus.rb (text scan)
+    #   3. config/application.rb (text scan — fallback for apps that
+    #      call connects_to in application config instead of the pgbus
+    #      initializer)
+    #
+    # Returns a String (the database name, e.g. "pgbus") or nil if no
+    # separate database is configured.
+    class DatabaseTargetDetector
+      # Matches:
+      #   c.connects_to = { database: { writing: :pgbus } }
+      #   c.connects_to(database: { writing: :queue_db })
+      #   Pgbus.configuration.connects_to = { database: { writing: :pgbus } }
+      #
+      # Rejects:
+      #   c.connects_to = { role: :writing }        (different API shape)
+      #   connects_to :something                    (no database: key)
+      #
+      # The [^;\n]*? and [^}]*? laziness keeps the scan within a
+      # reasonable window so a stray "writing:" later in the file
+      # can't cross-contaminate.
+      CONNECTS_TO_PATTERN = /connects_to\b[^;\n]*?database\s*:\s*\{[^}]*?writing\s*:\s*:?(?<name>[a-zA-Z_][a-zA-Z0-9_]*)/m
+
+      def initialize(destination_root:)
+        @destination_root = destination_root
+      end
+
+      # Returns the database name string if a separate DB is configured,
+      # nil otherwise. Checks runtime config first, then falls back to
+      # static file scanning.
+      def detect
+        runtime_database_name || scan_initializer || scan_application_config
+      end
+
+      private
+
+      attr_reader :destination_root
+
+      # Runtime path: Pgbus.configuration.connects_to. Only works if the
+      # host app has loaded pgbus AND booted the initializer. The update
+      # generator runs after Rails app boot so this is usually available.
+      def runtime_database_name
+        return nil unless defined?(Pgbus) && Pgbus.respond_to?(:configuration)
+
+        extract_database_name(Pgbus.configuration.connects_to)
+      rescue StandardError
+        nil
+      end
+
+      def scan_initializer
+        scan_file(File.join(destination_root, "config", "initializers", "pgbus.rb"))
+      end
+
+      def scan_application_config
+        scan_file(File.join(destination_root, "config", "application.rb"))
+      end
+
+      def scan_file(path)
+        return nil unless File.exist?(path)
+
+        content = File.read(path)
+        match = content.match(CONNECTS_TO_PATTERN)
+        return nil unless match
+
+        match[:name]
+      rescue StandardError
+        nil
+      end
+
+      # Parses `{ database: { writing: :name } }` or the String variant
+      # into the database name. Returns nil for anything we don't
+      # recognize.
+      def extract_database_name(connects_to)
+        return nil unless connects_to.is_a?(Hash)
+
+        db = connects_to[:database] || connects_to["database"]
+        return nil unless db.is_a?(Hash)
+
+        (db[:writing] || db["writing"])&.to_s
+      end
+    end
+  end
+end

data/lib/pgbus/generators/migration_detector.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module Generators
+    # Inspects a live ActiveRecord connection and determines which of
+    # pgbus's migration generators need to run to bring the schema up
+    # to date.
+    #
+    # Usage:
+    #
+    #   detector = Pgbus::Generators::MigrationDetector.new(connection)
+    #   detector.missing_migrations
+    #   # => [:add_uniqueness_keys, :add_job_stats_queue_index, ...]
+    #
+    # The returned symbols correspond to generator names that the
+    # pgbus:update generator invokes via Thor composition. Each symbol
+    # maps to exactly one generator (see GENERATOR_MAP).
+    #
+    # Detection rules:
+    #
+    # 1. Fresh install (no core tables) → returns [:fresh_install] as a
+    #    sentinel. The caller should tell the user to run pgbus:install
+    #    instead of stacking 8 migrations.
+    #
+    # 2. Core tables missing → queued unconditionally. These are features
+    #    pgbus assumes are present.
+    #
+    # 3. Opt-in feature tables missing → queued unconditionally. The user
+    #    asked for update-to-latest, so we add the migration files but
+    #    don't enable the feature in config. They'll opt in separately.
+    #
+    # 4. Columns missing on existing tables → queued. These are in-place
+    #    schema upgrades (e.g. add_job_stats_latency adds
+    #    enqueue_latency_ms + retry_count).
+    #
+    # 5. Indexes missing on existing tables → queued. Additive, safe.
+    #
+    # 6. Modern replacements for legacy tables (e.g. pgbus_job_locks →
+    #    pgbus_uniqueness_keys) → queue the migration path only if the
+    #    legacy table still exists. Otherwise queue the fresh install.
+    class MigrationDetector
+      # Sentinel returned when the database looks empty of pgbus tables.
+      # The caller (pgbus:update generator) should redirect the user to
+      # pgbus:install rather than trying to stack the full schema as
+      # individual add_* migrations.
+      FRESH_INSTALL = :fresh_install
+
+      # The set of tables that the base pgbus:install migration creates.
+      # If NONE of these exist, we treat the DB as a fresh install.
+      CORE_INSTALL_TABLES = %w[
+        pgbus_processed_events
+        pgbus_processes
+        pgbus_failed_events
+        pgbus_semaphores
+        pgbus_blocked_executions
+        pgbus_batches
+      ].freeze
+
+      # generator_key → Rails generator name. Passed to Thor's invoke.
+      #
+      # Note: uniqueness_keys uses the migrate_job_locks generator for
+      # both the fresh-install and upgrade-from-job_locks paths. The
+      # template is idempotent: `unless table_exists?(:pgbus_uniqueness_keys)`
+      # creates it, and `if table_exists?(:pgbus_job_locks)` drops the
+      # legacy table. One generator covers both cases.
+      GENERATOR_MAP = {
+        uniqueness_keys: "pgbus:migrate_job_locks",
+        add_job_stats: "pgbus:add_job_stats",
+        add_job_stats_latency: "pgbus:add_job_stats_latency",
+        add_job_stats_queue_index: "pgbus:add_job_stats_queue_index",
+        add_stream_stats: "pgbus:add_stream_stats",
+        add_presence: "pgbus:add_presence",
+        add_queue_states: "pgbus:add_queue_states",
+        add_outbox: "pgbus:add_outbox",
+        add_recurring: "pgbus:add_recurring",
+        add_failed_events_index: "pgbus:add_failed_events_index"
+      }.freeze
+
+      # Human-friendly description of each migration for the generator
+      # output. Keeps the update generator's run log readable.
+      DESCRIPTIONS = {
+        uniqueness_keys: "uniqueness keys table (job deduplication, also upgrades legacy job_locks if present)",
+        add_job_stats: "job stats table (Insights dashboard)",
+        add_job_stats_latency: "job stats latency columns (enqueue_latency_ms, retry_count)",
+        add_job_stats_queue_index: "job stats (queue_name, created_at) index",
+        add_stream_stats: "stream stats table (opt-in real-time Insights)",
+        add_presence: "presence members table (Turbo Streams presence)",
+        add_queue_states: "queue states table (pause/resume)",
+        add_outbox: "outbox entries table (transactional outbox)",
+        add_recurring: "recurring tasks + executions tables",
+        add_failed_events_index: "unique index on pgbus_failed_events (queue_name, msg_id)"
+      }.freeze
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      # Returns an Array of generator keys (symbols) in the order they
+      # should run. Dependencies are resolved implicitly via order: the
+      # base table creation for a feature always comes before the
+      # column/index add-ons.
+      def missing_migrations
+        return [FRESH_INSTALL] if fresh_install?
+
+        [
+          *uniqueness_key_migrations,
+          *job_stats_migrations,
+          *stream_stats_migrations,
+          *presence_migrations,
+          *queue_states_migrations,
+          *outbox_migrations,
+          *recurring_migrations,
+          *failed_events_index_migrations
+        ]
+      end
+
+      private
+
+      attr_reader :connection
+
+      def fresh_install?
+        CORE_INSTALL_TABLES.none? { |t| table_exists?(t) }
+      end
+
+      # Legacy pgbus_job_locks → modern pgbus_uniqueness_keys.
+      # The migrate_job_locks template is idempotent: it creates
+      # uniqueness_keys if missing and drops job_locks if present.
+      # One symbol covers both cases; see GENERATOR_MAP.
+      def uniqueness_key_migrations
+        return [] if table_exists?("pgbus_uniqueness_keys")
+
+        [:uniqueness_keys]
+      end
+
+      def job_stats_migrations
+        migrations = []
+
+        unless table_exists?("pgbus_job_stats")
+          migrations << :add_job_stats
+          # The latency columns and queue index are add-ons to job_stats.
+          # If we're creating the base table now, the add_job_stats
+          # template doesn't include them — add the upgrade migrations
+          # so a fresh install lands on the current schema.
+          migrations << :add_job_stats_latency
+          migrations << :add_job_stats_queue_index
+          return migrations
+        end
+
+        # Base table exists — check each add-on independently.
+        cols = column_names("pgbus_job_stats")
+        migrations << :add_job_stats_latency unless cols.include?("enqueue_latency_ms") && cols.include?("retry_count")
+
+        migrations << :add_job_stats_queue_index unless index_exists?("pgbus_job_stats", "idx_pgbus_job_stats_queue_time")
+
+        migrations
+      end
+
+      def stream_stats_migrations
+        table_exists?("pgbus_stream_stats") ? [] : [:add_stream_stats]
+      end
+
+      def presence_migrations
+        table_exists?("pgbus_presence_members") ? [] : [:add_presence]
+      end
+
+      def queue_states_migrations
+        table_exists?("pgbus_queue_states") ? [] : [:add_queue_states]
+      end
+
+      def outbox_migrations
+        table_exists?("pgbus_outbox_entries") ? [] : [:add_outbox]
+      end
+
+      def recurring_migrations
+        # pgbus_recurring_tasks + pgbus_recurring_executions are the two
+        # tables the recurring generator creates. If BOTH exist, nothing
+        # to do. If either is missing, we need the generator (which is
+        # idempotent via if_not_exists on both tables).
+        return [] if table_exists?("pgbus_recurring_tasks") && table_exists?("pgbus_recurring_executions")
+
+        [:add_recurring]
+      end
+
+      def failed_events_index_migrations
+        # pgbus_failed_events is created by pgbus:install, but the
+        # unique (queue_name, msg_id) index was added later via its own
+        # generator. If the table exists without the unique index,
+        # FailedEventRecorder's upsert silently swallows ON CONFLICT
+        # errors — so this is a real bug waiting to bite.
+        return [] unless table_exists?("pgbus_failed_events")
+        return [] if index_exists?("pgbus_failed_events", "idx_pgbus_failed_events_queue_msg")
+
+        [:add_failed_events_index]
+      end
+
+      # --- schema probes -------------------------------------------------
+
+      def table_exists?(name)
+        connection.table_exists?(name)
+      rescue StandardError
+        false
+      end
+
+      def column_names(table)
+        connection.columns(table).map(&:name)
+      rescue StandardError
+        []
+      end
+
+      def index_exists?(table, index_name)
+        connection.indexes(table).any? { |idx| idx.name == index_name }
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/pgbus/process/dispatcher.rb

@@ -33,6 +33,7 @@ module Pgbus
         @last_batch_cleanup_at = monotonic_now
         @last_recurring_cleanup_at = monotonic_now
         @last_archive_compaction_at = monotonic_now
+        @last_stream_archive_compaction_at = monotonic_now
         @last_outbox_cleanup_at = monotonic_now
         @last_job_lock_cleanup_at = monotonic_now
         @last_stats_cleanup_at = monotonic_now
@@ -79,6 +80,7 @@ module Pgbus
         run_if_due(now, :@last_batch_cleanup_at, BATCH_CLEANUP_INTERVAL) { cleanup_batches }
         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_stream_archive_compaction_at, ARCHIVE_COMPACTION_INTERVAL) { prune_stream_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 }
@@ -140,13 +142,20 @@ module Pgbus
       end
 
       def cleanup_stats
-        return unless config.stats_enabled
-
         retention = config.stats_retention
         return unless retention&.positive?
 
-        deleted = JobStat.cleanup!(older_than: Time.current - retention)
-        Pgbus.logger.debug { "[Pgbus] Cleaned up #{deleted} old job stats" } if deleted.positive?
+        cutoff = Time.current - retention
+
+        if config.stats_enabled
+          deleted = JobStat.cleanup!(older_than: cutoff)
+          Pgbus.logger.debug { "[Pgbus] Cleaned up #{deleted} old job stats" } if deleted.positive?
+        end
+
+        return unless config.streams_stats_enabled
+
+        deleted = StreamStat.cleanup!(older_than: cutoff)
+        Pgbus.logger.debug { "[Pgbus] Cleaned up #{deleted} old stream stats" } if deleted.positive?
       end
 
       def cleanup_job_locks
@@ -241,6 +250,55 @@ module Pgbus
         Pgbus.logger.warn { "[Pgbus] Archive compaction failed: #{e.message}" }
       end
 
+      # Prunes per-stream archive tables. Unlike compact_archives (which
+      # uses the global archive_retention, typically 7 days), streams need
+      # per-stream retention because a chat-history stream and a
+      # presence-ping stream have wildly different storage requirements.
+      # Lookup order for a given queue: exact string match, then regex
+      # match, then streams_default_retention (5 minutes by default).
+      def prune_stream_archives
+        prefix = config.streams_queue_prefix
+        return if prefix.nil? || prefix.empty?
+
+        batch_size = config.archive_compaction_batch_size || 1000
+        conn = config.connects_to ? Pgbus::BusRecord.connection : ActiveRecord::Base.connection
+        queue_names = conn.select_values("SELECT queue_name FROM pgmq.meta ORDER BY queue_name")
+
+        queue_names.each do |full_name|
+          next unless full_name.start_with?("#{prefix}_")
+
+          retention = retention_for_stream_queue(full_name)
+          next unless retention.positive?
+
+          cutoff = Time.current - retention
+          stripped = full_name.delete_prefix("#{config.queue_prefix}_")
+          deleted = Pgbus.client.purge_archive(stripped, older_than: cutoff, batch_size: batch_size)
+          if deleted.positive?
+            Pgbus.logger.debug do
+              "[Pgbus] Compacted #{deleted} stream archive entries from #{full_name}"
+            end
+          end
+        rescue StandardError => e
+          Pgbus.logger.warn { "[Pgbus] Stream archive compaction failed for #{full_name}: #{e.message}" }
+        end
+      rescue StandardError => e
+        Pgbus.logger.warn { "[Pgbus] Stream archive compaction failed: #{e.message}" }
+      end
+
+      def retention_for_stream_queue(full_name)
+        retention_map = config.streams_retention || {}
+        # Exact-match first — cheapest and most common path
+        exact = retention_map[full_name]
+        return exact.to_f if exact
+
+        # Regex-match second for pattern-based overrides (e.g. /^chat_/)
+        retention_map.each do |key, value|
+          return value.to_f if key.is_a?(Regexp) && key.match?(full_name)
+        end
+
+        config.streams_default_retention.to_f
+      end
+
       def cleanup_recurring_executions
         retention = config.recurring_execution_retention
         return unless retention&.positive?

data/lib/pgbus/streams/cursor.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module Streams
+    # Parses an SSE replay cursor from a Rack request. The cursor is the highest
+    # PGMQ msg_id the client has already seen; the streamer replays everything
+    # strictly greater on (re)connect.
+    #
+    # Two sources, by precedence:
+    #   1. Last-Event-ID header (sent automatically by EventSource on reconnect)
+    #   2. ?since= query param (sent by the custom element on first connect,
+    #      because EventSource cannot send custom headers on the initial request)
+    #
+    # Returns 0 when no cursor is present (i.e. "deliver everything from now").
+    module Cursor
+      # PGMQ msg_id is BIGINT — strictly within signed 64-bit range.
+      MAX_MSG_ID = (2**63) - 1
+
+      class InvalidCursor < ArgumentError
+      end
+
+      # Strict integer pattern: optional leading minus, then digits. No plus prefix,
+      # no decimal, no whitespace. Negatives are caught by validate! with a clearer
+      # error message than "must be numeric".
+      INTEGER_PATTERN = /\A-?\d+\z/
+
+      def self.parse(query_since:, last_event_id:)
+        raw = pick(last_event_id, query_since)
+        return 0 if raw.nil?
+
+        value = coerce(raw)
+        validate!(value)
+        value
+      end
+
+      def self.pick(last_event_id, query_since)
+        return last_event_id if present?(last_event_id)
+        return query_since   if present?(query_since)
+
+        nil
+      end
+
+      def self.present?(value)
+        return false if value.nil?
+        # Any Integer is "present" so precedence is decided here, not by
+        # the sign of the value. validate! rejects negatives separately
+        # so a caller passing a literal -1 still crashes loud rather than
+        # silently falling through to query_since.
+        return true if value.is_a?(Integer)
+
+        !value.to_s.strip.empty?
+      end
+
+      def self.coerce(raw)
+        return raw if raw.is_a?(Integer)
+
+        str = raw.to_s
+        raise InvalidCursor, "cursor must be numeric (got #{raw.inspect})" unless str.match?(INTEGER_PATTERN)
+
+        Integer(str, 10)
+      end
+
+      def self.validate!(value)
+        raise InvalidCursor, "cursor must not be negative (got #{value})" if value.negative?
+        raise InvalidCursor, "cursor #{value} is out of BIGINT range" if value > MAX_MSG_ID
+      end
+
+      private_class_method :pick, :present?, :coerce, :validate!
+    end
+  end
+end

data/lib/pgbus/streams/envelope.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module Streams
+    # Encodes Server-Sent Events frames per https://html.spec.whatwg.org/multipage/server-sent-events.html.
+    #
+    # Pgbus uses three frame types:
+    #   - `message(id:, event:, data:)` — a real broadcast (carries an `id:` so the client
+    #     can resume via `Last-Event-ID` on reconnect)
+    #   - `comment(text)` — a heartbeat or sentinel that the SSE parser ignores
+    #   - `retry_directive(ms)` — tells `EventSource` how long to wait before reconnecting
+    #
+    # All frames end with `\n\n` (the SSE event terminator). `data:` lines must not
+    # contain newlines — the SSE spec uses `\n` as the field terminator, so a multi-line
+    # payload would arrive as multiple events. We strip `\r` and `\n` from data and
+    # comment text rather than splitting into multiple `data:` lines, because Turbo
+    # Stream HTML is already flat and the simpler encoding is easier to debug.
+    module Envelope
+      NEWLINES = /[\r\n]+/
+
+      RESPONSE_HEADERS = "HTTP/1.1 200 OK\r\n" \
+                         "content-type: text/event-stream\r\n" \
+                         "cache-control: no-cache, no-transform\r\n" \
+                         "x-accel-buffering: no\r\n" \
+                         "connection: keep-alive\r\n" \
+                         "\r\n"
+
+      def self.message(id:, event:, data:)
+        raise ArgumentError, "id is required" if id.nil?
+        raise ArgumentError, "event is required" if event.nil? || event.to_s.empty?
+
+        "id: #{id}\nevent: #{event}\ndata: #{strip_newlines(data.to_s)}\n\n"
+      end
+
+      def self.comment(text)
+        ": #{strip_newlines(text.to_s)}\n\n"
+      end
+
+      def self.retry_directive(milliseconds)
+        unless milliseconds.is_a?(Integer) && !milliseconds.negative?
+          raise ArgumentError, "retry must be a non-negative integer (got #{milliseconds.inspect})"
+        end
+
+        "retry: #{milliseconds}\n\n"
+      end
+
+      def self.http_response_headers
+        RESPONSE_HEADERS
+      end
+
+      def self.strip_newlines(str)
+        str.gsub(NEWLINES, "")
+      end
+
+      private_class_method :strip_newlines
+    end
+  end
+end

data/lib/pgbus/streams/filters.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module Streams
+    # Process-wide registry of server-side audience filter predicates.
+    # Used by `Pgbus.stream(name).broadcast(html, visible_to: :label)`
+    # to restrict delivery to connections whose authorize-hook context
+    # matches the predicate.
+    #
+    # Typical setup at boot time:
+    #
+    #   Pgbus::Streams.filters.register(:admin_only) { |user| user.admin? }
+    #   Pgbus::Streams.filters.register(:workspace_member) do |user, stream|
+    #     user.workspaces.pluck(:id).include?(stream.split(":").last.to_i)
+    #   end
+    #
+    # Broadcasts reference filters by label:
+    #
+    #   Pgbus.stream("workspace:42").broadcast(html, visible_to: :admin_only)
+    #
+    # The Dispatcher looks up the filter in the registry, evaluates it
+    # against each connection's context (populated from the StreamApp's
+    # authorize hook return value), and only delivers to connections
+    # where the predicate returns true.
+    #
+    # Why a registry of labels instead of passing a Proc directly to
+    # broadcast: predicates can't be serialized to JSON, so they can't
+    # travel through PGMQ. The label is serialized; the predicate lives
+    # in-process on the subscriber side. This also means the predicate
+    # is evaluated on the same process that holds the SSE connection,
+    # so the user context (typically an ActiveRecord model or a session
+    # hash) is always available.
+    class Filters
+      def initialize(logger: nil)
+        @mutex = Mutex.new
+        @filters = {}
+        @logger = logger
+      end
+
+      def register(label, callable = nil, &block)
+        raise ArgumentError, "filter label must be a Symbol (got #{label.class})" unless label.is_a?(Symbol)
+
+        predicate = callable || block
+        raise ArgumentError, "filter must be given a block or callable" if predicate.nil?
+
+        @mutex.synchronize { @filters[label] = predicate }
+      end
+
+      def lookup(label)
+        @mutex.synchronize { @filters[label] }
+      end
+
+      # Evaluates the named filter against a context. The context is
+      # whatever the StreamApp's authorize hook returned when the
+      # connection was established — typically a user model.
+      #
+      # Policy decisions:
+      #   - label=nil → visible (no filter attached to the broadcast)
+      #   - unknown label → NOT visible + warning log. Fail-closed so
+      #     a typo or renamed filter doesn't turn a restricted
+      #     broadcast into a public one. The whole point of audience
+      #     filtering is data isolation; failing open on a typo
+      #     defeats the feature. The warning log is loud enough that
+      #     typos still get noticed in dev (check the log or wonder
+      #     why no subscriber sees your broadcast).
+      #   - predicate raises → NOT visible (fail-closed on runtime
+      #     error to avoid leaking data on an exception path).
+      def visible?(label, context)
+        return true if label.nil?
+
+        predicate = lookup(label)
+        if predicate.nil?
+          log_warn("unknown filter label #{label.inspect} — broadcast dropped (fail-closed)")
+          return false
+        end
+
+        begin
+          !!predicate.call(context)
+        rescue StandardError => e
+          log_error("filter #{label.inspect} raised #{e.class}: #{e.message} — dropping broadcast (fail-closed)")
+          false
+        end
+      end
+
+      private
+
+      def log_warn(message)
+        logger = @logger || (Pgbus.logger if defined?(Pgbus) && Pgbus.respond_to?(:logger))
+        logger&.warn { "[Pgbus::Streams::Filters] #{message}" }
+      end
+
+      def log_error(message)
+        logger = @logger || (Pgbus.logger if defined?(Pgbus) && Pgbus.respond_to?(:logger))
+        logger&.error { "[Pgbus::Streams::Filters] #{message}" }
+      end
+    end
+  end
+end