flu-rails 8.0.3 → 8.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53b6a5973d48efbc23dc72483a46a4eba091d295a4f8bd3e1c927cd3d9c06671
-  data.tar.gz: c425c485c1f1dfe7e1c61382296c17b49108cf3a8b9a257df15e02ce6e96ff45
+  metadata.gz: 24d179705111c94185f7421297a692e1f962feeef2a9c2132a04e744d70a6503
+  data.tar.gz: 93526441dcfaea7cc3a5be4795c5e86cdb9a4acdbaf95b825e530259b3c89d64
 SHA512:
-  metadata.gz: ec67a57f43091e09464f0d78444b224a2e76dd85c004c79d2d07a033ef5ca50cbc9882329e05a5b6d55c5d919d424fc6baa0435d2a96e5230142e50a3ba37029
-  data.tar.gz: eb021576551ca0f52d874a9f9c66d8cb71d5194e9e36867a38bcb220b8df6c9cf97ddef6b299419292d7592c5591851fb1221fba2b6fafa605e4a070ece475a6
+  metadata.gz: bd84b67b67c9f209fbab6c5309d719719e3d9f19df12e1d7816acc6690c084dad052e8590cc39b85cfcc9477b6c187d1ec352a3a8e55a932c5f51d22c062e458
+  data.tar.gz: e7e0eab197a600c06a10c1bb6ec801499cfe3d55327e94232b565830b5ee6fa69c4a5bf7c19ab3082f0492917d83e6c36581ce53600d5cbf9ef0259df1b620b1

data/CHANGELOG.md

