rails_semantic_logger 4.2.1 → 4.3.0

data/lib/rails_semantic_logger/delayed_job/plugin.rb

@@ -0,0 +1,11 @@
+module RailsSemanticLogger
+  module DelayedJob
+    class Plugin < Delayed::Plugin
+      callbacks do |lifecycle|
+        lifecycle.before(:execute) do |job, &block|
+          ::SemanticLogger.reopen
+        end
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/engine.rb

@@ -1,3 +1,6 @@
+require 'active_record/log_subscriber'
+require 'action_controller/log_subscriber'
+
 module RailsSemanticLogger
   class Engine < ::Rails::Engine
     # Make the SemanticLogger config available in the Rails application config
@@ -16,22 +19,22 @@ module RailsSemanticLogger
     #   end
     config.semantic_logger = ::SemanticLogger
 
-    config.rails_semantic_logger                   = ActiveSupport::OrderedOptions.new
+    config.rails_semantic_logger = ActiveSupport::OrderedOptions.new
 
     # Convert Action Controller and Active Record text messages to semantic data
     #   Rails -- Started -- { :ip => "127.0.0.1", :method => "GET", :path => "/dashboards/inquiry_recent_activity" }
     #   UserController -- Completed #index -- { :action => "index", :db_runtime => 54.64, :format => "HTML", :method => "GET", :mongo_runtime => 0.0, :path => "/users", :status => 200, :status_message => "OK", :view_runtime => 709.88 }
-    config.rails_semantic_logger.semantic          = true
+    config.rails_semantic_logger.semantic = true
 
     # Change Rack started message to debug so that it does not appear in production
-    config.rails_semantic_logger.started           = false
+    config.rails_semantic_logger.started = false
 
     # Change Processing message to debug so that it does not appear in production
-    config.rails_semantic_logger.processing        = false
+    config.rails_semantic_logger.processing = false
 
     # Change Action View render log messages to debug so that they do not appear in production
     #   ActionView::Base --   Rendered data/search/_user.html.haml (46.7ms)
-    config.rails_semantic_logger.rendered          = false
+    config.rails_semantic_logger.rendered = false
 
     # Override the Awesome Print options for logging Hash data as text:
     #
@@ -41,7 +44,7 @@ module RailsSemanticLogger
     #
     #  Note: The option :multiline is set to false if not supplied.
     #  Note: Has no effect if Awesome Print is not installed.
-    config.rails_semantic_logger.ap_options        = {multiline: false}
+    config.rails_semantic_logger.ap_options = {multiline: false}
 
     # Whether to automatically add an environment specific log file appender.
     # For Example: 'log/development.log'
@@ -54,7 +57,7 @@ module RailsSemanticLogger
     config.rails_semantic_logger.add_file_appender = true
 
     # Silence asset logging
-    config.rails_semantic_logger.quiet_assets      = false
+    config.rails_semantic_logger.quiet_assets = false
 
     # Override the output format for the primary Rails log file.
     #
@@ -90,18 +93,18 @@ module RailsSemanticLogger
     #
     #   # In application.rb:
     #   config.rails_semantic_logger.format = MyFormatter.new
-    config.rails_semantic_logger.format            = :default
+    config.rails_semantic_logger.format = :default
 
     # DEPRECATED
     # Instead, supply a Hash to config.log_tags
-    config.rails_semantic_logger.named_tags        = nil
+    config.rails_semantic_logger.named_tags = nil
 
     # Add a filter to the file logger [Regexp|Proc]
     #   RegExp: Only include log messages where the class name matches the supplied
     #           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.
-    config.rails_semantic_logger.filter            = nil
+    config.rails_semantic_logger.filter = nil
 
     # Initialize SemanticLogger. In a Rails environment it will automatically
     # insert itself above the configured rails logger to add support for its
@@ -111,14 +114,18 @@ module RailsSemanticLogger
     Rails::Application::Bootstrap.initializers.delete_if { |i| i.name == :initialize_logger }
 
     initializer :initialize_logger, group: :all do
-      config                       = Rails.application.config
+      config = Rails.application.config
 
       # Set the default log level based on the Rails config
       SemanticLogger.default_level = config.log_level
 
+      if defined?(Rails::Rack::Logger) && config.rails_semantic_logger.semantic
+        config.middleware.swap(Rails::Rack::Logger, RailsSemanticLogger::Rack::Logger, config.log_tags)
+      end
+
       # 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
