rails_semantic_logger 4.20.0 → 5.1.0

data/lib/rails_semantic_logger/active_record/log_subscriber.rb

@@ -1,42 +1,61 @@
+# This subscriber is a reimplementation of Rails' own ActiveRecord::LogSubscriber that emits
+# structured (message + payload) log entries instead of formatted text. When Rails changes its
+# subscriber, those changes must be brought across here. Compare against the upstream source for
+# each supported Rails version:
+#
+#   Rails 8.1: https://github.com/rails/rails/blob/8-1-stable/activerecord/lib/active_record/log_subscriber.rb
+#   Rails 8.0: https://github.com/rails/rails/blob/8-0-stable/activerecord/lib/active_record/log_subscriber.rb
+#   Rails 7.2: https://github.com/rails/rails/blob/7-2-stable/activerecord/lib/active_record/log_subscriber.rb
+#
+# The upstream subscriber is functionally identical across Rails 7.2, 8.0, and 8.1 for everything
+# that affects structured output. The only differences between those versions are in the internal
+# `query_source_location` helper (used by `verbose_query_logs` to print the "↳ source" line) and a
+# `:nodoc:` comment, neither of which changes the event payload. As a result no version-specific
+# behavior is required here.
+#
+# As of Rails 8.1 there is also a parallel ActiveRecord::StructuredEventSubscriber (it emits
+# structured events to Rails.event rather than text to Rails.logger). It is the authoritative,
+# Rails-maintained reference for field names and payload shape; the fields below (e.g. :lock_wait
+# and the strict_loading_violation payload) follow it. We do not use it (see CLAUDE.md), but diff
+# against it when adding fields:
+#
+#   Rails 8.1: https://github.com/rails/rails/blob/8-1-stable/activerecord/lib/active_record/structured_event_subscriber.rb
 module RailsSemanticLogger
   module ActiveRecord
     class LogSubscriber < ActiveSupport::LogSubscriber
       IGNORE_PAYLOAD_NAMES = %w[SCHEMA EXPLAIN].freeze
 
-      class << self
-        attr_reader :logger
-      end
+      def strict_loading_violation(event)
+        return unless logger.debug?
 
-      # Rails 7.1 stopped using runtime in log subscribers
-      if Rails.version.to_f < 7.1
-        def self.runtime=(value)
-          ::ActiveRecord::RuntimeRegistry.sql_runtime = value
-        end
+        payload    = event.payload
+        owner      = payload[:owner]
+        reflection = payload[:reflection]
 
-        def self.runtime
-          ::ActiveRecord::RuntimeRegistry.sql_runtime ||= 0
-        end
+        log_payload = {owner: owner.name, association: reflection.name}
+        log_payload[:class] = reflection.klass.name unless reflection.polymorphic?
 
-        def self.reset_runtime
-          rt           = runtime
-          self.runtime = 0
-          rt
-        end
+        logger.debug(
+          message: reflection.strict_loading_violation_message(owner),
+          payload: log_payload
+        )
       end
 
       def sql(event)
-        self.class.runtime += event.duration if self.class.respond_to?(:runtime)
         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_payload[:async] = true if event.payload[:async]
+        log_payload               = {sql: payload[:sql]}
+        log_payload[:binds]       = bind_values(payload) unless (payload[:binds] || []).empty?
+        log_payload[:allocations] = event.allocations
+        log_payload[:cached]      = true if payload[:cached]
+        if payload[:async]
+          log_payload[:async]     = true
+          log_payload[:lock_wait] = payload[:lock_wait] if payload[:lock_wait]
+        end
 
         log = {
           message:  name,
@@ -54,137 +73,38 @@ module RailsSemanticLogger
 
       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?
 
-        if rails_filter_params_include?(key)
-          value = "[FILTERED]"
-        elsif binds.key?(key)
-          value = (Array(binds[key]) << value)
-        end
-
+        value      = (Array(binds[key]) << value) if binds.key?(key)
         binds[key] = value
       end
 
-      def rails_filter_params_include?(key)
-        filter_parameters = Rails.configuration.filter_parameters
-
-        return filter_parameters.first.match? key if filter_parameters.first.is_a? Regexp
-
-        filter_parameters.include? key
-      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
+        ::ActiveRecord::Base.logger
       end
 
-      def bind_values_v6_1(payload)
+      def bind_values(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])
+          filtered_value   = filter(attribute_name(attr, i), casted_params[i])
+          attr_name, value = render_bind(attr, filtered_value)
           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]
