message_bus 4.6.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac878307b45991461b9a20bf6a4f31935c164aa6abce9ba8d931ae291869dbb9
-  data.tar.gz: 201fd5f776e4fb437eb3f2be49961d9469f81745b60b6f84dcccb332212cdd5d
+  metadata.gz: 83e05555f3305e70e3a20f0e6d8e7d62b100581e12c7353df3e59550d191045d
+  data.tar.gz: 74517b6497d898f3f19a0fe43235e72952c43ecd65107b6f3ad10336da83ad65
 SHA512:
-  metadata.gz: f54fb643cb48006c33585e2af967b9e0ae9bb69c5c034b3e454cbe82b9330e1fbbfdb3d58bf60cf6056522e67a59c2b519f18dd851d0fe3fe62e4d96dfe559e5
-  data.tar.gz: 9c358176d7f5441931f1d0505b2c9e17c330806af06fa310393ba321e9db0b0041c433cc12c79e5247d85f85983ffc592b45ee8be4cd939297e7e8411360e6ae
+  metadata.gz: 1dd4b38ed1ed3458f5858130e0fb74575321819220b53579c06c7350a21595061b82189e4ce78ffd0c7248c1c39b7412499e36d8dd01ca7fbb0d85c0cbb5ec18
+  data.tar.gz: d6a13a35bc7a89f423950ee0162cea651d48a5bc858468653995e3bcaaff9062baa972dcc842dd102a82120984915643b94a9de339c8d08cc145e4d0b0b17193

data/.github/workflows/ci.yml

@@ -50,9 +50,15 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ["3.2", "3.3", "3.4"]
+        ruby: ["3.3", "3.4", "4.0"]
         rack: ["rack2", "rack3"]
         redis: ["redis:7.4", "valkey/valkey"]
+        experimental: [false]
+        include:
+          - ruby: ruby-head
+            rack: rack3
+            redis: redis:7.4
+            experimental: true
 
     services:
       postgres:
@@ -77,6 +83,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - uses: ruby/setup-ruby@v1
+        continue-on-error: ${{ matrix.experimental }}
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
@@ -92,6 +99,7 @@ jobs:
         run: pnpm install
 
       - name: Tests
+        continue-on-error: ${{ matrix.experimental }}
         env:
           TESTOPTS: --verbose
         run: bundle exec rake

data/CHANGELOG

@@ -1,8 +1,24 @@
+04-09-2026
+
+- Version 5.0.0
+
+  - BREAKING: Drop support for EOL Ruby 3.2; Ruby 3.3 or newer is now required
+  - DEV: Test against all maintained Ruby versions: 3.3, 3.4, and 4.0, plus Ruby head as a non-blocking compatibility check
+  - DEV: Keep the Rack 2 test suite compatible with Ruby 4.0
+  - DEV: Stabilize time-sensitive backlog expiry and long-polling tests on busy CI runners
+  - FIX: Recover Redis and PostgreSQL backend subscribers from half-open connections without restarting the process
+  - FIX: Keep the keepalive watchdog active if a subscriber reconnect request fails
+  - FIX: Replay missed global messages after Redis and PostgreSQL subscriber reconnects without delivering duplicates
+  - FIX: Request PostgreSQL reconnects on the subscriber thread to respect libpq thread ownership
+
 03-08-2026
 
 - Version 4.6.0
 
   - DEV: Export the JavaScript client as a CommonJS/ES module so it can be imported directly by bundlers and ESM projects, while still assigning the `MessageBus` global for existing consumers
+  - DEV: Add `logger` as a runtime dependency
+  - DEV: Make `MessageBus::Message` a regular class instead of a `Struct`
+  - PERF: Use `Set#intersect?` when checking allowed groups
 
 13-02-2026
 

data/Dockerfile

@@ -1,4 +1,4 @@
-FROM ruby:2.7
+FROM ruby:3.3
 
 RUN cd /tmp && \
   wget --quiet https://bitbucket.org/ariya/phantomjs/downloads/phantomjs-2.1.1-linux-x86_64.tar.bz2 && \

data/README.md

@@ -12,7 +12,7 @@ Read the generated docs: <https://www.rubydoc.info/gems/message_bus>
 
 ## Ruby version support
 
