effective_logging 1.9.0 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8579f18cb5a349073e20276b59d179894d2f4a47
-  data.tar.gz: 45ce181f84a26e8d3643b0cf963b4db2e5bfb1f3
+  metadata.gz: 3e724ec2b890ab6af1c5f9a6e5fa573231cf64b8
+  data.tar.gz: dad4e05c79b2eeca0be0434e5aa4987dbb7e6ec0
 SHA512:
-  metadata.gz: d6d687512499402104b60abfe397d44ec7463fc4d114918b3285f528f8cc56721bfe22bcd393d8e71604c71ee4c322f0290e6a22225d4a9a14cd81101aeb4662
-  data.tar.gz: 9ba528f0e309582355fd07595ca9580c682d03c7dca31c8be402449413324089a00c04a6eef7450d51dcea2593b51077b1fde928f8e3c2330d546890dd0be769
+  metadata.gz: d0227e4b2c520bafc19e5a27a71b7f51964d30302f48a99f1902d51dd87dd6d97d172468fc8938c568c28e00f5a563108e2a42d71a83c03f13e11e7124cba3fc
+  data.tar.gz: e0ba574c10badde2f13e6533ca8d2838c2d2da107abf2d7e05b4da69dce67dea11bf38003ab2d130828bf67b2a588c3d48d787720dc997d7701d2275d53a6d9f

data/README.md

@@ -102,7 +102,7 @@ Any email sent by the application will be automatically logged.
 
 This behaviour can be disabled in the config/initializers/effective_logging.rb initializer.
 
-If the TO email address match a User, the :user will be set appropriately.
+If the TO email address match a User, the :associated will be set to this user.
 
 You can specify additional fields to be logged via your mailer:
 