+      def attribute_name(attr, index)
+        if attr.respond_to?(:name)
+          attr.name
+        elsif attr.respond_to?(:[]) && attr[index].respond_to?(:name)
+          attr[index].name
         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)
+      def render_bind(attr, value)
         case attr
         when ActiveModel::Attribute
           value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>" if attr.type.binary? && attr.value
@@ -197,37 +117,19 @@ module RailsSemanticLogger
         [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
+      # Filter sensitive bind values using the same parameter filter Rails uses for ActiveRecord,
+      # which is derived from ActiveRecord::Base.filter_attributes (config.filter_parameters).
+      def filter(name, value)
+        return value if name.nil?
 
-      def type_casted_binds_v5_1_5(casted_binds)
-        casted_binds.respond_to?(:call) ? casted_binds.call : casted_binds
+        filtered = ::ActiveRecord::Base.inspection_filter.filter_param(name.to_s, value)
+        # filter_param returns the same object when nothing was filtered, otherwise a mask object
+        # (a String delegate). Coerce the mask to a plain String for clean structured output.
+        filtered.equal?(value) ? value : filtered.to_s
       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) ||
-            Rails::VERSION::MAJOR >= 7 # ~> 6.1.0 && >= 7.x.x
-        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
+      def type_casted_binds(casted_binds)
+        casted_binds.respond_to?(:call) ? casted_binds.call : casted_binds
       end
     end
   end

data/lib/rails_semantic_logger/appenders.rb

@@ -0,0 +1,92 @@
+module RailsSemanticLogger
+  # Collects the appenders declared by the application via:
+  #
+  #   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
+  #
+  # When at least one appender is declared this way, Rails Semantic Logger stops
+  # building its own default file appender (`format`, `ap_options`, `filter`, and
+  # `add_file_appender` no longer apply) and instead creates exactly the appenders
+  # declared here.
+  #
+  # The methods name the *context* in which the appender is created; the
+  # destination and formatting are ordinary `SemanticLogger.add_appender` arguments:
+  #
+  #   #add         - always created, during Rails initialization.
+  #   #add_server  - created only when serving requests (`rails server`, Sidekiq
+  #                  in server mode). Defaults to `$stdout`.
+  #   #add_console - created only inside a `rails console` session. Defaults to
+  #                  `$stderr` so log output does not tangle with command results.
+  #
+  # Because each call appends to its context, any appender works in any context,
+  # and a context can have several (e.g. a server-only stdout *and* file appender).
+  class Appenders
+    include Enumerable
+
+    # Destination keys understood by SemanticLogger.add_appender. When none is
+    # supplied to #add_server / #add_console, the context's default stream is used.
+    DESTINATIONS = %i[io file_name appender logger metric].freeze
+
+    def initialize
+      @definitions = []
+      @server      = []
+      @console     = []
+    end
+
+    # Declare an appender. Accepts the same arguments (and optional block) as
+    # SemanticLogger.add_appender. Returns self so calls can be chained.
+    def add(**args, &block)
+      @definitions << [args, block]
+      self
+    end
+
+    # Declare an appender that is only created when the application is serving
+    # requests: `rails server`, Sidekiq in server mode, or when the app calls
+    # RailsSemanticLogger.add_server_appenders from its own server's boot hook.
+    # It is never created during a non-serving boot (rake tasks, runners,
+    # generators), so it only appears where it is useful.
+    #
+    # Accepts the same arguments (and optional block) as SemanticLogger.add_appender.
+    # When no destination is given it defaults to `$stdout`; the formatter defaults
+    # to `:color`.
+    def add_server(**args, &block)
+      @server << [defaults(args, io: $stdout), block]
+      self
+    end
+
+    # Declare an appender that is only created when running inside a `rails console`
+    # session. Identical to #add_server except it defaults to `$stderr`.
+    #
+    # Accepts the same arguments (and optional block) as SemanticLogger.add_appender.
+    def add_console(**args, &block)
+      @console << [defaults(args, io: $stderr), block]
+      self
+    end
+
+    # The appenders declared via #add_server / #add_console, each as
+    # [Hash args, Proc|nil block].
+    attr_reader :server, :console
+
+    # Yields each #add declaration as [Hash args, Proc|nil block].
+    def each(&)
+      @definitions.each(&)
+    end
+
+    def any?
+      @definitions.any? || @server.any? || @console.any?
+    end
+
+    private
+
+    # Apply the context default stream and formatter, without overriding a
+    # destination (io/file_name/...) the caller already supplied.
+    def defaults(args, io:)
+      args = {formatter: :color}.merge(args)
+      args[:io] = io unless DESTINATIONS.any? { |key| args.key?(key) }
+      args
+    end
+  end
+end

data/lib/rails_semantic_logger/engine.rb

@@ -42,9 +42,13 @@ module RailsSemanticLogger
       # 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
+          if config.rails_semantic_logger.appenders?
+            # The application declared its own appenders; create those and skip the default file appender.
+            RailsSemanticLogger.add_appenders(config.rails_semantic_logger.appenders)
+          elsif config.rails_semantic_logger.add_file_appender
+            # DEPRECATED: This option is deprecated and will be removed in a future version.
             path = config.paths["log"].first
-            FileUtils.mkdir_p(File.dirname(path)) unless File.exist?(File.dirname(path))
+            FileUtils.mkdir_p(File.dirname(path))
 
             # Add the log file to the list of appenders
             # Use the colorized formatter if Rails colorized logs are enabled
@@ -63,31 +67,42 @@ module RailsSemanticLogger
 
               app.formatter = formatter
             end
-            SemanticLogger.add_appender(file_name: path, formatter: formatter, filter: config.rails_semantic_logger.filter)
+            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
+          # If unable to create the appenders, 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)
 
+          message =
+            if path
+              "Rails Error: Unable to access log file. Please ensure that #{path} exists and is chmod 0666."
+            else
+              "Rails Error: Unable to create the configured appenders."
+            end
           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.",
+            "#{message} The log level has been raised to WARN and the output directed to STDERR " \
+            "until the problem is fixed.",
             e
           )
           logger
         end
 
+      # Logger and init-time appenders are now built; settings read above no
+      # longer take effect, so flag late changes (e.g. from config/initializers).
+      config.rails_semantic_logger.logger_initialized!
+
       # 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"] }
+      ActiveSupport.on_load(:action_cable) { self.logger = SemanticLogger[::ActionCable] }
     end
 
     # Before any initializers run, but after the gems have been loaded
@@ -105,7 +120,7 @@ module RailsSemanticLogger
       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
       if config.rails_semantic_logger.replace_sidekiq_logger && defined?(::Sidekiq)
@@ -114,42 +129,44 @@ module RailsSemanticLogger
         end
 
         ::Sidekiq.configure_server do |config|
-          config.logger = ::SemanticLogger[::Sidekiq]
-          if config.respond_to?(:options)
-            config.options[:job_logger] = RailsSemanticLogger::Sidekiq::JobLogger
-          else
-            config[:job_logger] = RailsSemanticLogger::Sidekiq::JobLogger
-          end
+          config.logger       = ::SemanticLogger[::Sidekiq]
+          config[:job_logger] = RailsSemanticLogger::Sidekiq::JobLogger
 
-          # Add back the default console logger unless already added
-          SemanticLogger.add_appender(io: $stdout, formatter: :color) unless SemanticLogger.appenders.console_output?
+          # Add back the default console logger (unless the app declared its own appenders, or one exists)
+          RailsSemanticLogger.add_server_appenders
 
           # Replace default error handler when present
           existing = RailsSemanticLogger::Sidekiq::Defaults.delete_default_error_handler(config.error_handlers)
           config.error_handlers << RailsSemanticLogger::Sidekiq::Defaults::ERROR_HANDLER if existing
         end
 
