effective_logging 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f4ffc97c7a82cc7200aa95e8c47c498816bbce9b
-  data.tar.gz: bb2df38354a9a0cb055f91ab5a07bae5199ac8ea
+  metadata.gz: 1df4e571d32d8173adad1e00cc1df96abf6cab61
+  data.tar.gz: e17269c8ad802e902237ce2ac10339da99c04cf7
 SHA512:
-  metadata.gz: 56fa1f182939c81552fdc31bccc3c0976a7a3052c92963ad6c74e6ebab551c2f455dc8294c21690607bde318707054d3d2b1a94603ea9f9af1c99d0cc7a69a23
-  data.tar.gz: 7d8631e9a817b077e1d6615092c62b6a865750ab30934cfa59719306e0ba1e5fa7ceb7f8f8ee0915569c4ac45e9c84ee0adc786e285c3f07be0103111b241101
+  metadata.gz: 583ddd1c3f1cf4cba8a6e28b5163909b44944dc51350b1cee16a8fc22b3fdaf8bb935505621f27caf742ad321ef5fefb55ced9a1650af737ee80296fc5ea443f
+  data.tar.gz: 14d0148fd0d692dd55214a38fe513f32285b8003c5557042b42ec3ec3295e961355ca885e09b1bb933e1154ed2e84df8770e4f663899d02a8994c311c042a0b2

data/README.md

