flu-rails 8.0.6 → 8.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80a0fc1ea3123f0811eb936297c9aacc868e2b3f8e6d771a53dfd768901c6f83
-  data.tar.gz: 4764f353735e58b7e8a9183190fd104836caa15c7f99ed8df03a26bed5b21565
+  metadata.gz: bbe2d214138e198e66d6291a86e2614950e53f14c5556ee424cc98bd1a993981
+  data.tar.gz: c4884ce66ae50205a1a5033a3264da67dbd105d5f4e6210a6afbd9619161a1c8
 SHA512:
-  metadata.gz: cfdf59bb4782cad462e48110c90084506141bb4d5b16ee39db055feafc5f925eb3cf705bd772038d1fb67bc4c5f9e40841d5a82959362c3c999adad3951d7175
-  data.tar.gz: 0f888571495893ff2e503b10133364bb5fe556aaf0f48105ab6a4c106b11234cbc5fbb5c59002224542674f73976da593b535d5e90a3485a3558e3fc95e9f9d1
+  metadata.gz: fbd2777d9c2e08e2a46b2af5ed1baa357fa0bd16d75bf38b69352ef20318d4aa2b6ef75892a7e5438a2f31659e9fda808b0caef7897909e1c13928923e10c395
+  data.tar.gz: bb2e43abb4c22309616ca7c1bdca175922a89732cbd259978f634e9064e1f61a39bfc8b8a7007c0ba96f96b87dd573b1f5c71253ac1784921b0a97fa423d6eba

data/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+### [8.0.8] - 2026-08-26
+
+**Fixed**
+
+* Keep the event publisher across code reloads. The railtie re-runs `init` on every reload, and `init` disconnected the publisher it replaced -- but a tracked model publishes through the very publisher it was tracked with, so every model the reload did not reload kept publishing on a connection that had just been closed, and nothing ever reopened it: `Flu::NotConnectedError` ("'connect' was never called, or 'disconnect' was") on every event from then on, until the process was restarted. The publisher now outlives the reloads, and only a change of kind (the real publisher for the dummy one, or the other way round) replaces and disconnects it.
+* Reopen a connection Bunny has stopped recovering. Bunny reopens a connection it lost, but not one that never opened, nor one whose recovery attempts ran out: `publish` only ever reconnected after a fork, so a publisher left with such a connection raised on every event for the rest of the process. It now reopens it on the next publication, and no more than once every five seconds, since a broker that hangs rather than refuses costs a full `connect_timeout` per attempt.
+
+**Changed**
+
+* `connect` no longer retries an unreachable broker forever. It gives up after `max_connect_wait` seconds and raises `Flu::ConnectionLostError`. The railtie calls it from `to_prepare`, which runs on every code reload: waiting on a broker that never answers held the reload interlock, and the request behind it, for good.
+* A broker that cannot be reached at startup no longer keeps the application from booting. `Flu.start` logs the failure, and publishing opens the connection once the broker answers again.
+
+**Added**
+
+* `max_connect_wait` (default `30`), how many seconds the startup retries a broker that does not answer before letting the application boot. `nil` waits for the broker for as long as it takes.
+
 ### [8.0.6] - 2026-08-19
 
 **Fixed**

data/README.md

@@ -16,7 +16,7 @@ For now, events are generated from:
 Add the gem to your project's Gemfile:
 
   ```ruby
-  gem "flu-rails", "8.0.6"
+  gem "flu-rails", "8.0.8"
   ```
 
 Then, create an initializer into your Rails app (`config/initializers/flu-rails.rb`)
@@ -50,7 +50,8 @@ Each configuration is detailed below.
 ### Start up
 
 `flu-rails` starts automatically through its `Railtie`: there is nothing to call by hand.
-Its startup waits until its RabbitMQ exchange is connected.
+Its startup waits for its RabbitMQ exchange to be connected, for at most `max_connect_wait` seconds. A broker that is still not there by then does not keep the application from booting:
+publishing reopens the connection itself once the broker answers again.
 
 ### Track changes on an ActiveRecord model
 
