startback 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 844c222d0b34ee64835caafe69e4a52b0fad2176653b007208fb16feba998556
-  data.tar.gz: c7a8ff0dd59aa367d4de6fdf4f23c4c916ac52e98e935316ca267af834ef7655
+  metadata.gz: 618541ed038c6a619973934e3430a23eebd0ac9606f91d2535fbd7354e2835b1
+  data.tar.gz: 0161c46f4272637e7ae3862eca10d5098c2f109cc28ef9e019826ca2d627aa79
 SHA512:
-  metadata.gz: e928708f893554970de832c1b0c1f1235134614f0fe7e6b82ed8208502f423c6f911d0ad3898f3ddd8185d0bdc85634d03ec40e9b169164100e64c72b1ca824e
-  data.tar.gz: ab333a49176eda2128b6cc1c502135be60c4cbc9479f05afef983186452f412c9c388f12cd2cece970e3da5a2a39da05e24dd7c2793f5d57e53d2365d90847d0
+  metadata.gz: a12d45c8d149de30c27658638572bc32d9d5ba6d8fb0fd92a5a94a14681be318ce79473463476e5cd67c750639affbdb5d25aafc20ae4b3accd6a649a2762d20
+  data.tar.gz: 8b3e16023edb27a7969984576b512974ad1a68277e9d08e94b8399b1c9c475a1063f0e5afd4b49141577a58ab00853ac53193bfa3d018875b87e3dec1a21d839

data/CHANGELOG.md

@@ -1,3 +1,40 @@
+## 2.1.1 - 2026-10-23
+
+The Bunny event bus keeps consuming across a broker restart. **Nothing to do
+to get the fix**; `alive?` is there for whoever wants a liveness probe.
+
+### Listeners survive a broker restart
+
+2.1.0 adopts a pre-existing exchange or queue passively when its properties
+differ from the requested ones -- what an older Startback left behind, a
+transient topology. Bunny does not record passive declarations for topology
+recovery. After a broker restart the transient objects are gone, Bunny's
+replay of the queue binding fails with `NOT_FOUND`, the broker closes the
+channel the consumer lived on, and the application keeps running without
+consuming anything, with nothing louder than an error line in Bunny's log.
+It took a manual restart to get it back.
+
+Once Bunny reports the connection recovered, the bus now forgets what it
+knew of the topology and subscribes again every listener whose consumer did
+not come back, declaring the exchange and queue as requested -- durable,
+since the transient ones are gone. Listeners whose consumer survived are left
+alone. An application's own `recovery_completed` connection option is still
+called, first.
+
+### `Bus::Bunny::Async#alive?`
+
+True when the bus is connected and every listener still has a consumer on an
+open channel. A recovery that fails to subscribe a listener again leaves it
+dead and logs the error; Bunny's own recovery may also never complete at all.
+`alive?` reports both, which makes it the right thing for a liveness probe to
+check:
+
+```ruby
+map '/health/bus' do
+  run ->(_env) { bus.async.alive? ? [204, {}, []] : [503, {}, ["Bus is not consuming"]] }
+end
+```
+
 ## 2.1.0 - 2026-09-30
 
 Ruby 4.0 support, docker images for several ruby versions, and the Bunny

data/lib/startback/event/bus/bunny/async.rb

@@ -28,6 +28,15 @@ module Startback
         # A warning is logged, and the durable declaration takes effect on its
         # own at the next broker restart, transient objects not surviving one.
         #
+        # Listeners **survive a broker restart**. Bunny recovers the topology
+        # it recorded, but not what was adopted passively: rebinding such a
+        # queue fails with NOT_FOUND and closes the channel its consumer lives
+        # on. Once Bunny reports the connection recovered, the bus therefore
+        # subscribes again every listener whose consumer did not come back.
+        # `alive?` tells whether every listener still consumes, which is what
+        # a liveness probe wants to ask: Bunny's own recovery may also never
+        # complete at all.
+        #
         # Examples:
         #
         #     # Connects to RabbitMQ using all default options