@@ -89,6 +89,13 @@ log.error('record 2 failed to import', :associated => @record2)
 log.success('record 3 imported', :associated => @record3)
 ```
 
+### Model
+
+(optional) Sometimes you'd like to work with the `Effective::Log` relationship directly.  Add to your model:
+
+```ruby
+has_many :logs, class_name: Effective::Log, as: :associated
+```
 
 ### Automatic Logging of E-mails
 
@@ -185,6 +192,46 @@ end
 Similarly, skip_log_page_views also accepts any options that a before_filter would accept.
 
 
+### Logging ActiveRecord changes
+
+All changes made to an ActiveRecord object can be logged.
+
+This logging includes the resource's base attributes, all autosaved associations (any accepts_nested_attributes has_manys) and the string representation of all belongs_tos.
+
+It will recurse through all accepts_nested_attributes has_many's and handle any number of child objects.
+
+Add to your model:
+
+```ruby
+class Post < ActiveRecord::Base
+  log_changes
+end
+```
+
+And to your controller:
+
+```ruby
+class ApplicationController < ActionController::Base
+  set_log_changes_user
+end
+```
+
+Then to see the log for this resource, on any view:
+
+```erb
+<%= render_datatable(@post.log_changes_datatable) %>
+```
+
+The `log_changes` mixin sets up `before_save`, `before_destroy` and `after_commit` hooks to record both an activity log, and an audit log of all changes.
+
+Each changed attribute will have its before and after values logged to form an activity log.
+
+And on each create / destroy / update, a full dump of all current attributes is saved, forming an audit log.
+
+There is some initial support for passing `only`, `except`, and `additionally` to the mixin to customize what attributes are saved.
+
+Define your model with `log_changes additionally: [:method1, :method2]` to also log the value of methods.
+
 ### Logging From JavaScript
 
 First, require the javascript in your application.js:

data/app/controllers/effective/logs_controller.rb

@@ -42,14 +42,14 @@ module Effective
 
     # This is the User show event
     def show
-      @log = Effective::Log.where(:user_id => current_user.id).includes(:logs).find(params[:id])
-      @log.next_log = Effective::Log.unscoped.where(:user_id => current_user.id).order(:id).where(:parent_id => @log.parent_id).where('id > ?', @log.id).first
-      @log.prev_log = Effective::Log.unscoped.where(:user_id => current_user.id).order(:id).where(:parent_id => @log.parent_id).where('id < ?', @log.id).last
+      @log = Effective::Log.includes(:logs).find(params[:id])
+      @log.next_log = Effective::Log.unscoped.order(:id).where(parent_id: @log.parent_id).where('id > ?', @log.id).first
+      @log.prev_log = Effective::Log.unscoped.order(:id).where(parent_id: @log.parent_id).where('id < ?', @log.id).last
 
       @page_title = "Log ##{@log.to_param}"
 
       if @log.logs.present?
-        @log.datatable = Effective::Datatables::Logs.new(:user_id => current_user.id, :log_id => @log.id) if defined?(EffectiveDatatables)
+        @log.datatable = Effective::Datatables::Logs.new(log_id: @log.id) if defined?(EffectiveDatatables)
       end
 
       EffectiveLogging.authorized?(self, :show, @log)

data/app/helpers/effective_logging_helper.rb

@@ -64,7 +64,7 @@ module EffectiveLoggingHelper
     value = log.details[key]
 
     if value.kind_of?(Hash)
-      tableize_hash(value, :class => 'table', :style => 'width: 50%', :th => true)
+      tableize_hash(value, :class => 'table', :th => true)
     elsif value.kind_of?(Array)
       value.map { |value| effective_logging_simple_format(value) }.join.html_safe
     else

data/app/models/concerns/acts_as_loggable.rb

@@ -0,0 +1,68 @@
+module ActsAsLoggable
+  extend ActiveSupport::Concern
+
+  module ActiveRecord
+    def log_changes(*options)
+      @acts_as_loggable_options = options.try(:first) || {}
+
+      unless @acts_as_loggable_options.kind_of?(Hash)
+        raise ArgumentError.new("invalid arguments passed to (effective_logging) log_changes. Example usage: log_changes except: [:created_at]")
+      end
+
+      include ::ActsAsLoggable
+    end
+  end
+
+  included do
+    has_many :logged_changes, -> { where(status: EffectiveLogging.log_changes_status) }, as: :associated, class_name: Effective::Log
+
+    before_save do
+      @acts_as_loggable_new_record = new_record?
+      EffectiveLogging::ActiveRecordLogger.new(self, log_changes_options).changed! unless @acts_as_loggable_new_record
+      true
+    end
+
+    before_destroy do
+      EffectiveLogging::ActiveRecordLogger.new(self, log_changes_options).destroyed!
+      true
+    end
+
+    after_commit do
+      if @acts_as_loggable_new_record
+        EffectiveLogging::ActiveRecordLogger.new(self, log_changes_options).created!
+      else
+        EffectiveLogging::ActiveRecordLogger.new(self, log_changes_options).updated!
+      end
+      true
+    end
+
+    # Parse Options
+    log_changes_options = {
+      only: Array(@acts_as_loggable_options[:only]).map { |attribute| attribute.to_s },
+      except: Array(@acts_as_loggable_options[:except]).map { |attribute| attribute.to_s },
+      additionally: Array(@acts_as_loggable_options[:additionally]).map { |attribute| attribute.to_s }
+    }
+
+    self.send(:define_method, :log_changes_options) { log_changes_options }
+  end
+
+  module ClassMethods
+  end
+
+  # Regular instance methods
+
+  def log_changes_datatable
+    if persisted?
+      @log_changes_datatable ||= (
+        Effective::Datatables::Logs.new(
+          associated_id: id,
+          associated_type: self.class.name,
+          status: false,
+          log_changes: true
+        )
+      )
+    end
+  end
+
+end
+

data/app/models/effective/datatables/logs.rb

@@ -15,12 +15,17 @@ if defined?(EffectiveDatatables)
           end
 
           unless attributes[:status] == false
-            table_column :status, filter: { type: :select, values: EffectiveLogging.statuses }
+            table_column :status, filter: { type: :select, values: (EffectiveLogging.statuses + [EffectiveLogging.log_changes_status]) }
+          end
+
+          table_column :message do |log|
+            log.message.starts_with?("\t") ? log.message.gsub("\t", "  ") : log.message
           end
 
-          table_column :message
           table_column :logs_count, visible: false
 
+          table_column :associated, filter: false, sortable: false, visible: false
+
           table_column :details, visible: false, sortable: false do |log|
             tableize_hash(log.details.except(:email), th: true, sub_th: false, width: '100%')
           end
@@ -47,6 +52,10 @@ if defined?(EffectiveDatatables)
             collection = collection.where(associated_id: attributes[:associated_id], associated_type: attributes[:associated_type])
           end
 
+          if attributes[:log_changes]
+            collection = collection.where(status: EffectiveLogging.log_changes_status)
+          end
+
           if attributes[:associated]
             collection = collection.where(associated: attributes[:associated])
           end

data/app/models/effective/log.rb

@@ -8,13 +8,13 @@ module Effective
     attr_accessor :prev_log
 
     # Self-Referencing relationship
-    belongs_to :parent, :class_name => 'Effective::Log', :counter_cache => true
-    has_many :logs, :dependent => :destroy, :class_name => 'Effective::Log', :foreign_key => :parent_id
+    belongs_to :parent, class_name: 'Effective::Log', counter_cache: true
+    has_many :logs, class_name: 'Effective::Log', foreign_key: :parent_id
 
     # The user this log item is referring to
     # An associated object, if we wanna add anything extra
     belongs_to :user
-    belongs_to :associated, :polymorphic => true
+    belongs_to :associated, polymorphic: true
 
     serialize :details, Hash
 
@@ -26,17 +26,17 @@ module Effective
     #   timestamps
     # end
 
-    validates_presence_of :message, :status
-    validates_inclusion_of :status, in: EffectiveLogging.statuses
+    validates :message, presence: true
+    validates :status, presence: true, inclusion: { in: (EffectiveLogging.statuses + [EffectiveLogging.log_changes_status]) }
 
-    default_scope -> { order("#{EffectiveLogging.logs_table_name.to_s}.updated_at DESC") }
+    default_scope -> { order(updated_at: :desc) }
 
     def log(message, status = EffectiveLogging.statuses.first, options = {})
       EffectiveLogger.log(message, status, (options || {}).merge({:parent => self}))
     end
 
     def details
-      ((self[:details] ||= {}) rescue {})
+      self[:details] || {}
     end
 
     # def next_log

data/lib/effective_logging.rb

@@ -1,10 +1,9 @@
 require 'haml-rails'
 require 'effective_logging/engine'
 require 'effective_logging/version'
-require 'effective_logging/log_page_views'
-require 'effective_logging/user_logger'
 
 module EffectiveLogging
+
   # The following are all valid config keys
   mattr_accessor :logs_table_name
   mattr_accessor :use_active_admin
@@ -39,4 +38,17 @@ module EffectiveLogging
     @statuses ||= (Array(@@additional_statuses).map { |status| status.to_s.downcase } | ['info', 'success', 'error'])
   end
 
+  def self.log_changes_status
+    'logged change'.freeze
+  end
+
+  # This is set by the "set_log_changes_user" before_filter.
+  def self.log_changes_user=(user)
+    @log_changes_user = user
+  end
+
+  def self.log_changes_user
+    @log_changes_user
+  end
+
 end

data/lib/effective_logging/active_record_logger.rb

@@ -0,0 +1,131 @@
+module EffectiveLogging
+  class ActiveRecordLogger
+    attr_accessor :resource, :logger, :depth, :options
+
+    def initialize(resource, options = {})
+      raise ArgumentError.new('options must be a Hash') unless options.kind_of?(Hash)
+      raise ArgumentError.new('logger must respond to logged_changes') unless (options[:logger] || resource).respond_to?(:logged_changes)
+
+      @resource = resource
+      @logger = options.delete(:logger) || resource
+      @depth = options.delete(:depth) || 0
+      @options = options
+    end
+
+    # execute! is called when we recurse, otherwise the following methods are best called individually
+    def execute!
+      if resource.new_record?
+        created!
+      elsif resource.marked_for_destruction?
+        destroyed!
+      else
+        changed!
+      end
+    end
+
+    # before_destroy
+    def destroyed!
+      log('Deleted', applicable(attributes))
+    end
+
+    # after_commit
+    def created!
+      log('Created', applicable(attributes))
+    end
+
+    # after_commit
+    def updated!
+      log('Updated', applicable(attributes))
+    end
+
+    # before_save
+    def changed!
+      applicable(changes).each do |attribute, (before, after)|
+        if after.present?
+          log("#{attribute.titleize} changed from '#{before}' to '#{after}'", { attribute: attribute, before: before, after: after })
+        else
+          log("#{attribute.titleize} set to '#{before}'", { attribute: attribute, value: before })
+        end
+      end
+
+      # Log changes on all accepts_as_nested_parameters has_many associations
+      (resource.class.try(:reflect_on_all_autosave_associations) || []).each do |association|
+        child_name = association.name.to_s.singularize.titleize
+
+        resource.send(association.name).each_with_index do |child, index|
+          ActiveRecordLogger.new(child, options.merge(logger: logger, depth: (depth + 1), prefix: "#{child_name} ##{index+1}: ")).execute!
+        end
+      end
+    end
+
+    def attributes
+      attributes = { attributes: resource.attributes }
+
+      # Collect to_s representations of all belongs_to associations
+      (resource.class.try(:reflect_on_all_associations, :belongs_to) || []).each do |association|
+        attributes[association.name] = resource.send(association.name).to_s.presence || 'nil'
+      end
+
+      # Collect to_s representations for all has_one associations
+      (resource.class.try(:reflect_on_all_associations, :has_one) || []).each do |association|
+        attributes[association.name] = resource.send(association.name).to_s.presence || 'nil'
+      end
+
+      # Collects attributes for all accepts_as_nested_parameters has_many associations
+      (resource.class.try(:reflect_on_all_autosave_associations) || []).each do |association|
+        attributes[association.name] = {}
+
+        resource.send(association.name).each_with_index do |child, index|
+          attributes[association.name][index+1] = ActiveRecordLogger.new(child, options.merge(logger: logger)).attributes
+        end
+      end
+
+      attributes
+    end
+
+    def changes
+      changes = resource.changes
+
+      # Log to_s changes on all belongs_to associations
+      (resource.class.try(:reflect_on_all_associations, :belongs_to) || []).each do |association|
+        if (change = changes.delete(association.foreign_key)).present?
+          changes[association.name] = [association.klass.find_by_id(change.first), resource.send(association.name)]
+        end
+      end
+
+      changes
+    end
+
+    private
+
+    def log(message, details = {})
+      logger.logged_changes.build(
+        user: EffectiveLogging.log_changes_user,
+        status: EffectiveLogging.log_changes_status,
+        message: "#{"\t" * depth}#{options[:prefix]}#{message}",
+        details: details
+      ).tap { |log| log.save }
+    end
+
+    # TODO: Make this work better with nested objects
+    def applicable(attributes)
+      atts = if options[:only].present?
+        attributes.slice(*options[:only])
+      elsif options[:except].present?
+        attributes.except(*options[:except])
+      else
+        attributes
+      end
+
+      options[:additionally].each do |attribute|
+        value = (resource.send(attribute) rescue :effective_logging_nope)
+        next if attributes[attribute].present? || value == :effective_logging_nope
+
+        atts[attribute] = value
+      end
+
+      atts
+    end
+
+  end
+end

data/lib/effective_logging/engine.rb

@@ -2,6 +2,8 @@ module EffectiveLogging
   class Engine < ::Rails::Engine
     engine_name 'effective_logging'
 
+    config.autoload_paths += Dir["#{config.root}/lib/"]
+
     # Set up our default configuration options.
     initializer "effective_logging.defaults", :before => :load_config_initializers do |app|
       eval File.read("#{config.root}/lib/generators/templates/effective_logging.rb")
@@ -23,6 +25,20 @@ module EffectiveLogging
       end
     end
 
+    # Include acts_as_loggable concern and allow any ActiveRecord object to call it with log_changes()
+    initializer 'effective_logging.active_record' do |app|
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Base.extend(ActsAsLoggable::ActiveRecord)
+      end
+    end
+
+    # Register the log_page_views concern so that it can be called in ActionController or elsewhere
+    initializer 'effective_logging.log_changes_action_controller' do |app|
+      ActiveSupport.on_load :action_controller do
+        ActionController::Base.include(EffectiveLogging::LogChangesUser)
+      end
+    end
+
     # Register the log_page_views concern so that it can be called in ActionController or elsewhere
     initializer 'effective_logging.action_controller' do |app|
       ActiveSupport.on_load :action_controller do

data/lib/effective_logging/log_changes_user.rb

@@ -0,0 +1,17 @@
+module EffectiveLogging
+  module LogChangesUser
+
+    # Add me to your ApplicationController
+    # before_action :set_log_changes_user
+
+    def set_log_changes_user
+      if responds_to?(:current_user)
+        EffectiveLogging.log_changes_user = current_user
+      else
+        raise "(effective_logging) set_log_changes_user expects a current_user() method to be available"
+      end
+    end
+
+  end
+end
+

data/lib/effective_logging/version.rb

@@ -1,3 +1,3 @@
 module EffectiveLogging
-  VERSION = '1.4.1'.freeze
+  VERSION = '1.5.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_logging
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-12 00:00:00.000000000 Z
+date: 2016-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -96,6 +96,7 @@ files:
 - app/controllers/admin/logs_controller.rb
 - app/controllers/effective/logs_controller.rb
 - app/helpers/effective_logging_helper.rb
+- app/models/concerns/acts_as_loggable.rb
 - app/models/effective/access_denied.rb
 - app/models/effective/datatables/logs.rb
 - app/models/effective/log.rb
@@ -111,8 +112,10 @@ files:
 - config/routes.rb
 - db/migrate/01_create_effective_logging.rb.erb
 - lib/effective_logging.rb
+- lib/effective_logging/active_record_logger.rb
 - lib/effective_logging/email_logger.rb
 - lib/effective_logging/engine.rb
+- lib/effective_logging/log_changes_user.rb
 - lib/effective_logging/log_page_views.rb
 - lib/effective_logging/user_logger.rb
 - lib/effective_logging/version.rb