sapience 0.1.1 → 0.1.2

data/lib/sapience/extensions/grape/middleware/logging.rb

@@ -0,0 +1,91 @@
+require "grape/middleware/base"
+
+module Sapience
+  module Extensions
+    module Grape
+      module Middleware
+        class Logging < ::Grape::Middleware::Base
+          ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            Grape::Timings.append_db_runtime(event)
+          end if defined?(ActiveRecord)
+
+          def initialize(app, options = {})
+            super
+            @logger = @options[:logger]
+          end
+
+          def before
+            reset_db_runtime
+            start_time
+          end
+
+          def after
+            stop_time
+            @logger.info(parameters)
+            nil
+          end
+
+          def call!(env)
+            super
+          end
+
+          protected
+
+          def response
+            super
+          rescue
+            nil
+          end
+
+          def parameters # rubocop:disable AbcSize
+            {
+              status: (response.nil? ? "fail" : response.status),
+              time: {
+                total: total_runtime,
+                db: db_runtime,
+                view: view_runtime,
+              },
+              method: request.request_method,
+              path: request.path,
+              params: request.params,
+              host: request.host,
+              ip: (request.env["HTTP_X_FORWARDED_FOR"] || request.env["REMOTE_ADDR"]),
+              ua: request.env["HTTP_USER_AGENT"],
+            }
+          end
+
+          private
+
+          def request
+            @request ||= ::Rack::Request.new(env)
+          end
+
+          def total_runtime
+            ((stop_time - start_time) * 1000).round(2)
+          end
+
+          def view_runtime
+            total_runtime - db_runtime
+          end
+
+          def db_runtime
+            Grape::Timings.db_runtime.round(2)
+          end
+
+          def reset_db_runtime
+            Grape::Timings.reset_db_runtime
+          end
+
+          def start_time
+            @start_time ||= Time.now
+          end
+
+          def stop_time
+            @stop_time ||= Time.now
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sapience/extensions/grape/timings.rb

@@ -0,0 +1,25 @@
+module Sapience
+  module Extensions
+    module Grape
+      module Timings
+        extend self
+
+        def db_runtime=(value)
+          Thread.current[:grape_db_runtime] = value
+        end
+
+        def db_runtime
+          Thread.current[:grape_db_runtime] ||= 0
+        end
+
+        def reset_db_runtime
+          self.db_runtime = 0
+        end
+
+        def append_db_runtime(event)
+          self.db_runtime += event.duration
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# Replace rack started message with a semantic equivalent
+class Rails::Rack::Logger # rubocop:disable ClassAndModuleChildren
+  def started_request_message(request)
+    {
+      message: "Started",
+      method:  request.request_method,
+      path:    request.filtered_path,
+      ip:      request.ip,
+    }
+  end
+end

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

@@ -0,0 +1,24 @@
+# Drop rack Started message to debug level message
+class Rails::Rack::Logger # rubocop:disable ClassAndModuleChildren
+
+  private
+
+  module Extensions
+    def info(*args, &block)
+      debug(*args, &block)
+    end
+
+    def info?
+      debug?
+    end
+  end
+
+  def logger
+    @logger ||= begin
+      logger = Sapience["Rails"]
+      logger.extend(Extensions)
+      logger
+    end
+  end
+
+end

data/lib/sapience/formatters/color.rb

@@ -1,7 +1,7 @@
 # Load AwesomePrint if available
 begin
   require "awesome_print"
-rescue LoadError
+rescue LoadError # rubocop:disable Lint/HandleExceptions
 end
 
 module Sapience
@@ -33,7 +33,7 @@ module Sapience
         message << "#{level_color}#{log.level_to_s}#{colors::CLEAR} [#{log.process_info}]"
 
         # Tags
-        message << " " << log.tags.collect { |tag| "[#{level_color}#{tag}#{colors::CLEAR}]" }.join(" ") if log.tags && (log.tags.size > 0)
+        message << " " << log.tags.collect { |tag| "[#{level_color}#{tag}#{colors::CLEAR}]" }.join(" ") if log.tags && (log.tags.size > 0) # rubocop:disable LineLength
 
         # Duration
         message << " (#{colors::BOLD}#{log.duration_human}#{colors::CLEAR})" if log.duration