+      Rails.logger = config.logger = begin
         if config.rails_semantic_logger.add_file_appender
           path = config.paths['log'].first
           FileUtils.mkdir_p(File.dirname(path)) unless File.exist?(File.dirname(path))
@@ -130,16 +137,16 @@ module RailsSemanticLogger
           formatter  = {color: {ap: ap_options}} if (formatter == :default) && (config.colorize_logging != false)
 
           # Set internal logger to log to file only, in case another appender experiences errors during writes
-          appender                         = SemanticLogger::Appender::File.new(file_name: path, level: config.log_level, formatter: formatter)
+          appender = SemanticLogger::Appender::File.new(
+            file_name: path,
+            level:     config.log_level,
+            formatter: formatter
+          )
           appender.name                    = 'SemanticLogger'
           SemanticLogger::Processor.logger = appender
 
           # Check for previous file or stdout loggers
-          if SemanticLogger::VERSION.to_f >= 4.2
-            SemanticLogger.appenders.each { |appender| appender.formatter = formatter if appender.is_a?(SemanticLogger::Appender::File) }
-          elsif config.colorize_logging == false
-            SemanticLogger.appenders.each { |appender| appender.formatter = SemanticLogger::Formatters::Default.new if appender.is_a?(SemanticLogger::Appender::File) }
-          end
+          SemanticLogger.appenders.each { |app| app.formatter = formatter if app.is_a?(SemanticLogger::Appender::File) }
           SemanticLogger.add_appender(file_name: path, formatter: formatter, filter: config.rails_semantic_logger.filter)
         end
 
@@ -153,54 +160,29 @@ module RailsSemanticLogger
 
         logger = SemanticLogger[Rails]
         logger.warn(
-          "Rails Error: Unable to access log file. Please ensure that #{path} exists and is chmod 0666. " +
-            "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed.",
+          "Rails Error: Unable to access log file. Please ensure that #{path} exists and is chmod 0666. " \
+            'The log level has been raised to WARN and the output directed to STDERR until the problem is fixed.',
           exc
         )
         logger
       end
 
       # Replace Rails loggers
-      [:active_record, :action_controller, :action_mailer, :action_view].each do |name|
+      %i[active_record action_controller action_mailer action_view].each do |name|
         ActiveSupport.on_load(name) { include SemanticLogger::Loggable }
       end
       ActiveSupport.on_load(:action_cable) { self.logger = SemanticLogger['ActionCable'] }
     end
 