@@ -5,6 +5,81 @@ 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.5] - 2026-08-03
+
+**Fixed**
+
+* `QueueRepository#find_all` no longer lists queues across every vhost on the broker. It called `list_queues` without a vhost, which lists every vhost's queues -- on a broker shared with other applications, that meant every other application's queues too, not just this one's.
+* Sanitize the event name before building the routing key.
+* [Breaking change?] Publish only Flu's own events from `flu_publish_events!`. It called `run_callbacks(:commit)`, which runs every `after_commit` callback registered on the record (including the host application's own (mailers, jobs, cache invalidation)) rather than just the one `track_entity_changes` installs. It now calls `flu_commit_changes` directly, the same way the real `after_commit` callback does.
+* Guard the railtie require on `Rails::Railtie` rather than on `Rails`. Gems such as `rails-html-sanitizer` define an empty `Rails` namespace, which `is_testing_environment?` already accounted for a few lines below -- the railtie require itself did not, and raised `NameError: uninitialized constant Rails::Railtie` in that case.
+* Stop assuming `ActionDispatch` is loaded when serializing an event. `Event#to_json` referenced `ActionDispatch::Http::UploadedFile` unconditionally to special-case uploaded files, on every value it serialized. A plain script that builds and serializes an event without the rest of Rails loaded raised `NameError: uninitialized constant Flu::Event::ActionDispatch` on the very first field.
+* Track Single Table Inheritance subclasses. ActiveRecord hands the callbacks registered by `track_entity_changes` down to subclasses, but the class-level instance variables holding their settings were not inherited, so every save of an STI subclass of a tracked model raised `NoMethodError` on `nil`. `flu_is_tracked`, `flu_user_metadata_lambdas`, `flu_ignored_model_changes` and `flu_overriden_emitter_lambda` are now declared with `class_attribute`, which a subclass inherits until it sets its own value.
+* Always clear the per-request tracking state, even when an action raises. The request id and the entity metadata are stored in thread-local storage and were cleared from an `after_action`, which does not run when the action raises. Since application servers reuse their threads, a failed request left its id behind for the next request served by that same thread, whose entity changes were then attributed to a request that had already died. `track_requests` now installs a single `around_action` that clears both from an `ensure` block.
+
+**Added**
+
+* `rabbitmq_vhost` configuration option (default `"/"`), used by both `EventPublisher`'s AMQP connection and `QueueRepository`'s management API calls, to operate on a vhost other than the default.
+* `Flu::Error`, the base class of every error this gem raises on its own, and `Flu::NotConnectedError`.
+
+**Changed**
+
+* `EventFactory` no longer serializes an event to JSON before logging it, unless debug logging is actually enabled.
+* Publishing through a publisher that holds no connection now raises `Flu::NotConnectedError`, naming what to call and the option that turns the automatic connection off, instead of a `NoMethodError` on `nil`.
+* A `request` event is now built once every other `after_action` has run, so its `duration` covers them too. An action that raises still publishes nothing.
+* `EventPublisher` opens one Bunny channel per thread instead of sharing a single one.
+* `EventPublisher#connected?` now reports on the connection alone. The exchange is declared per thread, so it is no longer a single object whose absence says anything about the publisher as a whole.
+
+**Performance**
+
+* Optimize `deep_camelize` to use `each_with_object` and `ActiveSupport::Inflector#camelize` to improve performance and reduce memory consumption.
+* Add `# frozen_string_literal: true` to all ruby files to reduce string allocations.
+
+**Tests**
+
+* Cover `rabbitmq_vhost` against a real broker: `EventPublisher#connect` fails rather than silently falling back to the default vhost when it points at one that does not exist, and `QueueRepository#find_all` scoped to a dedicated vhost does not see a queue declared on another one -- proving the cross-vhost leak above was real.
+* Cover `duration`, which had no test at all: it is the elapsed wall-clock time since `request_start_time`, and a real controller request emits one that is a small, non-negative `Float`.
+* Cover `Event#to_routing_key`: dots are stripped from the name, spaces are left untouched, a name that would push the routing key past 255 characters is truncated with a warning through `Flu.logger`, and none of this raises when `Flu.logger` was never set. Cover the same against a real broker: a name with dots is delivered under a single routing-key segment, and a 300-character name that used to make Bunny raise is published and delivered instead.
+* Cover that `flu_publish_events!` does not run a host application's own `after_commit` callback, registered on the record's singleton class, exactly the way `run_callbacks(:commit)` used to run it too.
+* Cover loading `flu-rails` with an empty `Rails` namespace defined, through the same kind of subprocess as the `ActionDispatch` example above.
+* Cover that building an entity change, request or manual event does not serialize it when the logger's level is above `DEBUG`.
+* Cover `Event#to_json` without `ActionDispatch` loaded, through a subprocess that never requires actionpack -- the main suite always has it loaded, so this is the only honest way to exercise the guard.
+* Cover which channel a thread publishes on, against a real broker: each thread gets its own, reuses it across publications, and picks up a fresh one after the connection was closed under it.
+* Cover `entity_metadata`, which had no test at all: its lambda is evaluated before the action runs, and its result is cleared afterwards.
+* Cover what a raising action leaves behind in the thread-local tracking state.
+* Add `simplecov` as a development dependency to track and report code coverage.
+* Add support for the `RABBITMQ_VERSION` environment variable in `docker-compose.yml` to allow testing locally against different versions of RabbitMQ.
+* Configure GitHub Actions CI to run the test suite against a matrix of RabbitMQ versions (3.12, 3.13, and 4.0).
+
+### [8.0.4] - 2026-08-01
+
+**Security**
+
+* Honour the host application's `config.filter_parameters` when publishing a `request` event.
+
+**Fixed**
+
+* Stop opening two RabbitMQ connections on every boot. The railtie called `Flu.start
+* Close the publisher that `Flu.init` replaces.
+
+**Added**
+
+* `EventPublisher#disconnect` and `EventPublisher#connected?`.
+
+**Changed**
+
+* `ignored_request_params` and `default_ignored_request_params` are now matched as strings.
+* A published `request` event may now carry `"[FILTERED]"` in place of a param value. 
+* `EventPublisher#connect` is now idempotent: calling it on a connected publisher does nothing
+  instead of opening a second connection.
+
+**Tests**
+
+* Cover the connection lifecycle against a real broker: redundant `connect` calls, `disconnect`,
+  `connected?`, and reconnection after a disconnect — including an example asserting that no session
+  is left open behind the publisher.
+* Cover `Flu.init` disconnecting the publisher it replaces.
+
 ### [8.0.3] - 2026-08-01
 
 * Use `uuid_v7` as Event ID (requires Ruby 3.3)

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"
+  gem "flu-rails", "8.0.5"
   ```
 
 Then, create an initializer into your Rails app (`config/initializers/flu-rails.rb`)
@@ -43,6 +43,7 @@ Each configuration is detailed below.
 * RabbitMQ: no specific version is required by `flu-rails` itself. The broker is reached through
   `bunny` 3.x and `rabbitmq_http_api_client` 3.x, which target the
   [currently supported RabbitMQ release series](https://www.rabbitmq.com/release-information).
+  It is actively tested against RabbitMQ 3.12, 3.13, and 4.x.
 
 ## Usage
 
@@ -164,7 +165,7 @@ All options have a default value. However, all of them can be changed in your in
 | `rabbitmq_exchange_durable` | `true` | Boolean | Optional | Make the RabbitMQ's exchange durable or not. From RabbitMQ's [documentation](https://www.rabbitmq.com/tutorials/amqp-concepts.html#exchanges): _"Durable exchanges survive broker restart whereas transient exchanges do not (they have to be redeclared when broker comes back online)."_ | `false` |
 | `auto_connect_to_exchange` | `true`| Boolean | Optional | Thanks to `Railties`, `flu-rails` starts automatically when the Rails app boots. However, this can be useful to not connect RabbitMQ at start up. To do so, set `auto_connect_to_exchange` to `false`.  | `false` |
 | `default_ignored_model_changes` | `[:password, :password_confirmation, :created_at, :updated_at]` | Boolean | Optional | By default, all these attributes will be ignored from model changes when creating an event. For instance, this means that timestamp fields (`created_at` and `updated_at`) are not monitored when they change. | `[]` |
-| `default_ignored_request_params` | `[:password, :password_confirmation, :controller, :action]` | Boolean | Optional | By default, all these parameters will be ignored from controller request's `params` when creating an event. | `false` |
+| `default_ignored_request_params` | `[:password, :password_confirmation, :controller, :action]` | Boolean | Optional | By default, all these parameters will be ignored from controller request's `params` when creating an event. Independently of this option, any parameter your Rails application already masks through `config.filter_parameters` (passwords, tokens,...) is replaced with `"[FILTERED]"` in the event too, including inside nested params. | `false` |
 | `application_name` | `Rails.application.class.module_parent_name`, resolved on startup | String | Required | Is used as `emitter` for each event created by `flu-rails`, if not overriden by the `track_met`. | `my_app` |
 | `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 }` |
 
@@ -187,6 +188,14 @@ your machine, start a broker first:
   $ bundle exec rspec
 ```
 