@@ -49,7 +49,7 @@ module Sapience
           payload = log.payload
           message << " -- " <<
             if defined?(AwesomePrint) && payload.respond_to?(:ai)
-              payload.ai(@ai_options) rescue payload.inspect
+              payload.ai(@ai_options) rescue payload.inspect # rubocop:disable RescueModifier
             else
               payload.inspect
             end

data/lib/sapience/formatters/default.rb

@@ -24,7 +24,7 @@ module Sapience
         message << " -- #{log.message}" if log.message
 
         # Payload
-        if payload = log.payload_to_s
+        if (payload = log.payload_to_s)
           message << " -- " << payload
         end
 

data/lib/sapience/grape.rb

@@ -0,0 +1,25 @@
+require "sapience"
+require "sapience/extensions/grape/timings"
+require "sapience/extensions/grape/middleware/logging"
+
+module Grape
+  class API
+    def self.descendants # :nodoc:
+      descendants = []
+      ObjectSpace.each_object(singleton_class) do |k|
+        descendants.unshift k unless k == self
+      end
+      descendants
+    end
+  end
+end
+
+module Sapience
+  class Grape
+    Sapience.configure
+    ::Grape::API.send(:include, Sapience::Loggable)
+    ::Grape::API.descendants.each do |api|
+      api.send(:use, Sapience::Extensions::Grape::Middleware::Logging, logger: Sapience[self])
+    end
+  end
+end

data/lib/sapience/log.rb

@@ -43,6 +43,8 @@ module Sapience
   # metric_amount [Numeric]
   #   Used for numeric or counter metrics.
   #   For example, the number of inquiries or, the amount purchased etc.
+
+  # 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
@@ -84,7 +86,7 @@ module Sapience
     # Returns nil if their is no duration
     def duration_to_s
       return unless duration
-      duration < 10.0 ? "#{"%.3f" % duration}ms" : "#{"%.1f" % duration}ms"
+      format((duration < 10.0 ? "%.3fms" : "%.1fms"), duration)
     end
 
     # Returns [String] the duration in human readable form
@@ -98,7 +100,7 @@ module Sapience
       elsif seconds >= 60.0 # 1 minute
         Time.at(seconds).strftime("%-Mm %-Ss")
       elsif seconds >= 1.0 # 1 second
-        "#{"%.3f" % seconds}s"
+        format "%.3fs", seconds
       else
         duration_to_s
       end
@@ -116,7 +118,7 @@ module Sapience
       file, line = file_name_and_line(true)
       file_name  = " #{file}:#{line}" if file
 
-      "#{$PROCESS_ID}:#{"%.#{thread_name_length}s" % thread_name}#{file_name}"
+      format "#{$PROCESS_ID}:%.#{thread_name_length}s#{file_name}", thread_name
     end
 
     CALLER_REGEXP = /^(.*):(\d+).*/
@@ -129,7 +131,7 @@ module Sapience
 
     # Returns [String, String] the file_name and line_number from the backtrace supplied
     # in either the backtrace or exception
-    def file_name_and_line(short_name = false)
+    def file_name_and_line(short_name = false) # rubocop:disable CyclomaticComplexity
       return unless backtrace || (exception && exception.backtrace)
       stack = backtrace || exception.backtrace
       extract_file_and_line(stack, short_name) if stack && stack.size > 0
@@ -155,7 +157,7 @@ module Sapience
     # Ruby MRI supports micro seconds
     # DEPRECATED
     def formatted_time
-      "#{time.strftime("%Y-%m-%d %H:%M:%S")}.#{"%06d" % (time.usec)}"
+      format("#{time.strftime("%Y-%m-%d %H:%M:%S")}.%06d", time.usec)
     end
 
     # Returns [Hash] representation of this log entry
@@ -217,5 +219,5 @@ module Sapience
       h
     end
   end
-
+  # rubocop:enable LineLength
 end

data/lib/sapience/loggable.rb

@@ -2,26 +2,28 @@ module Sapience
   # rubocop:disable TrivialAccessors
   module Loggable
     def self.included(base)
