LogBook

gem 'rails_log_book'

rails generate log_book:install
rake db:migrate

  class User < ActiveRecord::Base
    include LogBook::Recorder

    has_log_book_records
  end

  class UsersController < ApplicationController
    include LogBook::ControllerRecord
  end

class Hotel < ApplicationRecord
  include LogBook::Recorder
  has_log_book_records

  has_many :amenities
  accepts_nested_attributes_for :amenities
end

class HotelAmenity < ApplicationRecord
  include LogBook::Recorder
  has_log_book_records, parent: :hotel

  belongs_to :hotel
  belongs_to :amenity
end

class Amenity < ApplicationRecord
  has_many :hotels
end

class HotelsController < ApplicationController
  def create
    @hotel = Hotel.create(hotel_params)
  end

  def hotel_params
    params.require(:hotel).permit(amenities_attributes: [:id, :status])
  end
end

# having this params passed to hotels_controller:
{ name: 'Hotel', amenitites_attributes: { 0: {id: 1, status: :avaliable}, 1: { id: 4, status: :unavaliable } } }

# Without squashing you would have these records in the DB (abbreviated for clairity)
[
  {subject_type: 'Hotel',        subject_id: 1, parent_type: nil,     parent_id: nil, record_changes: { name: [nil, 'Hotel']}},
  {subject_type: 'HotelAmenity', subject_id: 1, parent_type: 'Hotel', parent_id: 1,   record_changes: { name: [nil, 'avaliable']}},
  {subject_type: 'HotelAmenity', subject_id: 4, parent_type: 'Hotel', parent_id: 1,   record_changes: { name: [nil, 'unavaliable']}},
]

# The above is rather difficult to paginate if you want to show changes done on HotelAmenities to show under Hotel.
# With squashing enabled:
[
  {
    subject_type: 'Hotel',
    subject_id: 1,
    parent_type: nil,
    parent_id: nil,
    record_changes: {
      name: [nil, 'Hotel'],
      hotel_amenitites: {
        1: {status: [nil, 'avaliable']},
        2: {status: [nil, 'unavaliable']}
      }
    }
  }
]

  class User < ActiveRecord::Base
    include LogBook::Recorder

    # all fields
    # has_log_book_records

    # Only fields
    # has_log_book_records only: [:email, :name]

    # Ignored fields
    # has_log_book_records except: [:password]

    # Default ignored fields
    # primary_key (id), LogBook.config.ignored_attributes (:created_at, :updated_at)
  end

  class User < ActiveRecord::Base
    include LogBook::Recorder

    # all events
    # has_log_book_records

    # Only record on create and destroy (not update)
    # has_log_book_records on: [:create, :destroy]
  end

  class User < ActiveRecord::Base
    include LogBook::Recorder
    belongs_to :company

    # Parent is Company and will be recorded with each user change
    # has_log_book_records parent: :company
  end

  class Account < ActiveRecord::Base
    include LogBook::Recorder
    has_many :user_memberships
    has_many :users, through: :user_memberships
  end

  def UserMembership < ActiveRecord::Base
    belongs_to :account
    belongs_to :user
  end

  class User < ActiveRecord::Base
    has_one :user_membership
    has_one :account, through: :user_membership

    # Parent is Company and will be recorded with each user change
    # has_log_book_records parent_of: :account
  end

  class User < ActiveRecord::Base
    include LogBook::Recorder

    # runs `log_book_meta(record)` method to assign to `:meta` field
    # has_log_book_records meta: true

    # runs `meta_method` method to assing to `:meta` field
    # has_log_book_records meta: :meta_method

    # runs passed proc to assing to `:meta` field
    # has_log_book_records meta: -> { { slug: email.split('@').first } }
  end

  class Admin::UsersController < ActionController::Base
    inlcude LogBook::ControllerRecord

    # defaults to `current_user`
    def current_author
      current_admin
    end

# config/initializers/log_book.rb
LogBook.configure do |config|
  config.ignored_attributes = [:updated_at, :created_at]
  config.author_method = :current_user
  config.record_squashing = false
  config.always_record = false
  config.skip_if_empty_actions = [:update]
end

LogBook.with_recording {}         #=> Enables recording within block
LogBook.author=(author)           #=> Records as a different author within block
LogBook.action=(value)            #=> Change default action for this request
LogBook.with_record_squashing {}  #=> Squashes records within block
LogBook.enable_recording          #=> Enables recording from this point
LogBook.disable_recording         #=> Disables recording from this point
LogBook.record_squashing_enabled  #=> Enables record squashing from this point
LogBook.recording_enabled         #=> Returns true if recording is enabled