+You can optionally specify the RabbitMQ version to use by providing the `RABBITMQ_VERSION` environment variable (defaults to `4-management-alpine`):
+
+```
+  $ RABBITMQ_VERSION=3.13-management-alpine docker compose up -d rabbitmq
+```
+
+Our continuous integration pipeline (via GitHub Actions) systematically runs the integration test suite against a matrix of RabbitMQ versions (3.12, 3.13, and 4.x) to ensure seamless backward and forward compatibility.
+
 Without one, those examples are reported as skipped and the rest of the suite still runs. Set
 `FLU_REQUIRE_RABBITMQ` to turn that skip into a failure — this is what the CI workflow does, so that
 a build cannot report success without having reached RabbitMQ:
@@ -304,8 +313,8 @@ scoped RubyGems credential.
 3. Tag the commit and push the tag:
 
 ```
-  $ git tag -a v8.0.3 -m "Version 8.0.3"
-  $ git push origin v8.0.3
+  $ git tag -a v8.0.5 -m "Version 8.0.5"
+  $ git push origin v8.0.5
 ```
 
 The workflow then checks that the tag matches `Flu::VERSION`, runs the tests, builds the gem

data/flu-rails.gemspec

@@ -35,5 +35,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "ostruct",      "~> 0.6"
   spec.add_development_dependency "rake",         ">= 13.0"
   spec.add_development_dependency "rspec",        "~> 3.13"
+  spec.add_development_dependency "simplecov"
   spec.add_development_dependency "sqlite3",      "~> 2.9"
 end

data/lib/flu-rails/action_controller_extender.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/inflections"
 require "active_support/core_ext/time/zones"
 require "random/formatter"
@@ -69,19 +71,17 @@ module Flu
               end
             end
 
-            before_action do
+            prepend_around_action do |_controller, action|
               flu_define_request_id
