effective_logging 1.0.0

data/app/helpers/effective_logging_helper.rb

@@ -0,0 +1,59 @@
+module EffectiveLoggingHelper
+  def bootstrap_class_for_status(status)
+    case status
+      when 'success'  ; 'success'
+      when 'info'     ; 'info'
+      when 'warning'  ; 'warning'
+      when 'error'    ; 'danger'
+      else 'primary'
+    end
+  end
+
+  def render_log(log)
+    render(:partial => 'effective/logs/log', :locals => {:log => log})
+  end
+
+  def parents_of_log(log)
+    parents = [log.parent]
+    parents << parents.last.parent while(parents.last.try(:parent_id).present?)
+    parents.compact.reverse
+  end
+
+  # Call me with :th => true, :sub_th => false
+  # Any other options are sent to the table tag
+  def tableize_hash(hash, options = {})
+    if hash.present?
+      content_tag(:table, options) do
+        hash.map do |k, v|
+          content_tag(:tr) do
+            content_tag((options[:th] ? :th : :td), k) +
+            content_tag(:td) do
+              if v.kind_of?(Hash)
+                tableize_hash(v, options.merge({:class => 'table table-bordered', :th => (options.key?(:sub_th) ? options[:sub_th] : options[:th])}))
+              elsif v.kind_of?(Array)
+                '[' + v.join(', ') + ']'
+              else
+                v
+              end
+            end
+          end
+        end.join('').html_safe
+      end.html_safe
+    end
+  end
+
+  # This is called on the Logs#show Admin page, and is intended for override by the application
+  def effective_logging_object_link_to(obj, action = :show)
+    if obj.kind_of?(User)
+      return (
+        if action == :show && defined?(admin_user_path)
+          link_to('View', admin_user_path(obj))
+        elsif action == :edit && defined?(edit_admin_user_path)
+          link_to('Edit', edit_admin_user_path(obj))
+        end
+      )
+    end
+  end
+
+
+end

data/app/models/effective/access_denied.rb

@@ -0,0 +1,17 @@
+unless defined?(Effective::AccessDenied)
+  module Effective
+    class AccessDenied < StandardError
+      attr_reader :action, :subject
+
+      def initialize(message = nil, action = nil, subject = nil)
+        @message = message
+        @action = action
+        @subject = subject
+      end
+
+      def to_s
+        @message || I18n.t(:'unauthorized.default', :default => 'Access Denied')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+if defined?(EffectiveDatatables)
+  module Effective
+    module Datatables
+      class Logs < Effective::Datatable
+        include EffectiveLoggingHelper
+
+        default_order :created_at, :desc
+
+        table_column :created_at
+        table_column :user
+
+        table_column :status, :filter => {:type => :select, :values => EffectiveLogging.statuses }
+        table_column :message, :width => '50%'
+
+        table_column :details, :visible => false do |log|
+          log.details.delete(:email)
+          tableize_hash(log.details, :th => true, :sub_th => false, :width => '100%')
+        end
+
+        table_column :actions, :sortable => false, :filter => false do |log|
+          show_path =
+            if datatables_active_admin_path?
+              admin_effective_log_path(log)
+            elsif datatables_admin_path?
+              effective_logging.admin_log_path(log)
+            else
+              effective_logging.log_path(log)
+            end
+
+          if log.logs_count.to_i > 0
+            link_to "View&nbsp;(#{log.logs_count}&nbsp;more)".html_safe, show_path
+          else
+            link_to 'View', show_path
+          end
+        end
+
+        # A nil attributes[:log_id] means give me all the top level log entries
+        # If we set a log_id then it's for sub logs
+        def collection
+          if attributes[:user_id].present?
+            Effective::Log.unscoped.where(:parent_id => attributes[:log_id]).where(:user_id => attributes[:user_id]).includes(:user)
+          else
+            Effective::Log.unscoped.where(:parent_id => attributes[:log_id]).includes(:user)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/effective/log.rb

@@ -0,0 +1,59 @@
+module Effective
+  class Log < ActiveRecord::Base
+    self.table_name = EffectiveLogging.logs_table_name.to_s
+
+    # These 3 attr_accessors are set on the controller #show actions
+    attr_accessor :datatable
+    attr_accessor :next_log
+    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
+
+    # 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
+
+    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
+
+    default_scope -> { order("#{EffectiveLogging.logs_table_name.to_s}.updated_at DESC") }
+
+    def log(message, status = EffectiveLogging.statuses.first, options = {})
+      EffectiveLogger.log(message, status, (options || {}).merge({:parent => self}))
+    end
+
+    def details
+      self[:details] ||= {}
+    end
+
+    # def next_log
+    #   @next_log ||= Log.unscoped.order(:id).where(:parent_id => self.parent_id).where('id > ?', self.id).first
+    # end
+
+    # def prev_log
+    #   @prev_log ||= Log.unscoped.order(:id).where(:parent_id => self.parent_id).where('id < ?', self.id).last
+    # end
+
+    # Dynamically add logging methods based on the defined statuses
+    # EffectiveLogging.info 'my message'
+    (EffectiveLogging.statuses || []).each do |status|
+      send(:define_method, status) { |message, options={}| log(message, status, options) }
+    end
+
+  end
+end
+
+