-    # Support fork frameworks
-    config.after_initialize do
-      # Silence asset logging by applying a filter to the Rails logger itself, not any of the appenders.
-      if config.rails_semantic_logger.quiet_assets && config.assets.prefix #&& defined?(Rails::Rack::Logger)
-        assets_regex = %r(\A/{0,2}#{config.assets.prefix})
-        if Rails.version.to_i >= 5
-          Rails::Rack::Logger.logger.filter = -> log { log.payload[:path] !~ assets_regex if log.payload }
-        else
-          # Also strips the empty log lines
-          Rails::Rack::Logger.logger.filter = -> log { log.payload.nil? ? (log.message != '') : (log.payload[:path] !~ assets_regex) }
-        end
-      end
-
-      # Passenger provides the :starting_worker_process event for executing
-      # code after it has forked, so we use that and reconnect immediately.
-      if defined?(PhusionPassenger)
-        PhusionPassenger.on_event(:starting_worker_process) do |forked|
-          ::SemanticLogger.reopen if forked
-        end
-      end
-
-      # Re-open appenders after Resque has forked a worker
-      if defined?(Resque)
-        Resque.after_fork { |job| ::SemanticLogger.reopen }
-      end
+    # Before any initializers run, but after the gems have been loaded
+    config.before_initialize do
+      if config.respond_to?(:assets) && defined?(Rails::Rack::Logger) && config.rails_semantic_logger.semantic
+        config.rails_semantic_logger.quiet_assets = true if config.assets.quiet
 
-      # Re-open appenders after Spring has forked a process
-      if defined?(Spring)
-        Spring.after_fork { |job| ::SemanticLogger.reopen }
+        # Otherwise Sprockets can't find the Rails::Rack::Logger middleware
+        config.assets.quiet = false
       end
-    end
 
-    # Before any initializers run, but after the gems have been loaded
-    config.before_initialize do
       # Replace the Mongo Loggers
       Mongoid.logger          = SemanticLogger[Mongoid] if defined?(Mongoid)
       Moped.logger            = SemanticLogger[Moped] if defined?(Moped)
@@ -216,15 +198,13 @@ module RailsSemanticLogger
       Sidetiq.logger          = SemanticLogger[Sidetiq] if defined?(Sidetiq)
 
       # Replace the DelayedJob logger
-      Delayed::Worker.logger = SemanticLogger[Delayed::Worker] if defined?(Delayed::Worker)
+      if defined?(Delayed::Worker)
+        Delayed::Worker.logger = SemanticLogger[Delayed::Worker]
+        Delayed::Worker.plugins << RailsSemanticLogger::DelayedJob::Plugin
+      end
 
       # Replace the Bugsnag logger
       Bugsnag.configure { |config| config.logger = SemanticLogger[Bugsnag] } if defined?(Bugsnag)
-
-      # Backward compatibility
-      if config.rails_semantic_logger.named_tags
-        config.log_tags = config.rails_semantic_logger.named_tags
-      end
     end
 
     # After any initializers run, but after the gems have been loaded
@@ -241,23 +221,53 @@ module RailsSemanticLogger
       require('rails_semantic_logger/extensions/active_model_serializers/logging') if defined?(ActiveModelSerializers)
 
       if config.rails_semantic_logger.semantic
-        require('rails_semantic_logger/extensions/rails/rack/logger') if defined?(Rails::Rack::Logger)
-        require('rails_semantic_logger/extensions/action_controller/log_subscriber') if defined?(ActionController)
-        require('rails_semantic_logger/extensions/active_record/log_subscriber') if defined?(ActiveRecord::LogSubscriber)
-      end
+        # Active Record
+        RailsSemanticLogger.swap_subscriber(
+          ::ActiveRecord::LogSubscriber,
+          RailsSemanticLogger::ActiveRecord::LogSubscriber,
+          :active_record
+        )
 
-      unless config.rails_semantic_logger.started
-        require('rails_semantic_logger/extensions/rails/rack/logger_info_as_debug') if defined?(Rails::Rack::Logger)
-      end
+        # Rack
+        RailsSemanticLogger::Rack::Logger.started_request_log_level = :info if config.rails_semantic_logger.started
+
+        # Silence asset logging by applying a filter to the Rails logger itself, not any of the appenders.
+        if config.rails_semantic_logger.quiet_assets && config.assets.prefix
+          assets_regex                                    = %r(\A/{0,2}#{config.assets.prefix})
+          RailsSemanticLogger::Rack::Logger.logger.filter = ->(log) { log.payload[:path] !~ assets_regex if log.payload }
+        end
+
+        # Action View
+        RailsSemanticLogger::ActionView::LogSubscriber.rendered_log_level = :info if config.rails_semantic_logger.rendered
+        RailsSemanticLogger.swap_subscriber(
+          ::ActionView::LogSubscriber,
+          RailsSemanticLogger::ActionView::LogSubscriber,
+          :action_view
+        )
 
-      unless config.rails_semantic_logger.rendered
-        require('rails_semantic_logger/extensions/action_view/log_subscriber') if defined?(ActionView::LogSubscriber)
+        # Action Controller
+        RailsSemanticLogger.swap_subscriber(
+          ::ActionController::LogSubscriber,
+          RailsSemanticLogger::ActionController::LogSubscriber,
+          :action_controller
+        )
       end
 
-      if config.rails_semantic_logger.processing
-        require('rails_semantic_logger/extensions/action_controller/log_subscriber_processing') if defined?(ActionView::LogSubscriber)
+      #
+      # Forking Frameworks
+      #
+
+      # Passenger provides the :starting_worker_process event for executing
+      # code after it has forked, so we use that and reconnect immediately.
+      if defined?(PhusionPassenger)
+        PhusionPassenger.on_event(:starting_worker_process) { |forked| ::SemanticLogger.reopen if forked }
       end
-    end
 
+      # Re-open appenders after Resque has forked a worker
+      Resque.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Resque)
+
+      # Re-open appenders after Spring has forked a process
+      Spring.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Spring)
+    end
   end
 end

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

@@ -1,7 +1,9 @@
 # Log actual exceptions, not a string representation
 ActionController::Live
