rails_semantic_logger 5.0.0 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 213d85a11e285b1353549f41b8a8c28068a33d3913e270d72eed94f6ee1d861c
-  data.tar.gz: 8233c4128fdc790e3cefedd3efc8d8c6b274393604527cc162dff97842227fea
+  metadata.gz: '08056406dee88f7c5eb0d29107d9d82b95487cf913ace9a6dd292c49641f58c4'
+  data.tar.gz: 5dfdb7970f4baf88676218aa9a0778245957c094dc1ee7103e7940c456a54e06
 SHA512:
-  metadata.gz: 52330aaea8cf48aa21a62b8c5654163ce481382fa67bd6935c02d3deecfcef3a83a32b30c563941eb49404d86063ff2056778692781bd14a96174b55d2372f9f
-  data.tar.gz: 5da348c363745f1e3b7a2fc73c36221658f86dafcad53d5078990d9d204fe5bf2224a319a156395597a7916bb2a950b1c27974114bbee37662f388295999758a
+  metadata.gz: e138fdae60edf8a40b1e0b57d4b351bc0069b48550f0ecd0ee443ef8bbb154984c8923a07632d441cf154b39f7777e266073254f6cd57bd6bf83c26dd59c5b63
+  data.tar.gz: 5e7e1e27aded0d3a1731cab0f756dfada2d11dcf1f2a756bd41ecfa912c44f9931649df0a2e56f32d21328a64f22db1a9f97c02c6ac939f17974342f4805c7d8

data/README.md

@@ -1,7 +1,7 @@
 # Rails Semantic Logger
 [![Gem Version](https://img.shields.io/gem/v/rails_semantic_logger.svg)](https://rubygems.org/gems/rails_semantic_logger) [![Build Status](https://github.com/reidmorrison/rails_semantic_logger/workflows/build/badge.svg)](https://github.com/reidmorrison/rails_semantic_logger/actions?query=workflow%3Abuild) [![Downloads](https://img.shields.io/gem/dt/rails_semantic_logger.svg)](https://rubygems.org/gems/rails_semantic_logger) [![License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](http://opensource.org/licenses/Apache-2.0) ![](https://img.shields.io/badge/status-Production%20Ready-blue.svg)
 
-Rails Semantic Logger replaces the Rails default logger with [Semantic Logger](https://logger.rocketjob.io/), so that Rails, your application code, and many common gems all log through structured logging instead of plain text.
+Rails Semantic Logger replaces the Rails default logger with [Semantic Logger](https://logger.reidmorrison.com/), so that Rails, your application code, and many common gems all log through structured logging instead of plain text.
 
 When any large Rails application is deployed to production one of the first steps is to move to centralized logging, so that logs can be viewed and searched from a central location. That quickly falls apart when consuming human readable text logs:
 
@@ -67,17 +67,17 @@ end
 
 Because declaring an appender replaces the default file appender, JSON to stdout becomes the only destination, exactly what a container platform wants. Once logs are emitted as structured JSON, a centralized logging system can parse each field, including the nested `payload` and any `metric` data, into a searchable hierarchy, so you can build searches, alerts, and dashboards against well-defined fields instead of brittle text matching.
 
-See [Configuring appenders](https://logger.rocketjob.io/rails#configuring-where-logs-go-the-appenders-block) for the full guide, including formatters, third-party destinations, the [container platform recipe](https://logger.rocketjob.io/rails#production-on-a-container-platform-docker-kubernetes-heroku), tuning what Rails logs, and worked examples of querying the JSON.
+See [Configuring appenders](https://logger.reidmorrison.com/rails#configuring-where-logs-go-the-appenders-block) for the full guide, including formatters, third-party destinations, the [container platform recipe](https://logger.reidmorrison.com/rails#production-on-a-container-platform-docker-kubernetes-heroku), tuning what Rails logs, and worked examples of querying the JSON.
 
 ## Documentation
 
-For complete documentation see: https://logger.rocketjob.io/rails
+For complete documentation see: https://logger.reidmorrison.com/rails
 
 ## Upgrading
 
 The way appenders (log destinations) are configured changed in v5. See the
-[v4 to v5 migration guide](https://logger.rocketjob.io/rails#migrating-from-v4-to-v5) for the
-before/after mapping, and [Migrating from earlier versions](https://logger.rocketjob.io/rails#migrating-from-earlier-versions)
+[v4 to v5 migration guide](https://logger.reidmorrison.com/rails#migrating-from-v4-to-v5) for the
+before/after mapping, and [Migrating from earlier versions](https://logger.reidmorrison.com/rails#migrating-from-earlier-versions)
 for older releases.
 
 ## New Versions of Rails, etc.

data/Rakefile

@@ -5,10 +5,12 @@ require "bundler/setup"
 require "rake/testtask"
 require_relative "lib/rails_semantic_logger/version"
 
+desc "Build the gem"
 task :gem do
   system "gem build rails_semantic_logger.gemspec"
 end
 
+desc "Build and publish the gem, and tag the release"
 task publish: :gem do
   system "git tag -a v#{RailsSemanticLogger::VERSION} -m 'Tagging #{RailsSemanticLogger::VERSION}'"
   system "git push --tags"

data/lib/rails_semantic_logger/action_controller/log_subscriber.rb

@@ -137,7 +137,8 @@ module RailsSemanticLogger
           payload[:source] = source if source
         end
 
-        controller_logger(event).info(message: "Redirected to", payload: payload, metric: "rails.controller.redirect_to")
+        controller_logger(event).info(message: "Redirected to", payload: payload,
+                                      metric: "rails.controller.redirect_to")
       end
 
       def send_data(event)

data/lib/rails_semantic_logger/action_view/log_subscriber.rb

@@ -142,7 +142,7 @@ module RailsSemanticLogger
         end
 
         def rails_root
-          @root ||= "#{Rails.root}/"
+          @rails_root ||= "#{Rails.root}/"
         end
 
         def logger
@@ -161,12 +161,12 @@ module RailsSemanticLogger
         super
       end
 
-      private
+      EMPTY = "".freeze
 
       @logger             = ::ActionView::Base.logger
       @rendered_log_level = :debug
 
-      EMPTY = "".freeze
+      private
 
       def should_log?
         logger.send("#{self.class.rendered_log_level}?")

data/lib/rails_semantic_logger/appenders.rb

@@ -16,8 +16,8 @@ module RailsSemanticLogger
   # 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_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.
   #
@@ -44,9 +44,10 @@ module RailsSemanticLogger
     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.
+    # 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

data/lib/rails_semantic_logger/engine.rb

@@ -25,6 +25,27 @@ module RailsSemanticLogger
     # insert itself above the configured rails logger to add support for its
     # additional features
 
+    # Register this gem's deprecator with the application so that the standard Rails
+    # deprecation settings govern it: `config.active_support.report_deprecations`,
+    # `config.active_support.deprecation`, and
+    # `Rails.application.deprecators[:rails_semantic_logger]`. Rails' own
+    # `active_support.deprecation_behavior` initializer only reaches deprecators in
+    # that collection.
+    #
+    # Runs before the environment file is read so that an application can also reach
+    # the deprecator by name from `config/environments/*.rb`.
+    initializer "rails_semantic_logger.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:rails_semantic_logger] = RailsSemanticLogger.deprecator
+    end
+
+    # The deprecated appender options are set from `config/application.rb` and
+    # `config/environments/*.rb`, which Rails reads before it applies the deprecation
+    # settings above, so their warnings are recorded rather than emitted. Now that
+    # the settings are in place, emit them.
+    initializer "rails_semantic_logger.flush_deprecations", after: "active_support.deprecation_behavior" do |app|
+      app.config.rails_semantic_logger.flush_deprecations!
+    end
+
     # Replace Rails logger initializer
     Rails::Application::Bootstrap.initializers.delete_if { |i| i.name == :initialize_logger }
 
@@ -48,7 +69,7 @@ module RailsSemanticLogger
           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
@@ -67,21 +88,28 @@ 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
@@ -122,12 +150,8 @@ module RailsSemanticLogger
         end
 
         ::Sidekiq.configure_server do |config|
-          config.logger = ::SemanticLogger[::Sidekiq]
-          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
+          config.logger       = ::SemanticLogger[::Sidekiq]
+          config[:job_logger] = RailsSemanticLogger::Sidekiq::JobLogger
 
           # Add back the default console logger (unless the app declared its own appenders, or one exists)
           RailsSemanticLogger.add_server_appenders
@@ -137,15 +161,12 @@ module RailsSemanticLogger
           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=)
+      if config.rails_semantic_logger.replace_solid_queue_logger &&
+         defined?(::SolidQueue) && ::SolidQueue.respond_to?(:logger=)
         ::SolidQueue.logger = SemanticLogger[::SolidQueue]
       end
 
@@ -224,14 +245,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,
@@ -264,10 +289,6 @@ module RailsSemanticLogger
           )
         end
 
-        if config.rails_semantic_logger.replace_sidekiq_logger && defined?(::Sidekiq)
-          require("rails_semantic_logger/extensions/sidekiq/sidekiq")
-        end
-
         # SolidQueue
         if config.rails_semantic_logger.replace_solid_queue_logger && defined?(::SolidQueue::LogSubscriber)
           RailsSemanticLogger.swap_subscriber(

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

@@ -1,53 +1,81 @@
-require "action_cable/connection/tagged_logger_proxy"
-
-# Upstream source (identical across supported versions):
+# Upstream source (identical across supported versions, only the namespace differs):
 #   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
-      # 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
+#   https://github.com/rails/rails/blob/main/actioncable/lib/action_cable/server/tagged_logger_proxy.rb
+module RailsSemanticLogger
+  module ActionCable
+    # Rails 8.2 moved the proxy from ActionCable::Connection to ActionCable::Server, as part of
+    # the ActionCable::Server::Socket refactor, without leaving a back-compat alias behind.
+    # Resolve whichever constant this version of ActionCable ships rather than hard-coding a
+    # namespace, so that a `require` of the old path cannot fail the app's boot. See #326.
+    TaggedLoggerProxy =
+      if defined?(::ActionCable::Server::TaggedLoggerProxy)
+        ::ActionCable::Server::TaggedLoggerProxy
+      else
+        require "action_cable/connection/tagged_logger_proxy"
+        ::ActionCable::Connection::TaggedLoggerProxy
       end
+  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
+RailsSemanticLogger::ActionCable::TaggedLoggerProxy.class_eval do
+  # 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
 
-      private
+  # 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
 
-      # 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
+  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

data/lib/rails_semantic_logger/options.rb

@@ -181,7 +181,7 @@ module RailsSemanticLogger
     # 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
+    # requests (`rails server`, Sidekiq in server mode; defaults to
     # `$stdout`), and `add_console` for one created only inside a `rails console`
     # session (defaults to `$stderr`). Any appender works in any context, so a
     # context may declare several (e.g. a server-only stdout and file appender).
@@ -256,14 +256,56 @@ module RailsSemanticLogger
       @add_file_appender = value
     end
 
+    # Emit the deprecation warnings recorded by the deprecated appender option
+    # setters, and warn immediately from any later call. Called by the engine once
+    # Rails has applied the application's deprecation configuration.
+    #
+    # The deprecated options are documented to be set in `config/application.rb` or
+    # `config/environments/*.rb`, which Rails reads in `load_environment_config`,
+    # long before `active_support.deprecation_behavior` applies
+    # `config.active_support.report_deprecations`, `config.active_support.deprecation`,
+    # and any per-deprecator settings. Warning from the setter itself would therefore
+    # land in a window where nothing the application configures can reach it. The
+    # setters record instead, and this flushes once the settings are in place.
+    #
+    # Each option is reported once, attributed to the first place it was set, so an
+    # application setting several deprecated options gets one warning per option
+    # rather than one per assignment.
+    def flush_deprecations!
+      @deprecations_flushed = true
+      pending = pending_deprecations
+      @pending_deprecations = {}
+      pending.each_value { |message, callstack| RailsSemanticLogger.deprecator.warn(message, callstack) }
+      nil
+    end
+
     private
 
     def deprecate_appender_option(option, via: "appenders.add(...)")
-      RailsSemanticLogger.deprecator.warn(
+      message =
         "`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} }`."
-      )
+
+      # Skip this method and the setter that called it, so the warning is attributed
+      # to the application code that set the option, whether it is emitted now or
+      # flushed later by #flush_deprecations!.
+      callstack = caller_locations(2)
+
+      return RailsSemanticLogger.deprecator.warn(message, callstack) if deprecations_flushed?
+
+      pending_deprecations[option] ||= [message, callstack]
+      nil
+    end
+
+    # Deprecations recorded before Rails applied its deprecation configuration,
+    # keyed by option so that each is reported only once. See #flush_deprecations!.
+    def pending_deprecations
+      @pending_deprecations ||= {}
+    end
+
+    def deprecations_flushed?
+      defined?(@deprecations_flushed) && @deprecations_flushed
     end
 
     # Warn when an init-time setting is changed after the logger and its

data/lib/rails_semantic_logger/sidekiq/defaults.rb

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

data/lib/rails_semantic_logger/sidekiq/job_logger.rb

@@ -1,6 +1,10 @@
 module RailsSemanticLogger
   module Sidekiq
     class JobLogger
+      # Job attributes copied into the logging context, matching Sidekiq's own defaults.
+      # Sidekiq 8 makes this configurable via `config[:logged_job_attributes]`.
+      DEFAULT_LOGGED_JOB_ATTRIBUTES = %w[bid tags].freeze
+
       class << self
         attr_writer :perform_messages
 
@@ -9,8 +13,9 @@ module RailsSemanticLogger
         end
       end
 
-      # Sidekiq 6.5 does not take any arguments, whereas v7 is given a logger
-      def initialize(*_args)
+      # Sidekiq 7 passes its logger, whereas Sidekiq 8 passes its config.
+      def initialize(arg = nil)
+        @config = arg if arg.respond_to?(:[])
       end
 
       def call(item, queue, &block)
@@ -56,17 +61,24 @@ module RailsSemanticLogger
       private
 
       def perform_messages_enabled?
+        return false if @config && @config[:skip_default_job_logging]
+
         self.class.perform_messages != false
       end
 
       def job_hash_context(job_hash)
-        h         = {jid: job_hash["jid"], 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 = {jid: job_hash["jid"], class: job_hash["wrapped"] || job_hash["class"]}
+        logged_job_attributes.each do |attr|
+          h[attr.to_sym] = job_hash[attr] if job_hash.key?(attr)
+        end
         h[:queue] = job_hash["queue"] if job_hash["queue"]
         h
       end
 
+      def logged_job_attributes
+        (@config && @config[:logged_job_attributes]) || DEFAULT_LOGGED_JOB_ATTRIBUTES
+      end
+
       def job_latency_ms(job)
         return unless job && job["enqueued_at"]
 

data/lib/rails_semantic_logger/solid_queue/log_subscriber.rb

@@ -54,7 +54,11 @@ module RailsSemanticLogger
         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"
+          action = if event.payload[:skipped].present?
+                     "Skipped recurring task – already dispatched"
+                   else
+                     "Enqueued recurring task"
+                   end
           log_event(event, :debug, action, **attributes)
         end
       end

data/lib/rails_semantic_logger/version.rb

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

data/lib/rails_semantic_logger.rb

@@ -116,7 +116,7 @@ module RailsSemanticLogger
 
   # Swap an existing subscriber with a new one
   def self.swap_subscriber(old_class, new_class, notifier)
-    subscribers = ActiveSupport::LogSubscriber.subscribers.select { |s| s.is_a?(old_class) }
+    subscribers = ActiveSupport::LogSubscriber.subscribers.grep(old_class)
     subscribers.each { |subscriber| unattach(subscriber) }
 
     new_class.attach_to(notifier)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_semantic_logger
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Reid Morrison
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '5.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '5.1'
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -76,7 +76,6 @@ files:
 - lib/rails_semantic_logger/extensions/active_support/tagged_logging.rb
 - lib/rails_semantic_logger/extensions/mongoid/config.rb
 - lib/rails_semantic_logger/extensions/rails/server.rb
-- lib/rails_semantic_logger/extensions/sidekiq/sidekiq.rb
 - lib/rails_semantic_logger/options.rb
 - lib/rails_semantic_logger/rack/logger.rb
 - lib/rails_semantic_logger/sidekiq/defaults.rb
@@ -84,13 +83,14 @@ files:
 - lib/rails_semantic_logger/sidekiq/loggable.rb
 - lib/rails_semantic_logger/solid_queue/log_subscriber.rb
 - lib/rails_semantic_logger/version.rb
-homepage: https://logger.rocketjob.io
+homepage: https://logger.reidmorrison.com
 licenses:
 - Apache-2.0
 metadata:
   bug_tracker_uri: https://github.com/reidmorrison/rails_semantic_logger/issues
-  documentation_uri: https://logger.rocketjob.io
-  source_code_uri: https://github.com/reidmorrison/rails_semantic_logger/tree/v5.0.0
+  documentation_uri: https://logger.reidmorrison.com
+  source_code_uri: https://github.com/reidmorrison/rails_semantic_logger/tree/v5.2.0
+  changelog_uri: https://github.com/reidmorrison/rails_semantic_logger/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:

data/lib/rails_semantic_logger/extensions/sidekiq/sidekiq.rb

@@ -1,87 +0,0 @@
-# Sidekiq patches
-if Sidekiq::VERSION.to_i == 4
-  require "sidekiq/logging"
-  require "sidekiq/middleware/server/logging"
-  require "sidekiq/processor"
-elsif Sidekiq::VERSION.to_i == 5
-  require "sidekiq/logging"
-end
-
-module Sidekiq
-  # Sidekiq v4 & v5
-  if defined?(::Sidekiq::Logging)
-    # Replace Sidekiq logging context
-    module Logging
-      def self.with_context(msg, &)
-        SemanticLogger.tagged(msg, &)
-      end
-
-      def self.job_hash_context(job_hash)
-        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
-      end
-    end
-  end
-
-  # Sidekiq v4
-  if defined?(::Sidekiq::Middleware::Server::Logging)
-    # Convert string to machine readable format
-    class Processor
-      def log_context(job_hash)
-        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
-      end
-    end
-
-    # Let Semantic Logger handle duration logging
-    module Middleware
-      module Server
-        class Logging
-          # rubocop:disable Style/ExplicitBlockArgument
-          def call(worker, item, queue)
-            SemanticLogger.tagged(queue: queue) do
-              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"]
-
-            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
-    end
-  end
-end