-      base.class_eval do
-        # Returns [Sapience::Logger] class level logger
-        def self.logger
-          @sapience ||= Sapience[self]
-        end
+      base.send(:extend, Extensions)
+    end
 
-        # Replace instance class level logger
-        def self.logger=(logger)
-          @sapience = logger
-        end
+    # Returns [Sapience::Logger] instance level logger
+    def logger
+      @logger ||= self.class.logger
+    end
 
-        # Returns [Sapience::Logger] instance level logger
-        def logger
-          @sapience ||= self.class.logger
-        end
+    # Replace instance level logger
+    def logger=(logger)
+      @logger = logger
+    end
+
+    module Extensions
+      # Returns [Sapience::Logger] class level logger
+      def logger
+        @logger ||= Sapience[self]
+      end
 
-        # Replace instance level logger
-        def logger=(logger)
-          @sapience = logger
-        end
+      # Replace instance class level logger
+      def logger=(logger)
+        @logger = logger
       end
     end
   end

data/lib/sapience/logger.rb

@@ -32,42 +32,45 @@ module Sapience
       super
     end
 
-    # Returns [Integer] the number of log entries that have not been written
-    # to the appenders
-    #
-    # When this number grows it is because the logging appender thread is not
-    # able to write to the appenders fast enough. Either reduce the amount of
-    # logging, increase the log level, reduce the number of appenders, or
-    # look into speeding up the appenders themselves
-    def self.queue_size
-      queue.size
-    end
-
     # Flush all queued log entries disk, database, etc.
     #  All queued log messages are written and then each appender is flushed in turn
-    def self.flush
-      msg = "Flushing appenders with #{queue_size} log messages on the queue"
-      if queue_size > 1_000
-        logger.warn msg
-      elsif queue_size > 100
-        logger.info msg
-      elsif queue_size > 0
-        logger.trace msg
+    def self.flush # rubocop:disable AbcSize
+      return unless appender_thread
+      appender_thread << lambda do
+        Sapience.appenders.each do |appender|
+          begin
+            logger.trace "Appender thread: Flushing appender: #{appender.name}"
+            appender.flush
+          rescue StandardError => exc
+            logger.error "Appender thread: Failed to flush appender: #{appender.inspect}", exc
+          end
+        end
+
+        logger.trace "Appender thread: All appenders flushed"
       end
-      process_request(:flush)
     end
 
     # Close all appenders and flush any outstanding messages
     def self.close
-      msg = "Closing appenders with #{queue_size} log messages on the queue"
-      if queue_size > 1_000
-        logger.warn msg
-      elsif queue_size > 100
-        logger.info msg
-      elsif queue_size > 0
-        logger.trace msg
+      return unless appender_thread
+      appender_thread << lambda do
+        Sapience.appenders.each do |appender|
+          begin
+            close_appender(appender)
+          rescue StandardError => exc
+            logger.error "Appender thread: Failed to close appender: #{appender.inspect}", exc
+          end
+        end
+
+        logger.trace "Appender thread: All appenders flushed"
       end
-      process_request(:close)
+    end
+
+    def self.close_appender(appender)
+      logger.trace "Appender thread: Closing appender: #{appender.name}"
+      appender.flush
+      appender.close
+      Sapience.remove_appender(appender)
     end
 
     @@lag_check_interval = 5000
@@ -104,25 +107,25 @@ module Sapience
     def log(log, message = nil, progname = nil, &block)
       # Compatibility with ::Logger
       return add(log, message, progname, &block) unless log.is_a?(Sapience::Log)
-      self.class.queue << log if @@appender_thread
+      @@appender_thread.post(log) do |log_message|
+        Sapience.appenders.each do |appender|
+          begin
+            appender.log(log_message)
+          rescue StandardError => exc
+            logger.error "Appender thread: Failed to log to appender: #{appender.inspect}", exc
+          end
+        end
+      end if @@appender_thread
     end
 
-    private
-
-    @@appender_thread    = nil
-    @@queue              = Queue.new
-
-    # Queue to hold messages that need to be logged to the various appenders
-    def self.queue
-      @@queue
-    end
+    @@appender_thread = nil
 
     # Internal logger for Sapience
     #   For example when an appender is not working etc..
     #   By default logs to STDERR
     def self.logger
       @@logger ||= begin
