effective_logging 3.0.10 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ced9c07cb086b859429b90b1ccbac95ae8e201b775bcd583b3d289004289094d
-  data.tar.gz: 7411b720f373bc75ad92be98649481daefc15755d972835909e65d272d243b40
+  metadata.gz: e1dc7b7f4024ac664b211eba56892cd43828ec911f37361b91f1ac6496f87fb7
+  data.tar.gz: 512c990d5a8dddfcc665e28ff7dd6ef66302ce4f855d68d87fa89af44ef79ed4
 SHA512:
-  metadata.gz: caef27d98294627b0a21fa7d6dee8ab0d08d86e8297eddcbfcc403724bbfb75ca79b317192ee96ef744704e88fd03a04b41a913289c7a6e1c92753a140640a38
-  data.tar.gz: 579cabf40e8107f4a44c23da05e87c7d6887c4e7604b265475a8a4ae6769f99ce421e3e358df70f1d56935e06724254ceebec651cf8a41f5935811d44ad5cff2
+  metadata.gz: 612a1bed2cc27c80ee726a023a079e0a5a2dcf80b7d390e07bb9a692bf60da43c974d754bc29f99a17bc95d589e18457aa52261564da19e509947b47046a8f3c
+  data.tar.gz: 798375484126e11a779eaffbdf1c53e26a5530f701440b4190660948b52ee9c728e1e7f300684b088a636d4b9df1d08087b71dc3477a434a23c2422b576b27c7

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2019 Code and Effect Inc.
+Copyright 2021 Code and Effect Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -211,14 +211,6 @@ class Post < ActiveRecord::Base
 end
 ```
 
-and to your controller:
-
-```ruby
-class ApplicationController < ActionController::Base
-  before_action :set_effective_logging_current_user
-end
-```
-
 Then to see the log for this resource, on any view:
 
 ```erb

data/app/controllers/admin/logs_controller.rb

@@ -1,32 +1,20 @@
 module Admin
   class LogsController < ApplicationController
-    before_action :authenticate_user!
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_logging) }
+
+    include Effective::CrudController
     skip_log_page_views
 
-    layout (EffectiveLogging.layout.kind_of?(Hash) ? EffectiveLogging.layout[:admin_logs] : EffectiveLogging.layout)
+    if (config = EffectiveLogging.layout)
+      layout(config.kind_of?(Hash) ? config[:admin] : config)
+    end
 
     def index
+      EffectiveResources.authorize!(self, :index, Effective::Log)
       @datatable = EffectiveLogsDatatable.new(self)
-
       @page_title = 'Logs'
-
-      EffectiveLogging.authorize!(self, :index, Effective::Log)
-      EffectiveLogging.authorize!(self, :admin, :effective_logging)
     end
 
-    def show
-      @log = Effective::Log.includes(:logs).find(params[:id])
-      @log.next_log = Effective::Log.order(:id).where(parent_id: @log.parent_id).where('id > ?', @log.id).first
-      @log.prev_log = Effective::Log.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 = EffectiveLogsDatatable.new(self, log_id: @log.id)
-      end
-
-      EffectiveLogging.authorize!(self, :show, @log)
-      EffectiveLogging.authorize!(self, :admin, :effective_logging)
-    end
   end
 end

data/app/controllers/effective/logs_controller.rb

@@ -1,11 +1,17 @@
 module Effective
   class LogsController < ApplicationController
+    before_action(:authenticate_user!, only: [:index, :show]) if defined?(Devise)
+
+    include Effective::CrudController
     skip_log_page_views
-    before_action :authenticate_user!, only: [:index, :show]
+
+    if (config = EffectiveLogging.layout)
+      layout(config.kind_of?(Hash) ? config[:application] : config)
+    end
 
     # This is a post from our Javascript
     def create
-      EffectiveLogging.authorize!(self, :create, Effective::Log.new)
+      EffectiveResources.authorize!(self, :create, Effective::Log.new)
 
       @log = Effective::Log.new.tap do |log|
         log.message = log_params[:message]
@@ -34,27 +40,10 @@ module Effective
 
     # This is the User index event
     def index
-      EffectiveLogging.authorize!(self, :index, Effective::Log.new(user_id: current_user.id))
-
+      EffectiveResources.authorize!(self, :index, Effective::Log.new(user_id: current_user.id))
       @datatable = EffectiveLogsDatatable.new(self, user_id: current_user.id)
     end
 
-    # This is the User show event
-    def show
-      @log = Effective::Log.includes(:logs).find(params[:id])
-
-      EffectiveLogging.authorize!(self, :show, @log)
-
-      @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 = EffectiveLogsDatatable.new(self, log_id: @log.id)
-      end
-    end
-
     def html_part
       @log = Effective::Log.find(params[:id])
 

data/app/datatables/effective_log_changes_datatable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class EffectiveLogChangesDatatable < Effective::Datatable
   datatable do
     order :updated_at
@@ -5,19 +7,19 @@ class EffectiveLogChangesDatatable < Effective::Datatable
     col :updated_at, label: 'Date'
     col :id, visible: false
 
-    col :user, sort: false
+    col :user, search: :string, sort: false
 
     col :associated_type, visible: false
-    col :associated_id, visible: false
-    col :associated_to_s, visible: false
+    col :associated_id, visible: false, label: 'Associated Id'
+    col :associated_to_s, visible: false, label: 'Associated'
 
     col :message, sort: false do |log|
-      message = log.message.gsub("\n", '<br>')
+      (log.message || '').gsub!("\n", '<br>')
 
       if log.associated_id == attributes[:changes_to_id] && log.associated_type == attributes[:changes_to_type]
-        message
+        log.message
       else
-        "#{log.associated_type} #{log.associated_to_s} - #{message}"
+        "#{log.associated_type} #{log.associated_to_s} - #{log.message}"
       end
 
     end.search do |collection, term, column, sql_column|
@@ -29,9 +31,7 @@ class EffectiveLogChangesDatatable < Effective::Datatable
       tableize_hash(log.details)
     end
 
-    unless attributes[:actions] == false
-      actions_col partial: 'admin/logs/actions', partial_as: :log
-    end
+    actions_col
   end
 
   # A nil attributes[:log_id] means give me all the top level log entries

data/app/datatables/effective_logs_datatable.rb

@@ -7,19 +7,17 @@ class EffectiveLogsDatatable < Effective::Datatable
 
     if attributes[:user] == false
       # Do not include
-    elsif attributes[:for]
-      col :user, search: :string
     else
-      col :user
+      col :user, search: :string, sort: false
     end
 
     unless attributes[:status] == false
       col :status, search: { collection: EffectiveLogging.statuses }
     end
 
-    col :associated_type, search: { as: :string }
-    col :associated_id, search: { as: :integer }, visible: false, label: 'Associated Id'
-    col :associated_to_s, search: { as: :string }, label: 'Associated'
+    col :associated_type, visible: false
+    col :associated_id, visible: false, label: 'Associated Id'
+    col :associated_to_s, label: 'Associated'
 
     col :message do |log|
       log.message.gsub("\n", '<br>')
@@ -31,9 +29,7 @@ class EffectiveLogsDatatable < Effective::Datatable
       tableize_hash(log.details.except(:email))
     end
 
-    unless attributes[:actions] == false
-      actions_col partial: 'admin/logs/actions', partial_as: :log
-    end
+    actions_col
   end
 
   # A nil attributes[:log_id] means give me all the top level log entries

data/app/models/concerns/acts_as_loggable.rb

@@ -27,8 +27,8 @@ module ActsAsLoggable
       except: Array(@acts_as_loggable_options[:except])
     }
 
-    if name == 'User'
-      log_changes_options[:except] += %i(sign_in_count current_sign_in_at current_sign_in_ip last_sign_in_at last_sign_in_ip encrypted_password remember_created_at reset_password_token invitation_sent_at invitation_created_at invitation_token)
+    if name.end_with?('User')
+      log_changes_options[:except] += %i(sign_in_count current_sign_in_at current_sign_in_ip last_sign_in_at last_sign_in_ip encrypted_password remember_created_at reset_password_token invitation_sent_at invitation_created_at invitation_token access_token refresh_token token_expires_at)
     end
 
     self.send(:define_method, :log_changes_options) { log_changes_options }
@@ -67,4 +67,3 @@ module ActsAsLoggable
   end
 
 end
-

data/app/models/effective/log.rb

@@ -2,42 +2,40 @@ 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, optional: true
     has_many :logs, class_name: 'Effective::Log', foreign_key: :parent_id
 
-    belongs_to :user, optional: true
+    belongs_to :user, polymorphic: true, optional: true
     belongs_to :changes_to, polymorphic: true, optional: true # This is the log_changes to: option
     belongs_to :associated, polymorphic: true, optional: true
 
-    serialize :details, Hash
+    effective_resource do
+      logs_count          :integer  # Rails Counter Cache
 
-    # Attributes
-    # logs_count          :integer  # Rails Counter Cache
+      changes_to_type     :string
+      changes_to_id       :string
 
-    # changes_to_type     :string
-    # changes_to_id       :string
+      associated_type     :string
+      associated_id       :integer
+      associated_to_s     :string
 
-    # associated_type     :string
-    # associated_id       :integer
-    # associated_to_s     :string
-    # message             :text
-    # details             :text
-    # status              :string
-    # timestamps
+      status              :string
+      message             :text
+      details             :text
+
+      timestamps
+    end
+
+    serialize :details, Hash
 
     validates :message, presence: true
     validates :status, presence: true, inclusion: { in: EffectiveLogging.statuses }
 
     scope :deep, -> { includes(:user, :associated) }
     scope :sorted, -> { order(:id) }
-    scope :logged_changes, -> { where(status: EffectiveLogging.log_changes_status)}
-    scope :changes, -> { where(status: EffectiveLogging.log_changes_status)}
+    scope :logged_changes, -> { where(status: EffectiveLogging.log_changes_status) }
+    scope :changes, -> { where(status: EffectiveLogging.log_changes_status) }
 
     def to_s
       "Log #{id}"
@@ -55,6 +53,18 @@ module Effective
       self[:details] || {}
     end
 
+    def next_log
+      Log.order(id: :asc).where(parent_id: parent_id).where('id > ?', id).first
+    end
+
+    def prev_log
+      Log.order(id: :desc).where(parent_id: parent_id).where('id < ?', id).first
+    end
+
+    def child_logs_datatable
+      EffectiveLogsDatatable.new(log_id: id)
+    end
+
     # Dynamically add logging methods based on the defined statuses
     # EffectiveLogging.info 'my message'
     (EffectiveLogging.statuses || []).each do |status|
@@ -63,5 +73,3 @@ module Effective
 
   end
 end
-
-

data/app/models/effective_logger.rb

@@ -6,7 +6,7 @@ class EffectiveLogger
 
     options = Hash(options).delete_if { |k, v| v.blank? }
 
-    if options[:user].present? && !options[:user].kind_of?(User)
+    if options[:user].present? && !options[:user].class.name.end_with?('User')
       raise ArgumentError.new('Log.log :user => ... argument must be a User object')
     end
 
@@ -30,6 +30,7 @@ class EffectiveLogger
       message: message,
       status: status,
       user_id: options.delete(:user_id),
+      user_type: options.delete(:user_type),
       user: options.delete(:user),
       parent: options.delete(:parent),
       associated: options.delete(:associated),

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

@@ -8,18 +8,22 @@
         %p= log.message.to_s.gsub("\n", '<br>').html_safe
 
       .col-md-4.text-right
-        - if log.prev_log
-          = link_to 'Prev', request.fullpath.sub('/' + log.to_param, '/' + log.prev_log.to_param), class: 'btn btn-primary'
+        - prev_log = log.prev_log
+        - next_log = log.next_log
 
-        - if log.next_log
-          = link_to 'Next', request.fullpath.sub('/' + log.to_param, '/' + log.next_log.to_param), class: 'btn btn-primary'
+        - if prev_log.present?
+          = link_to 'Prev', request.fullpath.sub('/' + log.to_param, '/' + prev_log.to_param), class: 'btn btn-primary'
+
+        - if next_log.present?
+          = link_to 'Next', request.fullpath.sub('/' + log.to_param, '/' + next_log.to_param), class: 'btn btn-primary'
 
   .panel-body.card-body
     .row
       .col-md-6
         %p
           - status_class = bootstrap_class_for_status(log.status)
-          %span{:class => (defined?(EffectiveBootstrap) ? "badge badge-#{status_class}" : "label label-#{status_class}")}= log.status
+          %span{class: (defined?(EffectiveBootstrap) ? "badge badge-#{status_class}" : "label label-#{status_class}")}= log.status
+
           = log.created_at.strftime("%F %H:%M:%S")
           = '(' + time_ago_in_words(log.created_at) + ' ago)'
 
@@ -28,7 +32,8 @@
           %p
             %strong User:
             = (log.user.to_s.starts_with?('#<User:0x') ? (log.user.email rescue log.user) : log.user)
-        - if (log.associated.present? rescue false)
+
+        - if log.associated_id.present? && log.associated_type.present? && (log.associated.present? rescue false)
           %p
             %strong Associated:
             - if log.associated.to_s.starts_with?('#<')
@@ -40,14 +45,11 @@
       - next unless value.present?
       .row
         .col-md-12
-          %p
+          .mt-3
             %strong= "#{key.to_s.titleize}:"
           = format_log_details_value(log, key)
 
     - if log.logs.present?
       %hr
       %p This log contains #{log.logs_count} additional sub entries:
-
-      - unless log.datatable.nil?
-        = render_datatable(log.datatable)
-
+      = render_datatable(log.child_logs_datatable)

data/config/effective_logging.rb

@@ -2,37 +2,11 @@ EffectiveLogging.setup do |config|
   # Configure Database Tables
   config.logs_table_name = :logs
 
-  # Authorization Method
-  #
-  # This method is called by all controller actions with the appropriate action and resource
-  # If the method returns false, an Effective::AccessDenied Error will be raised (see README.md for complete info)
-  #
-  # Use via Proc (and with CanCan):
-  # config.authorization_method = Proc.new { |controller, action, resource| can?(action, resource) }
-  #
-  # Use via custom method:
-  # config.authorization_method = :my_authorization_method
-  #
-  # And then in your application_controller.rb:
-  #
-  # def my_authorization_method(action, resource)
-  #   current_user.is?(:admin)
-  # end
-  #
-  # Or disable the check completely:
-  # config.authorization_method = false
-  config.authorization_method = Proc.new { |controller, action, resource| authorize!(action, resource) } # CanCanCan
-
   # Admin Screens Layout Settings
-  config.layout = 'application'   # All EffectiveLogging controllers will use this layout
-
-  # config.layout = {
-  #   logs: 'application',
-  #   admin_logs: 'admin',
-  # }
+  # config.layout = { application: 'application', admin: 'admin' }
 
   # EffectiveLogger.info('my message') macros
-  # The following statuses are already present: info, success, error, view, change, email, sign_in, sign_out
+  # The following exist: info, success, error, view, change, download, email, sign_in, sign_out
   # Add more here
   config.additional_statuses = []
 
@@ -40,6 +14,9 @@ EffectiveLogging.setup do |config|
   #### Automatic Logging Functionality ####
   #########################################
 
+  # Log all active storage downloads
+  config.active_storage_enabled = true
+
   # Log all sent emails
   config.email_enabled = true
 

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

@@ -3,6 +3,7 @@ class CreateEffectiveLogging < ActiveRecord::Migration[4.2]
     create_table <%= @logs_table_name %> do |t|
       t.integer       :parent_id
 
+      t.string        :user_type
       t.integer       :user_id
 
       t.string        :changes_to_type

data/lib/effective_logging.rb

@@ -3,53 +3,34 @@ require 'effective_logging/engine'
 require 'effective_logging/version'
 
 module EffectiveLogging
-
-  # The following are all valid config keys
-  mattr_accessor :logs_table_name
-
-  mattr_accessor :authorization_method
-  mattr_accessor :layout
-  mattr_accessor :additional_statuses
-
-  mattr_accessor :email_enabled
-  mattr_accessor :sign_in_enabled
-  mattr_accessor :sign_out_enabled
-
   mattr_accessor :supressed
 
-  def self.setup
-    yield self
+  def self.config_keys
+    [
+      :logs_table_name, :layout, :additional_statuses,
+      :active_storage_enabled, :email_enabled, :sign_in_enabled, :sign_out_enabled
+    ]
   end
 
-  def self.authorized?(controller, action, resource)
-    @_exceptions ||= [Effective::AccessDenied, (CanCan::AccessDenied if defined?(CanCan)), (Pundit::NotAuthorizedError if defined?(Pundit))].compact
-
-    return !!authorization_method unless authorization_method.respond_to?(:call)
-    controller = controller.controller if controller.respond_to?(:controller)
-
-    begin
-      !!(controller || self).instance_exec((controller || self), action, resource, &authorization_method)
-    rescue *@_exceptions
-      false
-    end
-  end
-
-  def self.authorize!(controller, action, resource)
-    raise Effective::AccessDenied unless authorized?(controller, action, resource)
-  end
-
-  def self.supressed(&block)
-    @@supressed = true; yield; @@supressed = false
-  end
-
-  def self.supressed?
-    @@supressed == true
-  end
+  include EffectiveGem
 
   def self.statuses
     @statuses ||= (
-      Array(@@additional_statuses).map { |status| status.to_s.downcase } |  # union
-      ['info', 'success', 'error', 'view', log_changes_status, ('email' if email_enabled), ('sign_in' if sign_in_enabled), ('sign_out' if sign_out_enabled)].compact
+      base = [
+        'info',
+        'success',
+        'error',
+        'view',
+        log_changes_status, # 'change'
+        ('download' if active_storage_enabled),
+        ('email' if email_enabled),
+        ('sign_in' if sign_in_enabled),
+        ('sign_out' if sign_out_enabled)
+      ].compact
+
+      additional = Array(additional_statuses).map { |status| status.to_s.downcase }
+
+      base | additional # union
     )
   end
 
@@ -59,11 +40,21 @@ module EffectiveLogging
 
   # This is set by the "set_effective_logging_current_user" before_filter.
   def self.current_user=(user)
-    @effective_logging_current_user = user
+    Thread.current[:effective_logging_current_user] = user
   end
 
   def self.current_user
-    @effective_logging_current_user
+    Thread.current[:effective_logging_current_user]
+  end
+
+  def self.supressed(&block)
+    Thread.current[:effective_logging_supressed] = true
+    yield
+    Thread.current[:effective_logging_supressed] = nil
+  end
+
+  def self.supressed?
+    Thread.current[:effective_logging_supressed] == true
   end
 
 end

data/lib/effective_logging/active_storage_logger.rb

@@ -0,0 +1,23 @@
+module EffectiveLogging
+  module ActiveStorageLogger
+
+    def track_downloads
+      user = current_user if respond_to?(:current_user)
+
+      key = decode_verified_key()
+      return unless key.present?
+
+      blob = ActiveStorage::Blob.where(key: key[:key]).first
+      return unless blob.present?
+
+      blob.attachments.each do |attachment|
+        associated = attachment.record
+        filename = blob.filename.to_s
+        message = [associated.to_s, filename.to_s].uniq.join(' ')
+
+        EffectiveLogger.download(message, associated: associated, filename: filename, user: user)
+      end
+    end
+
+  end
+end

data/lib/effective_logging/email_logger.rb

@@ -5,30 +5,56 @@ module EffectiveLogging
       return unless message.present?
 
       # collect a Hash of arguments used to invoke EffectiveLogger.success
-      logged_fields = { from: message.from.join(','), to: message.to, subject: message.subject }
+      fields = { from: message.from.join(','), to: message.to, subject: message.subject, cc: message.cc, bcc: message.bcc }
 
       # 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: { 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) || {})
+        fields.merge!(message.header['log'].instance_variable_get(:@value) || {})
 
         # Get rid of the extra header, as it should not be set in the real mail message.
         message.header['log'] = nil
       end
 
+      # Pass a tenant to your mailer
+      # mail(to: 'admin@example.com', subject: @post.title, tenant: Tenant.current)
+      tenant = if message.header['tenant'].present?
+        value = message.header['tenant'].to_s.to_sym # OptionalField, not a String here
+        message.header['tenant'] = nil
+        value
+      end || (Tenant.current if defined?(Tenant))
+
+      user_klass = "#{tenant.to_s.classify}::User".safe_constantize
+
       body = (message.body.try(:parts) || []).find { |part| part.content_type.to_s.downcase.include?('text/html') }
+      body ||= message.body
 
-      logged_fields[:email] = "#{message.header}<hr>#{(body.presence || message.body)}"
+      fields[:email] = "#{message.header}<hr>#{body}"
 
-      (message.to || []).each do |to|
-        user = (User.where(email: to).first rescue nil)
+      if tenant.present?
+        Tenant.as(tenant) { log_email(message, fields, user_klass) }
+      else
+        log_email(message, fields, user_klass)
+      end
+
+      true
+    end
 
-        logged_fields[:to] = to
-        logged_fields[:associated] ||= user
-        logged_fields[:user] ||= user
+    private
+
+    def self.log_email(message, fields, user_klass)
+      tos = Array(message.to) - [nil, '']
+
+      tos.each do |to|
+        user = (user_klass.where(email: to.downcase).first if user_klass.present?)
+
+        user_fields = fields.merge(to: to, user: user, associated: user)
+        ::EffectiveLogger.email("#{message.subject} - #{tos.join(', ')}", user_fields)
+      end
 
-        ::EffectiveLogger.email("#{message.subject} - #{message.to.join(', ')}", logged_fields)
+      if tos.blank? && (message.cc.present? || message.bcc.present?)
+        ::EffectiveLogger.email("#{message.subject} - multiple recipients", fields)
       end
     end
 

data/lib/effective_logging/engine.rb

@@ -1,4 +1,5 @@
 require 'effective_logging/active_record_logger'
+require 'effective_logging/active_storage_logger'
 require 'effective_logging/email_logger'
 require 'effective_logging/log_page_views'
 require 'effective_logging/set_current_user'
@@ -27,6 +28,16 @@ module EffectiveLogging
       end
     end
 
+    # Log all ActiveStorage downloads
+    initializer 'effective_logging.active_storage' do |app|
+      if EffectiveLogging.active_storage_enabled == true && defined?(ActiveStorage)
+        Rails.application.config.to_prepare do
+          ActiveStorage::DiskController.include(EffectiveLogging::ActiveStorageLogger)
+          ActiveStorage::DiskController.class_eval { after_action(:track_downloads, only: :show) }
+        end
+      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|
       Rails.application.config.to_prepare do

data/lib/effective_logging/log_page_views.rb

@@ -39,7 +39,7 @@ module EffectiveLogging
         return if @_effective_logging_skip_log_page_view == true
         return if (self.class.log_page_views_opts[:skip_namespace] || []).include?(self.class.parent)
 
-        user = EffectiveLogging.current_user || current_user
+        user = EffectiveLogging.current_user || (current_user if respond_to?(:current_user))
 
         if self.class.log_page_views_opts[:details] == false
           ::EffectiveLogger.view("#{request.request_method} #{request.path}", user: user)
@@ -66,4 +66,3 @@ module EffectiveLogging
 
   end
 end
-

data/lib/effective_logging/set_current_user.rb

@@ -3,11 +3,16 @@ module EffectiveLogging
     module ActionController
 
       # Add me to your ApplicationController
-      # before_action :set_effective_logging_current_user
+      # around_action :set_effective_logging_current_user
 
       def set_effective_logging_current_user
         EffectiveLogging.current_user = current_user
-        yield if block_given?
+
+        if block_given?
+          retval = yield
+          EffectiveLogging.current_user = nil
+          retval
+        end
       end
 
     end

data/lib/effective_logging/version.rb

@@ -1,3 +1,3 @@
 module EffectiveLogging
-  VERSION = '3.0.10'.freeze
+  VERSION = '3.1.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_logging
 version: !ruby/object:Gem::Version
-  version: 3.0.10
+  version: 3.1.1
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-08 00:00:00.000000000 Z
+date: 2021-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -98,10 +98,8 @@ files:
 - app/datatables/effective_logs_datatable.rb
 - app/helpers/effective_logging_helper.rb
 - app/models/concerns/acts_as_loggable.rb
-- app/models/effective/access_denied.rb
 - app/models/effective/log.rb
 - app/models/effective_logger.rb
-- app/views/admin/logs/_actions.html.haml
 - app/views/admin/logs/index.html.haml
 - app/views/admin/logs/show.html.haml
 - app/views/effective/logs/_log.html.haml
@@ -112,6 +110,7 @@ files:
 - db/migrate/01_create_effective_logging.rb.erb
 - lib/effective_logging.rb
 - lib/effective_logging/active_record_logger.rb
+- lib/effective_logging/active_storage_logger.rb
 - lib/effective_logging/email_logger.rb
 - lib/effective_logging/engine.rb
 - lib/effective_logging/log_page_views.rb

data/app/models/effective/access_denied.rb

@@ -1,17 +0,0 @@
-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/views/admin/logs/_actions.html.haml

@@ -1,8 +0,0 @@
-- show_path = (datatable.admin_namespace? ? effective_logging.admin_log_path(log) : effective_logging.log_path(log))
-
-- if defined?(EffectiveBootstrap)
-  = dropdown(variation: :dropleft) do
-    = dropdown_link_to 'View', show_path
-- else
-  = link_to show_path, title: 'View' do
-    %span.glyphicon.glyphicon-eye-open