rails_semantic_logger 4.20.0 → 5.1.0

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

@@ -6,21 +6,12 @@ module ActionDispatch
     private
 
     undef_method :log_error
-    if (Rails::VERSION::MAJOR == 7 && Rails::VERSION::MINOR >= 1) || Rails::VERSION::MAJOR > 7
-      def log_error(request, wrapper)
-        Rails.application.deprecators.silence do
-          return if !log_rescued_responses?(request) && wrapper.rescue_response?
+    def log_error(request, wrapper)
+      Rails.application.deprecators.silence do
+        return if !log_rescued_responses?(request) && wrapper.rescue_response?
 
-          level = request.get_header("action_dispatch.debug_exception_log_level")
-          ActionController::Base.logger.log(level, wrapper.exception)
-        end
-      end
-    else
-      def log_error(_request, wrapper)
-        ActiveSupport::Deprecation.silence do
-          level = wrapper.respond_to?(:rescue_response?) && wrapper.rescue_response? ? :debug : :fatal
-          ActionController::Base.logger.log(level, wrapper.exception)
-        end
+        level = request.get_header("action_dispatch.debug_exception_log_level")
+        ActionController::Base.logger.log(level, wrapper.exception)
       end
     end
   end

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

@@ -8,9 +8,9 @@ module ActiveJob
     private
 
     undef_method :tag_logger
-    def tag_logger(*tags, &block)
+    def tag_logger(*tags, &)
       if logger.respond_to?(:tagged)
-        logger.tagged(*tags, &block)
+        logger.tagged(*tags, &)
       else
         yield
       end

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

@@ -7,8 +7,8 @@ module ActiveModelSerializers
 
     private
 
-    def tag_logger(*tags, &block)
-      logger.tagged(*tags, &block)
+    def tag_logger(*tags, &)
+      logger.tagged(*tags, &)
     end
   end
 

data/lib/rails_semantic_logger/extensions/active_support/logger.rb

@@ -1,27 +1,36 @@
 require "active_support/logger"
 
 module ActiveSupport
-  # More hacks to try and stop Rails from being it's own worst enemy.
+  # More hacks to try and stop Rails from being its own worst enemy.
   class Logger
     class << self
+      # Keep a handle on the genuine constructor so that callers which supply a
+      # real log destination still get a real logger (see #new below).
+      alias _semantic_logger_original_new new
+
       undef :logger_outputs_to?
 
-      # Prevent broadcasting since SemanticLogger already supports multiple loggers
-      if method_defined?(:broadcast)
-        undef :broadcast
-        def broadcast(_logger)
-          Module.new
-        end
+      # Prevent Rails from trying to merge/broadcast loggers (e.g. ActiveRecord's
+      # `console` hook and `rails server`'s log_to_stdout). SemanticLogger already
+      # multiplexes through its own appenders, and SemanticLogger::Logger does not
+      # implement #broadcast_to, so the merge path would otherwise raise.
+      def logger_outputs_to?(*_args)
+        true
       end
-    end
 
-    # Prevent Console from trying to merge loggers
-    def self.logger_outputs_to?(*_args)
-      true
-    end
-
-    def self.new(*_args, **_kwargs)
-      SemanticLogger[self]
+      # Historically every `ActiveSupport::Logger.new(...)` call was redirected to
+      # SemanticLogger, silently discarding the requested destination. That broke
+      # third-party callers such as Webpacker's `ActiveSupport::Logger.new(STDOUT)`,
+      # whose output never reached STDOUT (issue #141). Only redirect to
+      # SemanticLogger when no destination is supplied; otherwise honor the caller
+      # and build a genuine logger pointed at the requested destination.
+      def new(*args, **kwargs)
+        if args.empty? && kwargs.empty?
+          SemanticLogger[self]
+        else
+          _semantic_logger_original_new(*args, **kwargs)
+        end
+      end
     end
   end
 end

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

@@ -9,7 +9,7 @@ module Rails
     def log_to_stdout
       wrapped_app # touch the app so the logger is set up
 
-      SemanticLogger.add_appender(io: $stdout, formatter: :color) unless SemanticLogger.appenders.console_output?
+      RailsSemanticLogger.add_server_appenders
     end
   end
 end

data/lib/rails_semantic_logger/options.rb

@@ -4,7 +4,9 @@ module RailsSemanticLogger
   # * 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" }
+  # rubocop:disable Layout/LineLength
   #     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 }
+  # rubocop:enable Layout/LineLength
   #
   #     config.rails_semantic_logger.semantic = true
   #
@@ -44,6 +46,10 @@ module RailsSemanticLogger
   #
   #       config.rails_semantic_logger.add_file_appender = true
   #
+  #   DEPRECATED: declare appenders via #appenders instead. Declaring any appender there already
+  #   replaces the default file appender, so this flag is no longer needed:
+  #     config.rails_semantic_logger.appenders { |appenders| appenders.add(file_name: ...) }
+  #
   # * Silence asset logging
   #
   #     config.rails_semantic_logger.quiet_assets = false
@@ -52,6 +58,10 @@ module RailsSemanticLogger
   #
   #     config.rails_semantic_logger.console_logger = false
   #
+  #   DEPRECATED: declare a console appender explicitly via #appenders instead, or
+  #   declare none to disable it:
+  #     config.rails_semantic_logger.appenders { |appenders| appenders.add_console(...) }
+  #
   # * Override the output format for the primary Rails log file.
   #
   #     Valid options:
@@ -97,10 +107,6 @@ module RailsSemanticLogger
   #
   #     config.rails_semantic_logger.filter = nil
   #
-  # * named_tags: *DEPRECATED*
-  #   Instead, supply a Hash to config.log_tags
-  #   config.rails_semantic_logger.named_tags = nil
-  #
   # * Change the message format of Action Controller action.
   #   A block that will be called to format the message.
   #   It is supplied with the `message` and `payload` and should return the formatted data.
@@ -112,26 +118,171 @@ module RailsSemanticLogger
   # * Do not replace the Sidekiq logger with a Semantic Logger logger.
   #
   #     config.rails_semantic_logger.replace_sidekiq_logger = false
+  #
+  # * Do not replace the SolidQueue logger / log subscriber.
+  #
+  #     config.rails_semantic_logger.replace_solid_queue_logger = false
   class Options
-    attr_accessor :semantic, :started, :processing, :rendered, :ap_options, :add_file_appender,
-                  :quiet_assets, :format, :named_tags, :filter, :console_logger, :action_message_format,
-                  :replace_sidekiq_logger
+    # Settings consumed while the logger itself is built, during Rails'
+    # `:initialize_logger` initializer. Changing them after that (e.g. from
+    # `config/initializers/*`, which Rails loads later) has no effect.
+    LOGGER_INIT_SETTINGS = %i[semantic replace_sidekiq_logger replace_solid_queue_logger].freeze
+
+    # Settings consumed as Rails finishes initializing (`config.after_initialize`),
+    # which runs *after* `config/initializers/*`. They may still be set there, but
+    # changing them after the application has booted has no effect.
+    POST_INIT_SETTINGS = %i[started processing rendered quiet_assets action_message_format].freeze
+
+    attr_reader(*LOGGER_INIT_SETTINGS, *POST_INIT_SETTINGS)
+
+    # DEPRECATED: configure these on the appender instead, via #appenders.
+    attr_reader :ap_options, :format, :filter, :console_logger, :add_file_appender
+
+    LOGGER_INIT_SETTINGS.each do |setting|
+      define_method("#{setting}=") do |value|
+        warn_if_logger_initialized(setting)
+        instance_variable_set(:"@#{setting}", value)
+      end
+    end
+
+    POST_INIT_SETTINGS.each do |setting|
+      define_method("#{setting}=") do |value|
+        warn_if_fully_initialized(setting)
+        instance_variable_set(:"@#{setting}", value)
+      end
+    end
 
     # Setup default values
     def initialize
-      @semantic               = true
-      @started                = false
-      @processing             = false
-      @rendered               = false
-      @ap_options             = {multiline: false}
-      @add_file_appender      = true
-      @quiet_assets           = false
-      @format                 = :default
-      @named_tags             = nil
-      @filter                 = nil
-      @console_logger         = true
-      @action_message_format  = nil
-      @replace_sidekiq_logger = true
+      @semantic                   = true
+      @started                    = false
+      @processing                 = false
+      @rendered                   = false
+      @ap_options                 = {multiline: false}
+      @add_file_appender          = true
+      @quiet_assets               = false
+      @format                     = :default
+      @filter                     = nil
+      @console_logger             = true
+      @action_message_format      = nil
+      @replace_sidekiq_logger     = true
+      @replace_solid_queue_logger = true
+    end
+
+    # Declare the appenders for Rails Semantic Logger to create, replacing the
+    # default file appender:
+    #
+    #   config.rails_semantic_logger.appenders do |appenders|
+    #     appenders.add(file_name: "log/#{Rails.env}.log", formatter: :json)
+    #     appenders.add_server(io: $stdout, formatter: :color)
+    #     appenders.add_console(io: $stderr, formatter: :color)
+    #   end
+    #
+    # The method names the context in which the appender is created; the destination
+    # is an ordinary `SemanticLogger.add_appender` argument. Use `add` for an
+    # appender that is always created, `add_server` for one created only when serving
+    # requests (`rails server`, Sidekiq in server mode; defaults to
+    # `$stdout`), and `add_console` for one created only inside a `rails console`
+    # session (defaults to `$stderr`). Any appender works in any context, so a
+    # context may declare several (e.g. a server-only stdout and file appender).
+    #
+    # `add_server` appenders are created automatically under `rails server` and
+    # Sidekiq in server mode. App servers without a first-party hook (bare puma,
+    # rackup, Passenger, Unicorn) are not detected; create them from the server's
+    # own boot hook instead, e.g. in `config/puma.rb`:
+    #
+    #   on_booted { RailsSemanticLogger.add_server_appenders }
+    #
+    # Returns the underlying RailsSemanticLogger::Appenders collection. When at
+    # least one appender has been declared, the default file appender (and the
+    # `format`, `ap_options`, `filter`, and `add_file_appender` options) is no
+    # longer used.
+    def appenders
+      @appenders ||= RailsSemanticLogger::Appenders.new
+      if block_given?
+        warn_if_logger_initialized(:appenders)
+        yield @appenders
+      end
+      @appenders
+    end
+
+    # Whether the application declared its own appenders via #appenders.
+    def appenders?
+      defined?(@appenders) && @appenders.any?
+    end
+
+    # Marks that Rails Semantic Logger has already built its logger and the
+    # init-time appenders. Called by the engine at the end of the
+    # `:initialize_logger` initializer. After this point, settings that are only
+    # read while building those appenders no longer have any effect, so changing
+    # them emits a warning (see #warn_if_logger_initialized).
+    def logger_initialized!
+      @logger_initialized = true
+    end
+
+    # Marks that Rails has finished initializing the application (the engine's
+    # `config.after_initialize` has run). Called by the engine. After this point,
+    # the POST_INIT_SETTINGS have already been consumed, so changing them warns.
+    def fully_initialized!
+      @fully_initialized = true
+    end
+
+    def ap_options=(value)
+      deprecate_appender_option(:ap_options)
+      warn_if_logger_initialized(:ap_options)
+      @ap_options = value
+    end
+
+    def format=(value)
+      deprecate_appender_option(:format)
+      warn_if_logger_initialized(:format)
+      @format = value
+    end
+
+    def filter=(value)
+      deprecate_appender_option(:filter)
+      warn_if_logger_initialized(:filter)
+      @filter = value
+    end
+
+    def console_logger=(value)
+      deprecate_appender_option(:console_logger, via: "appenders.add_console(...)")
+      @console_logger = value
+    end
+
+    def add_file_appender=(value)
+      deprecate_appender_option(:add_file_appender)
+      warn_if_logger_initialized(:add_file_appender)
+      @add_file_appender = value
+    end
+
+    private
+
+    def deprecate_appender_option(option, via: "appenders.add(...)")
+      RailsSemanticLogger.deprecator.warn(
+        "`config.rails_semantic_logger.#{option}=` is deprecated and will be removed in a future release. " \
+        "Declare the destination and formatting directly instead, via " \
+        "`config.rails_semantic_logger.appenders { |appenders| #{via} }`."
+      )
+    end
+
+    # Warn when an init-time setting is changed after the logger and its
+    # appenders have already been built. This is the classic footgun of putting
+    # logger configuration in `config/initializers/*`, which Rails loads *after*
+    # the logger is initialized, so the change silently has no effect.
+    def warn_if_logger_initialized(setting)
+      return unless defined?(@logger_initialized) && @logger_initialized
+
+      RailsSemanticLogger.warn_initialized_too_late(setting)
+    end
+
+    # Warn when a setting consumed at the end of Rails initialization is changed
+    # after the application has already booted. Unlike #warn_if_logger_initialized,
+    # `config/initializers/*` is *not* too late for these, so it is not suggested.
+    def warn_if_fully_initialized(setting)
+      return unless defined?(@fully_initialized) && @fully_initialized
+
+      RailsSemanticLogger.warn_initialized_too_late(setting, config_initializers_too_late: false)
     end
   end
 end

data/lib/rails_semantic_logger/rack/logger.rb

@@ -31,23 +31,16 @@ module RailsSemanticLogger
 
       private
 
-      @logger                    = SemanticLogger["Rack"]
+      @logger                    = SemanticLogger[::Rack]
       @started_request_log_level = :debug
 
       def call_app(request, env)
         instrumenter        = ActiveSupport::Notifications.instrumenter
-        if (Rails::VERSION::MAJOR == 7 && Rails::VERSION::MINOR >= 1) || Rails::VERSION::MAJOR > 7
-          handle              = instrumenter.build_handle "request.action_dispatch", request: request
-          instrumenter_finish = lambda {
-            handle.finish
-          }
-          handle.start
-        else
-          instrumenter_state  = instrumenter.start "request.action_dispatch", request: request
-          instrumenter_finish = lambda {
-            instrumenter.finish_with_state(instrumenter_state, "request.action_dispatch", request: request)
-          }
-        end
+        handle              = instrumenter.build_handle "request.action_dispatch", request: request
+        instrumenter_finish = lambda {
+          handle.finish
+        }
+        handle.start
 
         logger.send(self.class.started_request_log_level) { started_request_message(request) }
         status, headers, body = @app.call(env)

data/lib/rails_semantic_logger/sidekiq/defaults.rb

@@ -2,38 +2,23 @@ module RailsSemanticLogger
   module Sidekiq
     module Defaults
       # Prevent exception logging during standard error handling since the Job Logger below already logs the exception.
+      # Logs the remaining Sidekiq context at :info (matching upstream Sidekiq's default handler) rather than :warn,
+      # since the exception itself is already logged at :error by the Job Logger.
+      # Sidekiq 7.1.6+ calls error handlers with a third config argument; earlier 7.x versions pass only two.
       ERROR_HANDLER =
-        if ::Sidekiq::VERSION.to_f < 7.1 ||
-           (::Sidekiq::VERSION.to_f == 7.1 && ::Sidekiq::VERSION.split(".").last.to_i < 6)
-          lambda do |_ex, ctx|
-            unless ctx.empty?
-              job_hash = ctx[:job] || {}
-              klass    = job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
-              logger   = klass ? SemanticLogger[klass] : ::Sidekiq.logger
-              ctx[:context] ? logger.warn(ctx[:context], ctx) : logger.warn(ctx)
-            end
-          end
-        else
-          lambda do |_ex, ctx, _default_configuration|
-            unless ctx.empty?
-              job_hash = ctx[:job] || {}
-              klass    = job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
-              logger   = klass ? SemanticLogger[klass] : ::Sidekiq.logger
-              ctx[:context] ? logger.warn(ctx[:context], ctx) : logger.warn(ctx)
-            end
+        lambda do |_ex, ctx, _config = nil|
+          unless ctx.empty?
+            job_hash = ctx[:job] || {}
+            klass    = job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
+            logger   = klass ? SemanticLogger[klass] : ::Sidekiq.logger
+            ctx[:context] ? logger.info(ctx[:context], ctx) : logger.info(ctx)
           end
         end
 