@@ -170,6 +171,7 @@ All options have a default value. However, all of them can be changed in your in
 | `bunny_options` | `{}` | Hash of symbols | Optional | Additional options to add when connecting the RabbitMQ broker. This overrides the existing options with the same name. | `{ verify_peer: true }` |
 | `max_pending_events` | `1000` | Integer | Optional | An event the broker refused waits for the connection to be back, and is published by the next commit of the thread or at the end of the request. This is how many a thread keeps waiting before handing the oldest to `on_publication_failure`. They are held in memory: a process that dies takes them with it. | `5000` |
 | `on_publication_failure` | `nil` | Lambda | Optional | Called with the event and the error when an event cannot be published, instead of logging it. The transaction the event belongs to has already committed by then, so this is the last chance to keep it: store it and publish it again later. The event is `nil` when it could not even be built. | `lambda { |event, error| OutboxEvent.create!(payload: event&.to_json, error: error.message) }` |
+| `max_connect_wait` | `30` | Integer or `nil` | Optional | How many seconds the startup retries a broker that does not answer before giving up and letting the application boot. Publishing reopens the connection itself once the broker answers again. `nil` waits for the broker for as long as it takes. | `nil` |
 
 ## How to execute tests
 
@@ -315,8 +317,8 @@ scoped RubyGems credential.
 3. Tag the commit and push the tag:
 
 ```
-  $ git tag -a v8.0.6 -m "Version 8.0.6"
-  $ git push origin v8.0.6
+  $ git tag -a v8.0.8 -m "Version 8.0.8"
+  $ git push origin v8.0.8
 ```
 
 The workflow then checks that the tag matches `Flu::VERSION`, runs the tests, builds the gem

data/lib/flu-rails/configuration.rb

@@ -20,6 +20,7 @@ module Flu
                   :application_name,
                   :bunny_options,
                   :on_publication_failure,
-                  :max_pending_events
+                  :max_pending_events,
+                  :max_connect_wait
   end
 end

data/lib/flu-rails/event_publisher.rb

@@ -13,11 +13,15 @@ module Flu
     CONNECTION_LOST_MESSAGE = "the connection to RabbitMQ is down. Bunny reopens it in the " \
                               "background when 'automatically_recover' is on, and publishing " \
                               "works again once it has."
+    CONNECTION_FAILED_MESSAGE = "could not reach RabbitMQ within %s seconds. Publishing reopens " \
+                                "the connection itself once the broker answers again."
+    RECONNECTION_INTERVAL = 5
 
     def initialize(configuration)
-      @logger        = configuration.logger
-      @configuration = configuration
-      @mutex         = Mutex.new
+      @logger          = configuration.logger
+      @configuration   = configuration
+      @mutex           = Mutex.new
+      @next_attempt_at = 0
     end
 
     def publish(event, persistent=true)
@@ -29,19 +33,20 @@ module Flu
       raise ConnectionLostError, CONNECTION_LOST_MESSAGE
     end
 
+    # Retries a broker that is not there yet, for at most 'max_connect_wait' seconds. Waiting on it
+    # forever would hold whatever called it -- the railtie calls it from 'to_prepare', which runs on
+    # every code reload, holding the reload interlock and the request that triggered it.
     def connect
       @mutex.synchronize do
-        unless connected?
-          connected = false
-          while !connected
-            begin
-              connect_to_exchange
-              connected = true
-            rescue Bunny::TCPConnectionFailedForAllHosts
-              @logger.warn("RabbitMQ connection failed, try again in 1 second.")
-              sleep 1
-            end
-          end
+        next if connected?
+        give_up_at = deadline
+        begin
+          connect_to_exchange
+        rescue Bunny::TCPConnectionFailedForAllHosts
+          raise ConnectionLostError, format(CONNECTION_FAILED_MESSAGE, @configuration.max_connect_wait) if expired?(give_up_at)
+          @logger.warn("RabbitMQ connection failed, try again in 1 second.")
+          sleep 1
+          retry
         end
       end
     end
