flu-rails 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 95ccc91aa5396a70d42d46300b5d7fc48321a3c3d3bea32e77d88b0b4a542e35
+  data.tar.gz: e71784f540b50b412469fb10af164b30942d29190fe2a9e9d7b0725a41b713bd
+SHA512:
+  metadata.gz: e85087d058f0ce9e3cb32c7e7a3dc97471f158b9c973f491a66ccdb33f47f84c78cc78a364a16b3345dd0f036e57a1c686495c57ae2eb60e7decdb153c2a0e9f
+  data.tar.gz: a15ad5ed11e2c3a2a3cade60e643b4b21b5583196d3c52429b2ae09fdec8445f7ab282f013899218add3c95af4b9a655331fe8a24b9565ab408d969cc8e5fffb

data/CHANGELOG.md

@@ -0,0 +1,128 @@
+# Changelog
+
+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).
+
+### [1.2.0] - 2026-07-31
+
+* Declare `required_ruby_version` as `>= 3.2`
+* Test the specs on Ruby 3.2, 3.3 and 3.4 through GitHub Actions (`.github/workflows/ci.yml`)
+* Declare `logger` as an explicit runtime dependency (it is required directly, and stops being a default gem in Ruby 3.5)
+* Relax the exact development dependency pins (`rspec`, `sqlite3`, `byebug`) to pessimistic constraints,
+  and drop the redundant lower bounds on `bunny` and `rabbitmq_http_api_client`
+* Drop `bundler` as a development dependency
+* Add `ostruct` as a development dependency (used by the specs, becomes a bundled gem in Ruby 3.5)
+* Remove the unused `Flu::Dummy::EventPublisherDummy`, superseded by `Flu::Dummy::InMemoryEventPublisher` since `0.2.0`
+* Fill in the gemspec `homepage`, `description` and `metadata`, and build `spec.files` from `Dir.glob`
+  instead of `git ls-files` (which returned nothing outside of a git checkout, such as in the Docker image)
+* Stop tracking `Gemfile.lock`, so that each supported Ruby resolves its own dependencies
+
+### [1.1.0] - 2026-07-30
+
+* Upgrade dependencies
+    * `bunny`: `~> 3.1`
+    * `bundler`: `>= 2.6.9`
+    * `sqlite3`: `2.9.5`
+    * `byebug`: `13.0.0`
+* Remove `activesupport` runtime dependency (no longer used directly)
+* Replace deprecated `ActiveSupport::Configurable` with plain `attr_accessor` in `Configuration` (removed in Rails 8.2)
+
+### [1.0.8] - 2026-04-08
+
+* Upgrade dependencies:
+    * `ruby`: `>= 3`
+    * `bunny`: `~> 2.23`
+    * `activesupport`: `>= 7.0.0`
+    * `bundler`: `>= 2.6.9`
+    * `sqlite3`: `2.9.2`
+    * `byebug`: `13.0.0`
+* Upgrade Docker base image to `ruby:3.4.9-slim-trixie`
+
+### [1.0.7] - 2023-04-04
+
+* Upgrade constraints on dependencies:
+    * `rabbitmq_http_api_client`: `2.2`
+    * `rails` : `>= 7`
+
+### [1.0.6] - 2022-11-18
+
+* Make sure the deep camelization when serializing an event has no side-effet
+
+### [1.0.5] - 2022-11-02
+
+* Support for requests without any user agent
+
+### [1.0.4] - 2022-11-02
+
+* Allow the emitter to be overriden in `track_requests` and `track_entity_changes`
+
+### [1.0.3] - 2022-03-30
+
+* Update `Gemfile.lock` to avoid wrong CVE detections. The version of Rails should always be specified by the parent project. This change has no functional impact.
+
+### [1.0.2] - 2021-11-06
+
+* Breaking change : force every `port` to be an integer
+
+## [1.0.0] - 2021-11-05
+
+* Add `bunny_options`
+* Add `rabbitmq_manage¨ment_scheme`
+* MIT License
+
+## [0.4.2]
+
+* Add capability to add request metadata in the entity_change events related to the request
+* Upgrade `rabbitmq_http_api_client`to `2.0`, bunny to `2.19`
+
+## [0.4.1]
+
+* Use of `rabbitmq_http_api_client:1.14.0`, which supports `faraday >= 1`
+
+## [0.4.0]
+
+* Drop support of Rails 5
+* Upgrade dependencies: `rabbitmq_http_api_client:1.13.0`, `activesupport:>=6.0.0`, `bunny:>=2.14.4`
+
+## [0.3.1]
+
+* Eager load with Zeitwerk when available
+
+## [0.3.0]
+
+* Support for Rails 6+
+
+## [0.2.0]
+
+* Expose `InMemoryEventPublisher` for testing purpose
+
+## [0.1.9]
+
+* `publish_events!` allows to publish programmatically all the events that are stacked on an ActiveRecord
+
+## [0.1.8]
+
+* Events can be published manually according to a transactionnal context
+
+## [0.1.7]
+
+* Support for ActiveRecord >= 5.1
+
+## [0.1.6]
+
+* Allow to use the Event and the EventPublisher in non-rails environment
+
+## [0.1.5]
+
+* Allow to use the EventFactory in non-rails environment
+
+## [0.1.4]
+
+* Prevent events to be published including an invalid Unicode character (such as `\u0000`)
+
+## [0.1.3]
+
+* Support for polymorphic one-to-one associations
+* Support for `ActionController:API`

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,272 @@
+# Gem for flu-rails
+
+[![CI](https://github.com/crepesourcing/flu-rails/actions/workflows/ci.yml/badge.svg)](https://github.com/crepesourcing/flu-rails/actions/workflows/ci.yml)
+
+## Description
+
+This project aims at seamlessly creating/emitting events from an existing Rails project (without changing its codebase) in order to execute asynchronous tasks such as event storing, real time analytics, system monitoring,...
+
+For now, events are generated from:
+
+* CRUD operations on Active record models
+* Requests on Rails controllers actions
+
+## Installation
+
+Add the gem to your project's Gemfile:
+
+  ```ruby
+  gem "flu-rails", git: "https://github.com/crepesourcing/flu-rails.git"
+  ```
+
+Then, create an initializer into your Rails app (`config/initializers/flu-rails.rb`)
+
+  ```ruby
+    Flu.configure do |config|
+      config.development_environments  = []
+      config.rabbitmq_host             = ENV["RABBITMQ_HOST"]
+      config.rabbitmq_port             = ENV["RABBITMQ_PORT"]
+      config.rabbitmq_user             = ENV["RABBITMQ_USER"]
+      config.rabbitmq_password         = ENV["RABBITMQ_PASSWORD"]
+      config.rabbitmq_exchange_name    = ENV["RABBITMQ_EXCHANGE_NAME"]
+    end
+  ```
+Each configuration is detailed below.
+
+`flu-rails` will start automatically with `railties`.
+
+## Requirements
+
+* Ruby >= 3.2 (tested against 3.2, 3.3 and 3.4)
+* Tested with Rails 8 (`activerecord` and `actionpack`)
+* Tested with RabbitMQ 3.5.8
+
+## Usage
+
+### Start up
+
+If your application does not include `Railties`, `flu-rails` can be started as followed:
+  ```
+  Flu.init
+  Flu.start
+  ```
+
+`flu-rails` startup waits until its RabbitMQ exchange is connected.
+
+### Track changes on an ActiveRecord model
+
+All subclasses of `ActiveRecord::Base` that call `track_entity_changes` are "tracked". _E.g._:
+
+  ```ruby
+  class Car < ActiveRecord::Base
+    track_entity_changes
+  end
+  ```
+
+`track_entity_changes` has several options:
+
+| Option | Default Value | Type | Required? | Description  | Example |
+| ---- | ----- | ------ | ----- | ------ | ----- |
+| `user_metadata` | `{}`| Hash of lambdas | Optional | This hash can define two keys: `:create` and `:update`. Each value is a lambda that returns a hash. | `{create: lambda {{other_id: id}}}` |
+| `ignored_model_changes` | `[]`| Array of strings | Optional | Same as the global parameter `default_ignored_model_changes` for a dedicated class. This option does not override `default_ignored_model_changes`. | `[:rsa_key, :salt]` |
+| `emitter` | Emitter from configuration | Lambda that returns a string | Optional | This lambda is executed in each controller action to override the configuration's `emitter`. The result of this lambda cannot contain a dot ("`.`"). | `lambda { "overriden_emitter" }` |
+
+For instance:
+
+  ```ruby
+  class Invoice < ActiveRecord::Base
+    track_entity_changes user_metadata: {
+      create: lambda {
+        {
+          user_full_name: user.full_name,
+          user_birthdate: user.birthdate
+        }
+      }
+    }
+
+    belongs_to :user
+  end
+  ```
+
+### Track requests to a Rails Controller action
+
+All subclasses of `ActionController::Base` or `ActionController::API` (Rails 5) that call `track_requests` are "tracked". _E.g._:
+
+  ```ruby
+  class ApplicationController < ActionController::Base
+    track_requests
+  end
+  ```
+
+`track_requests` has several options:
+
+| Option | Default Value | Type | Required? | Description  | Example |
+| ---- | ----- | ------ | ----- | ------ | ----- |
+| `user_metadata` | `nil`| Lambda that returns a hash | Optional | This lambda is executed in each controller action to create an additional event attribute: `user_metadata`. | `lambda { {id: 4}}` |
+| `entity` | `nil`| Lambda that returns a hash | Optional | This lambda is executed in each controller action to attach a hash to every `entity_change` event related to it as an attribute named: `request_metadata`. | `lambda { {path: request.path}}` |
+| `emitter` | Emitter from configuration | Lambda that returns a string | Optional |  This lambda is executed in each controller action to override the configuration's `emitter`. The result of this lambda cannot contain a dot ("`.`"). | `lambda { "overriden_emitter" }` |
+
+For instance,
+
+```ruby
+class ApplicationController < ActionController::Base
+  track_requests user_metadata: lambda {
+    {
+      constant_pouet: "Pouet",
+      user_agent:     request.headers["User-Agent"]
+    }
+  }
+```
+
+### Create and emit an event manually
+
+Flu's components can be used programmatically to create and emit events manually
+
+  ```ruby
+  data = {
+    recipient_name: "Lazar",
+    recipient_email: "lazar@fourtytwo.net",
+    message: "Hi!"
+  }
+  kind = :manual
+  name = "send email"
+  event = Flu.event_factory.build_event(name, kind, data)
+  Flu.event_publisher.publish(event)
+  ```
+
+*Warning!* When calling Flu's `publisher` programmatically in a transaction, these events won't be published according to the transaction's commit. They will be published instantly, contrary to the `ActiveRecord` events that will be published when the transaction commits.
+If you want to publish events manually taking the transaction into account, please use the dedicated method `flu_add_manual_event(name: string, data: Hash)` (available on every `ActiveRecord` extended with `track_entity_changes`). For instance:
+```ruby
+Invoice.transaction do
+  invoice = Invoice.new
+  invoice.save!
+  invoice.flu_add_manual_event("a custom name", { some_data: true }) ## kind is :manual
+  Invoice.new.save!
+end
+```
+3 events will be published according to the following order: `entity_change.create invoice`, `manual.a custom name`, `entity_change.create_invoice`. 
+
+
+## Overall configuration options
+
+All options have a default value. However, all of them can be changed in your initializer file.
+
+| Option | Default Value | Type | Required? | Description  | Example |
+| ---- | ----- | ------ | ----- | ------ | ----- |
+| `development_environments` | `[]`| Array of strings | Optional | If `Rails.env` matches one of these values then no connection is attempted to the exchange (messages are created by not published to any exchange).  | `["test", "development"]` |
+| `rejected_user_agents` | `[]`| Array of regexp | Optional | When calling a controller action, an event can be prevented from being emitted if the request's `user_agent` matches a regular expression. This option is a list of regular expressions.| `[/[^\(]*[^\)]Chrome\//]`|
+| `logger` | `Logger.new(STDOUT)`| Logger | Optional | The logger used by `flu-rails` | `Rails.logger` | 
+| `rabbitmq_host` | `"localhost"` | String | Required | RabbitMQ exchange's host. | `"192.168.42.42"` |
+| `rabbitmq_port` | `"5672"` | Integer | Required | RabbitMQ exchange's port. | `"1234"` |
+| `rabbitmq_user` | `""` | String | Required | RabbitMQ exchange's username. | `"root"` |
+| `rabbitmq_password` | `""` | String | Required | RabbitMQ exchange's password. | `"pouet"` |
+| `rabbitmq_exchange_name` | `"events"` | String | Required | RabbitMQ exchange's name. | `"myproject"` |
+| `rabbitmq_management_scheme` | `"http"` | String | Required | RabbitMQ exchange's management scheme. This scheme is used when `flu-rails` must access metadata information about queues, messages, etc. This port is used to create/delete bindings between the queue and its exchange. | `"https"` |
+| `rabbitmq_management_port` | `"15672"` | Integer | Optional | RabbitMQ exchange's management port. This port is used when `flu-rails` must access metadata information about queues, messages, etc. This port is important if you want to use an instance of `QueueRepository`. Not required for simple use cases. | `"4242"` |
+| `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` |
+| `application_name` | `Rails.application.class.parent_name.to_s.camelize` | 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 }` |
+
+## How to execute tests
+
+From the `flu-rails` directory:
+
+```
+  $ docker build . -t flu:test
+  $ docker run -v `pwd`:/usr/src/app/ flu:test rspec spec
+```
+
+## Example of Events
+
+### Structure of an Active Record change
+
+An event is created and published to the message broker every time a CRUD operation is executed on an ActiveRecord model. Events are published only once the current transaction is commited. Events are not published if a transaction rollbacks.
+
+For example, this code will produces an event _"create country"_:
+
+  ```ruby
+  class Country < ActiveRecord::Base
+    track_entity_changes user_metadata: {
+      create: lambda {
+        {
+          continent_name: continent.name
+        }
+      }
+    }
+    belongs_to :continent
+  end
+
+  country = Country.new(name: "Belgium", short_name: "BE", continent: Continent.find(12))
+  country.save!
+  ```
+
+The generated event looks like:
+
+```json
+{
+  "meta": {
+    "id": "540e4f55-9afa-48ac-80d9-7b0ae3654682",
+    "name": "create country",
+    "emitter": "my_application",
+    "timestamp": "2017-02-16T14:13:42.509Z",
+    "kind": "entity_change",
+    "status": "new"
+  },
+  "data": {
+    "changes": {
+      "id": [null, 42],
+      "name": [null, "Belgium"],
+      "shortName": [null, "BE"],
+      "continentId": [null, 42]
+    },
+    "entity_id": 42,
+    "request_id": null,
+    "action_name": "create",
+    "entity_name": "country",
+    "associations": {
+      "continent_id": 12
+    },
+    "user_metadata": {
+      "continent_name": "Europe"
+    }
+  }
+}
+```
+(`request_id` is not `nil` if this code is executed through a controller action)
+
+### Structure of an Rails controller request
+
+For instance, calling the action `destroy` of `CountryController` will emit this event:
+
+```json
+{
+  "meta": {
+    "id": "a79d411d-7a34-4d31-870b-e09dcd7e5127",
+    "name": "request to destroy countries",
+    "emitter": "my_application",
+    "timestamp": "2017-02-16T14:20:03.463Z",
+    "kind": "request",
+    "status": "new"
+  },
+  "data": {
+    "requestId": "ec01b901-db42-4c60-9da1-e3ec96a017fc",
+    "controllerName": "countries",
+    "actionName": "destroy",
+    "path": "/countries",
+    "responseCode": 200,
+    "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36",
+    "duration": 0.065510717,
+    "params": {
+      "format": "json"
+    },
+    "userMetadata": {}
+  }
+}
+```
+
+## Side-notes
+
+* `assocations` node contains `belongs_to` associations only.

data/lib/flu-rails/action_controller_extender.rb

@@ -0,0 +1,89 @@
+module Flu
+  class ActionControllerExtender
+    def self.extend_controllers(event_factory, event_publisher, logger)
+      all_controller_types.each do |controller_type|
+        controller_type.class_eval do
+          def self.flu_is_tracked=(is_tracked)
+            @flu_is_tracked = is_tracked
+          end
+
+          def self.flu_is_tracked
+            @flu_is_tracked || false
+          end 
+
+          define_singleton_method(:track_requests) do |options = {}|
+            self.flu_is_tracked      = true
+            user_metadata_lambda     = options[:user_metadata]
+            entity_metadata_lambda   = options[:entity_metadata]
+            ignored_request_params   = options.fetch(:ignored_request_params, []).map(&:to_sym)
+            emitter_lambda           = options[:emitter]
+
+            before_action do
+              define_request_id
+              @request_start_time = Time.zone.now
+            end
+            prepend_before_action do
+              define_request_entity_metadata_lambda(entity_metadata_lambda)
+            end
+            prepend_after_action do
+              track_requests(event_factory, event_publisher, user_metadata_lambda, ignored_request_params, emitter_lambda)
+              remove_request_entity_metadata_lambda
+            end
+            after_action do
+              remove_request_id
+            end
+
+            def define_request_id
+              request_id      = SecureRandom.uuid
+              @flu_request_id = request_id
+              Flu::CoreExt.flu_tracker_request_id = request_id
+            end
+
+            def remove_request_id
+              Flu::CoreExt.flu_tracker_request_id = nil
+            end
+
+            def define_request_entity_metadata_lambda(entity_metadata_lambda)
+              Flu::CoreExt.flu_tracker_request_entity_metadata = instance_exec(&entity_metadata_lambda) if entity_metadata_lambda
+            end
+
+            def remove_request_entity_metadata_lambda
+              Flu::CoreExt.flu_tracker_request_entity_metadata = nil
+            end
+
+            def rejected_origin?(request)
+              rejected_user_agents  = Regexp.union(Flu.config.rejected_user_agents)
+              user_agent            = request.user_agent
+              matching_user_agents  = user_agent&.match(rejected_user_agents)
+              !matching_user_agents.nil?
+            end
+
+            def track_requests(event_factory, event_publisher, user_metadata_lambda, ignored_request_params, emitter_lambda)
+              if rejected_origin?(request)
+                logger.warn "Origin user agent rejected: #{request.user_agent}"
+              else
+                tracked_request                     = event_factory.create_data_from_request(@flu_request_id,
+                                                                                             params,
+                                                                                             request,
+                                                                                             response,
+                                                                                             @request_start_time,
+                                                                                             ignored_request_params)
+                tracked_request[:user_metadata]     = instance_exec(&user_metadata_lambda) if user_metadata_lambda
+                tracked_request[:overriden_emitter] = instance_exec(&emitter_lambda) if emitter_lambda
+                event                               = event_factory.build_request_event(tracked_request)
+                event_publisher.publish(event)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def self.all_controller_types
+      class_names = ["ActionController::Base", "ActionController::API"]
+      class_names.select { |class_name| Object.const_defined?(class_name) }.map(&:constantize)
+    end
+  end
+end

data/lib/flu-rails/active_record_extender.rb

@@ -0,0 +1,125 @@
+module Flu
+  class ActiveRecordExtender
+    def self.extend_models(event_factory, event_publisher)
+      ActiveRecord::Base.class_eval do
+        define_singleton_method(:track_entity_changes) do |options = {}|
+          self.flu_is_tracked               = true
+          self.flu_user_metadata_lambdas    = options.fetch(:user_metadata, {})
+          self.flu_ignored_model_changes    = options.fetch(:ignored_model_changes, []).map(&:to_s)
+          self.flu_overriden_emitter_lambda = options.fetch(:emitter, nil)
+        
+          after_create   { flu_track_entity_change(:create, flu_changes_depending_on_active_record_version, event_factory) }
+          after_update   { flu_track_entity_change(:update, flu_changes_depending_on_active_record_version, event_factory) }
+          after_destroy  { flu_track_entity_change(:destroy, { "id" => [id, nil] }, event_factory) }
+          after_commit   { flu_commit_changes(event_factory, event_publisher) }
+          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]
+            column_names.push(association.foreign_type) if association.polymorphic?
+            column_names
+          end
+        end
+
+        def flu_changes_depending_on_active_record_version
+          respond_to?(:saved_changes) ? saved_changes : changes
+        end
+
+        def flu_changes
+          @flu_changes ||= []
+        end
+
+        def flu_publish_events!
+          run_callbacks(:commit)
+        end
+
+        def flu_add_manual_event(name, data)
+          raise "data must be a hash" if data.nil? || !data.is_a?(Hash)
+          flu_changes.push({
+            name: name,
+            data: data,
+            flu_is_a_manual_event: true
+          })
+        end
+
+        def flu_changes_as_events(event_factory)
+          flu_changes.select do |data|
+            !data[:changes].try(:empty?) || data[:flu_is_a_manual_event]
+          end.map do |data|
+            if data[:flu_is_a_manual_event]
+              event_factory.build_manual_event(data[:name], data[:data])
+            else
+              event_factory.build_entity_change_event(data)
+            end
+          end
+        end
+
+        def flu_commit_changes(event_factory, event_publisher)
+          flu_changes_as_events(event_factory).each do |event|
+            event_publisher.publish(event)
+          end
+          flu_flush_changes
+        end
+
+        def flu_rollback_changes
+          flu_flush_changes
+        end
+
+        def flu_flush_changes
+          flu_changes.clear
+        end
+
+        def flu_track_entity_change(action_name, changes, event_factory)
+          unless changes.empty?
+            request_id                     = Flu::CoreExt.flu_tracker_request_id
+            request_entity_metadata        = Flu::CoreExt.flu_tracker_request_entity_metadata
+            data                           = event_factory.create_data_from_entity_changes(action_name,
+                                                                                           self,
+                                                                                           request_id,
+                                                                                           request_entity_metadata,
+                                                                                           changes,
+                                                                                           self.class.flu_user_metadata_lambdas[action_name],
+                                                                                           self.class.flu_association_columns,
+                                                                                           self.class.flu_ignored_model_changes,
+                                                                                           self.class.flu_overriden_emitter_lambda)
+            flu_changes.push(data) unless data.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flu-rails/configuration.rb

@@ -0,0 +1,20 @@
+module Flu
+  class Configuration
+    attr_accessor :development_environments,
+                  :rejected_user_agents,
+                  :logger,
+                  :rabbitmq_host,
+                  :rabbitmq_management_scheme,
+                  :rabbitmq_management_port,
+                  :rabbitmq_port,
+                  :rabbitmq_user,
+                  :rabbitmq_password,
+                  :rabbitmq_exchange_name,
+                  :rabbitmq_exchange_durable,
+                  :auto_connect_to_exchange,
+                  :default_ignored_model_changes,
+                  :default_ignored_request_params,
+                  :application_name,
+                  :bunny_options
+  end
+end