sapience 0.2.4 → 0.2.5

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

@@ -1,127 +1,82 @@
 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/)
+module Sapience
+  module Extensions
+    module ActionController
+      class LogSubscriber < ::ActionController::LogSubscriber # rubocop:disable ClassLength
+        alias_method :orig_start_processing, :start_processing
+        alias_method :orig_process_action, :process_action
+
+        # Log as debug to hide Processing messages in production
+        def start_processing(event)
+          debug { "Processing ##{event.payload[:action]}" }
+        end
+
+        def process_action(event) # rubocop:disable AbcSize, CyclomaticComplexity, PerceivedComplexity
+          return unless logger.info?
+          data      = request(event.payload)
+          data.merge! runtimes(event)
+          data.merge! exception(event.payload)
+          info(data)
+        end
+
+        private
+
+        def request(payload) # rubocop:disable AbcSize
+          {
+            method: payload[:method].upcase,
+            request_path: request_path(payload),
+            format: format(payload),
+            status: payload[:status].to_i,
+            controller: payload[:params]["controller"],
+            action: payload[:params]["action"],
+            host: Sapience.config.host,
+            route: "#{payload[:params].delete("controller")}##{payload[:params]["action"]}",
+            message: "Completed ##{payload[:params].delete("action")}",
+            tags: Sapience.tags,
+            params: payload[:params],
+          }
+        end
+
+        def format(payload)
+          if ::ActionPack::VERSION::MAJOR == 3 && ::ActionPack::VERSION::MINOR == 0
+            payload[:formats].first
+          else
+            payload[:format]
+          end
+        end
+
+        def runtimes(event)
+          {
+            total: event.duration,
+            view: event.payload[:view_runtime],
+            db: event.payload[:db_runtime],
+          }.each_with_object({}) do |(name, runtime), runtimes|
+            runtimes[:runtimes] ||= {}
+            runtimes[:runtimes][name] = runtime.to_f.round(2) if runtime
+            runtimes
+          end
+        end
+
+        # Monkey patching to enable exception logging
+        def exception(payload)
+          if payload[:exception]
+            exception, message = payload[:exception]
+            message ||= exception.message
+            status = ActionDispatch::ExceptionWrapper.status_code_for_exception(exception)
+            backtrace = $ERROR_INFO.try(:backtrace).try(:first)
+            backtrace ||= exception.backtrace.first
+            message = "#{exception}\n#{message}\n#{backtrace}"
+            { status: status, error: message }
+          else
+            {}
+          end
+        end
+
+        def request_path(payload)
+          payload[:path].split("?").first
+        end
       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_dispatch/debug_exceptions.rb

@@ -3,6 +3,8 @@
 class ActionDispatch::DebugExceptions # rubocop:disable ClassAndModuleChildren
   private
 
+  alias_method :orig_log_error, :log_error
+
   def log_error(_request, wrapper)
     ActiveSupport::Deprecation.silence do
       ActionController::Base.logger.fatal(wrapper.exception)

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

@@ -1,9 +1,19 @@
-class ActionView::LogSubscriber # rubocop:disable ClassAndModuleChildren
-  def info(message = nil, &block)
-    debug(message, &block)
-  end
+require "action_view/log_subscriber"
+
+module Sapience
+  module Extensions
+    module ActionView
+      class LogSubscriber < ::ActionView::LogSubscriber
+        include Sapience::Loggable
+
+        def info(message = nil, &block)
+          logger.debug(message, &block)
+        end
 
-  def info?
-    debug?
+        def info?
+          logger.debug?
+        end
+      end
+    end
   end
 end

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

@@ -4,6 +4,8 @@ class ActionView::StreamingTemplateRenderer # rubocop:disable ClassAndModuleChil
   class Body
     private
 
+    alias_method :log_error_original, :log_error
+
     def log_error(exception) #:nodoc:
       ActionView::Base.logger.fatal(exception)
     end

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

@@ -6,7 +6,7 @@ module ActiveJob::Logging # rubocop:disable ClassAndModuleChildren
 
   private
 
-  alias_method :tag_logger_old, :tag_logger
+  alias_method :orig_tag_logger, :tag_logger
 
   def tag_logger(*tags, &block)
     logger.tagged(*tags, &block)

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

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

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

