rails_semantic_logger 4.1.3 → 4.12.0

data/lib/rails_semantic_logger/active_record/log_subscriber.rb

@@ -0,0 +1,218 @@
+module RailsSemanticLogger
+  module ActiveRecord
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      IGNORE_PAYLOAD_NAMES = %w[SCHEMA EXPLAIN].freeze
+
+      class << self
+        attr_reader :logger
+      end
+
+      def self.runtime=(value)
+        ::ActiveRecord::RuntimeRegistry.sql_runtime = value
+      end
+
+      def self.runtime
+        ::ActiveRecord::RuntimeRegistry.sql_runtime ||= 0
+      end
+
+      def self.reset_runtime
+        rt           = runtime
+        self.runtime = 0
+        rt
+      end
+
+      def sql(event)
+        self.class.runtime += event.duration
+        return unless logger.debug?
+
+        payload = event.payload
+        name    = payload[:name]
+        return if IGNORE_PAYLOAD_NAMES.include?(name)
+
+        log_payload         = {sql: payload[:sql]}
+        log_payload[:binds] = bind_values(payload) unless (payload[:binds] || []).empty?
+        log_payload[:allocations] = event.allocations if event.respond_to?(:allocations)
+        log_payload[:cached] = event.payload[:cached]
+
+        log = {
+          message:  name,
+          payload:  log_payload,
+          duration: event.duration
+        }
+
+        # Log the location of the query itself.
+        if logger.send(:level_index) >= SemanticLogger.backtrace_level_index
+          log[:backtrace] = SemanticLogger::Utils.strip_backtrace(caller)
+        end
+
+        logger.debug(log)
+      end
+
+      private
+
+      @logger = SemanticLogger["ActiveRecord"]
+
+      # When multiple values are received for a single bound field, it is converted into an array
+      def add_bind_value(binds, key, value)
+        key        = key.downcase.to_sym unless key.nil?
+        value      = (Array(binds[key]) << value) if binds.key?(key)
+        binds[key] = value
+      end
+
+      def logger
+        self.class.logger
+      end
+
+      #
+      # Rails 3,4,5 hell trying to get the bind values
+      #
+
+      def bind_values_v3(payload)
+        binds = {}
+        payload[:binds].each do |col, v|
+          if col
+            add_bind_value(binds, col.name, v)
+          else
+            binds[nil] = v
+          end
+        end
+        binds
+      end
+
+      def bind_values_v4(payload)
+        binds = {}
+        payload[:binds].each do |col, v|
+          attr_name, value = render_bind(col, v)
+          add_bind_value(binds, attr_name, value)
+        end
+        binds
+      end
+
+      def bind_values_v5_0_0(payload)
+        binds = {}
+        payload[:binds].each do |attr|
+          attr_name, value = render_bind(attr)
+          add_bind_value(binds, attr_name, value)
+        end
+        binds
+      end
+
+      def bind_values_v5_0_3(payload)
+        binds         = {}
+        casted_params = type_casted_binds(payload[:binds], payload[:type_casted_binds])
+        payload[:binds].zip(casted_params).map do |attr, value|
+          attr_name, value = render_bind(attr, value)
+          add_bind_value(binds, attr_name, value)
+        end
+        binds
+      end
+
+      def bind_values_v5_1_5(payload)
+        binds         = {}
+        casted_params = type_casted_binds(payload[:type_casted_binds])
+        payload[:binds].zip(casted_params).map do |attr, value|
+          attr_name, value = render_bind(attr, value)
+          add_bind_value(binds, attr_name, value)
+        end
+        binds
+      end
+
+      def bind_values_v6_1(payload)
+        binds         = {}
+        casted_params = type_casted_binds(payload[:type_casted_binds])
+        payload[:binds].each_with_index do |attr, i|
+          attr_name, value = render_bind(attr, casted_params[i])
+          add_bind_value(binds, attr_name, value)
+        end
+        binds
+      end
+
+      def render_bind_v4_2(column, value)
+        if column
+          if column.binary?
+            # This specifically deals with the PG adapter that casts bytea columns into a Hash.
+            value = value[:value] if value.is_a?(Hash)
+            value = value ? "<#{value.bytesize} bytes of binary data>" : "<NULL binary data>"
+          end
+
+          [column.name, value]
+        else
+          [nil, value]
+        end
+      end
+
+      def render_bind_v5_0_0(attribute)
+        value =
+          if attribute.type.binary? && attribute.value
+            if attribute.value.is_a?(Hash)
+              "<#{attribute.value_for_database.to_s.bytesize} bytes of binary data>"
+            else
+              "<#{attribute.value.bytesize} bytes of binary data>"
+            end
+          else
+            attribute.value_for_database
+          end
+
+        [attribute.name, value]
+      end
+
+      def render_bind_v5_0_3(attr, value)
+        if attr.is_a?(Array)
+          attr = attr.first
+        elsif attr.type.binary? && attr.value
+          value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+        end
+
+        [attr&.name, value]
+      end
+
+      def render_bind_v6_1(attr, value)
+        case attr
+        when ActiveModel::Attribute
+          if attr.type.binary? && attr.value
+            value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+          end
+        when Array
+          attr = attr.first
+        else
+          attr = nil
+        end
+
+        [attr&.name || :nil, value]
+      end
+
+      def type_casted_binds_v5_0_3(binds, casted_binds)
+        casted_binds || ::ActiveRecord::Base.connection.type_casted_binds(binds)
+      end
+
+      def type_casted_binds_v5_1_5(casted_binds)
+        casted_binds.respond_to?(:call) ? casted_binds.call : casted_binds
+      end
+
+      if Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR.zero? && Rails::VERSION::TINY <= 2 # 5.0.0 - 5.0.2
+        alias bind_values bind_values_v5_0_0
+        alias render_bind render_bind_v5_0_0
+      elsif Rails::VERSION::MAJOR == 5 &&
+            ((Rails::VERSION::MINOR.zero? && Rails::VERSION::TINY <= 6) ||
+              (Rails::VERSION::MINOR == 1 && Rails::VERSION::TINY <= 4)) # 5.0.3 - 5.0.6 && 5.1.0 - 5.1.4
+        alias bind_values bind_values_v5_0_3
+        alias render_bind render_bind_v5_0_3
+        alias type_casted_binds type_casted_binds_v5_0_3
+      elsif (Rails::VERSION::MAJOR == 6 && Rails::VERSION::MINOR > 0) || # ~> 6.1.0
+            Rails::VERSION::MAJOR == 7
+        alias bind_values bind_values_v6_1
+        alias render_bind render_bind_v6_1
+        alias type_casted_binds type_casted_binds_v5_1_5
+      elsif Rails::VERSION::MAJOR >= 5 # ~> 5.1.5 && ~> 5.0.7 && 6.x.x
+        alias bind_values bind_values_v5_1_5
+        alias render_bind render_bind_v5_0_3
+        alias type_casted_binds type_casted_binds_v5_1_5
+      elsif Rails.version.to_i >= 4 # 4.x
+        alias bind_values bind_values_v4
+        alias render_bind render_bind_v4_2
+      else # 3.x
+        alias bind_values bind_values_v3
+      end
+    end
+  end
+end

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|
+          ::SemanticLogger.reopen
+        end
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/engine.rb