-        l      = Sapience::Appender::File.new(STDERR, :warn)
+        l      = Sapience::Appender::File.new(io: STDERR, level: :warn)
         l.name = name
         l
       end
@@ -131,106 +134,23 @@ module Sapience
     # Start the appender thread
     def self.start_appender_thread
       return false if appender_thread_active?
-      @@appender_thread = Thread.new { appender_thread }
+
+      @@appender_thread = Concurrent::SingleThreadExecutor.new
       fail "Failed to start Appender Thread" unless @@appender_thread
       true
     end
 
     # Returns true if the appender_thread is active
     def self.appender_thread_active?
-      @@appender_thread && @@appender_thread.alive?
+      @@appender_thread && @@appender_thread.running?
     end
 
     # Separate appender thread responsible for reading log messages and
     # calling the appenders in it's thread
     # rubocop:disable BlockNesting, AssignmentInCondition, PerceivedComplexity, CyclomaticComplexity, AbcSize, LineLength, RescueException
     def self.appender_thread
-      # This thread is designed to never go down unless the main thread terminates
-      # Before terminating at_exit is used to flush all the appenders
-      #
-      # Should any appender fail to log or flush, the exception is logged and
-      # other appenders will still be called
-      Thread.current.name = "Sapience::AppenderThread"
-      logger.trace "V#{VERSION} Appender thread active"
-      begin
-        count = 0
-        while message = queue.pop
-          if message.is_a?(Log)
-            Sapience.appenders.each do |appender|
-              begin
-                appender.log(message)
-              rescue Exception => exc
-                logger.error "Appender thread: Failed to log to appender: #{appender.inspect}", exc
-              end
-            end
-            count += 1
-            # Check every few log messages whether this appender thread is falling behind
-            if count > lag_check_interval
-              if (diff = Time.now - message.time) > lag_threshold_s
-                logger.warn "Appender thread has fallen behind by #{diff} seconds with #{queue_size} messages queued up. Consider reducing the log level or changing the appenders"
-              end
-              count = 0
-            end
-          else
-            case message[:command]
-            when :flush
-              Sapience.appenders.each do |appender|
-                begin
-                  logger.trace "Appender thread: Flushing appender: #{appender.name}"
-                  appender.flush
-                rescue Exception => exc
-                  logger.error "Appender thread: Failed to flush appender: #{appender.inspect}", exc
-                end
-              end
-
-              message[:reply_queue] << true if message[:reply_queue]
-              logger.trace "Appender thread: All appenders flushed"
-            when :close
-              Sapience.appenders.each do |appender|
-                begin
-                  logger.trace "Appender thread: Closing appender: #{appender.name}"
-                  appender.flush
-                  appender.close
-                  Sapience.remove_appender(appender)
-                rescue Exception => exc
-                  logger.error "Appender thread: Failed to close appender: #{appender.inspect}", exc
-                end
-              end
-
-              message[:reply_queue] << true if message[:reply_queue]
-              logger.trace "Appender thread: All appenders flushed"
-            else
-              logger.warn "Appender thread: Ignoring unknown command: #{message[:command]}"
-            end
-          end
-        end
-      rescue Exception => exception
-        # This block may be called after the file handles have been released by Ruby
-        begin
-          logger.error "Appender thread restarting due to exception", exception
-        rescue Exception
-          nil
-        end
-        retry
-      ensure
-        @@appender_thread = nil
-        # This block may be called after the file handles have been released by Ruby
-        begin
-          logger.trace "Appender thread has stopped"
-        rescue Exception
-          nil
-        end
-      end
+      @@appender_thread
     end
     # rubocop:enable BlockNesting, AssignmentInCondition, PerceivedComplexity, CyclomaticComplexity, AbcSize, LineLength, RescueException
-
-    # Close all appenders and flush any outstanding messages
-    def self.process_request(command)
-      return false unless appender_thread_active?
-
-      reply_queue = Queue.new
-      queue << { command: command, reply_queue: reply_queue }
-      reply_queue.pop
-    end
   end
 end