-MessageBus only support officially supported versions of Ruby; as of [2025-03-14](https://www.ruby-lang.org/en/downloads/branches/) this means we only support Ruby version 3.2 and up.
+MessageBus only supports Ruby versions currently maintained by the Ruby core team. As of [2026-09-04](https://www.ruby-lang.org/en/downloads/branches/), the supported versions are Ruby 3.3, 3.4, and 4.0; the minimum required version is Ruby 3.3.
 
 ## Can you handle concurrent requests?
 
@@ -368,7 +368,7 @@ message_bus can be configured to use one of several available storage backends,
 
 ### Keepalive
 
-To ensure correct operation of message_bus, every 60 seconds a message is broadcast to itself. If for any reason the message is not consumed by the same process within 3 keepalive intervals a warning log message is raised.
+To ensure correct operation of message_bus, every 60 seconds a message is broadcast to itself. If for any reason the message is not consumed by the same process within 3 keepalive intervals, a warning log message is raised and the backend subscriber is asked to reconnect, so a wedged connection (for example, a half-open socket) can self-heal without a process restart.
 
 To control keepalive interval use
 

data/lib/message_bus/backends/base.rb

@@ -175,6 +175,18 @@ module MessageBus
         raise ConcreteClassMustImplementError
       end
 
+      # Asks the subscriber to drop its connection and re-establish it, so a
+      # wedged connection (a half-open socket, for example) recovers without a
+      # process restart. The backend's rescue/retry around {#global_subscribe}
+      # performs the actual reconnection.
+      #
+      # Called from the keepalive watchdog thread, never from the subscriber
+      # thread; implementations must not touch anything requiring
+      # single-thread ownership (see the Postgres backend). Backends with no
+      # way to detach a stuck connection may leave this as the inherited no-op.
+      def request_reconnect
+      end
+
       # Subscribe to messages on all channels. Each message since the last ID
       # specified will be delivered by yielding to the passed block as soon as
       # it is available. This will block until subscription is terminated.

data/lib/message_bus/backends/postgres.rb

@@ -20,6 +20,10 @@ module MessageBus
     #
     # @see Base general information about message_bus backends
     class Postgres < Base
+      # Raised inside the subscriber thread to make it drop its LISTEN
+      # connection and reconnect. See {Postgres#request_reconnect}.
+      ReconnectRequested = Class.new(StandardError)
+
       class Client
         INHERITED_CONNECTIONS = []
 
@@ -45,6 +49,7 @@ module MessageBus
           @available = []
           @allocated = {}
           @subscribe_connection = nil
+          @reconnect_requested = false
           @subscribed = false
           @mutex = Mutex.new
           @pid = Process.pid
@@ -153,35 +158,55 @@ module MessageBus
 
         def subscribe(channel)
           obj = Object.new
-          sync { @listening_on[channel] = obj }
+          sync do
+            @listening_on[channel] = obj
+            @reconnect_requested = false
+          end
           listener = Listener.new
           yield listener
 
           conn = @subscribe_connection = raw_pg_connection
-          conn.exec "LISTEN #{channel}"
-          listener.do_sub.call
-          while listening_on?(channel, obj)
-            conn.wait_for_notify(10) do |_, _, payload|
-              break unless listening_on?(channel, obj)
 
-              listener.do_message.call(nil, payload)
+          begin
+            conn.exec "LISTEN #{channel}"
+            listener.do_sub.call
+            while listening_on?(channel, obj)
+              raise ReconnectRequested if reconnect_requested?
+
+              conn.wait_for_notify(10) do |_, _, payload|
+                break unless listening_on?(channel, obj)
+
+                listener.do_message.call(nil, payload)
+              end
             end
-          end
-          listener.do_unsub.call
+            listener.do_unsub.call
 
-          conn.exec "UNLISTEN #{channel}"
-          nil
-        ensure
-          @subscribe_connection&.close
-          @subscribe_connection = nil
+            conn.exec "UNLISTEN #{channel}"
+            nil
+          ensure
+            @subscribe_connection&.close
+            @subscribe_connection = nil
+          end
         end
 
         def unsubscribe
           sync { @listening_on.clear }
         end
 
+        # Sets a flag rather than closing the connection directly, since only
+        # the owning thread may touch a PGconn. Picked up by {#subscribe}'s
+        # wait_for_notify loop, which raises to trigger the retry in
+        # {Postgres#global_subscribe}.
+        def request_reconnect
+          sync { @reconnect_requested = true }
+        end
+
         private
 
+        def reconnect_requested?
+          sync { @reconnect_requested }
+        end
+
         def exec_prepared(conn, *a)
           r = conn.exec_prepared(*a)
           yield r if block_given?
@@ -378,6 +403,16 @@ module MessageBus
         @subscribed = false
       end
 
+      # (see Base#request_reconnect)
+      #
+      # Flags the subscriber thread instead of closing its connection: a
+      # PG::Connection may only be used by its owning thread. The reconnect
+      # therefore takes effect when the subscriber's `wait_for_notify` call
+      # next returns, so within 10 seconds.
+      def request_reconnect
+        client.request_reconnect
+      end
+
       # (see Base#global_subscribe)
       def global_subscribe(last_id = nil)
         raise ArgumentError unless block_given?
@@ -385,15 +420,18 @@ module MessageBus
         highest_id = last_id
 
         begin
+          # Seed a cursor if we don't already have one, so that a reconnect
+          # (triggered by ReconnectRequested below) always has a replay
+          # point and never treats "no explicit last_id" as "never replay".
+          highest_id ||= client.max_id
+
           client.subscribe(postgresql_channel_name) do |on|
             h = {}
 
             on.subscribe do
-              if highest_id
-                process_global_backlog(highest_id) do |m|
-                  h[m.global_id] = true
-                  yield m
-                end
+              highest_id = process_global_backlog(highest_id) do |m|
+                h[m.global_id] = true
+                yield m
               end
               h = nil if h.empty?
               @subscribed = true
@@ -410,25 +448,19 @@ module MessageBus
               end
               m = MessageBus::Message.decode m
 
-              # we have 3 options
-              #
-              # 1. message came in the correct order GREAT, just deal with it
-              # 2. message came in the incorrect order COMPLICATED, wait a tiny bit and clear backlog
-              # 3. message came in the incorrect order and is lowest than current highest id, reset
-
-              if h
-                # If already yielded during the clear backlog when subscribing,
-                # don't yield a duplicate copy.
-                unless h.delete(m.global_id)
-                  h = nil if h.empty?
-                  yield m
-                end
-              else
+              # If already yielded during the clear backlog when subscribing,
+              # don't yield a duplicate copy.
+              duplicate = h && h.delete(m.global_id)
+              h = nil if h&.empty?
+
+              unless duplicate
+                highest_id = m.global_id if m.global_id > highest_id
                 yield m
               end
             end
           end
         rescue => error
+          @subscribed = false
           @config[:logger].warn "#{error} subscribe failed, reconnecting in 1 second. Call stack\n#{error.backtrace.join("\n")}"
           sleep 1
           retry

data/lib/message_bus/backends/redis.rb

@@ -60,6 +60,7 @@ module MessageBus
         @flush_backlog_thread = nil
         @pub_redis = nil
         @subscribed = false
+        @subscriber_connection = nil
         # after 7 days inactive backlogs will be removed
         @max_backlog_age = 604_800
       end
@@ -286,13 +287,18 @@ LUA
           end
 
         begin
-          global_redis = new_redis_connection
+          global_redis = @subscriber_connection = new_redis_connection
 
-          clear_backlog.call(&blk) if highest_id
+          # Seed a cursor if we don't already have one, so that a reconnect
+          # (triggered by request_reconnect below) always has a replay point
+          # and never treats "no explicit last_id" as "never replay".
+          highest_id ||= current_global_id
+
+          clear_backlog.call(&blk)
 
           global_redis.subscribe(redis_channel_name) do |on|
             on.subscribe do
-              clear_backlog.call(&blk) if highest_id
+              clear_backlog.call(&blk)
               @subscribed = true
             end
 
@@ -312,7 +318,7 @@ LUA
               # 2. message came in the incorrect order COMPLICATED, wait a tiny bit and clear backlog
               # 3. message came in the incorrect order and is lowest than current highest id, reset
 
-              if highest_id.nil? || m.global_id == highest_id + 1
+              if m.global_id == highest_id + 1
                 highest_id = m.global_id
                 yield m
               else
@@ -321,15 +327,22 @@ LUA
             end
           end
         rescue => error
+          @subscribed = false
           @logger.warn "#{error} subscribe failed, reconnecting in 1 second. Call stack #{error.backtrace.join("\n")}"
           sleep 1
           global_redis&.disconnect!
           retry
         ensure
           global_redis&.disconnect!
+          @subscriber_connection = nil
         end
       end
 
+      # (see Base#request_reconnect)
+      def request_reconnect
+        @subscriber_connection&.disconnect!
+      end
+
       private
 
       def new_redis_connection
@@ -362,8 +375,12 @@ LUA
         "__mb_global_backlog_n"
       end
 
+      def current_global_id
+        pub_redis.get(global_id_key).to_i
+      end
+
       def process_global_backlog(highest_id, raise_error)
-        highest_id = 0 if highest_id > pub_redis.get(global_id_key).to_i
+        highest_id = 0 if highest_id > current_global_id
 
         global_backlog(highest_id).each do |old|
           if highest_id + 1 == old.global_id

data/lib/message_bus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MessageBus
-  VERSION = "4.6.0"
+  VERSION = "5.0.0"
 end

data/lib/message_bus.rb

@@ -591,7 +591,9 @@ module MessageBus::Implementation
 
   # @param [Integer] interval the keepalive interval in seconds.
   #   Set to 0 to disable; anything higher and a keepalive will run every N
-  #   seconds. If it fails, the process is killed.
+  #   seconds. If a keepalive message is not received within 3 intervals, a
+  #   warning is logged and the backend subscriber is asked to reconnect
+  #   (see {Backends::Base#request_reconnect}).
   def keepalive_interval=(interval)
     configure(keepalive_interval: interval)
   end
@@ -748,13 +750,26 @@ module MessageBus::Implementation
 
     blk = proc do
       if !@destroyed && thread.alive? && keepalive_interval > MIN_KEEPALIVE
+        begin
+          publish("/__mb_keepalive__/", Process.pid, user_ids: [-1])
 
-        publish("/__mb_keepalive__/", Process.pid, user_ids: [-1])
-        if (Time.now - (@last_message || Time.now)) > keepalive_interval * 3
-          logger.warn "Global messages on #{Process.pid} timed out, message bus is no longer functioning correctly"
-        end
+          if (Time.now - (@last_message || Time.now)) > keepalive_interval * 3
+            logger.warn "Global messages on #{Process.pid} timed out, message bus is no longer functioning correctly"
+
+            # Reset first so a slow reconnect isn't re-triggered on the next tick.
+            @last_message = Time.now
 
-        timer.queue(keepalive_interval, &blk) if keepalive_interval > MIN_KEEPALIVE
+            begin
+              backend_instance.request_reconnect
+            rescue => e
+              logger.warn "Failed to request subscriber reconnect on #{Process.pid}: #{e}"
+            end
+          end
+        ensure
+          # This proc is the only thing that re-schedules itself; an exception
+          # escaping here would disable the watchdog permanently.
+          timer.queue(keepalive_interval, &blk) if keepalive_interval > MIN_KEEPALIVE
+        end
       end
     end
 

data/message_bus.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
   gem.name          = "message_bus"
   gem.require_paths = ["lib"]
   gem.version       = MessageBus::VERSION
-  gem.required_ruby_version = ">= 3.2.0"
+  gem.required_ruby_version = ">= 3.3.0"
 
   gem.add_runtime_dependency 'rack', '> 2', '< 4'
   gem.add_runtime_dependency 'logger'
@@ -24,9 +24,10 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'pg'
   gem.add_development_dependency 'concurrent-ruby' # for distributed-cache
 
-  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'minitest', '< 6'
   gem.add_development_dependency 'minitest-hooks'
   gem.add_development_dependency 'minitest-global_expectations'
+  gem.add_development_dependency 'cgi' # Rack 2 tests on Ruby 4+
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'http_parser.rb'
   gem.add_development_dependency 'thin'

data/spec/helpers.rb

@@ -2,6 +2,7 @@
 
 require 'logger'
 require 'method_source'
+require 'stringio'
 
 def wait_for(timeout_milliseconds = 2000, &blk)
   timeout = timeout_milliseconds / 1000.0
@@ -23,7 +24,7 @@ def test_config_for_backend(backend)
 
   case backend
   when :redis
-    config[:url] = ENV['REDISURL']
+    config[:redis_config] = { url: ENV['REDISURL'] }
   when :postgres
     config[:backend_options] = {
       host: ENV['PGHOST'],
@@ -34,3 +35,62 @@ def test_config_for_backend(backend)
   end
   config
 end
+
+# Captures logger output regardless of where each backend stashes its
+# logger instance, so shared reconnect-continuity tests can detect the
+# "subscribe failed, reconnecting in 1 second" line that both network
+# backends emit right before their retry sleep.
+def capture_backend_log(bus)
+  log_output = StringIO.new
+  logger = Logger.new(log_output)
+
+  case CURRENT_BACKEND
+  when :redis
+    bus.instance_variable_set(:@logger, logger)
+  when :postgres
+    bus.instance_variable_get(:@config)[:logger] = logger
+  end
+
+  log_output
+end
+
+# Postgres polls wait_for_notify(10) by default; shorten that only for
+# Postgres so reconnect-continuity assertions run quickly without
+# affecting Redis, which reacts to disconnect immediately.
+def speed_up_reconnect_detection(bus)
+  instrument_postgres_client(bus) if CURRENT_BACKEND == :postgres
+end
+
+# Records LISTEN attempts and which thread closed each subscriber
+# connection (pool connections are excluded), and shortens the notify poll
+# so a reconnect request is picked up quickly.
+def instrument_postgres_client(backend)
+  recorded = { subscribes: [], close_threads: [] }
+  client = backend.send(:client)
+  real_subscribe = client.method(:subscribe)
+  real_raw_pg_connection = client.method(:raw_pg_connection)
+
+  client.define_singleton_method(:subscribe) do |channel, &blk|
+    recorded[:subscribes] << channel
+    real_subscribe.call(channel, &blk)
+  end
+
+  client.define_singleton_method(:raw_pg_connection) do
+    conn = real_raw_pg_connection.call
+    subscriber = false
+
+    conn.define_singleton_method(:wait_for_notify) do |_timeout = nil, &blk|
+      subscriber = true
+      super(0.05, &blk)
+    end
+
+    conn.define_singleton_method(:close) do
+      recorded[:close_threads] << Thread.current if subscriber
+      super()
+    end
+
+    conn
+  end
+
+  recorded
+end

data/spec/lib/message_bus/backend_spec.rb

@@ -17,6 +17,10 @@ describe BACKEND_CLASS do
     it "has the same public methods as the base class" do
       @bus.public_methods.sort.must_equal MessageBus::Backends::Base.new(test_config_for_backend(CURRENT_BACKEND)).public_methods.sort
     end
+
+    it "treats request_reconnect as an optional no-op rather than an error" do
+      MessageBus::Backends::Base.new.request_reconnect.must_be_nil
+    end
   end
 
   it "should be able to access the backlog" do
@@ -108,114 +112,30 @@ describe BACKEND_CLASS do
   end
 
   it "can set backlog age" do
-    @bus.max_backlog_age = 1
-
-    expected_backlog_size = 0
-
-    # Start at time = 0s
+    @bus.max_backlog_age = 0
     @bus.publish "/foo", "bar"
-    expected_backlog_size += 1
-
-    @bus.global_backlog.length.must_equal expected_backlog_size
-    @bus.backlog("/foo", 0).length.must_equal expected_backlog_size
-
-    sleep 1.25 # Should now be at time =~ 1.25s. Our backlog should have expired by now.
-    expected_backlog_size = 0
-
-    case CURRENT_BACKEND
-    when :postgres
-      # Force triggering backlog expiry: postgres backend doesn't expire backlogs on a timer, but at publication time.
-      @bus.global_backlog.length.wont_equal expected_backlog_size
-      @bus.backlog("/foo", 0).length.wont_equal expected_backlog_size
-      @bus.publish "/foo", "baz"
-      expected_backlog_size += 1
-    end
-
-    # Assert that the backlog did expire, and now has only the new publication in it.
-    @bus.global_backlog.length.must_equal expected_backlog_size
-    @bus.backlog("/foo", 0).length.must_equal expected_backlog_size
-
-    sleep 0.75 # Should now be at time =~ 2s
 
-    @bus.publish "/foo", "baz" # Publish something else before another expiry
-    expected_backlog_size += 1
+    # Redis and PostgreSQL expire synchronously during publication. The memory
+    # backend normally expires on a timer, so invoke the same expiry operation
+    # directly rather than making the test wait for that timer to run.
+    @bus.send(:client).expire if CURRENT_BACKEND == :memory
 
-    sleep 0.75 # Should now be at time =~ 2.75s
-    # Our oldest message is now 1.5s old, but we didn't cease publishing for a period of 1s at a time, so we should not have expired the backlog.
-
-    @bus.publish "/foo", "baz" # Publish something else to ward off another expiry
-    expected_backlog_size += 1
-
-    case CURRENT_BACKEND
-    when :postgres
-      # Postgres expires individual messages that have lived longer than the TTL, not whole backlogs
-      expected_backlog_size -= 1
-    else
-      # Assert that the backlog did not expire, and has all of our publications since the last expiry.
-    end
-    @bus.global_backlog.length.must_equal expected_backlog_size
-    @bus.backlog("/foo", 0).length.must_equal expected_backlog_size
+    @bus.global_backlog.must_be_empty
+    @bus.backlog("/foo", 0).must_be_empty
   end
 
   it "can set backlog age on publish" do
     @bus.max_backlog_age = 100
-
-    expected_backlog_size = 0
-
     initial_id = @bus.last_id("/foo")
 
-    # Start at time = 0s
-    @bus.publish "/foo", "bar", max_backlog_age: 1
-    expected_backlog_size += 1
+    @bus.publish "/foo", "bar", max_backlog_age: 0
+    @bus.send(:client).expire if CURRENT_BACKEND == :memory
 
-    @bus.global_backlog.length.must_equal expected_backlog_size
-    @bus.backlog("/foo", 0).length.must_equal expected_backlog_size
-
-    sleep 1.25 # Should now be at time =~ 1.25s. Our backlog should have expired by now.
-    expected_backlog_size = 0
-
-    case CURRENT_BACKEND
-    when :postgres
-      # Force triggering backlog expiry: postgres backend doesn't expire backlogs on a timer, but at publication time.
-      @bus.global_backlog.length.wont_equal expected_backlog_size
-      @bus.backlog("/foo", 0).length.wont_equal expected_backlog_size
-      @bus.publish "/foo", "baz", max_backlog_age: 1
-      expected_backlog_size += 1
-    end
-
-    # Assert that the backlog did expire, and now has only the new publication in it.
-    @bus.global_backlog.length.must_equal expected_backlog_size
-    @bus.backlog("/foo", 0).length.must_equal expected_backlog_size
-
-    # for the time being we can give pg a pass here
-    # TODO: make the implementation here consistent
-    if CURRENT_BACKEND != :postgres
-      # ids are not opaque we expect them to be reset on our channel if it
-      # got cleared due to an expire, the reason for this is cause we will leak entries due to tracking
-      # this in turn can bloat storage for the backend
-      @bus.last_id("/foo").must_equal initial_id
-    end
+    @bus.global_backlog.must_be_empty
+    @bus.backlog("/foo", 0).must_be_empty
 
-    sleep 0.75 # Should now be at time =~ 2s
-
-    @bus.publish "/foo", "baz", max_backlog_age: 1 # Publish something else before another expiry
-    expected_backlog_size += 1
-
-    sleep 0.75 # Should now be at time =~ 2.75s
-    # Our oldest message is now 1.5s old, but we didn't cease publishing for a period of 1s at a time, so we should not have expired the backlog.
-
-    @bus.publish "/foo", "baz", max_backlog_age: 1 # Publish something else to ward off another expiry
-    expected_backlog_size += 1
-
-    case CURRENT_BACKEND
-    when :postgres
-      # Postgres expires individual messages that have lived longer than the TTL, not whole backlogs
-      expected_backlog_size -= 1
-    else
-      # Assert that the backlog did not expire, and has all of our publications since the last expiry.
-    end
-    @bus.global_backlog.length.must_equal expected_backlog_size
-    @bus.backlog("/foo", 0).length.must_equal expected_backlog_size
+    # The memory and Redis backends discard channel ID state on expiry.
+    @bus.last_id("/foo").must_equal initial_id if CURRENT_BACKEND != :postgres
   end
 
   it "can set backlog size on publish" do
@@ -392,4 +312,277 @@ describe BACKEND_CLASS do
     got.map { |m| m.data }.must_equal ["12"]
   end
 
+  it "tolerates request_reconnect when nothing is subscribed" do
+    @bus.request_reconnect
+
+    @bus.publish("/reconnect-noop", "bar")
+
+    @bus.backlog("/reconnect-noop", 0).map(&:data).must_equal ["bar"]
+  end
+
+  it "retries global_subscribe after a redis subscribe failure" do
+    test_only(:redis)
+
+    log_output = StringIO.new
+    @bus.instance_variable_set(:@logger, Logger.new(log_output))
+
+    fail_first_subscribe = true
+    real_new_redis_connection = @bus.method(:new_redis_connection)
+
+    @bus.define_singleton_method(:new_redis_connection) do
+      redis = real_new_redis_connection.call
+
+      if fail_first_subscribe
+        fail_first_subscribe = false
+        redis.define_singleton_method(:subscribe) do |_channel, &_blk|
+          raise IOError, "forced subscribe failure"
+        end
+      end
+
+      redis
+    end
+
+    got = []
+
+    t = Thread.new do
+      @bus.global_subscribe(0) do |msg|
+        got << msg
+      end
+    end
+
+    wait_for(4000) { log_output.string.include?("forced subscribe failure") }
+    wait_for(5000) { @bus.subscribed }
+
+    @bus.publish("/redis-retry", "delivered-after-retry")
+    wait_for(3000) { got.any? { |m| m.data == "delivered-after-retry" } }
+
+    @bus.global_unsubscribe
+    t.join(2)
+    t.kill if t.alive?
+
+    log_output.string.must_include "subscribe failed, reconnecting in 1 second"
+    got.map(&:data).must_include "delivered-after-retry"
+  end
+
+  it "retries global_subscribe after request_reconnect disconnects redis" do
+    test_only(:redis)
+
+    log_output = StringIO.new
+    @bus.instance_variable_set(:@logger, Logger.new(log_output))
+    subscribe_attempts = 0
+    real_new_redis_connection = @bus.method(:new_redis_connection)
+
+    @bus.define_singleton_method(:new_redis_connection) do
+      redis = real_new_redis_connection.call
+      real_subscribe = redis.method(:subscribe)
+      redis.define_singleton_method(:subscribe) do |*args, &blk|
+        subscribe_attempts += 1
+        real_subscribe.call(*args, &blk)
+      end
+      redis
+    end
+
+    got = []
+
+    t = Thread.new do
+      @bus.global_subscribe(0) do |msg|
+        got << msg
+      end
+    end
+
+    wait_for(5000) { @bus.subscribed }
+    wait_for(5000) { subscribe_attempts >= 1 }
+
+    @bus.publish("/redis-reconnect", "before-reconnect")
+    wait_for(3000) { got.any? { |m| m.data == "before-reconnect" } }
+
+    @bus.request_reconnect
+
+    wait_for(7000) { log_output.string.include?("subscribe failed, reconnecting in 1 second") }
+    wait_for(7000) { subscribe_attempts >= 2 }
+
+    @bus.publish("/redis-reconnect", "after-reconnect")
+    wait_for(5000) { got.any? { |m| m.data == "after-reconnect" } }
+
+    @bus.global_unsubscribe
+    t.join(2)
+    t.kill if t.alive?
+
+    got.map(&:data).must_include "after-reconnect"
+    subscribe_attempts.must_be :>=, 2
+  end
+
+  it "replays messages published during a reconnect window without loss or duplication" do
+    test_never(:memory)
+
+    log_output = capture_backend_log(@bus)
+    speed_up_reconnect_detection(@bus)
+
+    got = []
+
+    t = Thread.new do
+      @bus.global_subscribe do |msg|
+        got << msg
+      end
+    end
+
+    wait_for(5000) { @bus.subscribed }
+
+    @bus.publish("/reconnect-continuity", "before")
+    wait_for(3000) { got.any? { |m| m.data == "before" } }
+
+    @bus.request_reconnect
+    wait_for(7000) { log_output.string.include?("subscribe failed, reconnecting in 1 second") }
+
+    @bus.publish("/reconnect-continuity", "during")
+
+    wait_for(7000) { @bus.subscribed }
+
+    @bus.publish("/reconnect-continuity", "after")
+    wait_for(5000) { got.any? { |m| m.data == "after" } }
+
+    @bus.global_unsubscribe
+    t.join(3)
+    t.kill if t.alive?
+
+    got.map(&:data).must_equal ["before", "during", "after"]
+  end
+
+  it "replays a message published during a reconnect window that opened before any message was received" do
+    test_never(:memory)
+
+    log_output = capture_backend_log(@bus)
+    speed_up_reconnect_detection(@bus)
+
+    got = []
+
+    t = Thread.new do
+      @bus.global_subscribe do |msg|
+        got << msg
+      end
+    end
+
+    wait_for(5000) { @bus.subscribed }
+
+    # Request reconnect before any live message has been received, so the
+    # backend has never had a chance to derive a cursor from a message: it
+    # must fall back to the cursor seeded at subscription start.
+    @bus.request_reconnect
+    wait_for(7000) { log_output.string.include?("subscribe failed, reconnecting in 1 second") }
+
+    @bus.publish("/reconnect-continuity-cold", "during")
+
+    wait_for(7000) { @bus.subscribed }
+
+    @bus.publish("/reconnect-continuity-cold", "after")
+    wait_for(5000) { got.any? { |m| m.data == "after" } }
+
+    @bus.global_unsubscribe
+    t.join(3)
+    t.kill if t.alive?
+
+    got.map(&:data).must_equal ["during", "after"]
+  end
+
+  it "reports subscribed as false during a reconnect window and true once replaced" do
+    test_never(:memory)
+
+    log_output = capture_backend_log(@bus)
+    speed_up_reconnect_detection(@bus)
+
+    got = []
+
+    t = Thread.new do
+      @bus.global_subscribe do |msg|
+        got << msg
+      end
+    end
+
+    wait_for(5000) { @bus.subscribed }
+
+    @bus.request_reconnect
+    wait_for(7000) { log_output.string.include?("subscribe failed, reconnecting in 1 second") }
+
+    @bus.subscribed.must_equal false
+
+    wait_for(7000) { @bus.subscribed }
+    @bus.subscribed.must_equal true
+
+    @bus.global_unsubscribe
+    t.join(3)
+    t.kill if t.alive?
+  end
+
+  it "reconnects the postgres subscriber from its own thread" do
+    test_only(:postgres)
+
+    log_output = StringIO.new
+    @bus.instance_variable_get(:@config)[:logger] = Logger.new(log_output)
+    recorded = instrument_postgres_client(@bus)
+
+    got = []
+
+    t = Thread.new do
+      @bus.global_subscribe(0) do |msg|
+        got << msg
+      end
+    end
+
+    wait_for(5000) { @bus.subscribed }
+
+    @bus.publish("/pg-reconnect", "before-reconnect")
+    wait_for(3000) { got.any? { |m| m.data == "before-reconnect" } }
+
+    @bus.request_reconnect
+    wait_for(7000) { recorded[:subscribes].length >= 2 }
+
+    # ReconnectRequested is raised before on.unsubscribe fires, so @subscribed
+    # must already have been reset explicitly by the rescue path.
+    @bus.subscribed.must_equal false
+
+    @bus.publish("/pg-reconnect", "during-reconnect")
+
+    wait_for(5000) { @bus.subscribed }
+
+    @bus.publish("/pg-reconnect", "after-reconnect")
+    wait_for(5000) { got.any? { |m| m.data == "after-reconnect" } }
+
+    @bus.global_unsubscribe
+    t.join(3)
+    t.kill if t.alive?
+
+    # Exact order, no duplicates, no loss: the cursor must be advanced by
+    # every accepted live message and carried across the reconnect.
+    got.map(&:data).must_equal ["before-reconnect", "during-reconnect", "after-reconnect"]
+    log_output.string.must_include "subscribe failed, reconnecting in 1 second"
+
+    # Regression check: only the subscriber thread may close its own PGconn.
+    recorded[:close_threads].uniq.must_equal [t]
+  end
+
+  it "ignores a postgres reconnect request made while nothing was subscribed" do
+    test_only(:postgres)
+
+    recorded = instrument_postgres_client(@bus)
+    @bus.request_reconnect
+
+    got = []
+
+    t = Thread.new do
+      @bus.global_subscribe(0) do |msg|
+        got << msg
+      end
+    end
+
+    wait_for(5000) { @bus.subscribed }
+
+    @bus.publish("/pg-stale-reconnect", "delivered")
+    wait_for(3000) { got.any? { |m| m.data == "delivered" } }
+
+    @bus.global_unsubscribe
+    t.join(3)
+    t.kill if t.alive?
+
+    recorded[:subscribes].length.must_equal 1
+  end
 end

data/spec/lib/message_bus/rack/middleware_spec.rb

@@ -99,13 +99,14 @@ describe MessageBus::Rack::Middleware do
       t.join
     end
 
-    it "should timeout within its alloted slot" do
+    it "should timeout within its allotted slot" do
       begin
         @bus.long_polling_interval = 10
-        s = Time.now.to_f * 1000
+        started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         post "/message-bus/ABC", '/foo' => nil
-        # allow for some jitter
-        (Time.now.to_f * 1000 - s).must_be :<, 100
+        elapsed_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000
+        # Leave enough headroom for scheduler jitter on busy CI runners.
+        elapsed_ms.must_be :<, 250
       ensure
         @bus.long_polling_interval = 5000
       end

data/spec/lib/message_bus_spec.rb

@@ -398,4 +398,110 @@ describe MessageBus do
       channel.must_equal('/test')
     end
   end
+
+  describe "keepalive reconnect watchdog" do
+    def fast_keepalive
+      0.5
+    end
+
+    before do
+      @original_min_keepalive = MessageBus::Implementation::MIN_KEEPALIVE
+      MessageBus::Implementation.send(:remove_const, :MIN_KEEPALIVE)
+      MessageBus::Implementation.const_set(:MIN_KEEPALIVE, 0)
+
+      @log_output = StringIO.new
+      @bus.configure(keepalive_interval: fast_keepalive, logger: Logger.new(@log_output))
+    end
+
+    after do
+      MessageBus::Implementation.send(:remove_const, :MIN_KEEPALIVE)
+      MessageBus::Implementation.const_set(:MIN_KEEPALIVE, @original_min_keepalive)
+    end
+
+    def stall_global_subscribe(backend)
+      backend.define_singleton_method(:global_subscribe) do |_last_id = nil, &_blk|
+        @subscribed = true
+        sleep(0.001) while @subscribed
+      end
+    end
+
+    it "invokes request_reconnect and logs a warning when subscriber reads stall" do
+      backend = @bus.backend_instance
+      reconnect_calls = 0
+      stall_global_subscribe(backend)
+
+      backend.define_singleton_method(:request_reconnect) do
+        reconnect_calls += 1
+        @subscribed = false
+      end
+
+      @bus.after_fork
+      wait_for(1000) { @bus.listening? }
+
+      wait_for(4000) { reconnect_calls == 1 }
+      wait_for(4000) { @log_output.string.include?("no longer functioning correctly") }
+
+      reconnect_calls.must_equal 1
+      @log_output.string.must_include "timed out"
+      @log_output.string.must_include "no longer functioning correctly"
+    end
+
+    it "resets @last_message so reconnect attempts are not immediate cascades" do
+      backend = @bus.backend_instance
+      reconnect_times = []
+      stall_global_subscribe(backend)
+
+      backend.define_singleton_method(:request_reconnect) do
+        reconnect_times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      @bus.after_fork
+      wait_for(1000) { @bus.listening? }
+      wait_for(7000) { reconnect_times.length >= 2 }
+
+      first_gap = reconnect_times[1] - reconnect_times[0]
+      first_gap.must_be :>=, fast_keepalive * 2.8
+    end
+
+    it "stays armed and tries again when request_reconnect raises" do
+      backend = @bus.backend_instance
+      reconnect_calls = 0
+      stall_global_subscribe(backend)
+
+      backend.define_singleton_method(:request_reconnect) do
+        reconnect_calls += 1
+        raise IOError, "simulated connection error"
+      end
+
+      @bus.after_fork
+      wait_for(1000) { @bus.listening? }
+
+      wait_for(8000) { reconnect_calls >= 2 }
+
+      reconnect_calls.must_be :>=, 2
+      @log_output.string.must_include "Failed to request subscriber reconnect"
+      @log_output.string.must_include "simulated connection error"
+    end
+
+    it "stays armed when the keepalive publish raises" do
+      backend = @bus.backend_instance
+      publish_calls = 0
+      real_publish = backend.method(:publish)
+      stall_global_subscribe(backend)
+
+      backend.define_singleton_method(:publish) do |*args, &blk|
+        publish_calls += 1
+        raise IOError, "simulated publish failure" if publish_calls == 1
+
+        real_publish.call(*args, &blk)
+      end
+
+      @bus.after_fork
+      wait_for(1000) { @bus.listening? }
+      wait_for(5000) { publish_calls >= 3 }
+
+      publish_calls.must_be :>=, 3
+      @log_output.string.must_include "simulated publish failure"
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -19,7 +19,9 @@ BACKEND_CLASS = MessageBus::BACKENDS.fetch(CURRENT_BACKEND)
 puts "Running with backend: #{CURRENT_BACKEND}"
 
 def test_only(*backends)
-  skip "Test doesn't apply to #{CURRENT_BACKEND}" if backends.exclude?(CURRENT_BACKEND)
+  return if backends.include?(CURRENT_BACKEND)
+
+  skip "Test doesn't apply to #{CURRENT_BACKEND}"
 end
 
 def test_never(*backends)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: message_bus
 version: !ruby/object:Gem::Version
-  version: 4.6.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Sam Saffron
@@ -87,6 +87,20 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: minitest-hooks
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -100,7 +114,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest-hooks
+  name: minitest-global_expectations
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -114,7 +128,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest-global_expectations
+  name: cgi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -382,7 +396,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="