rails_semantic_logger 5.0.0 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 213d85a11e285b1353549f41b8a8c28068a33d3913e270d72eed94f6ee1d861c
-  data.tar.gz: 8233c4128fdc790e3cefedd3efc8d8c6b274393604527cc162dff97842227fea
+  metadata.gz: f0d257eeb6faedaba38caba805893dc4c269dfaf0b1b0f5cc496d54e3bc3f6ad
+  data.tar.gz: 5ae1af5ac5514a6fd84f70f4b0d13232791f942b3fead595a082ae15c1258893
 SHA512:
-  metadata.gz: 52330aaea8cf48aa21a62b8c5654163ce481382fa67bd6935c02d3deecfcef3a83a32b30c563941eb49404d86063ff2056778692781bd14a96174b55d2372f9f
-  data.tar.gz: 5da348c363745f1e3b7a2fc73c36221658f86dafcad53d5078990d9d204fe5bf2224a319a156395597a7916bb2a950b1c27974114bbee37662f388295999758a
+  metadata.gz: 7a79e69e2a466f8a0f414b21e3890118eac262c7bb2983a91cfac547fc04f3cb91535bde3aa1ff611d57a1b5a6e56d7ba885f8177f3d0a0777682de844ba2b9e
+  data.tar.gz: cc0fb18514ef84ee7e3ec270a70bf155aa54e6f71e0fffe59f0492fb712d5dab64ec27c42ab69afaccde1259aeb75913319d1fbc07f70bea7938e3fe231ef8aa

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

@@ -48,7 +48,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 +67,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 +129,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 +140,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 +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,
@@ -264,10 +268,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

@@ -30,12 +30,29 @@ module ActionCable
       # 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) }
+          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.

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).

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.1.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.1.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
@@ -90,7 +89,8 @@ licenses:
 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
+  source_code_uri: https://github.com/reidmorrison/rails_semantic_logger/tree/v5.1.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