data/app/models/effective/user_logger.rb

@@ -0,0 +1,7 @@
+module Effective
+  class UserLogger
+    def self.successful_login(user)
+      EffectiveLogger.success("user login from #{user.try(:current_sign_in_ip) || 'unknown IP'}", :user => user)
+    end
+  end
+end

data/app/models/effective_logger.rb

@@ -0,0 +1,38 @@
+# Call EffectiveLog.info or EffectiveLog.success  EffectiveLog.error
+
+class EffectiveLogger
+  def self.log(message, status = EffectiveLogging.statuses.first, options = {})
+    if options[:user].present? && !options[:user].kind_of?(User)
+      raise ArgumentError.new("Log.log :user => ... argument must be a User object")
+    end
+
+    if options[:parent].present? && !options[:parent].kind_of?(Effective::Log)
+      raise ArgumentError.new("Log.log :parent => ... argument must be an Effective::Log object")
+    end
+
+    if options[:associated].present? && !options[:associated].kind_of?(ActiveRecord::Base)
+      raise ArgumentError.new("Log.log :associated => ... argument must be an ActiveRecord::Base object")
+    end
+
+    Effective::Log.new().tap do |log|
+      log.message = message
+      log.status = status
+
+      log.user_id = options.delete(:user_id)
+      log.user = options.delete(:user)
+      log.parent = options.delete(:parent)
+      log.associated = options.delete(:associated)
+
+      log.details = options.delete_if { |k, v| v.blank? } if options.kind_of?(Hash)
+
+      log.save
+    end
+  end
+
+  # Dynamically add logging methods based on the defined statuses
+  # EffectiveLogging.info 'my message'
+  (EffectiveLogging.statuses || []).each do |status|
+    self.singleton_class.send(:define_method, status) { |message, options={}| log(message, status, options) }
+  end
+
+end

data/app/views/active_admin/effective_logging/logs/index.html.haml

@@ -0,0 +1,8 @@
+.fluid-container
+  .row
+    .col-sm-12
+      - unless (@datatable.collection.length rescue 0) > 0
+        %p
+          There are no logs
+      - else
+        = render_datatable @datatable

data/app/views/active_admin/effective_logging/logs/show.html.haml

@@ -0,0 +1,4 @@
+.fluid-container
+  .row
+    .col-sm-12
+      = render_log(@log)

data/app/views/admin/logs/index.html.haml

@@ -0,0 +1,7 @@
+%h2= @page_title
+
+- unless (@datatable.collection.length rescue 0) > 0
+  %p
+    There are no logs
+- else
+  = render_datatable @datatable

data/app/views/admin/logs/show.html.haml

@@ -0,0 +1,3 @@
+%h2= @page_title
+= render_log(@log)
+

data/app/views/effective/logs/_log.html.haml

@@ -0,0 +1,59 @@
+.panel{:class => "panel-#{bootstrap_class_for_status(log.status)}"}
+  .panel-heading
+    - parents_of_log(log).each do |parent|
+      = link_to(log.message, (request.fullpath.gsub(log.to_param, parent.to_param) rescue '#'))
+      = ' > '
+    %strong= log.message
+    .pull-right
+      = link_to_if(log.prev_log.present?, '< Prev', (request.fullpath.gsub(log.to_param, log.prev_log.try(:to_param).to_s))) { 'Prev' }
+      = ' - '
+      = link_to_if(log.next_log.present?, 'Next >', (request.fullpath.gsub(log.to_param, log.next_log.try(:to_param).to_s))) { 'Next' }
+
+  .panel-body
+    .row
+      .col-lg-6
+        %span.label{:class => "label-#{bootstrap_class_for_status(log.status)}"}= log.status
+        &nbsp;
+        = log.created_at.strftime("%Y-%m-%d %H:%M:%S")
+        = '(' + time_ago_in_words(log.created_at) + ' ago)'
+
+      .col-lg-6
+        - if log.user.present?
+          %strong User:
+          &nbsp;
+          = (log.user.to_s.starts_with?('#<User:0x') ? (log.user.email rescue log.user) : log.user)
+        - if log.associated.present?
+          %br
+          %strong Regarding:
+          &nbsp;
+          - if log.associated.to_s.starts_with?('#<')
+            = "#{log.associated.class.name} ##{log.associated.to_param}"
+          - else
+            = log.associated
+
+    - log.details.each do |key, value|
+      - next unless value.present?
+      .row
+        .col-lg-12
+          %br
+          %p
+            %strong= "#{key.to_s.titleize}:"
+          - if value.kind_of?(Hash)
+            = tableize_hash(value, :class => 'table', :style => 'width: 50%', :th => true)
+          - else
+            - allowed_tags = ActionView::Base.sanitized_allowed_tags.to_a + ['table', 'thead', 'tbody', 'tfoot', 'tr', 'td', 'th']
+            - allowed_attributes = ActionView::Base.sanitized_allowed_attributes.to_a + ['colspan', 'rowspan']
+            = simple_format(sanitize(value.to_s, :tags => allowed_tags, :attributes => allowed_attributes), {}, :sanitize => false)
+
+    - if log.logs.present?
+      .row
+        .col-lg-12
+          %br
+          %p
+            %strong Additional Entries:
+            = "this log contains #{log.logs_count} additional sub entries"
+      - if log.datatable.present?
+        %hr
+        .row
+          .col-lg-12= render_datatable log.datatable
+

