rails_semantic_logger 4.4.5 → 4.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c899a97af82d65b03bee094d84f29ea78e62afb88b47bbf1dd9809805df998d3
-  data.tar.gz: a0feb72c5299a8ee795a9a797405d15732094bae04d2dab5a582d5197139b20c
+  metadata.gz: de0436e82a0d6ed583904e4da19a5dbc5611e7673b1b9904b0b4757f00e71057
+  data.tar.gz: 42335c2218f2d434f352f695c9ce2cc9362c7b7cbe70664a3585d5910c91e6f7
 SHA512:
-  metadata.gz: a7146775a00bbc077bb374a71f0dcd04c675bd9398f5169c2b22557a1f04072e3abd7aaf8ee606836f64d062033e12d5f01dd52390c988ef5be30c4e302d905e
-  data.tar.gz: cd7ce812d642c7afb72468941acafae6282ea749e655615e3441fafb6a221ad1a0c26625dd330a6278d058ded947bbc20afe6e206e9b0aab82bf1e5a7049cce8
+  metadata.gz: e0681cc160523f2cef6b6c5fdb169147150bf26470ce628210877e41691911fd81c0f800320dea191d61c6e7be0e3b2ad9d6bf259d0b711caad1c934ec914a72
+  data.tar.gz: 3e276c344146b0b16b71b1bfa915b0e8d602c20c750322fca09179c95ac3d85a1138e7b8bbaa96fc62f30effaf09d36cde8e5e7eb8268edbcf3f0e7f1c597f3c

data/lib/rails_semantic_logger.rb

@@ -1,4 +1,5 @@
 require "semantic_logger"
+require "rails_semantic_logger/extensions/rails/server" if defined?(Rails::Server)
 require "rails_semantic_logger/engine"
 
 module RailsSemanticLogger

data/lib/rails_semantic_logger/action_controller/log_subscriber.rb

@@ -38,8 +38,12 @@ module RailsSemanticLogger
           end
 
           payload[:status_message] = ::Rack::Utils::HTTP_STATUS_CODES[payload[:status]] if payload[:status].present?
+
           # Causes excessive log output with Rails 5 RC1
           payload.delete(:headers)
+          # Causes recursion in Rails 6.1.rc1
+          payload.delete(:request)
+          payload.delete(:response)
 
           params = payload[:params]
           if params

data/lib/rails_semantic_logger/engine.rb

@@ -33,191 +33,184 @@ module RailsSemanticLogger
     initializer :initialize_logger, group: :all do
       config = Rails.application.config
 
-      unless config.rails_semantic_logger.disabled
-        # Set the default log level based on the Rails config
-        SemanticLogger.default_level = config.log_level
+      # 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
+      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
-              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
-
-            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::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.",
-              e
+      # 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
             )
-            logger
+            appender.name                    = "SemanticLogger"
+            SemanticLogger::Processor.logger = appender
+
+            # Check for previous file or stdout loggers
+            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
 
-        # Replace Rails loggers
-        %i[active_record action_controller action_mailer action_view].each do |name|
-          ActiveSupport.on_load(name) { include SemanticLogger::Loggable }
+          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::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.",
+            e
+          )
+          logger
         end
-        ActiveSupport.on_load(:action_cable) { self.logger = SemanticLogger["ActionCable"] }
+
+      # Replace Rails loggers
+      %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
 
     # Before any initializers run, but after the gems have been loaded
     config.before_initialize do
-      unless config.rails_semantic_logger.disabled
-        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
+      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
 
-          # Otherwise Sprockets can't find the Rails::Rack::Logger middleware
-          config.assets.quiet = false
-        end
-
-        # 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)
+        # Otherwise Sprockets can't find the Rails::Rack::Logger middleware
+        config.assets.quiet = false
+      end
 
-        # Replace the Resque Logger
-        Resque.logger        = SemanticLogger[Resque] if defined?(Resque) && Resque.respond_to?(:logger)
+      # 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)
 
-        # Replace the Sidekiq logger
-        Sidekiq.logger       = SemanticLogger[Sidekiq] if defined?(Sidekiq)
+      # Replace the Resque Logger
+      Resque.logger        = SemanticLogger[Resque] if defined?(Resque) && Resque.respond_to?(:logger)
 
-        # Replace the Sidetiq logger
-        Sidetiq.logger       = SemanticLogger[Sidetiq] if defined?(Sidetiq)
+      # Replace the Sidekiq logger
+      Sidekiq.logger       = SemanticLogger[Sidekiq] if defined?(Sidekiq)
 
-        # Replace the DelayedJob logger
-        if defined?(Delayed::Worker)
-          Delayed::Worker.logger = SemanticLogger[Delayed::Worker]
-          Delayed::Worker.plugins << RailsSemanticLogger::DelayedJob::Plugin
-        end
+      # Replace the Sidetiq logger
+      Sidetiq.logger       = SemanticLogger[Sidetiq] if defined?(Sidetiq)
 