@@ -1,35 +1,51 @@
-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
+require "active_support/notifications"
+require "active_record/log_subscriber"
+
+module Sapience
+  module Extensions
+    module ActiveRecord
+      class LogSubscriber < ::ActiveRecord::LogSubscriber
+        include Sapience::Loggable
+
+        def identity(event)
+          lsevent = logstash_event(event)
+          logger << lsevent.to_json + "\n" if logger && lsevent
         end
-      else
-        payload[:binds].each do |col, v|
-          attr_name, value = render_bind(col, v)
-          binds[attr_name] = value
+        alias_method :sql, :identity
+
+        private
+
+        def logstash_event(event)
+          data = event.payload
+
+          return if "SCHEMA" == data[:name]
+
+          data.merge! runtimes(event)
+          data.merge! extract_sql(data)
+
+          data.merge! tags(data)
+          debug(data)
+        end
+
+        def runtimes(event)
+          if event.duration
+            { duration: event.duration.to_f.round(2) }
+          else
+            {}
+          end
+        end
+
+        def extract_sql(data)
+          { sql: data[:sql].squeeze(" ") }
+        end
+
+        def tags(data)
+          tags = Sapience.tags.dup
+          tags.push("request")
+          tags.push("exception") if data[:exception]
+          { tags: tags }
         end
       end
     end
-    debug(log)
   end
 end

data/lib/sapience/extensions/rails/rack/logger.rb

@@ -1,5 +1,6 @@
 # Replace rack started message with a semantic equivalent
 class Rails::Rack::Logger # rubocop:disable ClassAndModuleChildren
+  alias_method :started_request_message_original, :started_request_message
   def started_request_message(request)
     {
       message: "Started",

data/lib/sapience/extensions/rails/rack/logger_info_as_debug.rb

@@ -13,6 +13,8 @@ class Rails::Rack::Logger # rubocop:disable ClassAndModuleChildren
     end
   end
 
+  alias_method :orig_logger, :logger
+
   def logger
     @logger ||= begin
       logger = Sapience["Rails"]

data/lib/sapience/formatters/color.rb

@@ -62,7 +62,6 @@ module Sapience
         end
         message
       end
-
     end
   end
 end

data/lib/sapience/formatters/default.rb

@@ -35,7 +35,6 @@ module Sapience
         end
         message
       end
-
     end
   end
 end

data/lib/sapience/formatters/json.rb

@@ -16,7 +16,6 @@ module Sapience
         h[:timestamp] = format_time(log.time)
         h.to_json
       end
-
     end
   end
 end

data/lib/sapience/formatters/raw.rb

@@ -6,7 +6,6 @@ module Sapience
       def call(log, logger)
         log.to_h(log_host ? logger.host : nil, log_application ? logger.application : nil)
       end
-
     end
   end
 end

data/lib/sapience/log.rb

@@ -38,7 +38,7 @@ module Sapience
   #   Object supplied when measure_x was called
   #
   # backtrace [Array<String>]
-  #   The backtrace captured at source when the log level >= Sapience.config.backtrace_level
+  #   The backtrace_level captured at source when the log level >= Sapience.config.backtrace_level
   #
   # metric_amount [Numeric]
   #   Used for numeric or counter metrics.
@@ -47,34 +47,17 @@ module Sapience
   # rubocop:disable LineLength
   Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception, :metric, :backtrace, :metric_amount) do
     MAX_EXCEPTIONS_TO_UNWRAP = 5