data/app/views/effective/logs/index.html.haml

@@ -0,0 +1,7 @@
+%h2= @page_title
+
+- unless (@datatable.collection.length rescue 0) > 0
+  %p
+    You have no previous recorded activity
+- else
+  = render_datatable @datatable

data/app/views/effective/logs/show.html.haml

@@ -0,0 +1,2 @@
+%h2= @page_title
+= render_log(@log)

data/config/routes.rb

@@ -0,0 +1,18 @@
+EffectiveLogging::Engine.routes.draw do
+  scope :module => 'effective' do
+    # Create is our javascript POST event for EffectiveLogging from JS side
+    # The show and index routes are for user specific logs
+    resources :logs, :only => [:create, :show, :index]
+  end
+
+  if defined?(EffectiveDatatables)
+    namespace :admin do
+      resources :logs, :only => [:index, :show]
+    end
+  end
+
+end
+
+Rails.application.routes.draw do
+  mount EffectiveLogging::Engine => '/', :as => 'effective_logging'
+end

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

@@ -0,0 +1,29 @@
+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.integer       :logs_count
+
+      t.string        :message
+      t.text          :details
+
+      t.string        :status
+
+      t.timestamps
+    end
+
+    add_index <%= @logs_table_name %>, :user_id
+    add_index <%= @logs_table_name %>, :parent_id
+    add_index <%= @logs_table_name %>, [:associated_type, :associated_id]
+    add_index <%= @logs_table_name %>, :associated_id
+  end
+
+  def self.down
+    drop_table <%= @logs_table_name %>
+  end
+end

data/lib/effective_logging.rb

@@ -0,0 +1,32 @@
+require "effective_logging/engine"
+require "effective_logging/version"
+require "effective_logging/log_page_views"
+
+module EffectiveLogging
+  # The following are all valid config keys
+  mattr_accessor :logs_table_name
+  mattr_accessor :use_active_admin
+
+  mattr_accessor :authorization_method
+  mattr_accessor :layout
+  mattr_accessor :additional_statuses
+
+  mattr_accessor :emails_enabled
+  mattr_accessor :user_logins_enabled
+
+  def self.setup
+    yield self
+  end
+
+  def self.authorized?(controller, action, resource)
+    if authorization_method.respond_to?(:call) || authorization_method.kind_of?(Symbol)
+      raise Effective::AccessDenied.new() unless (controller || self).instance_exec(controller, action, resource, &authorization_method)
+    end
+    true
+  end
+
+  def self.statuses
+    @statuses ||= (Array(@@additional_statuses).map { |status| status.to_s.downcase } | ['info', 'success', 'error'])
+  end
+
+end

data/lib/effective_logging/email_logger.rb

@@ -0,0 +1,28 @@
+module EffectiveLogging
+  class EmailLogger
+    def self.delivered_email(message)
+      return unless message.present?
+
+      # Cleanup the Header
+      message_header = message.header.to_s
+      message_header.gsub!(";\r\n charset", '; charset')
+
+      # Cleanup the Body
+      if (message_body = message.body.to_s).include?('<html>')
+        message_body.gsub!(/(\r)*\n\s*/, '')
+        message_body.gsub!("<!DOCTYPE html>", '')
+      end
+
+      (message.to || []).each do |email|
+        user = User.where(:email => email).first
+
+        if user.present?
+          EffectiveLogger.success("email sent: #{message.subject}", :user => user, :recipient => email, :subject => message.subject, :email => message_header + '<hr>' + message_body)
+        else
+          EffectiveLogger.success("email sent to #{email}: #{message.subject}", :recipient => email, :subject => message.subject, :email => message_header + '<hr>' + message_body)
+        end
+      end
+    end
+
+  end
+end