@@ -102,6 +111,8 @@ module Startback
             @options = DEFAULT_OPTIONS.merge(options)
             @topology = {}
             @topology_lock = Mutex.new
+            @listeners = []
+            @listeners_lock = Mutex.new
             connect if @options[:autoconnect]
           end
           attr_reader :options
@@ -114,6 +125,7 @@ module Startback
             conn = options[:connection_options] || options[:url]
             try_max_times(10) do
               @bunny = ::Bunny.new(conn)
+              @bunny.after_recovery_completed { recovery_completed(conn) }
               @bunny.start
               channel # make sure we already create the channel
               log(:info, {op: "#{self.class.name}#connect", op_data: conn}, options[:context])
@@ -132,6 +144,13 @@ module Startback
             @bunny && @bunny.connected?
           end
 
+          # Whether the bus is connected and every listener still consumes:
+          # its channel is open and the broker did not cancel its consumer.
+          # False is what a liveness probe should restart the process on.
+          def alive?
+            !!connected? && listeners.all?(&:alive?)
+          end
+
           def channel
             unless @bunny
               raise Startback::Errors::Error, "Please connect your bus first, or use autoconnect: true"
@@ -163,19 +182,67 @@ module Startback
           def listen(type, processor = nil, listener = nil, &bl)
             raise ArgumentError, "A listener must be provided" unless listener || bl
 
-            fanout = declare(:fanout, type.to_s, fanout_options)
-            queue = declare(:queue, (processor || "main").to_s, queue_options)
+            subscription = Subscription.new(type.to_s, (processor || "main").to_s, listener || bl)
+            subscribe(subscription)
+            @listeners_lock.synchronize { @listeners << subscription }
+            subscription.consumer
+          end
+
+        protected
+
+          # What `listen` was asked for, kept to subscribe again after a
+          # broker restart, along with the consumer currently serving it.
+          class Subscription < Struct.new(:type, :processor, :listener, :consumer)
+            def alive?
+              channel = consumer && consumer.channel
+              !!channel && channel.open? && channel.consumers.key?(consumer.consumer_tag)
+            end
+          end
+
+          def listeners
+            @listeners_lock.synchronize { @listeners.dup }
+          end
+
+          def subscribe(subscription)
+            fanout = declare(:fanout, subscription.type, fanout_options)
+            queue = declare(:queue, subscription.processor, queue_options)
             # Bound by name on purpose: declaring the queue may have renewed
             # the channel, in which case `fanout` belongs to a closed one.
             queue.bind(fanout.name)
-            queue.subscribe do |delivery_info, properties, body|
+            subscription.consumer = queue.subscribe do |delivery_info, properties, body|
               stop_errors(self, "listen") do
-                (listener || bl).call(body)
+                subscription.listener.call(body)
               end
             end
           end
 
-        protected
+          # Called by Bunny once it reconnected and replayed the topology it
+          # recorded, after the application's own `recovery_completed`
+          # callback, if any.
+          #
+          # What Bunny replayed may no longer match the broker -- objects
+          # adopted passively are not replayed at all -- so the topology is
+          # probed anew, and the listeners left without a consumer subscribe
+          # again. One that fails stays dead, and `alive?` reports it.
+          def recovery_completed(conn)
+            conn[:recovery_completed].call if conn.is_a?(Hash) && conn[:recovery_completed]
+
+            @topology_lock.synchronize { @topology = {} }
+            listeners.reject(&:alive?).each do |subscription|
+              renew_channel!
+              subscribe(subscription)
+              log(:info, {
+                op: "#{self.class.name}#recovery_completed",
+                op_data: { type: subscription.type, processor: subscription.processor, msg: "Subscribed again" }
+              }, options[:context])
+            rescue StandardError => ex
+              log(:error, {
+                op: "#{self.class.name}#recovery_completed",
+                op_data: { type: subscription.type, processor: subscription.processor },
+                error: ex
+              }, options[:context])
+            end
+          end
 
           # Declares an exchange (`kind` = :fanout) or a queue (:queue) with
           # `options`, adopting one that already exists with other properties