@@ -1,3 +1,6 @@
+require "rails"
+require "rails_semantic_logger/options"
+
 module RailsSemanticLogger
   class Engine < ::Rails::Engine
     # Make the SemanticLogger config available in the Rails application config
@@ -16,92 +19,7 @@ module RailsSemanticLogger
     #   end
     config.semantic_logger = ::SemanticLogger
 
-    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
-
-    # Change Rack started message to debug so that it does not appear in production
-    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
-
-    # 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
-
-    # Override the Awesome Print options for logging Hash data as text:
-    #
-    #  Any valid AwesomePrint option for rendering data.
-    #  The defaults can changed be creating a `~/.aprc` file.
-    #  See: https://github.com/michaeldv/awesome_print
-    #
-    #  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}
-
-    # Whether to automatically add an environment specific log file appender.
-    # For Example: 'log/development.log'
-    #
-    # Note:
-    #   When Semantic Logger fails to log to an appender it logs the error to an
-    #   internal logger, which by default writes to STDERR.
-    #   Example, change the default internal logger to log to stdout:
-    #     SemanticLogger::Processor.logger = SemanticLogger::Appender::File.new(io: STDOUT, level: :warn)
-    config.rails_semantic_logger.add_file_appender = true
-
-    # Silence asset logging
-    config.rails_semantic_logger.quiet_assets      = false
-
-    # Override the output format for the primary Rails log file.
-    #
-    # Valid options:
-    # * :default
-    #     Plain text output with no color.
-    # * :color
-    #     Plain text output with color.
-    # * :json
-    #     JSON output format.
-    # * class
-    #
-    # * Proc
-    #     A block that will be called to format the output.
-    #     It is supplied with the `log` entry and should return the formatted data.
-    #
-    # Note:
-    # * `:default` is automatically changed to `:color` if `config.colorize_logging` is `true`.
-    #
-    # JSON Example, in `application.rb`:
-    #
-    #   config.rails_semantic_logger.format = :json
-    #
-    # Custom Example, create `app/lib/my_formatter.rb`:
-    #
-    #   # My Custom colorized formatter
-    #   class MyFormatter < SemanticLogger::Formatters::Color
-    #     # Return the complete log level name in uppercase
-    #     def level
-    #       "#{color}log.level.upcase#{color_map.clear}"
-    #     end
-    #   end
-    #
-    #   # In application.rb:
-    #   config.rails_semantic_logger.format = MyFormatter.new
-    config.rails_semantic_logger.format            = :default
-
-    # DEPRECATED
-    # Instead, supply a Hash to config.log_tags
-    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 = RailsSemanticLogger::Options.new
 
     # Initialize SemanticLogger. In a Rails environment it will automatically
     # insert itself above the configured rails logger to add support for its