-    # Call the block for exception and any nested exception
-    def each_exception # rubocop:disable AbcSize, PerceivedComplexity, CyclomaticComplexity
-      # With thanks to https://github.com/bugsnag/bugsnag-ruby/blob/6348306e44323eee347896843d16c690cd7c4362/lib/bugsnag/notification.rb#L81
-      depth      = 0
-      exceptions = []
-      ex         = exception
-      while !ex.nil? && !exceptions.include?(ex) && exceptions.length < MAX_EXCEPTIONS_TO_UNWRAP
-        exceptions << ex
-        yield(ex, depth)
-
-        depth += 1
-        ex    =
-          if ex.respond_to?(:cause) && ex.cause
-            ex.cause
-          elsif ex.respond_to?(:continued_exception) && ex.continued_exception
-            ex.continued_exception
-          elsif ex.respond_to?(:original_exception) && ex.original_exception
-            ex.original_exception
-          end
-      end
-    end
+    MILLISECONDS_IN_SECOND =   1_000
+    MILLISECONDS_IN_MINUTE =  60_000
+    MILLISECONDS_IN_HOUR = 3_600_000
+    MILLISECONDS_IN_DAY = 86_400_000
 
     # Returns [String] the exception backtrace including all of the child / caused by exceptions
     def backtrace_to_s
       trace = ""
       each_exception do |exception, i|
         if i == 0
-          trace = (exception.backtrace || []).join("\n")
+          trace << (exception.backtrace || []).join("\n")
         else
           trace << "\nCause: #{exception.class.name}: #{exception.message}\n#{(exception.backtrace || []).join("\n")}"
         end
@@ -90,19 +73,28 @@ module Sapience
     end
 
     # Returns [String] the duration in human readable form
-    def duration_human # rubocop:disable AbcSize
+    def duration_human # rubocop:disable AbcSize, CyclomaticComplexity, PerceivedComplexity
       return nil unless duration
-      seconds = duration / 1000
-      if seconds >= 86_400.0 # 1 day
-        "#{(seconds / 86_400).to_i}d #{Time.at(seconds).strftime("%-Hh %-Mm")}"
-      elsif seconds >= 3600.0 # 1 hour
-        Time.at(seconds).strftime("%-Hh %-Mm")
-      elsif seconds >= 60.0 # 1 minute
-        Time.at(seconds).strftime("%-Mm %-Ss")
-      elsif seconds >= 1.0 # 1 second
-        format "%.3fs", seconds
+      days, ms    = duration.divmod(MILLISECONDS_IN_DAY)
+      hours, ms   = ms.divmod(MILLISECONDS_IN_HOUR)
+      minutes, ms = ms.divmod(MILLISECONDS_IN_MINUTE)
+      seconds, ms = ms.divmod(MILLISECONDS_IN_SECOND)
+
+      str = ""
+      str << "#{days}d" if days > 0
+      str << " #{hours}h" if hours > 0
+      str << " #{minutes}m" if minutes > 0
+      str << " #{seconds}s" if seconds > 0
+      str << " #{ms}ms" if ms > 0
+
+      if days > 0 || hours > 0 || minutes > 0
+        str.strip
       else
-        duration_to_s
+        if seconds >= 1.0
+          format "%.3fs", duration / MILLISECONDS_IN_SECOND.to_f
+        else
+          duration_to_s
+        end
       end
     end
 
@@ -210,7 +202,7 @@ module Sapience
             message:     exception.message,
             stack_trace: exception.backtrace,
           }
-          root       = root[name]
+          root = root[name]
         end
       end
 
@@ -218,6 +210,33 @@ module Sapience
       h[:metric] = metric if metric
       h
     end
+
+    private
+
+    # Call the block for exception and any nested exception
+    def each_exception # rubocop:disable AbcSize, PerceivedComplexity, CyclomaticComplexity
+      # With thanks to https://github.com/bugsnag/bugsnag-ruby/blob/6348306e44323eee347896843d16c690cd7c4362/lib/bugsnag/notification.rb#L81
+      depth      = 0
+      exceptions = []
+      ex         = exception
+      while !ex.nil? && !exceptions.include?(ex) && exceptions.length < MAX_EXCEPTIONS_TO_UNWRAP
+        exceptions << ex
+        yield(ex, depth)
+
+        depth += 1
+        ex =
+          # continued_exception is only used by REXML
+          # original_exception is deprecated in Rails 5+
+          # Not worth testing to thoroughly?
+          if ex.respond_to?(:cause) && ex.cause
+            ex.cause
+          elsif ex.respond_to?(:continued_exception) && ex.continued_exception
+            ex.continued_exception
+          elsif ex.respond_to?(:original_exception) && ex.original_exception
+            ex.original_exception
+          end
+      end
+    end
   end
   # rubocop:enable LineLength
 end