-      # Returns the default logger after removing from the supplied list.
-      # Returns [nil] when the default logger was not present.
+      # Returns the default error handler after removing it from the supplied list.
+      # Returns [nil] when the default handler was not present.
       def self.delete_default_error_handler(error_handlers)
-        return error_handlers.delete(::Sidekiq::Config::ERROR_HANDLER) if defined?(::Sidekiq::Config::ERROR_HANDLER)
-        return error_handlers.delete(::Sidekiq::DEFAULT_ERROR_HANDLER) if defined?(::Sidekiq::DEFAULT_ERROR_HANDLER)
-
-        return unless defined?(::Sidekiq::ExceptionHandler)
-
-        existing = error_handlers.find { |handler| handler.is_a?(::Sidekiq::ExceptionHandler::Logger) }
-        error_handlers.delete(existing) if existing
+        error_handlers.delete(::Sidekiq::Config::ERROR_HANDLER)
       end
     end
   end

data/lib/rails_semantic_logger/sidekiq/job_logger.rb

@@ -1,6 +1,10 @@
 module RailsSemanticLogger
   module Sidekiq
     class JobLogger
+      # Job attributes copied into the logging context, matching Sidekiq's own defaults.
+      # Sidekiq 8 makes this configurable via `config[:logged_job_attributes]`.
+      DEFAULT_LOGGED_JOB_ATTRIBUTES = %w[bid tags].freeze
+
       class << self
         attr_writer :perform_messages
 
@@ -9,8 +13,9 @@ module RailsSemanticLogger
         end
       end
 
-      # Sidekiq 6.5 does not take any arguments, whereas v7 is given a logger
-      def initialize(*_args)
+      # Sidekiq 7 passes its logger, whereas Sidekiq 8 passes its config.
+      def initialize(arg = nil)
+        @config = arg if arg.respond_to?(:[])
       end
 
       def call(item, queue, &block)
@@ -19,7 +24,7 @@ module RailsSemanticLogger
 
         SemanticLogger.tagged(queue: queue) do
           if perform_messages_enabled?
-          # Latency is the time between when the job was enqueued and when it started executing.
+            # Latency is the time between when the job was enqueued and when it started executing.
             logger.info(
               "Start #perform",
               metric:        "sidekiq.queue.latency",
@@ -36,8 +41,8 @@ module RailsSemanticLogger
               metric:             "sidekiq.job.perform",
               &block
             )
-          else
-            yield if block_given?
+          elsif block_given?
+            yield
           end
         end
       end
@@ -56,21 +61,36 @@ module RailsSemanticLogger
       private
 
       def perform_messages_enabled?
+        return false if @config && @config[:skip_default_job_logging]
+
         self.class.perform_messages != false
       end
 
       def job_hash_context(job_hash)
-        h         = {jid: job_hash["jid"]}
-        h[:bid]   = job_hash["bid"] if job_hash["bid"]
-        h[:tags]  = job_hash["tags"] if job_hash["tags"]
+        h = {jid: job_hash["jid"], class: job_hash["wrapped"] || job_hash["class"]}
+        logged_job_attributes.each do |attr|
+          h[attr.to_sym] = job_hash[attr] if job_hash.key?(attr)
+        end
         h[:queue] = job_hash["queue"] if job_hash["queue"]
         h
       end
 
+      def logged_job_attributes
+        (@config && @config[:logged_job_attributes]) || DEFAULT_LOGGED_JOB_ATTRIBUTES
+      end
+
       def job_latency_ms(job)
         return unless job && job["enqueued_at"]
 
-        (Time.now.to_f - job["enqueued_at"].to_f) * 1000
+        enqueued_at = job["enqueued_at"]
+        if enqueued_at.is_a?(Float)
+          # Sidekiq <= 7: seconds since epoch
+          (Time.now.to_f - enqueued_at) * 1000
+        else
+          # Sidekiq 8+: milliseconds since epoch
+          now = Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
+          now - enqueued_at
+        end
       end
     end
   end