rails_semantic_logger 4.19.0 → 5.0.0

data/lib/rails_semantic_logger/active_record/log_subscriber.rb

@@ -1,46 +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
-      RAILS_VERSION_ENDING_SET_RUNTIME_SUPPORT = Gem::Version.new( "8.0.3")
 
-      class << self
-        attr_reader :logger
-      end
+      def strict_loading_violation(event)
+        return unless logger.debug?
 
-      def self.runtime=(value)
-        return if Rails.version >= RAILS_VERSION_ENDING_SET_RUNTIME_SUPPORT
+        payload    = event.payload
+        owner      = payload[:owner]
+        reflection = payload[:reflection]
 
-        ::ActiveRecord::RuntimeRegistry.respond_to?(:stats) ?
-          ::ActiveRecord::RuntimeRegistry.stats.sql_runtime = value :
-          ::ActiveRecord::RuntimeRegistry.sql_runtime = value
-      end
+        log_payload = {owner: owner.name, association: reflection.name}
+        log_payload[:class] = reflection.klass.name unless reflection.polymorphic?
 
-      def self.runtime
-        ::ActiveRecord::RuntimeRegistry.respond_to?(:stats) ?
-          ::ActiveRecord::RuntimeRegistry.stats.sql_runtime ||= 0 :
-          ::ActiveRecord::RuntimeRegistry.sql_runtime ||= 0
-      end
-
-      def self.reset_runtime
-        rt           = runtime
-        self.runtime = 0
-        rt
+        logger.debug(
+          message: reflection.strict_loading_violation_message(owner),
+          payload: log_payload
+        )
       end
 
       def sql(event)
-        self.class.runtime += event.duration
         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,
@@ -58,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
@@ -201,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,91 @@
+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`, a rack
+  #                  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`, a rack server started directly (puma, etc.), or
+    # Sidekiq in server mode. 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,7 +42,11 @@ 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))
 
@@ -83,11 +87,15 @@ module RailsSemanticLogger
           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,24 +113,24 @@ 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 defined?(::Sidekiq)
+      if config.rails_semantic_logger.replace_sidekiq_logger && defined?(::Sidekiq)
         ::Sidekiq.configure_client do |config|
           config.logger = ::SemanticLogger[::Sidekiq]
         end
 
         ::Sidekiq.configure_server do |config|
           config.logger = ::SemanticLogger[::Sidekiq]
-          if config.respond_to?(:options)
+          if ::Sidekiq::VERSION.to_i < 6 || (::Sidekiq::VERSION.to_i == 6 && ::Sidekiq::VERSION.to_f < 6.5)
             config.options[:job_logger] = RailsSemanticLogger::Sidekiq::JobLogger
           else
             config[:job_logger] = RailsSemanticLogger::Sidekiq::JobLogger
           end
 
-          # 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)
@@ -136,20 +144,29 @@ module RailsSemanticLogger
         end
       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
@@ -226,7 +243,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,44 +264,38 @@ module RailsSemanticLogger
           )
         end
 
-        require("rails_semantic_logger/extensions/sidekiq/sidekiq") if defined?(::Sidekiq)
-      end
-
-      #
-      # Forking Frameworks
-      #
+        if config.rails_semantic_logger.replace_sidekiq_logger && defined?(::Sidekiq)
+          require("rails_semantic_logger/extensions/sidekiq/sidekiq")
+        end
 
-      # 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,52 @@
 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) { @logger.public_send(severity, message, payload, exception, &block) }
+        end
+      end
+
+      private
+
+      # 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

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