data/lib/sapience/rails.rb

@@ -1,15 +1,72 @@
+require "sapience"
+
 module Sapience
   class Rails < ::Rails::Engine
+
+    # Replace Rails logger initializer
     ::Rails::Application::Bootstrap.initializers.delete_if { |i| i.name == :initialize_logger }
+
     initializer :initialize_logger, group: :all do
-      # TODO: Is this really needed?
-      # Existing loggers are ignored because servers like trinidad supply their
-      # own file loggers which would result in duplicate logging to the same log file
-      # ::Rails.logger = config.logger = begin
-      #   Sapience[::Rails]
-      # end
-
-      # Replace Rails loggers
+      Sapience.configure
+      ::Rails.logger = Sapience[::Rails]
+      [:active_record, :action_controller, :action_mailer, :action_view].each do |name|
+        ActiveSupport.on_load(name) { include Sapience::Loggable }
+      end
+      ActiveSupport.on_load(:action_cable) { self.logger = Sapience["ActionCable"] }
+    end
+
+    # Before any initializers run, but after the gems have been loaded
+    config.before_initialize do
+      # Replace the Mongoid Logger
+      Mongoid.logger              = Sapience[Mongoid] if defined?(Mongoid)
+      Moped.logger                = Sapience[Moped] if defined?(Moped)
+
+      # Replace the Resque Logger
+      Resque.logger               = Sapience[Resque] if defined?(Resque) && Resque.respond_to?(:logger)
+
+      # Replace the Sidekiq logger
+      Sidekiq::Logging.logger     = Sapience[Sidekiq] if defined?(Sidekiq)
+
+      # Replace the Sidetiq logger
+      Sidetiq.logger              = Sapience[Sidetiq] if defined?(Sidetiq)
+
+      # Replace the Raven logger
+      # Raven::Configuration.logger = Sapience[Raven::Configuration] if defined?(Raven::Configuration)
+      Raven.send(:include) { Sapience::Loggable }
+
+      # Replace the Sneakers logger
+      Sneakers.logger             = Sapience[Sneakers] if defined?(Sneakers)
+
+      # Replace the Bugsnag logger
+      Bugsnag.configure { |config| config.logger = Sapience[Bugsnag] } if defined?(Bugsnag)
+
+      # Set the logger for concurrent-ruby
+      Concurrent.global_logger = Sapience[Concurrent] if defined?(Concurrent)
+
+      # Rails Patches
+      Kernel.require "sapience/extensions/action_cable/tagged_logger_proxy" if defined?(ActionCable)
+      Kernel.require "sapience/extensions/action_controller/live" if defined?(ActionController::Live)
+      Kernel.require "sapience/extensions/action_dispatch/debug_exceptions" if defined?(ActionDispatch::DebugExceptions)
+      if defined?(ActionView::StreamingTemplateRenderer::Body)
+        Kernel.require "sapience/extensions/action_view/streaming_template_renderer"
+      end
+      Kernel.require "sapience/extensions/active_job/logging" if defined?(ActiveJob)
+      Kernel.require "sapience/extensions/active_model_serializers/logging" if defined?(ActiveModelSerializers)
+      Kernel.require "sapience/extensions/action_controller/log_subscriber" if defined?(ActionController)
+      Kernel.require "sapience/extensions/active_record/log_subscriber" if defined?(ActiveRecord::LogSubscriber)
+      Kernel.require "sapience/extensions/rails/rack/logger" if defined?(::Rails::Rack::Logger)
+      Kernel.require "sapience/extensions/rails/rack/logger_info_as_debug" if defined?(::Rails::Rack::Logger)
+      Kernel.require "sapience/extensions/action_view/log_subscriber" if defined?(ActionView::LogSubscriber)
+      if defined?(ActionView::LogSubscriber)
+        Kernel.require "sapience/extensions/action_controller/log_subscriber_processing"
+      end
+    end
+
+    # Before any initializers run, but after the gems have been loaded
+    config.after_initialize do
+      # Replace the Bugsnag logger
+      Bugsnag.configure { |config| config.logger = Sapience[Bugsnag] } if defined?(Bugsnag)
     end
+
   end
 end