@@ -66,6 +71,45 @@ module Flu
 
     private
 
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    # A nil 'max_connect_wait' waits on the broker for however long it takes.
+    def deadline
+      @configuration.max_connect_wait.nil? ? nil : now + @configuration.max_connect_wait
+    end
+
+    def expired?(give_up_at)
+      !give_up_at.nil? && now >= give_up_at
+    end
+
+    # A connection Bunny is recovering comes back on its own. One that never opened, or that Bunny
+    # has given up on, comes back from here or not at all.
+    def abandoned?
+      return false if @connection.nil? || @connection.open?
+      !@connection.recovering_from_network_failure? &&
+        (!@connection.automatically_recover? ||
+         @connection.closed? ||
+         @connection.status == :not_connected)
+    end
+
+    # A broker that hangs rather than refuses costs a full Bunny 'connect_timeout' per attempt, so
+    # publishing pays for one at most every 'RECONNECTION_INTERVAL' seconds.
+    def due_for_another_attempt?
+      return false if now < @next_attempt_at
+      @next_attempt_at = now + RECONNECTION_INTERVAL
+      true
+    end
+
+    # Reopening is best effort: the caller is publishing, and an event that cannot go out is
+    # reported through the connection errors below rather than through whatever the broker refused.
+    def reconnect
+      @mutex.synchronize { connect_to_exchange unless connected? }
+    rescue StandardError => error
+      @logger.warn("Could not reopen the connection to RabbitMQ: #{error.class}: #{error.message}")
+    end
+
     # A child inherits the parent's socket but none of the threads Bunny runs on it.
     def forked?
       !@pid.nil? && @pid != Process.pid
@@ -85,7 +129,7 @@ module Flu
     # A connection that is down is reported as such rather than left to 'create_channel', which
     # raises a bare 'RuntimeError' the caller has no way to tell from any other.
     def exchange
-      connect if forked?
+      reconnect if forked? || (abandoned? && due_for_another_attempt?)
       cached = Thread.current[exchange_key]
       return cached if cached && cached.channel.open?
       raise NotConnectedError, NOT_CONNECTED_MESSAGE if @connection.nil?

data/lib/flu-rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Flu
-  VERSION = "8.0.6"
+  VERSION = "8.0.8"
 end

data/lib/flu-rails.rb

@@ -73,10 +73,6 @@ module Flu
     raise "configuration.application_name must not be nil" if @configuration.application_name.nil?
     @logger          = @configuration.logger
     @event_factory   = Flu::EventFactory.new(@configuration)
-    # The railtie re-runs 'init' on every code reload. The publisher being replaced owns an open
-    # connection, its channel and Bunny's heartbeat thread: dropping the reference to it without
-    # closing it leaks all three for the lifetime of the process.
-    @event_publisher&.disconnect
     @event_publisher = create_event_publisher(@configuration)
     extend_models_and_controllers
   end
@@ -90,14 +86,24 @@ module Flu
     end
   end
 
+  # The railtie re-runs 'init' on every code reload. Building a new publisher on each of them left
+  # every reference the application had already taken on the previous one -- a tracked model
+  # publishes through the very publisher it was tracked with -- on a connection 'init' had closed
+  # and that nothing ever reopens. The publisher outlives the reloads, and only a change of kind
+  # replaces it: its connection, its channels and Bunny's heartbeat thread are then closed with it.
   def self.create_event_publisher(configuration)
-    if is_testing_environment?
+    publisher_class = event_publisher_class
+    return @event_publisher if @event_publisher.instance_of?(publisher_class)
+
+    @event_publisher&.disconnect
+    if publisher_class == Flu::Dummy::InMemoryEventPublisher
       logger.info("Loading Flu with a dummy event publisher (this will not connect any exchange)")
-      require_relative "flu-rails/dummy/in_memory_event_publisher"
-      Flu::Dummy::InMemoryEventPublisher.new(@configuration)
-    else
-      Flu::EventPublisher.new(@configuration)
     end
+    publisher_class.new(configuration)
+  end
+
+  def self.event_publisher_class
+    is_testing_environment? ? Flu::Dummy::InMemoryEventPublisher : Flu::EventPublisher
   end
 
   def self.is_testing_environment?
@@ -112,8 +118,13 @@ module Flu
     Flu::CoreExt.extend_controller_classes(@event_factory, @event_publisher, @logger)
   end
 
+  # A broker that is not there yet must not keep the application from booting: publishing reopens
+  # the connection itself once the broker answers again.
   def self.start
-    @event_publisher.connect if config.auto_connect_to_exchange
+    return unless config.auto_connect_to_exchange
+    @event_publisher.connect
+  rescue Flu::ConnectionLostError => error
+    config.logger&.error("Flu could not connect to RabbitMQ: #{error.message}")
   end
 
   def self.load_configuration
@@ -137,6 +148,7 @@ module Flu
       config.bunny_options                  = {}
       config.on_publication_failure         = nil
       config.max_pending_events             = 1000
+      config.max_connect_wait               = 30
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flu-rails
 version: !ruby/object:Gem::Version
-  version: 8.0.6
+  version: 8.0.8
 platform: ruby
 authors:
 - Loïc Vigneron