-module ActionController::Live
-  def log_error(exception)
-    logger.fatal(exception)
+module ActionController
+  module Live
+    def log_error(exception)
+      logger.fatal(exception)
+    end
   end
 end

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

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

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

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

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

@@ -1,11 +1,14 @@
 # Patch ActiveJob logger
 require 'active_job/logging'
 
-module ActiveJob::Logging
-  include SemanticLogger::Loggable
+module ActiveJob
+  module Logging
+    include SemanticLogger::Loggable
 
-  private
-  def tag_logger(*tags, &block)
-    logger.tagged(*tags, &block)
+    private
+
+    def tag_logger(*tags, &block)
+      logger.tagged(*tags, &block)
+    end
   end
 end

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

@@ -1,15 +1,18 @@
 # Patch ActiveModelSerializers logger
 require 'active_model_serializers/logging'
 
-module ActiveModelSerializers::Logging
-  include SemanticLogger::Loggable
+module ActiveModelSerializers
+  module Logging
+    include SemanticLogger::Loggable
 
-  private
-  def tag_logger(*tags, &block)
-    logger.tagged(*tags, &block)
+    private
+
+    def tag_logger(*tags, &block)
+      logger.tagged(*tags, &block)
+    end
   end
-end
 
-class ActiveModelSerializers::SerializableResource
-  include SemanticLogger::Loggable
+  class SerializableResource
+    include SemanticLogger::Loggable
+  end
 end

data/lib/rails_semantic_logger/extensions/rails/server.rb

@@ -1,7 +1,7 @@
 # Patch the Rails::Server log_to_stdout so that it logs via SemanticLogger
 Rails::Server
-module Rails #:nodoc:
-  class Server #:nodoc:
+module Rails
+  class Server
     private
 
     def log_to_stdout

data/lib/rails_semantic_logger/rack/logger.rb

@@ -0,0 +1,103 @@
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/object/blank'
+require 'active_support/log_subscriber'
+require 'action_dispatch/http/request'
+require 'rack/body_proxy'
+
+module RailsSemanticLogger
+  module Rack
+    class Logger < ActiveSupport::LogSubscriber
+      class << self
+        attr_reader :logger
+        attr_accessor :started_request_log_level
+      end
+
+      def initialize(app, taggers = nil)
+        @app     = app
+        @taggers = taggers || []
+      end
+
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+
+        # Check for named tags (Hash)
+        if @taggers && !@taggers.empty?
+          tags = @taggers.is_a?(Hash) ? compute_named_tags(request) : compute_tags(request)
+          logger.tagged(tags) { call_app(request, env) }
+        else
+          call_app(request, env)
+        end
+      end
+
+      private
+
+      @logger                    = SemanticLogger['Rack']
+      @started_request_log_level = :debug
+
+      def call_app(request, env)
+        instrumenter = ActiveSupport::Notifications.instrumenter
+        instrumenter.start 'request.action_dispatch', request: request
+
+        logger.send(self.class.started_request_log_level) { started_request_message(request) }
+
+        status, headers, body = @app.call(env)
+        body                  = ::Rack::BodyProxy.new(body) { finish(request) }
+        [status, headers, body]
+      rescue Exception
+        finish(request)
+        raise
+      end
+
+      def started_request_message(request)
+        {
+          message: 'Started',
+          payload: {
+            method: request.request_method,
+            path:   request.filtered_path,
+            ip:     request.ip
+          }
+        }
+      end
+
+      def compute_tags(request)
+        @taggers.collect do |tag|
+          case tag
+          when Proc
+            tag.call(request)
+          when Symbol
+            request.send(tag)
+          else
+            tag
+          end
+        end
+      end
+
+      # Leave out any named tags with a nil value
+      def compute_named_tags(request)
+        tagged = {}
+        @taggers.each_pair do |tag, value|
+          resolved    =
+            case value
+            when Proc
+              value.call(request)
+            when Symbol
+              request.send(value)
+            else
+              value
+            end
+          tagged[tag] = resolved unless resolved.nil?
+        end
+        tagged
+      end
+
+      def finish(request)
+        instrumenter = ActiveSupport::Notifications.instrumenter
+        instrumenter.finish 'request.action_dispatch', request: request
+      end
+
+      def logger
+        self.class.logger
+      end
+    end
+  end
+end