-              @request_start_time = Time.zone.now
-            end
-            prepend_before_action do
               flu_define_request_entity_metadata
-            end
-            prepend_after_action do
-              flu_track_request
-              flu_remove_request_entity_metadata
-            end
-            after_action do
-              flu_remove_request_id
+              @request_start_time = Time.zone.now
+              begin
+                action.call
+                flu_track_request
+              ensure
+                flu_remove_request_entity_metadata
+                flu_remove_request_id
+              end
             end
           end
         end

data/lib/flu-rails/active_record_extender.rb

@@ -1,9 +1,18 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/try"
 
 module Flu
   class ActiveRecordExtender
     def self.extend_models(event_factory, event_publisher)
       ActiveRecord::Base.class_eval do
+        unless singleton_class.method_defined?(:flu_is_tracked)
+          class_attribute :flu_is_tracked,               instance_accessor: false, default: false
+          class_attribute :flu_user_metadata_lambdas,    instance_accessor: false, default: {}.freeze
+          class_attribute :flu_ignored_model_changes,    instance_accessor: false, default: [].freeze
+          class_attribute :flu_overriden_emitter_lambda, instance_accessor: false, default: nil
+        end
+
         define_singleton_method(:track_entity_changes) do |options = {}|
           self.flu_is_tracked               = true
           self.flu_user_metadata_lambdas    = options.fetch(:user_metadata, {})
@@ -17,38 +26,6 @@ module Flu
           after_rollback { flu_rollback_changes }
         end
 
-        def self.flu_ignored_model_changes=(ignored_model_changes)
-          @flu_ignored_model_changes = ignored_model_changes
-        end
-
-        def self.flu_ignored_model_changes
-          @flu_ignored_model_changes
-        end
-
-        def self.flu_overriden_emitter_lambda=(overriden_emitter_lambda)
-          @flu_overriden_emitter_lambda = overriden_emitter_lambda
-        end
-
-        def self.flu_overriden_emitter_lambda
-          @flu_overriden_emitter_lambda
-        end
-
-        def self.flu_user_metadata_lambdas=(user_metadata_lambdas)
-          @flu_user_metadata_lambdas = user_metadata_lambdas
-        end
-
-        def self.flu_user_metadata_lambdas
-          @flu_user_metadata_lambdas
-        end
-
-        def self.flu_is_tracked=(is_tracked)
-          @flu_is_tracked = is_tracked
-        end
-
-        def self.flu_is_tracked
-          @flu_is_tracked || false
-        end
-
         def self.flu_association_columns
           @flu_association_columns ||= reflect_on_all_associations(:belongs_to).flat_map do |association|
             column_names = [association.foreign_key]
@@ -61,8 +38,15 @@ module Flu
           @flu_changes ||= []
         end
 
-        def flu_publish_events!
-          run_callbacks(:commit)
+        # Defined with 'define_method' rather than 'def', for the same reason as the tracking
+        # helpers in 'ActionControllerExtender#extend_controllers': a bare 'def' opens a new scope
+        # and would not close over 'event_factory' and 'event_publisher'. 
+        #
+        # Without them, publishing manually had no way to call 'flu_commit_changes' directly,
+        # and used 'run_callbacks(:commit)' instead, which runs *every* 'after_commit' callback on the record, 
+        # including the hoste application's own (mailers, jobs, cache invalidation), not just Flu's.
+        define_method(:flu_publish_events!) do
+          flu_commit_changes(event_factory, event_publisher)
         end
 
         def flu_add_manual_event(name, data)

data/lib/flu-rails/configuration.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 module Flu
   class Configuration
     attr_accessor :development_environments,
                   :rejected_user_agents,
                   :logger,
                   :rabbitmq_host,
+                  :rabbitmq_vhost,
                   :rabbitmq_management_scheme,
                   :rabbitmq_management_port,
                   :rabbitmq_port,

data/lib/flu-rails/core_ext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "active_record_extender"
 require_relative "action_controller_extender"
 

data/lib/flu-rails/dummy/in_memory_event_publisher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Flu
   module Dummy
     class InMemoryEventPublisher < Flu::EventPublisher
@@ -20,7 +22,14 @@ module Flu
   
       def connect
       end
