rails_semantic_logger 4.19.0 → 5.0.0

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/extensions/sidekiq/sidekiq.rb

@@ -12,12 +12,12 @@ module Sidekiq
   if defined?(::Sidekiq::Logging)
     # Replace Sidekiq logging context
     module Logging
-      def self.with_context(msg, &block)
-        SemanticLogger.tagged(msg, &block)
+      def self.with_context(msg, &)
+        SemanticLogger.tagged(msg, &)
       end
 
       def self.job_hash_context(job_hash)
-        h         = {jid: job_hash["jid"]}
+        h         = {jid: job_hash["jid"], class: job_hash["wrapped"] || job_hash["class"]}
         h[:bid]   = job_hash["bid"] if job_hash["bid"]
         h[:queue] = job_hash["queue"] if job_hash["queue"]
         h
@@ -30,7 +30,7 @@ module Sidekiq
     # Convert string to machine readable format
     class Processor
       def log_context(job_hash)
-        h         = {jid: job_hash["jid"]}
+        h         = {jid: job_hash["jid"], class: job_hash["wrapped"] || job_hash["class"]}
         h[:bid]   = job_hash["bid"] if job_hash["bid"]
         h[:queue] = job_hash["queue"] if job_hash["queue"]
         h
@@ -44,24 +44,41 @@ module Sidekiq
           # rubocop:disable Style/ExplicitBlockArgument
           def call(worker, item, queue)
             SemanticLogger.tagged(queue: queue) do
-              worker.logger.info(
-                "Start #perform",
-                metric:        "sidekiq.queue.latency",
-                metric_amount: job_latency_ms(item)
-              )
-              worker.logger.measure_info(
-                "Completed #perform",
-                on_exception_level: :error,
-                log_exception:      :full,
-                metric:             "sidekiq.job.perform"
-              ) { yield }
+              if perform_messages_enabled?
+                worker.logger.info(
+                  "Start #perform",
+                  metric:        "sidekiq.queue.latency",
+                  metric_amount: job_latency_ms(item)
+                )
+
+                worker.logger.measure_info(
+                  "Completed #perform",
+                  on_exception_level: :error,
+                  log_exception:      :full,
+                  metric:             "sidekiq.job.perform"
+                ) { yield }
+              else
+                yield
+              end
             end
           end
 
+          def perform_messages_enabled?
+            RailsSemanticLogger::Sidekiq::JobLogger.perform_messages != false
+          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

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.
@@ -108,24 +114,175 @@ module RailsSemanticLogger
   #     config.rails_semantic_logger.action_message_format = -> (message, payload) do
   #       "#{message} - #{payload[:controller]}##{payload[:action]}"
   #     end
+  #
+  # * 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
+    # 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
+      @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`, a rack 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,6 +2,8 @@ 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.
       ERROR_HANDLER =
         if ::Sidekiq::VERSION.to_f < 7.1 ||
            (::Sidekiq::VERSION.to_f == 7.1 && ::Sidekiq::VERSION.split(".").last.to_i < 6)
@@ -10,7 +12,7 @@ module RailsSemanticLogger
               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)
+              ctx[:context] ? logger.info(ctx[:context], ctx) : logger.info(ctx)
             end
           end
         else
@@ -19,7 +21,7 @@ module RailsSemanticLogger
               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)
+              ctx[:context] ? logger.info(ctx[:context], ctx) : logger.info(ctx)
             end
           end
         end

data/lib/rails_semantic_logger/sidekiq/job_logger.rb

@@ -1,6 +1,14 @@
 module RailsSemanticLogger
   module Sidekiq
     class JobLogger
+      class << self
+        attr_writer :perform_messages
+
+        def perform_messages
+          instance_variable_defined?(:@perform_messages) ? @perform_messages : true
+        end
+      end
+
       # Sidekiq 6.5 does not take any arguments, whereas v7 is given a logger
       def initialize(*_args)
       end
@@ -10,21 +18,27 @@ module RailsSemanticLogger
         logger = klass ? SemanticLogger[klass] : Sidekiq.logger
 
         SemanticLogger.tagged(queue: queue) do
-          # Latency is the time between when the job was enqueued and when it started executing.
-          logger.info(
-            "Start #perform",
-            metric:        "sidekiq.queue.latency",
-            metric_amount: job_latency_ms(item)
-          )
+          if perform_messages_enabled?
+            # Latency is the time between when the job was enqueued and when it started executing.
+            logger.info(
+              "Start #perform",
+              metric:        "sidekiq.queue.latency",
+              metric_amount: job_latency_ms(item)
+            )
+          end
 
           # Measure the duration of running the job
-          logger.measure_info(
-            "Completed #perform",
-            on_exception_level: :error,
-            log_exception:      :full,
-            metric:             "sidekiq.job.perform",
-            &block
-          )
+          if perform_messages_enabled?
+            logger.measure_info(
+              "Completed #perform",
+              on_exception_level: :error,
+              log_exception:      :full,
+              metric:             "sidekiq.job.perform",
+              &block
+            )
+          elsif block_given?
+            yield
+          end
         end
       end
 
@@ -41,8 +55,12 @@ module RailsSemanticLogger
 
       private
 
+      def perform_messages_enabled?
+        self.class.perform_messages != false
+      end
+
       def job_hash_context(job_hash)
-        h         = {jid: job_hash["jid"]}
+        h         = {jid: job_hash["jid"], class: job_hash["wrapped"] || job_hash["class"]}
         h[:bid]   = job_hash["bid"] if job_hash["bid"]
         h[:tags]  = job_hash["tags"] if job_hash["tags"]
         h[:queue] = job_hash["queue"] if job_hash["queue"]
@@ -52,7 +70,15 @@ module RailsSemanticLogger
       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