@@ -111,153 +29,230 @@ 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
-        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))
-
-          # Add the log file to the list of appenders
-          # Use the colorized formatter if Rails colorized logs are enabled
-          ap_options = config.rails_semantic_logger.ap_options
-          formatter  = config.rails_semantic_logger.format
-          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.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) }
+      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))
+
+            # Add the log file to the list of appenders
+            # Use the colorized formatter if Rails colorized logs are enabled
+            ap_options = config.rails_semantic_logger.ap_options
+            formatter  = config.rails_semantic_logger.format
+            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(path, formatter: formatter)
+            appender.name                    = "SemanticLogger"
+            SemanticLogger::Processor.logger = appender
+
+            # Check for previous file or stdout loggers
+            SemanticLogger.appenders.each do |app|
+              next unless app.is_a?(SemanticLogger::Appender::File) || app.is_a?(SemanticLogger::Appender::IO)
+
+              app.formatter = formatter
+            end
+            SemanticLogger.add_appender(file_name: path, formatter: formatter, filter: config.rails_semantic_logger.filter)
           end
-          SemanticLogger.add_appender(file_name: path, formatter: formatter, filter: config.rails_semantic_logger.filter)
-        end
 
-        SemanticLogger[Rails]
-      rescue StandardError => exc
-        # If not able to log to file, log to standard error with warning level only
-        SemanticLogger.default_level = :warn
-
-        SemanticLogger::Processor.logger = SemanticLogger::Appender::File.new(io: STDERR)
-        SemanticLogger.add_appender(io: STDERR)
-
-        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.",
-          exc
-        )
-        logger
-      end
+          SemanticLogger[Rails]
+        rescue StandardError => e
+          # If not able to log to file, log to standard error with warning level only
+          SemanticLogger.default_level = :warn
+
+          SemanticLogger::Processor.logger = SemanticLogger::Appender::IO.new($stderr)
+          SemanticLogger.add_appender(io: $stderr)
+
+          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.",
+            e
+          )
+          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'] }
+      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)
-      Mongo::Logger.logger    = SemanticLogger[Mongo] if defined?(Mongo::Logger)
+      Mongoid.logger       = SemanticLogger[Mongoid] if defined?(Mongoid)
+      Moped.logger         = SemanticLogger[Moped] if defined?(Moped)
+      Mongo::Logger.logger = SemanticLogger[Mongo] if defined?(Mongo::Logger)
 
       # Replace the Resque Logger