-  
+
+      def connected?
+        true
+      end
+
+      def disconnect
+      end
+
       def events_count
         @published_events_by_routing_key.map do | key, value |
           value.size

data/lib/flu-rails/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Flu
+  class Error < StandardError
+  end
+
+  class NotConnectedError < Error
+  end
+end

data/lib/flu-rails/event.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "json"
 
 module Flu
@@ -22,8 +24,11 @@ module Flu
       @data = data || {}
     end
 
+    ROUTING_KEY_MAX_LENGTH = 255
+
     def to_routing_key
-      "#{@meta[:status]}.#{@meta[:emitter]}.#{@meta[:kind]}.#{@meta[:name]}"
+      prefix = "#{@meta[:status]}.#{@meta[:emitter]}.#{@meta[:kind]}."
+      "#{prefix}#{routing_key_name(prefix.length)}"
     end
 
     def to_json(options=nil)
@@ -67,12 +72,22 @@ module Flu
 
     private
 
+    def routing_key_name(prefix_length)
+      name   = @meta[:name].to_s.delete(".")
+      budget = [ROUTING_KEY_MAX_LENGTH - prefix_length, 0].max
+      return name if name.length <= budget
+
+      Flu.logger&.warn("flu-rails: event name '#{@meta[:name]}' was truncated to #{budget} " \
+                        "characters to keep its routing key within Bunny's #{ROUTING_KEY_MAX_LENGTH}-character limit.")
+      name[0, budget]
+    end
+
     def map_complex_object(object)
       if object.is_a?(Array)
         map_array(object)
       elsif object.is_a?(Hash)
         map_hash(object)
-      elsif object.is_a?(ActionDispatch::Http::UploadedFile)
+      elsif defined?(ActionDispatch::Http::UploadedFile) && object.is_a?(ActionDispatch::Http::UploadedFile)
         map_file(object)
       else
         object

data/lib/flu-rails/event_factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "securerandom"
 require "active_support/core_ext/object/blank"
 require "active_support/core_ext/string/inflections"
@@ -11,7 +13,7 @@ module Flu
       @configuration                  = configuration
       @emitter                        = configuration.application_name
       @default_ignored_model_changes  = configuration.default_ignored_model_changes.map(&:to_s)
-      @default_ignored_request_params = configuration.default_ignored_request_params
+      @default_ignored_request_params = configuration.default_ignored_request_params.map(&:to_s)
     end
 
     def build_request_event(data)
@@ -20,7 +22,7 @@ module Flu
       raise ArgumentError, "data must have an controller_name" if !data.has_key?(:controller_name) || data[:controller_name].empty?
       name  = "request to #{data[:action_name]} #{data[:controller_name]}"
       event = build_event(name, :request, data)
-      @logger.debug("Track action: #{JSON.pretty_generate(event)}")
+      @logger.debug { "Track action: #{event.to_json}" }
       event
     end
 
@@ -31,7 +33,7 @@ module Flu
       raise ArgumentError, "data must have an entity_name" if !data.has_key?(:entity_name) || data[:entity_name].empty?
       name  = "#{data[:action_name]} #{data[:entity_name]}"
       event = build_event(name, :entity_change, data)
-      @logger.debug("Track change: " + JSON.pretty_generate(event))
+      @logger.debug { "Track change: #{event.to_json}" }
       event
     end
 
@@ -40,7 +42,7 @@ module Flu
       raise ArgumentError, "data must be a hash"           if !data.is_a?(Hash)
       raise ArgumentError, "name must not be nil or empty" if name.nil? || name.empty?
       event = build_event(name.to_s, :manual, data)
-      @logger.debug("Track manual: " + JSON.pretty_generate(event))
+      @logger.debug { "Track manual: #{event.to_json}" }
       event
     end
 
@@ -77,39 +79,30 @@ module Flu
         response_code:   response.status,
         user_agent:      request.user_agent,
         duration:        Time.zone.now - request_start_time,
-        params:          extract_params(params, ignored_request_params)
+        params:          extract_params(request, ignored_request_params)
       }
     end
 
     private
 
-    def extract_params(params, ignored_request_params)
-      remaining = params.except(*ignored_request_params).except(*@default_ignored_request_params)
-      remaining.respond_to?(:to_unsafe_h) ? remaining.to_unsafe_h.to_h : remaining.to_h
+    def extract_params(request, ignored_request_params)
+      excluded_params = ignored_request_params.map(&:to_s) + @default_ignored_request_params
+      request.filtered_parameters.except(*excluded_params)
     end
 
     def deep_camelize(value)
       case value
       when Array
-        value.map { |v| deep_camelize v }
+        value.map { |v| deep_camelize(v) }
       when Hash
-        value.reduce({}) do |camelized_hash, (k,v)|
-          camelized_hash[camelize(sanitize(k.to_s), false)] = deep_camelize v
-          camelized_hash
+        value.each_with_object({}) do |(k, v), camelized_hash|
+          camelized_hash[sanitize(k.to_s).camelize(:lower)] = deep_camelize(v)
         end
       else
         sanitize(value)
       end
     end
 
-    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
-      if first_letter_in_uppercase
-        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
-      else
-        (lower_case_and_underscored_word[0] || "") + camelize(lower_case_and_underscored_word)[1..-1]
-      end
-    end
-
     def extract_associations_from(entity, association_columns)
       association_columns.reduce({}) do |associations, column_name|
         associations[column_name] = entity[column_name]

data/lib/flu-rails/event_publisher.rb

@@ -1,51 +1,96 @@
+# frozen_string_literal: true
+
 require "bunny"
+require_relative "errors"
 require_relative "event"
 
 
 module Flu
   class EventPublisher
+    NOT_CONNECTED_MESSAGE = "no connection to RabbitMQ: 'connect' was never called, or " \
+                            "'disconnect' was. The railtie calls it at boot unless " \
+                            "'auto_connect_to_exchange' is false."
+
     def initialize(configuration)
       @logger        = configuration.logger
       @configuration = configuration
+      @exchange_key  = :"flu_exchange_#{object_id}" # Channels are cached per thread
     end
 
     def publish(event, persistent=true)
       routing_key = event.to_routing_key
-      @logger.debug("Publishing event with id '#{event.id}' with routing key: #{routing_key}")
-      @exchange.publish(event.to_json, routing_key: routing_key, persistent: persistent)
-      @logger.debug("Event published.")
+      @logger.debug { "Publishing event with id '#{event.id}' with routing key: #{routing_key}" }
+      exchange.publish(event.to_json, routing_key: routing_key, persistent: persistent)
+      @logger.debug { "Event published." }
     end
 
     def connect
-      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
+      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
       end
     end
 
+    def connected?
+      !@connection.nil? && @connection.open?
+    end
+
+    # Closing the connection closes every channel opened on it, and stops the heartbeat and
+    # recovery threads Bunny runs alongside it.
+    # The guard is on the connection alone: a connection that was opened before the exchange could
+    # be declared still has to be closed.
+    def disconnect
+      if !@connection.nil? && @connection.open?
+        @connection.close
+      end
+      @connection = nil
+      Thread.current[@exchange_key] = nil
+    end
+
     private
 
+    # One channel per thread rather than one for the whole publisher. 
+    # Bunny serialises every publication on the channel's own mutex.
+    #
+    # No bookkeeping of the channels handed out is needed. 
+    # Closing the connection closes all of them, so a thread holding a closed channel simply opens a new one on its next publication:
+    # 'disconnect' and a reconnection are both covered without reaching into other threads.
+    # Only the absence of a connection is reported here. A connection that exists but is closed or
+    # recovering is Bunny's story to tell, and its own error says more about it than this one could.
+    def exchange
+      cached = Thread.current[@exchange_key]
+      return cached if cached && cached.channel.open?
+      raise NotConnectedError, NOT_CONNECTED_MESSAGE if @connection.nil?
+      Thread.current[@exchange_key] = declare_exchange
+    end
+
+    def declare_exchange
+      channel = @connection.create_channel
+      channel.topic(@configuration.rabbitmq_exchange_name,
+                    durable: @configuration.rabbitmq_exchange_durable)
+    end
+
     def connect_to_exchange
       options = {
         host:     @configuration.rabbitmq_host,
+        vhost:    @configuration.rabbitmq_vhost,
         port:     @configuration.rabbitmq_port&.to_i,
         user:     @configuration.rabbitmq_user,
         password: @configuration.rabbitmq_password,
         automatically_recover: true
       }.merge(@configuration.bunny_options || {})