-        if defined?(::Sidekiq::Job) && (::Sidekiq::VERSION.to_i != 5)
-          ::Sidekiq::Job.singleton_class.prepend(RailsSemanticLogger::Sidekiq::Loggable)
-        else
-          ::Sidekiq::Worker.singleton_class.prepend(RailsSemanticLogger::Sidekiq::Loggable)
-        end
+        ::Sidekiq::Job.singleton_class.prepend(RailsSemanticLogger::Sidekiq::Loggable)
+      end
+
+      # Replace the SolidQueue logger
+      if config.rails_semantic_logger.replace_solid_queue_logger &&
+         defined?(::SolidQueue) && ::SolidQueue.respond_to?(:logger=)
+        ::SolidQueue.logger = SemanticLogger[::SolidQueue]
       end
 
       # Replace the Sidetiq logger
       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
+      Delayed::Worker.logger = SemanticLogger[Delayed::Worker] if defined?(Delayed::Worker)
 
       # Replace the Bugsnag logger
       Bugsnag.configure(false) { |config| config.logger = SemanticLogger[Bugsnag] } if defined?(Bugsnag)
 
       # Set the IOStreams PGP logger
-      IOStreams::Pgp.logger = SemanticLogger["IOStreams::Pgp"] if defined?(IOStreams)
+      if defined?(IOStreams)
+        if IOStreams.respond_to?(:logger=)
+          IOStreams.logger = SemanticLogger[IOStreams]
+        else
+          # Older IOStreams versions
+          IOStreams::Pgp.logger = SemanticLogger[IOStreams::Pgp]
+        end
+      end
     end
 
     # After any initializers run, but after the gems have been loaded
@@ -207,14 +224,18 @@ module RailsSemanticLogger
         if config.rails_semantic_logger.quiet_assets && config.respond_to?(: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 }
+          RailsSemanticLogger::Rack::Logger.logger.filter = lambda do |log|
+            log.payload[:path] !~ assets_regex if log.payload
+          end
         end
 
         # Action View
         if defined?(::ActionView)
           require "action_view/log_subscriber"
 
-          RailsSemanticLogger::ActionView::LogSubscriber.rendered_log_level = :info if config.rails_semantic_logger.rendered
+          if config.rails_semantic_logger.rendered
+            RailsSemanticLogger::ActionView::LogSubscriber.rendered_log_level = :info
+          end
           RailsSemanticLogger.swap_subscriber(
             ::ActionView::LogSubscriber,
             RailsSemanticLogger::ActionView::LogSubscriber,
@@ -226,7 +247,9 @@ module RailsSemanticLogger
         if defined?(::ActionController)
           require "action_controller/log_subscriber"
 
-          RailsSemanticLogger::ActionController::LogSubscriber.action_message_format = config.rails_semantic_logger.action_message_format
+          subscriber                       = RailsSemanticLogger::ActionController::LogSubscriber
+          subscriber.action_message_format = config.rails_semantic_logger.action_message_format
+          subscriber.processing_log_level  = :info if config.rails_semantic_logger.processing
           RailsSemanticLogger.swap_subscriber(
             ::ActionController::LogSubscriber,
             RailsSemanticLogger::ActionController::LogSubscriber,
@@ -245,46 +268,34 @@ module RailsSemanticLogger
           )
         end
 
-        if config.rails_semantic_logger.replace_sidekiq_logger && defined?(::Sidekiq)
-          require("rails_semantic_logger/extensions/sidekiq/sidekiq")
-        end
-      end
-
-      #
-      # 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
+        # SolidQueue
+        if config.rails_semantic_logger.replace_solid_queue_logger && defined?(::SolidQueue::LogSubscriber)
+          RailsSemanticLogger.swap_subscriber(
+            ::SolidQueue::LogSubscriber,
+            RailsSemanticLogger::SolidQueue::LogSubscriber,
+            :solid_queue
+          )
         end
       end
 
-      # Re-open appenders after Resque has forked a worker
-      Resque.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Resque.after_fork)
-
-      # Re-open appenders after Spring has forked a process
-      Spring.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Spring.after_fork)
-
-      # Re-open appenders after SolidQueue worker/dispatcher/scheduler has finished booting
-      SolidQueue.on_start { ::SemanticLogger.reopen } if defined?(SolidQueue.on_start)
-      SolidQueue.on_worker_start { ::SemanticLogger.reopen } if defined?(SolidQueue.on_worker_start)
-      SolidQueue.on_dispatcher_start { ::SemanticLogger.reopen } if defined?(SolidQueue.on_dispatcher_start)
-      SolidQueue.on_scheduler_start { ::SemanticLogger.reopen } if defined?(SolidQueue.on_scheduler_start)
+      # Forking frameworks (Passenger, Resque, Spring, SolidQueue, etc.) no longer
+      # need explicit reopen hooks: Semantic Logger v5 reopens appenders automatically
+      # in the child via a Process._fork / Process.daemon hook. Apps that opt out with
+      # `SemanticLogger.reopen_on_fork = false` are responsible for reopening themselves.
 
       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