@@ -111,7 +111,7 @@ def notify_admin_of_new_post(post)
   mail(
     to: 'admin@example.com',
     subject: 'A new post was created',
-    log: { :associated => post, :title => post.title }
+    log: { :post => post, :title => post.title }
   )
 end
 ```
@@ -229,7 +229,7 @@ And on each create / destroy / update, a full dump of all current attributes is
 
 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.
+Define your model with `log_changes additionally: [:method1, :method2]` to also _always_ log the value of that method. Even if it's unchanged.
 
 Apply your own formatting to the logged title of each attribute by creating an instance method on the resource:
 
@@ -328,7 +328,7 @@ render_datatable(@datatable)
 
 We can also use a similar method to create a datatable of logs for just one user.
 
-When initialized with :user_id, the 'User' column is hidden and the Logs are scoped to the User.
+When initialized with :user_id, the 'User' column is hidden and the Logs are scoped to any logs where this user is the User or Associated column.
 
 In your controller:
 

data/app/controllers/effective/logs_controller.rb

@@ -8,7 +8,6 @@ module Effective
       before_filter :authenticate_user!, only: [:index, :show]
     end
 
-
     # This is a post from our Javascript
     def create
       EffectiveLogging.authorized?(self, :create, Effective::Log.new())

data/app/helpers/effective_logging_helper.rb

@@ -8,12 +8,13 @@ module EffectiveLoggingHelper
       when 'info'     ; 'info'
       when 'warning'  ; 'warning'
       when 'error'    ; 'danger'
+      when 'change'   ; 'info'
       else 'primary'
     end
   end
 
   def render_log(log)
-    render(partial: 'effective/logs/log', locals: {:log => log})
+    render(partial: 'effective/logs/log', locals: {log: log})
   end
 
   def parents_of_log(log)

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

@@ -15,17 +15,19 @@ if defined?(EffectiveDatatables)
           end
 
           unless attributes[:status] == false
-            table_column :status, filter: { type: :select, values: (EffectiveLogging.statuses + [EffectiveLogging.log_changes_status]) }
+            table_column :status, filter: { type: :select, values: EffectiveLogging.statuses }
           end
 
+          table_column :associated_type, visible: false
+          table_column :associated_id, visible: false, label: 'Associated Id'
+          table_column :associated_to_s, label: 'Associated'
+
           table_column :message do |log|
             log.message.starts_with?("\t") ? log.message.gsub("\t", "  ") : log.message
           end
 
           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
@@ -42,22 +44,19 @@ if defined?(EffectiveDatatables)
         def collection
           collection = Effective::Log.unscoped.where(parent_id: attributes[:log_id]).includes(:user, :associated)
 
-          if attributes[:user_id].present?
-            collection = collection.where(user_id: attributes[:user_id])
+          if attributes[:log_changes]
+            collection = collection.where(status: EffectiveLogging.log_changes_status)
           end
 
-          if attributes[:user].present?
-            collection = collection.where(user: attributes[:user])
+          if (attributes[:user] || attributes[:user_id]).present?
+            user_id = attributes[:user_id] || (attributes[:user].kind_of?(User) ? attributes[:user].id : attributes[:user].to_i)
+            collection = collection.where('user_id = ? OR (associated_id = ? AND associated_type = ?)', user_id, user_id, 'User')
           end
 
           if attributes[:associated_id] && attributes[:associated_type]
             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

@@ -13,21 +13,24 @@ module Effective
 
     # 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 :user, optional: true
+    belongs_to :associated, polymorphic: true, optional: true
 
     serialize :details, Hash
 
-    # structure do
-    #   logs_count          :integer  # Rails Counter Cache
-    #   message             :string, :validates => [:presence]
-    #   details             :text
-    #   status              :string, :validates => [:presence, :inclusion => {:in => EffectiveLogging.statuses }]
-    #   timestamps
-    # end
+    # Attributes
+    # logs_count          :integer  # Rails Counter Cache
+
+    # associated_type     :string
+    # associated_id       :integer
+    # associated_to_s     :string
+    # message             :string
+    # details             :text
+    # status              :string
+    # timestamps
 
     validates :message, presence: true
-    validates :status, presence: true, inclusion: { in: (EffectiveLogging.statuses + [EffectiveLogging.log_changes_status]) }
+    validates :status, presence: true, inclusion: { in: EffectiveLogging.statuses }
 
     default_scope -> { order(updated_at: :desc) }
 
@@ -39,7 +42,7 @@ module Effective
     end
 
     def log(message, status = EffectiveLogging.statuses.first, options = {})
-      EffectiveLogger.log(message, status, (options || {}).merge({:parent => self}))
+      EffectiveLogger.log(message, status, (options || {}).merge(parent: self))
     end
 
     def details

data/app/models/effective_logger.rb

@@ -22,6 +22,11 @@ class EffectiveLogger
       log.user = options.delete(:user)
       log.parent = options.delete(:parent)
       log.associated = options.delete(:associated)
+      log.associated_to_s = options.delete(:associated_to_s)
+
+      if log.associated.present?
+        log.associated_to_s ||= (log.associated.to_s rescue nil)
+      end
 
       log.details = options.delete_if { |k, v| v.blank? } if options.kind_of?(Hash)
 

data/config/effective_logging.rb

@@ -42,10 +42,12 @@ EffectiveLogging.setup do |config|
   #### Automatic Logging Functionality ####
   #########################################
 
-  # Log all emails sent
-  config.emails_enabled = true
+  # Log all sent emails
+  config.email_enabled = true
 
-  # Log all successful user login attempts
-  config.user_logins_enabled = true
-  config.user_logouts_enabled = false
+  # Log all sign ins (successful only)
+  config.sign_in_enabled = true
+
+  # Log all sign outs
+  config.sign_out_enabled = false
 end

data/db/migrate/01_create_effective_logging.rb.erb

@@ -2,10 +2,12 @@ class CreateEffectiveLogging < ActiveRecord::Migration
   def self.up
     create_table <%= @logs_table_name %> do |t|
       t.integer       :parent_id
+
       t.integer       :user_id
 
       t.string        :associated_type
       t.integer       :associated_id
+      t.string        :associated_to_s
 
       t.integer       :logs_count
 
@@ -21,6 +23,7 @@ class CreateEffectiveLogging < ActiveRecord::Migration
     add_index <%= @logs_table_name %>, :parent_id
     add_index <%= @logs_table_name %>, [:associated_type, :associated_id]
     add_index <%= @logs_table_name %>, :associated_id
+    add_index <%= @logs_table_name %>, :associated_to_s
   end
 
   def self.down

data/lib/effective_logging/active_record_logger.rb

@@ -53,11 +53,7 @@ module EffectiveLogging
           resource.log_changes_formatted_attribute(attribute)
         end || attribute.titleize
 
-        if after.present?
-          log("#{attribute} changed from #{before.presence || BLANK} to #{after.presence || BLANK}", details: { attribute: attribute, before: before, after: after })
-        else
-          log("#{attribute} set to #{before || BLANK}", details: { attribute: attribute, value: before })
-        end
+        log("#{attribute}: #{before.presence || BLANK} to #{after.presence || BLANK}", details: { attribute: attribute, before: before, after: after })
       end
 
       # Log changes on all accepts_as_nested_parameters has_many associations
@@ -75,7 +71,7 @@ module EffectiveLogging
 
       # 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'
+        attributes[association.name] = resource.send(association.name).to_s.presence
       end
 
       # Collect to_s representations for all has_one associations
@@ -90,6 +86,8 @@ module EffectiveLogging
         Array(resource.send(association.name)).each_with_index do |child, index|
           attributes[association.name][index+1] = ActiveRecordLogger.new(child, options.merge(logger: logger)).attributes
         end
+
+        attributes[association.name].presence
       end
 
       attributes
@@ -101,7 +99,7 @@ module EffectiveLogging
       # 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)]
+          changes[association.name] = [(association.klass.find_by_id(change.first) if changes.first), resource.send(association.name)]
         end
       end
 
@@ -115,6 +113,8 @@ module EffectiveLogging
         user: EffectiveLogging.current_user,
         status: EffectiveLogging.log_changes_status,
         message: "#{"\t" * depth}#{options[:prefix]}#{message}",
+        associated: resource,
+        associated_to_s: (resource.to_s rescue nil),
         details: details
       ).tap { |log| log.save }
     end

data/lib/effective_logging/email_logger.rb

@@ -7,7 +7,7 @@ module EffectiveLogging
       logged_fields = { from: message.from.join(','), to: message.to, subject: message.subject }
 
       # Add a log header to your mailer to pass some objects or additional things to EffectiveLogger
-      # mail(to: 'admin@example.com', subject: @post.title, log: { associated: @post })
+      # mail(to: 'admin@example.com', subject: @post.title, log: { post: @post })
       if message.header['log'].present?
         # This is a bit sketchy, but gives access to the object in Rails 4.2 anyway
         logged_fields.merge!(message.header['log'].instance_variable_get(:@value) || {})
@@ -22,9 +22,9 @@ module EffectiveLogging
 
       (message.to || []).each do |to|
         logged_fields[:to] = to
-        logged_fields[:user] ||= (User.where(email: to).first rescue nil)
+        logged_fields[:associated] ||= (User.where(email: to).first rescue nil)
 
-        ::EffectiveLogger.success("email sent: #{message.subject}", logged_fields)
+        ::EffectiveLogger.email("#{message.subject} - #{message.to.join(', ')}", logged_fields)
       end
     end
 

data/lib/effective_logging/engine.rb

@@ -19,7 +19,7 @@ module EffectiveLogging
 
     # Automatically Log Emails
     initializer 'effective_logging.emails' do |app|
-      if EffectiveLogging.emails_enabled == true
+      if EffectiveLogging.email_enabled == true
         require 'effective_logging/email_logger'
         ActionMailer::Base.register_interceptor(EffectiveLogging::EmailLogger)
       end
@@ -51,12 +51,12 @@ module EffectiveLogging
 
     # This has to be run after initialization or User hasn't been loaded yet
     config.after_initialize do
-      if EffectiveLogging.user_logins_enabled || EffectiveLogging.user_logouts_enabled
+      if EffectiveLogging.sign_in_enabled || EffectiveLogging.sign_out_enabled
         ActiveSupport.on_load :active_record do
           if defined?(Devise)
             EffectiveLogging::UserLogger.create_warden_hooks()
           else
-            raise ArgumentError.new("EffectiveLogging.user_logins_enabled only works with Devise")
+            raise ArgumentError.new("EffectiveLogging.sign_in_enabled only works with Devise")
           end
         end
       end

data/lib/effective_logging/log_page_views.rb

@@ -48,15 +48,15 @@ module EffectiveLogging
         user = (current_user rescue nil)
 
         if self.class.log_page_views_opts[:details] == false
-          ::EffectiveLogger.info("page view: #{request.request_method} #{request.path}", :user => user)
+          ::EffectiveLogger.view("#{request.request_method} #{request.path}", user: user)
         else
-          ::EffectiveLogger.info(
-            "page view: #{request.request_method} #{request.path}",
-            :user => user,
-            :params => request.filtered_parameters.reject { |k, v| (k == 'controller' || k == 'action') },
-            :format => (request.format.to_s == 'text/html' ? nil : request.format.to_s),
-            :referrer => request.referrer,
-            :user_agent => request.user_agent
+          ::EffectiveLogger.view(
+            "#{request.request_method} #{request.path}",
+            user: user,
+            params: request.filtered_parameters.reject { |k, v| (k == 'controller' || k == 'action') },
+            format: (request.format.to_s == 'text/html' ? nil : request.format.to_s),
+            referrer: request.referrer,
+            user_agent: request.user_agent
           )
         end
       end

data/lib/effective_logging/user_logger.rb

@@ -2,32 +2,34 @@ module EffectiveLogging
   class UserLogger
     def self.create_warden_hooks
       Warden::Manager.after_authentication do |user, warden, opts|
-        if EffectiveLogging.user_logins_enabled && !EffectiveLogging.supressed?
-          ::EffectiveLogger.success('user login',
-            :user => user,
-            :ip => warden.request.ip.presence,
-            :referrer => warden.request.referrer,
-            :user_agent => warden.request.user_agent
+        if EffectiveLogging.sign_in_enabled && !EffectiveLogging.supressed?
+          ::EffectiveLogger.sign_in('Sign in',
+            user: user,
+            associated: user,
+            ip: warden.request.ip.presence,
+            referrer: warden.request.referrer,
+            user_agent: warden.request.user_agent
           )
         end
       end
 
       Warden::Manager.after_set_user do |user, warden, opts|
-        if EffectiveLogging.user_logins_enabled && !EffectiveLogging.supressed?
+        if EffectiveLogging.sign_in_enabled && !EffectiveLogging.supressed?
           if (opts[:event] == :set_user rescue false) # User has just reset their password and signed in
-            ::EffectiveLogger.success('user login',
-              :user => user,
-              :ip => warden.request.ip.presence,
-              :referrer => warden.request.referrer,
-              :user_agent => warden.request.user_agent,
-              :notes => 'after password reset'
+            ::EffectiveLogger.sign_in('Sign in',
+              user: user,
+              associated: user,
+              ip: warden.request.ip.presence,
+              referrer: warden.request.referrer,
+              user_agent: warden.request.user_agent,
+              notes: 'after password reset'
             )
           end
         end
       end
 
       Warden::Manager.before_logout do |user, warden, opts|
-        if EffectiveLogging.user_logouts_enabled && !EffectiveLogging.supressed?
+        if EffectiveLogging.sign_out_enabled && !EffectiveLogging.supressed?
           if user.respond_to?(:timedout?) && user.respond_to?(:timeout_in)
             scope = opts[:scope]
             last_request_at = (warden.request.session["warden.#{scope}.#{scope}.session"]['last_request_at'] rescue Time.zone.now)
@@ -40,12 +42,12 @@ module EffectiveLogging
             end
 
             if user.timedout?(last_request_at) && !warden.request.env['devise.skip_timeout']
-              ::EffectiveLogger.success('user logout', :user => user, :timedout => true)
+              ::EffectiveLogger.sign_out('Sign out', user: user, associated: user, timedout: true)
             else
-              ::EffectiveLogger.success('user logout', :user => user)
+              ::EffectiveLogger.sign_out('Sign out', user: user, associated: user)
             end
           else # User does not respond to timedout
-            ::EffectiveLogger.success('user logout', :user => user)
+            ::EffectiveLogger.sign_out('Sign out', user: user, associated: user)
           end
         end
       end

data/lib/effective_logging/version.rb

@@ -1,3 +1,3 @@
 module EffectiveLogging
-  VERSION = '1.9.0'.freeze
+  VERSION = '1.10.0'.freeze
 end

data/lib/effective_logging.rb

@@ -12,9 +12,9 @@ module EffectiveLogging
   mattr_accessor :layout
   mattr_accessor :additional_statuses
 
-  mattr_accessor :emails_enabled
-  mattr_accessor :user_logins_enabled
-  mattr_accessor :user_logouts_enabled
+  mattr_accessor :email_enabled
+  mattr_accessor :sign_in_enabled
+  mattr_accessor :sign_out_enabled
 
   def self.setup
     yield self
@@ -36,11 +36,15 @@ module EffectiveLogging
   end
 
   def self.statuses
-    @statuses ||= (Array(@@additional_statuses).map { |status| status.to_s.downcase } | ['info', 'success', 'error'])
+    @statuses ||= (
+      Array(@@additional_statuses).map do |status|
+        status.to_s.downcase
+      end | ['info', 'success', 'error', log_changes_status, ('email' if email_enabled), ('sign_in' if sign_in_enabled), ('sign_out' if sign_out_enabled), 'view'].compact
+    )
   end
 
   def self.log_changes_status
-    'logged change'.freeze
+    'change'.freeze
   end
 
   # This is set by the "set_effective_logging_current_user" before_filter.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_logging
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.10.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-08 00:00:00.000000000 Z
+date: 2017-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails