sapience 0.1.1 → 0.1.2

data/lib/sapience/appender/wrapper.rb

@@ -38,6 +38,7 @@ module Sapience
       #    logger =  Sapience['test']
       #    logger.info('Hello World', some: :payload)
       #
+      # rubocop:disable LineLength
       def initialize(options, &block)
         # Backward compatibility
         options = { logger: options } unless options.is_a?(Hash)
@@ -45,20 +46,20 @@ module Sapience
         @logger = options.delete(:logger)
 
         # Check if the custom appender responds to all the log levels. For example Ruby ::Logger
-        if does_not_implement = LEVELS[1..-1].find { |i| !@logger.respond_to?(i) }
-          fail(ArgumentError, "Supplied logger does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}")
+        if (does_not_implement = LEVELS[1..-1].find { |i| !@logger.respond_to?(i) })
+          fail ArgumentError, "Supplied logger does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}"
         end
 
-        fail "Sapience::Appender::Wrapper missing mandatory parameter :logger" unless @logger
+        fail ArgumentError, "Sapience::Appender::Wrapper missing mandatory parameter :logger" unless @logger
         super(options, &block)
       end
+      # rubocop:enable LineLength
 
       # Pass log calls to the underlying Rails, log4j or Ruby logger
       #  trace entries are mapped to debug since :trace is not supported by the
       #  Ruby or Rails Loggers
       def log(log)
         return false unless should_log?(log)
-
         @logger.send(log.level == :trace ? :debug : log.level, formatter.call(log, self))
         true
       end

data/lib/sapience/base.rb

@@ -1,4 +1,5 @@
 module Sapience
+  # rubocop:disable ClassLength
   class Base
     # Class name to be logged
     attr_accessor :name, :filter
@@ -176,7 +177,7 @@ module Sapience
 
     # Write log data to underlying data storage
     def log(_log_)
-      raise NotImplementedError.new('Logging Appender must implement #log(log)')
+      fail NotImplementedError, "Logging Appender must implement #log(log)"
     end
 
     private
@@ -198,10 +199,11 @@ module Sapience
     #    regular expression. All other messages will be ignored
     #    Proc: Only include log messages where the supplied Proc returns true
     #          The Proc must return true or false
-    def initialize(klass, level = nil, filter = nil) # rubocop:disable AbcSize, PerceivedComplexity, CyclomaticComplexity
+    # rubocop:disable AbcSize, PerceivedComplexity, CyclomaticComplexity, LineLength
+    def initialize(klass, level = nil, filter = nil)
       # Support filtering all messages to this logger using a Regular Expression
       # or Proc
-      raise ':filter must be a Regexp or Proc' unless filter.nil? || filter.is_a?(Regexp) || filter.is_a?(Proc)
+      fail ArgumentError, ":filter must be a Regexp or Proc" unless filter.nil? || filter.is_a?(Regexp) || filter.is_a?(Proc)
 
       @filter = filter.is_a?(Regexp) ? filter.freeze : filter
       @name   = klass.is_a?(String) ? klass : klass.name
@@ -213,6 +215,7 @@ module Sapience
         self.level = level
       end
     end
+    # rubocop:enable AbcSize, PerceivedComplexity, CyclomaticComplexity, LineLength
 
     # Return the level index for fast comparisons
     # Returns the global default level index if the level has not been explicitly
@@ -226,7 +229,7 @@ module Sapience
       return true if @filter.nil?
 
       if @filter.is_a?(Regexp)
-        (@filter =~ log.name) != nil
+        !(@filter =~ log.name).nil?
       elsif @filter.is_a?(Proc)
         @filter.call(log) == true
       end
@@ -239,7 +242,8 @@ module Sapience
     end
 
     # Log message at the specified level
-    def log_internal(level, index, message = nil, payload = nil, exception = nil) # rubocop:disable AbcSize, PerceivedComplexity, CyclomaticComplexity
+    # rubocop:disable AbcSize, PerceivedComplexity, CyclomaticComplexity, LineLength
+    def log_internal(level, index, message = nil, payload = nil, exception = nil)
       # Exception being logged?
       if exception.nil? && payload.nil? && message.respond_to?(:backtrace) && message.respond_to?(:message)
         exception = message
@@ -281,7 +285,7 @@ module Sapience
         log.message       = payload.delete(:message)
         log.metric        = payload.delete(:metric)
         log.metric_amount = payload.delete(:metric_amount) || 1
-        if duration = payload.delete(:duration)
+        if (duration = payload.delete(:duration))
           return false if duration <= min_duration
           log.duration = duration
         end
@@ -290,8 +294,9 @@ module Sapience
 
       self.log(log) if include_message?(log)
     end
+    # rubocop:enable AbcSize, PerceivedComplexity, CyclomaticComplexity, LineLength
 
-    SELF_PATTERN = File.join('lib', 'sapience')
+    SELF_PATTERN = File.join("lib", "sapience")
 
     # Extract the callers backtrace leaving out Sapience
     def extract_backtrace
@@ -303,13 +308,14 @@ module Sapience
     end
 
     # Measure the supplied block and log the message
-    def measure_internal(level, index, message, params) # rubocop:disable AbcSize, PerceivedComplexity, CyclomaticComplexity
+    # rubocop:disable AbcSize, PerceivedComplexity, CyclomaticComplexity, LineLength
+    def measure_internal(level, index, message, params)
       start     = Time.now
       exception = nil
       begin
         if block_given?
           result    =
-            if silence_level = params[:silence]
+            if (silence_level = params[:silence])
               # In case someone accidentally sets `silence: true` instead of `silence: :error`
               silence_level = :error if silence_level == true
               silence(silence_level) { yield(params) }
@@ -333,7 +339,7 @@ module Sapience
           if block_given?
             1000.0 * (end_time - start)
           else
-            params[:duration] || fail('Mandatory block missing when :duration option is not supplied')
+            params[:duration] || fail("Mandatory block missing when :duration option is not supplied")
           end
 
         # Add scoped payload
@@ -364,18 +370,20 @@ module Sapience
             logged_exception = nil
             backtrace        = exception.backtrace
           end
-          log = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, logged_exception, metric, backtrace)
+          log = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, logged_exception, metric, backtrace) # rubocop:disable LineLength
           self.log(log) if include_message?(log)
-          raise exception
+          fail exception
         elsif duration >= min_duration
           # Only log if the block took longer than 'min_duration' to complete
           # Add caller stack trace
           backtrace = extract_backtrace if index >= Sapience.config.backtrace_level_index
 
-          log = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, nil, metric, backtrace)
+          log = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, nil, metric, backtrace) # rubocop:disable LineLength
           self.log(log) if include_message?(log)
         end
       end
     end
+    # rubocop:enable AbcSize, PerceivedComplexity, CyclomaticComplexity, LineLength
   end
+  # rubocop:enable ClassLength
 end

data/lib/sapience/config_loader.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+require "erb"
+
+module Sapience
+  # This class represents the configuration of the RuboCop application
+  # and all its cops. A Config is associated with a YAML configuration
+  # file from which it was read. Several different Configs can be used
+  # during a run of the sapience program, if files in several
+  # directories are inspected.
+  module ConfigLoader
+    SAPIENCE_FILE = "sapience.yml".freeze
+    SAPIENCE_HOME = File.realpath(File.join(File.dirname(__FILE__), "..", ".."))
+    DEFAULT_FILE  = File.join(SAPIENCE_HOME, "config", "default.yml")
+
+    def self.load_from_file
+      file_path = config_file_path
+      path = File.absolute_path(file_path)
+      load_yaml_configuration(path)
+    end
+
+    class << self
+      private
+
+      def config_file_path
+        return application_config_file if File.exist?(application_config_file)
+
+        DEFAULT_FILE
+      end
+
+      def application_config_file
+        File.join(Rack::Directory.new("").root, "config", SAPIENCE_FILE)
+      end
+
+      def load_yaml_configuration(absolute_path)
+        text      = IO.read(absolute_path, encoding: "UTF-8")
+        erb       = ERB.new(text)
+        yaml_code = erb.result
+
+        hash = yaml_safe_load(yaml_code, absolute_path) || {}
+
+        unless hash.is_a?(Hash)
+          fail(TypeError, "Malformed configuration in #{absolute_path}")
+        end
+
+        hash
+      end
+
+      def yaml_safe_load(yaml_code, filename)
+        if YAML.respond_to?(:safe_load) # Ruby 2.1+
+          if defined?(SafeYAML) && SafeYAML.respond_to?(:load)
+            SafeYAML.load(yaml_code, filename,
+              whitelisted_tags: %w(!ruby/regexp))
+          else
+            YAML.safe_load(yaml_code, [Regexp], [], false, filename)
+          end
+        else
+          YAML.load(yaml_code, filename)
+        end
+      end
+    end
+  end
+end

data/lib/sapience/configuration/grape.rb

@@ -0,0 +1,9 @@
+module Sapience
+  class Configuration
+    class Grape
+      def self.configure
+        Grape::API.send(:include, Sapience::Loggable)
+      end
+    end
+  end
+end

data/lib/sapience/configuration.rb

@@ -1,19 +1,29 @@
 require "ostruct"
 
 module Sapience
+  # rubocop:disable ClassVars
   class Configuration
     attr_reader :default_level, :backtrace_level, :backtrace_level_index
     attr_writer :host
     attr_accessor :application, :ap_options, :appenders
 
-    def initialize
-      # Initial default Level for all new instances of Sapience::Logger
-      self.default_level   = :info
-      self.backtrace_level = :info
-      self.application     = "Sapience"
-      self.host            = nil
-      self.ap_options      = { multiline: false }
-      self.appenders       = [ { file: {io: STDOUT, formatter: :color } } ]
+    DEFAULT = {
+      log_level:   :info,
+      application: "Sapience",
+      host:        nil,
+      ap_options:  { multiline: false },
+      appenders:   [{ file: { io: STDOUT, formatter: :color } }],
+    }.freeze
+
+    # Initial default Level for all new instances of Sapience::Logger
+    def initialize(options = {}) # rubocop:disable AbcSize
+      @options             = DEFAULT.merge(options.deep_symbolize_keys!)
+      self.default_level   = @options[:log_level].to_sym
+      self.backtrace_level = @options[:log_level].to_sym
+      self.application     = @options[:application]
+      self.host            = @options[:host]
+      self.ap_options      = @options[:ap_options]
+      self.appenders       = @options[:appenders]
     end
 
     # Sets the global default log level
@@ -34,22 +44,22 @@ module Sapience
       return if level.nil?
 
       index =
-        if level.is_a?(Symbol)
-          LEVELS.index(level)
-        elsif level.is_a?(String)
-          level = level.downcase.to_sym
-          LEVELS.index(level)
-        elsif level.is_a?(Integer) && defined?(::Logger::Severity)
-          # Mapping of Rails and Ruby Logger levels to Sapience levels
-          @@map_levels ||= begin
-            levels = []
-            ::Logger::Severity.constants.each do |constant|
-              levels[::Logger::Severity.const_get(constant)] = LEVELS.find_index(constant.downcase.to_sym) || LEVELS.find_index(:error)
-            end
-            levels
+      if level.is_a?(Symbol)
+        LEVELS.index(level)
+      elsif level.is_a?(String)
+        level = level.downcase.to_sym
+        LEVELS.index(level)
+      elsif level.is_a?(Integer) && defined?(::Logger::Severity)
+        # Mapping of Rails and Ruby Logger levels to Sapience levels
+        @@map_levels ||= begin
+          levels = []
+          ::Logger::Severity.constants.each do |constant|
+            levels[::Logger::Severity.const_get(constant)] = LEVELS.find_index(constant.downcase.to_sym) || LEVELS.find_index(:error) # rubocop:disable LineLength
           end
-          @@map_levels[level]
+          levels
         end
+        @@map_levels[level]
+      end
       fail "Invalid level:#{level.inspect} being requested. Must be one of #{LEVELS.inspect}" unless index
       index
     end

data/lib/sapience/core_ext/hash.rb

@@ -0,0 +1,25 @@
+class Hash
+  # Returns a Hash with all keys symbolized
+  def deep_symbolize_keys!
+    deep_transform_keys! { |key| key.to_sym rescue key } # rubocop:disable RescueModifier
+  end
+
+  def deep_transform_keys!(&block)
+    _deep_transform_keys_in_object!(self, &block)
+  end
+
+  def _deep_transform_keys_in_object!(object, &block)
+    case object
+    when Hash
+      object.keys.each do |key|
+        value = object.delete(key)
+        object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+      end
+      object
+    when Array
+      object.map! { |e| _deep_transform_keys_in_object!(e, &block) }
+    else
+      object
+    end
+  end
+end

data/lib/sapience/core_ext/thread.rb

@@ -5,10 +5,10 @@ class Thread
   #    String representation of this thread's object_id
   def name
     @name ||= object_id.to_s
-  end unless defined?(:name)
+  end
 
   # Set the name of this thread
   def name=(name)
     @name = name.to_s
-  end unless defined?(:name=)
+  end
 end

data/lib/sapience/extensions/action_cable/tagged_logger_proxy.rb

@@ -0,0 +1,6 @@
+class ActionCable::Connection::TaggedLoggerProxy # rubocop:disable ClassAndModuleChildren
+  def tag(logger, &block)
+    current_tags = tags - logger.tags
+    logger.tagged(*current_tags, &block)
+  end
+end

data/lib/sapience/extensions/action_controller/live.rb

@@ -0,0 +1,6 @@
+# Log actual exceptions, not a string representation
+module ActionController::Live # rubocop:disable ClassAndModuleChildren
+  def log_error(exception)
+    logger.fatal(exception)
+  end
+end

data/lib/sapience/extensions/action_controller/log_subscriber.rb

@@ -0,0 +1,127 @@
+require "action_controller/log_subscriber"
+
+class ActionController::LogSubscriber # rubocop:disable ClassAndModuleChildren
+  # Log as debug to hide Processing messages in production
+  def start_processing(event)
+    controller_logger(event).debug { "Processing ##{event.payload[:action]}" }
+  end
+
+  def process_action(event) # rubocop:disable AbcSize, CyclomaticComplexity, PerceivedComplexity
+    controller_logger(event).info do
+      payload = event.payload.dup
+      payload[:params].except!(*INTERNAL_PARAMS)
+      payload.delete(:params) if payload[:params].empty?
+
+      format           = payload[:format]
+      payload[:format] = format.to_s.upcase if format.is_a?(Symbol)
+
+      payload[:path]   = extract_path(payload[:path]) if payload.key?(:path)
+
+      exception = payload.delete(:exception)
+      if payload[:status].nil? && exception.present?
+        exception_class_name = exception.first
+        payload[:status]     = ActionDispatch::ExceptionWrapper.status_code_for_exception(exception_class_name)
+      end
+
+      # Rounds off the runtimes. For example, :view_runtime, :mongo_runtime, etc.
+      payload.keys.each do |key|
+        payload[key] = payload[key].to_f.round(2) if key.to_s.match(/(.*)_runtime/)
+      end
+
+      payload[:message]        = "Completed ##{payload[:action]}"
+      payload[:status_message] = Rack::Utils::HTTP_STATUS_CODES[payload[:status]] if payload[:status].present?
+      payload[:duration]       = event.duration
+      # Causes excessive log output with Rails 5 RC1
+      payload.delete(:headers)
+      payload
+    end
+  end
+
+  def halted_callback(event)
+    controller_logger(event).info do
+      "Filter chain halted as #{event.payload[:filter].inspect} rendered or redirected"
+    end
+  end
+
+  def send_file(event)
+    controller_logger(event).info("Sent file") { { path: event.payload[:path], duration: event.duration } }
+  end
+
+  def redirect_to(event)
+    controller_logger(event).info("Redirected to") { { location: event.payload[:location] } }
+  end
+
+  def send_data(event)
+    controller_logger(event).info("Sent data") { { file_name: event.payload[:filename], duration: event.duration } }
+  end
+
+  def unpermitted_parameters(event)
+    controller_logger(event).debug do
+      unpermitted_keys = event.payload[:keys]
+      "Unpermitted parameter#{"s" if unpermitted_keys.size > 1}: #{unpermitted_keys.join(", ")}"
+    end
+  end
+
+  private
+
+  # Returns the logger for the supplied event.
+  # Returns ActionController::Base.logger if no controller is present
+  def controller_logger(event)
+    if (controller = event.payload[:controller])
+      begin
+        controller.constantize.logger
+      rescue NameError
+        ActionController::Base.logger
+      end
+    else
+      ActionController::Base.logger
+    end
+  end
+
+  def extract_path(path)
+    index = path.index("?")
+    index ? path[0, index] : path
+  end
+
+  def write_fragment(event)
+    controller_logger(event).info do
+      key_or_path = event.payload[:key] || event.payload[:path]
+      { message: "Write fragment #{key_or_path}", duration: event.duration }
+    end
+  end
+
+  def read_fragment(event)
+    controller_logger(event).info do
+      key_or_path = event.payload[:key] || event.payload[:path]
+      { message: "Read fragment #{key_or_path}", duration: event.duration }
+    end
+  end
+
+  def exist_fragment(event)
+    controller_logger(event).info do
+      key_or_path = event.payload[:key] || event.payload[:path]
+      { message: "Exist fragment #{key_or_path}", duration: event.duration }
+    end
+  end
+
+  def expire_fragment(event)
+    controller_logger(event).info do
+      key_or_path = event.payload[:key] || event.payload[:path]
+      { message: "Expire fragment #{key_or_path}", duration: event.duration }
+    end
+  end
+
+  def expire_page(event)
+    controller_logger(event).info do
+      key_or_path = event.payload[:key] || event.payload[:path]
+      { message: "Expire page #{key_or_path}", duration: event.duration }
+    end
+  end
+
+  def write_page(event)
+    controller_logger(event).info do
+      key_or_path = event.payload[:key] || event.payload[:path]
+      { message: "Write page #{key_or_path}", duration: event.duration }
+    end
+  end
+end

data/lib/sapience/extensions/action_controller/log_subscriber_processing.rb

@@ -0,0 +1,24 @@
+require "action_controller/log_subscriber"
+
+class ActionController::LogSubscriber # rubocop:disable ClassAndModuleChildren
+  # Log as info to show Processing messages in production
+  def start_processing(event)
+    controller_logger(event).info { "Processing ##{event.payload[:action]}" }
+  end
+
+  private
+
+  # Returns the logger for the supplied event.
+  # Returns ActionController::Base.logger if no controller is present
+  def controller_logger(event)
+    if (controller = event.payload[:controller])
+      begin
+        controller.constantize.logger
+      rescue NameError
+        ActionController::Base.logger
+      end
+    else
+      ActionController::Base.logger
+    end
+  end
+end

data/lib/sapience/extensions/action_dispatch/debug_exceptions.rb

@@ -0,0 +1,11 @@
+# Log actual exceptions, not a string representation
+
+class ActionDispatch::DebugExceptions # rubocop:disable ClassAndModuleChildren
+  private
+
+  def log_error(_request, wrapper)
+    ActiveSupport::Deprecation.silence do
+      ActionController::Base.logger.fatal(wrapper.exception)
+    end
+  end
+end

data/lib/sapience/extensions/action_view/log_subscriber.rb

@@ -0,0 +1,9 @@
+class ActionView::LogSubscriber # rubocop:disable ClassAndModuleChildren
+  def info(message = nil, &block)
+    debug(message, &block)
+  end
+
+  def info?
+    debug?
+  end
+end

data/lib/sapience/extensions/action_view/streaming_template_renderer.rb

@@ -0,0 +1,11 @@
+# Log actual exceptions, not a string representation
+
+class ActionView::StreamingTemplateRenderer # rubocop:disable ClassAndModuleChildren
+  class Body
+    private
+
+    def log_error(exception) #:nodoc:
+      ActionView::Base.logger.fatal(exception)
+    end
+  end
+end

data/lib/sapience/extensions/active_job/logging.rb

@@ -0,0 +1,14 @@
+# Patch ActiveJob logger
+require "active_job/logging"
+
+module ActiveJob::Logging # rubocop:disable ClassAndModuleChildren
+  include Sapience::Loggable
+
+  private
+
+  alias_method :tag_logger_old, :tag_logger
+
+  def tag_logger(*tags, &block)
+    logger.tagged(*tags, &block)
+  end
+end

data/lib/sapience/extensions/active_model_serializers/logging.rb

@@ -0,0 +1,14 @@
+# Patch ActiveModelSerializers logger
+require "active_model_serializers/logging"
+
+module ActiveModelSerializers::Logging # rubocop:disable ClassAndModuleChildren
+  include Sapience::Loggable
+
+  private
+
+  alias_method :tag_logger_old, :tag_logger
+
+  def tag_logger(*tags, &block)
+    logger.tagged(*tags, &block)
+  end
+end

data/lib/sapience/extensions/active_record/log_subscriber.rb

@@ -0,0 +1,35 @@
+ActiveRecord::LogSubscriber # rubocop:disable Lint/Void
+
+class ActiveRecord::LogSubscriber # rubocop:disable ClassAndModuleChildren
+  def sql(event) # rubocop:disable AbcSize
+    self.class.runtime += event.duration
+
+    return unless logger.debug?
+
+    payload = event.payload
+    name    = payload[:name]
+    return if IGNORE_PAYLOAD_NAMES.include?(name)
+
+    log = {
+      message:  name,
+      sql:      payload[:sql],
+      duration: event.duration,
+    }
+    unless (payload[:binds] || []).empty?
+      log[:binds] = binds = {}
+      # Changed with Rails 5
+      if Rails.version.to_i >= 5
+        payload[:binds].each do |attr|
+          attr_name, value = render_bind(attr)
+          binds[attr_name] = value
+        end
+      else
+        payload[:binds].each do |col, v|
+          attr_name, value = render_bind(col, v)
+          binds[attr_name] = value
+        end
+      end
+    end
+    debug(log)
+  end
+end