-        # Replace the Bugsnag logger
-        Bugsnag.configure { |config| config.logger = SemanticLogger[Bugsnag] } if defined?(Bugsnag)
+      # 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)
     end
 
     # After any initializers run, but after the gems have been loaded
     config.after_initialize do
-      unless config.rails_semantic_logger.disabled
-        # Replace the Bugsnag logger
-        Bugsnag.configure { |config| 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)
-        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)
-        require("rails_semantic_logger/extensions/rails/server") if defined?(Rails::Server)
-
-        if config.rails_semantic_logger.semantic
-          # Active Job
-          if defined?(::ActiveJob) && defined?(::ActiveJob::Logging::LogSubscriber)
-            RailsSemanticLogger.swap_subscriber(
-              ::ActiveJob::Logging::LogSubscriber,
-              RailsSemanticLogger::ActiveJob::LogSubscriber,
-              :active_job
-            )
-          end
-
-          if defined?(::ActiveJob) && defined?(::ActiveJob::LogSubscriber)
-            RailsSemanticLogger.swap_subscriber(
-              ::ActiveJob::LogSubscriber,
-              RailsSemanticLogger::ActiveJob::LogSubscriber,
-              :active_job
-            )
-          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
+      # Replace the Bugsnag logger
+      Bugsnag.configure { |config| 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)
+      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)
 
-          # 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
+      if config.rails_semantic_logger.semantic
+        # Active Job
+        if defined?(::ActiveJob) && defined?(::ActiveJob::Logging::LogSubscriber)
+          RailsSemanticLogger.swap_subscriber(
+            ::ActiveJob::Logging::LogSubscriber,
+            RailsSemanticLogger::ActiveJob::LogSubscriber,
+            :active_job
+          )
+        end
 
-          # Action View
-          RailsSemanticLogger::ActionView::LogSubscriber.rendered_log_level = :info if config.rails_semantic_logger.rendered
+        if defined?(::ActiveJob) && defined?(::ActiveJob::LogSubscriber)
           RailsSemanticLogger.swap_subscriber(
-            ::ActionView::LogSubscriber,
-            RailsSemanticLogger::ActionView::LogSubscriber,
-            :action_view
+            ::ActiveJob::LogSubscriber,
+            RailsSemanticLogger::ActiveJob::LogSubscriber,
+            :active_job
           )
+        end
+
+        # Active Record
+        if defined?(::ActiveRecord)
+          require "active_record/log_subscriber"
 
-          # Action Controller
           RailsSemanticLogger.swap_subscriber(
-            ::ActionController::LogSubscriber,
-            RailsSemanticLogger::ActionController::LogSubscriber,
-            :action_controller
+            ::ActiveRecord::LogSubscriber,
+            RailsSemanticLogger::ActiveRecord::LogSubscriber,
+            :active_record
           )
         end
 
-        #
-        # Forking Frameworks
-        #
+        # Rack
+        RailsSemanticLogger::Rack::Logger.started_request_log_level = :info if config.rails_semantic_logger.started
 
-        # 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
+        # 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
 
-        # Re-open appenders after Resque has forked a worker
-        Resque.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Resque)
+        # 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
+        )
+
+        # Action Controller
+        RailsSemanticLogger.swap_subscriber(
+          ::ActionController::LogSubscriber,
+          RailsSemanticLogger::ActionController::LogSubscriber,
+          :action_controller
+        )
+      end
 
-        # Re-open appenders after Spring has forked a process
-        Spring.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Spring.after_fork)
+      #
+      # 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
+
+      # 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)
     end
   end
 end

data/lib/rails_semantic_logger/options.rb

@@ -98,7 +98,7 @@ module RailsSemanticLogger
   #   config.rails_semantic_logger.named_tags = nil
   class Options
     attr_accessor :semantic, :started, :processing, :rendered, :ap_options, :add_file_appender,
-                  :quiet_assets, :format, :named_tags, :filter, :disabled
+                  :quiet_assets, :format, :named_tags, :filter
 
     # Setup default values
     def initialize
@@ -112,7 +112,6 @@ module RailsSemanticLogger
       @format            = :default
       @named_tags        = nil
       @filter            = nil
-      @disabled          = false
     end
   end
 end

data/lib/rails_semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module RailsSemanticLogger
-  VERSION = "4.4.5".freeze
+  VERSION = "4.4.6".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.4.5
+  version: 4.4.6
 platform: ruby
 authors:
 - Reid Morrison
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-21 00:00:00.000000000 Z
+date: 2020-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -98,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.0.8
 signing_key:
 specification_version: 4
 summary: Feature rich logging framework that replaces the Rails logger.