+        RailsSemanticLogger.add_console_appenders
 
         # Include method names on log entries in the console
         SemanticLogger.backtrace_level = SemanticLogger.default_level
       end
+
+      # Initialization is complete; the post-init settings have been consumed, so
+      # flag changes made after this point (e.g. at runtime) as having no effect.
+      config.rails_semantic_logger.fully_initialized!
     end
   end
 end

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

@@ -1,11 +1,69 @@
 require "action_cable/connection/tagged_logger_proxy"
 
+# Upstream source (identical across supported versions):
+#   https://github.com/rails/rails/blob/v7.2.2/actioncable/lib/action_cable/connection/tagged_logger_proxy.rb
+#   https://github.com/rails/rails/blob/v8.0.2/actioncable/lib/action_cable/connection/tagged_logger_proxy.rb
+#   https://github.com/rails/rails/blob/v8.1.3/actioncable/lib/action_cable/connection/tagged_logger_proxy.rb
 module ActionCable
   module Connection
     class TaggedLoggerProxy
-      def tag(logger, &block)
-        current_tags = tags - logger.tags
-        logger.tagged(*current_tags, &block)
+      # Mirrors upstream #tag, including the `respond_to?(:tagged)` guard so a
+      # target logger without tagging support (e.g. when handed a non-tagged
+      # ActiveRecord::Base.logger by the worker pool) simply yields. Diverges in
+      # one place: upstream reads the already-applied tags via
+      # `logger.formatter.current_tags` (ActiveSupport::TaggedLogging), but
+      # Semantic Logger exposes them via `#tags`, so resolve from whichever the
+      # target logger supports. See #220.
+      def tag(logger, &)
+        if logger.respond_to?(:tagged)
+          current_tags = tags - applied_tags_for(logger)
+          logger.tagged(*current_tags, &)
+        else
+          yield
+        end
+      end
+
+      # Upstream defines the severity methods with a single-arg signature
+      # (`message = nil`), which discards Semantic Logger's richer payload and
+      # exception arguments and raises ArgumentError when they are supplied.
+      # Redefine them to forward the full Semantic Logger signature down to the
+      # wrapped logger, while still applying the connection's tags. See #220.
+      %i[debug info warn error fatal unknown].each do |severity|
+        define_method(severity) do |message = nil, payload = nil, exception = nil, &block|
+          tag(@logger) { forward(severity, message, payload, exception, &block) }
+        end
+      end
+
+      private
+
+      # Only forward the extra payload/exception arguments when the wrapped logger's
+      # method can accept them. A standard Ruby Logger (e.g. the one wrapped by
+      # ActionCable::Connection::TestCase) only accepts a single `progname` argument
+      # and raises ArgumentError given more, so fall back to the single-arg call. See #317.
+      def forward(severity, message, payload, exception, &)
+        if extended_signature?(@logger, severity)
+          @logger.public_send(severity, message, payload, exception, &)
+        else
+          @logger.public_send(severity, message, &)
+        end
+      end
+
+      def extended_signature?(logger, severity)
+        params = logger.method(severity).parameters
+        params.any? { |type, _| type == :rest } || params.count { |type, _| %i[req opt].include?(type) } >= 3
+      end
+
+      # Tags already applied to the target logger, so they are not duplicated.
+      # Semantic Logger exposes them via `#tags`; ActiveSupport::TaggedLogging
+      # via `formatter.current_tags`. Fall back to none when neither is present.
+      def applied_tags_for(logger)
+        if logger.respond_to?(:tags)
+          Array(logger.tags)
+        elsif logger.respond_to?(:formatter) && logger.formatter.respond_to?(:current_tags)
+          logger.formatter.current_tags
+        else
+          []
+        end
       end
     end
   end