flu-rails 8.0.4 → 8.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fadf301a677ec0ec47d67f9eb8159aac7dfab535c268030331ce4d54c391e58
-  data.tar.gz: 90c8b9dc6c71fa9f01630b1e183114132ec1d63735cdc2cb62c5974750f3ff49
+  metadata.gz: 24d179705111c94185f7421297a692e1f962feeef2a9c2132a04e744d70a6503
+  data.tar.gz: 93526441dcfaea7cc3a5be4795c5e86cdb9a4acdbaf95b825e530259b3c89d64
 SHA512:
-  metadata.gz: 2a8f50d7eb2796ce8408f3a1ca36b68d55020d8858134fc136cef7be6fcb7978c316e99298a2d394ef0f0555602c1a955b3ff497b0a72e9b1f49ddf23ec4e1b8
-  data.tar.gz: dbc5b57979a4ebe601b8df0c26822c7dfa127c44f7292b97b654aff0363d04266552a60c2bda0d0ea00b2865421e47677d4f66592bf8c9e36bf6820f1ea290e8
+  metadata.gz: bd84b67b67c9f209fbab6c5309d719719e3d9f19df12e1d7816acc6690c084dad052e8590cc39b85cfcc9477b6c187d1ec352a3a8e55a932c5f51d22c062e458
+  data.tar.gz: e7e0eab197a600c06a10c1bb6ec801499cfe3d55327e94232b565830b5ee6fa69c4a5bf7c19ab3082f0492917d83e6c36581ce53600d5cbf9ef0259df1b620b1

data/CHANGELOG.md

@@ -5,6 +5,52 @@ 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**

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
 
@@ -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.4 -m "Version 8.0.4"
-  $ git push origin v8.0.4
+  $ 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

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"
@@ -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
 
@@ -91,25 +93,16 @@ module Flu
     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,19 +1,27 @@
+# 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
@@ -32,43 +40,57 @@ module Flu
     end
 
     def connected?
-      if @connection.nil? || @exchange.nil?
-        false
-      else
-        @connection.open?
-      end
+      !@connection.nil? && @connection.open?
     end
 
-    # Closing the connection closes the channel opened on it, and stops the heartbeat and recovery
-    # threads Bunny runs alongside it.
-    # The guard is on the connection alone, not on 'connected?': a connection that was opened before
-    # the exchange could be declared still has to be closed.
+    # 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 
+        @connection.close
       end
       @connection = nil
-      @channel    = nil
-      @exchange   = 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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Flu
   class Railtie < Rails::Railtie
     railtie_name :flu

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.4"
+  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
@@ -87,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.4
+  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