rails_semantic_logger 4.20.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

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`, 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

@@ -19,7 +19,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 +36,8 @@ module RailsSemanticLogger
               metric:             "sidekiq.job.perform",
               &block
             )
-          else
-            yield if block_given?
+          elsif block_given?
+            yield
           end
         end
       end
@@ -60,7 +60,7 @@ module RailsSemanticLogger
       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"]
@@ -70,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

data/lib/rails_semantic_logger/solid_queue/log_subscriber.rb

@@ -0,0 +1,179 @@
+module RailsSemanticLogger
+  module SolidQueue
+    class LogSubscriber < ::ActiveSupport::LogSubscriber
+      def dispatch_scheduled(event)
+        log_event(event, :debug, "Dispatch scheduled jobs", **event.payload.slice(:batch_size, :size))
+      end
+
+      def claim(event)
+        log_event(event, :debug, "Claim jobs", **event.payload.slice(:process_id, :job_ids, :claimed_job_ids, :size))
+      end
+
+      def release_many_claimed(event)
+        log_event(event, :info, "Release claimed jobs", **event.payload.slice(:size))
+      end
+
+      def fail_many_claimed(event)
+        log_event(event, :warn, "Fail claimed jobs", **event.payload.slice(:job_ids, :process_ids))
+      end
+
+      def release_claimed(event)
+        log_event(event, :info, "Release claimed job", **event.payload.slice(:job_id, :process_id))
+      end
+
+      def retry_all(event)
+        log_event(event, :debug, "Retry failed jobs", **event.payload.slice(:jobs_size, :size))
+      end
+
+      def retry(event)
+        log_event(event, :debug, "Retry failed job", **event.payload.slice(:job_id))
+      end
+
+      def discard_all(event)
+        log_event(event, :debug, "Discard jobs", **event.payload.slice(:jobs_size, :size, :status))
+      end
+
+      def discard(event)
+        log_event(event, :debug, "Discard job", **event.payload.slice(:job_id, :status))
+      end
+
+      def release_many_blocked(event)
+        log_event(event, :debug, "Unblock jobs", **event.payload.slice(:limit, :size))
+      end
+
+      def release_blocked(event)
+        log_event(event, :debug, "Release blocked job", **event.payload.slice(:job_id, :concurrency_key, :released))
+      end
+
+      def enqueue_recurring_task(event)
+        attributes      = event.payload.slice(:task, :active_job_id, :enqueue_error)
+        attributes[:at] = event.payload[:at]&.iso8601
+
+        if attributes[:active_job_id].nil? && event.payload[:skipped].nil?
+          log_event(event, :error, "Error enqueuing recurring task", **attributes)
+        elsif event.payload[:other_adapter]
+          log_event(event, :debug, "Enqueued recurring task outside Solid Queue", **attributes)
+        else
+          action = event.payload[:skipped].present? ? "Skipped recurring task – already dispatched" : "Enqueued recurring task"
+          log_event(event, :debug, action, **attributes)
+        end
+      end
+
+      def start_process(event)
+        process    = event.payload[:process]
+        attributes = process_attributes(process).merge(process.metadata)
+
+        log_event(event, :info, "Started #{process.kind}", **attributes)
+      end
+
+      def shutdown_process(event)
+        process    = event.payload[:process]
+        attributes = process_attributes(process).merge(process.metadata)
+
+        log_event(event, :info, "Shutdown #{process.kind}", **attributes)
+      end
+
+      def register_process(event)
+        process_kind = event.payload[:kind]
+        attributes   = event.payload.slice(:pid, :hostname, :process_id, :name)
+
+        if (error = event.payload[:error])
+          log_event(event, :warn, "Error registering #{process_kind}", exception: error, **attributes)
+        else
+          log_event(event, :debug, "Register #{process_kind}", **attributes)
+        end
+      end
+
+      def deregister_process(event)
+        process    = event.payload[:process]
+        attributes = {
+          process_id:        process.id,
+          pid:               process.pid,
+          hostname:          process.hostname,
+          name:              process.name,
+          last_heartbeat_at: process.last_heartbeat_at.iso8601,
+          claimed_size:      event.payload[:claimed_size],
+          pruned:            event.payload[:pruned]
+        }
+
+        if (error = event.payload[:error])
+          log_event(event, :warn, "Error deregistering #{process.kind}", exception: error, **attributes)
+        else
+          log_event(event, :debug, "Deregister #{process.kind}", **attributes)
+        end
+      end
+
+      def prune_processes(event)
+        log_event(event, :debug, "Prune dead processes", **event.payload.slice(:size))
+      end
+
+      def thread_error(event)
+        log_event(event, :error, "Error in thread", exception: event.payload[:error])
+      end
+
+      def graceful_termination(event)
+        attributes = event.payload.slice(:process_id, :supervisor_pid, :supervised_processes)
+
+        if event.payload[:shutdown_timeout_exceeded]
+          log_event(event, :warn, "Supervisor wasn't terminated gracefully - shutdown timeout exceeded", **attributes)
+        else
+          log_event(event, :info, "Supervisor terminated gracefully", **attributes)
+        end
+      end
+
+      def immediate_termination(event)
+        log_event(event, :info, "Supervisor terminated immediately",
+                  **event.payload.slice(:process_id, :supervisor_pid, :supervised_processes))
+      end
+
+      def unhandled_signal_error(event)
+        log_event(event, :error, "Received unhandled signal", **event.payload.slice(:signal))
+      end
+
+      def replace_fork(event)
+        supervisor_pid = event.payload[:supervisor_pid]
+        status         = event.payload[:status]
+        attributes     = event.payload.slice(:pid).merge(
+          status:          status.exitstatus || "no exit status set",
+          pid_from_status: status.pid,
+          signaled:        status.signaled?,
+          stopsig:         status.stopsig,
+          termsig:         status.termsig
+        )
+
+        if (replaced_fork = event.payload[:fork])
+          log_event(event, :info, "Replaced terminated #{replaced_fork.kind}",
+                    **attributes, hostname: replaced_fork.hostname, name: replaced_fork.name)
+        elsif supervisor_pid != 1 # Running Docker, possibly having some processes that have been reparented
+          log_event(event, :warn, "Tried to replace forked process but it had already died", **attributes)
+        end
+      end
+
+      private
+
+      def process_attributes(process)
+        {
+          pid:        process.pid,
+          hostname:   process.hostname,
+          process_id: process.process_id,
+          name:       process.name
+        }
+      end
+
+      def log_event(event, level, action, exception: nil, **attributes)
+        logger.public_send(level) do
+          msg = {message: action, payload: attributes, duration: event.duration}
+          msg[:exception] = exception if exception
+          # Emit a metric for every info/warn/error entry, named after the notification
+          # (e.g. "start_process.solid_queue" -> "rails.solid_queue.start_process"). Debug entries are excluded.
+          msg[:metric] = "rails.solid_queue.#{event.name.split('.').first}" unless level == :debug
+          msg
+        end
+      end
+
+      def logger
+        @logger ||= SemanticLogger[::SolidQueue]
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module RailsSemanticLogger
-  VERSION = "4.20.0".freeze
+  VERSION = "5.0.0".freeze
 end