-      Resque.logger           = SemanticLogger[Resque] if defined?(Resque) && Resque.respond_to?(:logger)
+      Resque.logger        = SemanticLogger[Resque] if defined?(Resque) && Resque.respond_to?(:logger=)
 
       # Replace the Sidekiq logger
-      Sidekiq::Logging.logger = SemanticLogger[Sidekiq] if defined?(Sidekiq)
+      if defined?(Sidekiq)
+        if Sidekiq.respond_to?(:logger=)
+          Sidekiq.logger = SemanticLogger[Sidekiq]
+        elsif Sidekiq::VERSION[0..1] == '7.'
+          method = Sidekiq.server? ? :configure_server : :configure_client
+          Sidekiq.public_send(method) { |cfg| cfg.logger = SemanticLogger[Sidekiq] }
+        end
+      end
 
       # Replace the Sidetiq logger
-      Sidetiq.logger          = SemanticLogger[Sidetiq] if defined?(Sidetiq)
+      Sidetiq.logger       = SemanticLogger[Sidetiq] if defined?(Sidetiq) && Sidetiq.respond_to?(:logger=)
+
+      # Replace the DelayedJob logger
+      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)
 
-      # Set the logger for concurrent-ruby
-      Concurrent.global_logger = SemanticLogger[Concurrent] if defined?(Concurrent)
+      # Set the IOStreams PGP logger
+      IOStreams::Pgp.logger = SemanticLogger["IOStreams::Pgp"] if defined?(IOStreams)
+    end
+
+    # After any initializers run, but after the gems have been loaded
+    config.after_initialize do
+      config = Rails.application.config
+
+      # Replace the Bugsnag logger
+      Bugsnag.configure { |bugsnag_config| bugsnag_config.logger = SemanticLogger[Bugsnag] } if defined?(Bugsnag)
 
       # Rails Patches
-      require('rails_semantic_logger/extensions/action_cable/tagged_logger_proxy') if defined?(ActionCable)
-      require('rails_semantic_logger/extensions/action_controller/live') if defined?(ActionController::Live)
-      require('rails_semantic_logger/extensions/action_dispatch/debug_exceptions') if defined?(ActionDispatch::DebugExceptions)
-      require('rails_semantic_logger/extensions/action_view/streaming_template_renderer') if defined?(ActionView::StreamingTemplateRenderer::Body)
-      require('rails_semantic_logger/extensions/active_job/logging') if defined?(ActiveJob)
-      require('rails_semantic_logger/extensions/active_model_serializers/logging') if defined?(ActiveModelSerializers)
+      require("rails_semantic_logger/extensions/action_cable/tagged_logger_proxy") if defined?(::ActionCable)
+      require("rails_semantic_logger/extensions/action_controller/live") if defined?(::ActionController::Live)
+      require("rails_semantic_logger/extensions/action_dispatch/debug_exceptions") if defined?(::ActionDispatch::DebugExceptions)
+      if defined?(::ActionView::StreamingTemplateRenderer::Body)
+        require("rails_semantic_logger/extensions/action_view/streaming_template_renderer")
+      end
+      require("rails_semantic_logger/extensions/active_job/logging") if defined?(::ActiveJob)
+      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 Job
+        if defined?(::ActiveJob) && defined?(::ActiveJob::Logging::LogSubscriber)
+          RailsSemanticLogger.swap_subscriber(
+            ::ActiveJob::Logging::LogSubscriber,
+            RailsSemanticLogger::ActiveJob::LogSubscriber,
+            :active_job
+          )
+        end
 
-      unless config.rails_semantic_logger.started
-        require('rails_semantic_logger/extensions/rails/rack/logger_info_as_debug') if defined?(Rails::Rack::Logger)
-      end
+        if defined?(::ActiveJob) && defined?(::ActiveJob::LogSubscriber)
+          RailsSemanticLogger.swap_subscriber(
+            ::ActiveJob::LogSubscriber,
+            RailsSemanticLogger::ActiveJob::LogSubscriber,
+            :active_job
+          )
+        end
 
-      unless config.rails_semantic_logger.rendered
-        require('rails_semantic_logger/extensions/action_view/log_subscriber') if defined?(ActionView::LogSubscriber)
-      end
+        # Active Record
+        if defined?(::ActiveRecord)
+          require "active_record/log_subscriber"
+
+          RailsSemanticLogger.swap_subscriber(
+            ::ActiveRecord::LogSubscriber,
+            RailsSemanticLogger::ActiveRecord::LogSubscriber,
+            :active_record
+          )
+        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_root                                     = config.relative_url_root.to_s + config.assets.prefix
+          assets_regex                                    = %r(\A/{0,2}#{assets_root})
+          RailsSemanticLogger::Rack::Logger.logger.filter = ->(log) { log.payload[:path] !~ assets_regex if log.payload }
+        end
+
+        # Action View
+        if defined?(::ActionView)
+          require "action_view/log_subscriber"
+
+          RailsSemanticLogger::ActionView::LogSubscriber.rendered_log_level = :info if config.rails_semantic_logger.rendered
+          RailsSemanticLogger.swap_subscriber(
+            ::ActionView::LogSubscriber,
+            RailsSemanticLogger::ActionView::LogSubscriber,
+            :action_view
+          )
+        end
 
-      if config.rails_semantic_logger.processing
-        require('rails_semantic_logger/extensions/action_controller/log_subscriber_processing') if defined?(ActionView::LogSubscriber)
+        # Action Controller
+        if defined?(::ActionController)
+          require "action_controller/log_subscriber"
+
+          RailsSemanticLogger.swap_subscriber(
+            ::ActionController::LogSubscriber,
+            RailsSemanticLogger::ActionController::LogSubscriber,
+            :action_controller
+          )
+        end
+
+        # Action Mailer
+        if defined?(::ActionMailer)
+          require "action_mailer/log_subscriber"
+
+          RailsSemanticLogger.swap_subscriber(
+            ::ActionMailer::LogSubscriber,
+            RailsSemanticLogger::ActionMailer::LogSubscriber,
+            :action_mailer
+          )
+        end
       end
 
-      # Backward compatibility
-      if config.rails_semantic_logger.named_tags
-        config.log_tags = config.rails_semantic_logger.named_tags
+      #
+      # 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) do |forked|
+          SemanticLogger.reopen if forked
+        end
       end
-    end
 
-    # After any initializers run, but after the gems have been loaded
-    config.after_initialize do
-      # Replace the Bugsnag logger
-      Bugsnag.configure { |config| config.logger = SemanticLogger[Bugsnag] } if defined?(Bugsnag)
-    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.after_fork)
+
+      console do |_app|
+        # Don't use a background thread for logging
+        SemanticLogger.sync!
+        # Add a stderr logger when running inside a Rails console unless one has already been added.
+        if config.rails_semantic_logger.console_logger && !SemanticLogger.appenders.console_output?
+          SemanticLogger.add_appender(io: STDERR, formatter: :color)
+        end
+
+        # Include method names on log entries in the console
+        SemanticLogger.backtrace_level = SemanticLogger.default_level
+      end
+    end
   end
 end

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

@@ -1,4 +1,4 @@
-ActionCable::Connection::TaggedLoggerProxy
+require "action_cable/connection/tagged_logger_proxy"
 
 module ActionCable
   module Connection