-      
+
       @connection = Bunny.new(options)
       @connection.start
-      @channel  = @connection.create_channel
-      @exchange = @channel.send(:topic,
-                                @configuration.rabbitmq_exchange_name,
-                                durable: @configuration.rabbitmq_exchange_durable)
+      Thread.current[@exchange_key] = declare_exchange
     end
   end
 end

data/lib/flu-rails/queue_repository.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rabbitmq/http/client"
 
 module Flu
@@ -9,23 +11,23 @@ module Flu
     end
 
     def find_all
-      @management_client.list_queues
+      @management_client.list_queues(@configuration.rabbitmq_vhost)
     end
 
     def find_queue(name)
-      @management_client.queue_info("/", name)
+      @management_client.queue_info(@configuration.rabbitmq_vhost, name)
     end
 
     def find_bindings_for_queue(name)
-      @management_client.list_queue_bindings("/", name)
+      @management_client.list_queue_bindings(@configuration.rabbitmq_vhost, name)
     end
 
     def purge_queue(name)
-      @management_client.purge_queue("/", name)
+      @management_client.purge_queue(@configuration.rabbitmq_vhost, name)
     end
 
     def delete_queue(name)
-      @management_client.delete_queue("/", name)
+      @management_client.delete_queue(@configuration.rabbitmq_vhost, name)
     end
 
     private

data/lib/flu-rails/railtie.rb

@@ -1,14 +1,19 @@
+# frozen_string_literal: true
+
 module Flu
   class Railtie < Rails::Railtie
     railtie_name :flu
 
+    # 'to_prepare' runs before eager loading, so that 'track_entity_changes' and 'track_requests'
+    # exist by the time the application's models and controllers are loaded. It runs again on every
+    # code reload, where 'Flu.init' builds a new publisher which has to be connected too.
+    #
+    # There is deliberately no 'after_initialize' hook here: it also runs at boot, right after this
+    # one, and the 'Flu.start' it used to make opened a second connection that replaced — and
+    # therefore leaked — the connection opened above.
     config.to_prepare do
       Flu.init
       Flu.start
     end
-
-    config.after_initialize do
-      Flu.start
-    end
   end
 end

data/lib/flu-rails/util.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Flu
   module Util
     class ExportService

data/lib/flu-rails/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Flu
-  VERSION = "8.0.3"
+  VERSION = "8.0.5"
 end

data/lib/flu-rails.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require "logger"
 require "json"
 require "active_support/core_ext/module/introspection"
 require_relative "flu-rails/version"
+require_relative "flu-rails/errors"
 require_relative "flu-rails/event"
 require_relative "flu-rails/event_factory"
 require_relative "flu-rails/queue_repository"
@@ -10,7 +13,7 @@ require_relative "flu-rails/core_ext"
 require_relative "flu-rails/event_publisher"
 require_relative "flu-rails/util"
 require_relative "flu-rails/dummy/in_memory_event_publisher"
-require_relative "flu-rails/railtie" if defined?(Rails)
+require_relative "flu-rails/railtie" if defined?(Rails::Railtie)
 
 module Flu
   def self.configure
@@ -38,6 +41,10 @@ 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
@@ -83,6 +90,7 @@ module Flu
       config.rejected_user_agents           = []
       config.logger                         = ::Logger.new(STDOUT)
       config.rabbitmq_host                  = "localhost"
+      config.rabbitmq_vhost                 = "/"
       config.rabbitmq_port                  = 5672
       config.rabbitmq_management_scheme     = "http"
       config.rabbitmq_management_port       = 15672

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flu-rails
 version: !ruby/object:Gem::Version
-  version: 8.0.3
+  version: 8.0.5
 platform: ruby
 authors:
 - Loïc Vigneron
@@ -152,6 +152,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -185,6 +199,7 @@ files:
 - lib/flu-rails/configuration.rb
 - lib/flu-rails/core_ext.rb
 - lib/flu-rails/dummy/in_memory_event_publisher.rb
+- lib/flu-rails/errors.rb
 - lib/flu-rails/event.rb
 - lib/flu-rails/event_factory.rb
 - lib/flu-rails/event_publisher.rb