data/lib/startback/version.rb

@@ -2,7 +2,7 @@ module Startback
   module Version
     MAJOR = 2
     MINOR = 1
-    TINY  = 0
+    TINY  = 1
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

data/spec/unit/event/bus/bunny/test_async.rb

@@ -259,6 +259,105 @@ module Startback
 
       end
 
+      describe "staying alive" do
+
+        # What a broker restart leaves behind when the queue was adopted
+        # passively: Bunny does not replay it, rebinding fails, and the
+        # consumer is gone. Deleting the queue from elsewhere gets the same
+        # outcome -- the broker cancels the consumer -- without a restart.
+        def kill_consumer!
+          BunnyBroker.delete_topology(queues: [processor])
+        end
+
+        # Bunny calls this once it reconnected and replayed its topology.
+        def complete_recovery!(b)
+          b.instance_variable_get(:@bunny).send(:notify_of_recovery_completion)
+        end
+
+        it 'is not alive before connecting' do
+          expect(bus.alive?).to eql(false)
+        end
+
+        it 'is alive once connected and listening' do
+          b = connected_bus
+          b.listen(type, processor) { |body| }
+          expect(b.alive?).to eql(true)
+        end
+
+        it 'is not alive once disconnected' do
+          b = connected_bus
+          b.listen(type, processor) { |body| }
+          b.disconnect
+          expect(b.alive?).to eql(false)
+        end
+
+        it 'is not alive when a consumer is gone' do
+          b = connected_bus
+          b.listen(type, processor) { |body| }
+          kill_consumer!
+
+          expect(BunnyBroker.wait_for { !b.alive? }).to eql(true)
+        end
+
+        it 'subscribes dead listeners again once a recovery completed' do
+          b = connected_bus
+          seen = Queue.new
+          b.listen(type, processor) { |body| seen << body }
+          kill_consumer!
+          BunnyBroker.wait_for { !b.alive? }
+
+          complete_recovery!(b)
+
+          expect(b.alive?).to eql(true)
+          b.emit(Event.new(type, { id: 12 }))
+          received = BunnyBroker.wait_for { seen.pop unless seen.empty? }
+          expect(received).not_to be_nil
+          expect(JSON.parse(received)["data"]).to eql({ "id" => 12 })
+        end
+
+        it 'declares the topology as requested when subscribing again' do
+          # An exchange adopted passively before the restart is gone after
+          # it: the durable declaration must win then, not the memoized
+          # `passive: true`, which would fail with NOT_FOUND.
+          b = connected_bus
+          b.listen(type, processor) { |body| }
+          b.instance_variable_get(:@topology)[[:fanout, type]] = { passive: true }
+          BunnyBroker.delete_topology(exchanges: [type], queues: [processor])
+          BunnyBroker.wait_for { !b.alive? }
+
+          complete_recovery!(b)
+
+          expect(b.alive?).to eql(true)
+          expect {
+            ch = b.channel
+            ch.fanout(type, durable: true, passive: true)
+            ch.queue(processor, durable: true, passive: true)
+          }.not_to raise_error
+        end
+
+        it 'leaves live listeners alone' do
+          b = connected_bus
+          consumer = b.listen(type, processor) { |body| }
+
+          complete_recovery!(b)
+
+          expect(b.send(:listeners).first.consumer).to equal(consumer)
+        end
+
+        it "still calls the application's own recovery_completed" do
+          called = Queue.new
+          b = connected_bus(connection_options: ::Bunny::Session.parse_uri(url).merge(
+            recovery_completed: -> { called << true }
+          ))
+          b.listen(type, processor) { |body| }
+
+          complete_recovery!(b)
+
+          expect(called.empty?).to eql(false)
+        end
+
+      end
+
       describe "the asynchronous contract" do
 
         it 'hides emit errors from the emitter' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: startback
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-30 00:00:00.000000000 Z
+date: 2026-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec