rails_semantic_logger 4.13.0 → 4.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b82f4b18da96047400658caaf0cbdb073ac21d0d9dfc9f8e89a270fae80550af
-  data.tar.gz: fcef56ce1f917619d302b3dced8680748f0945c3a5a16763aadf21007ef1a00d
+  metadata.gz: 3bb41dd02df0dc0dc472a66f83a82146878942a309670d4fb10da64bfdae4bc4
+  data.tar.gz: c1463e8da359c87fffc4e7d4e56919609320473fa0702b6a7f9b9fec1bdc5050
 SHA512:
-  metadata.gz: 6ca5b2a92ca494065abb52d7d44eb71e06ba044f190c10b710549b609f78924542eb4f5eb126c54f98bc1248daaa7e1e29b35139c527081f178c1119be76acdc
-  data.tar.gz: 604c669579b6bf2e25b718008406fd2a5bfcacd32f39a5714b05656773e59634d15d10d3afd0277c098bc73f5836e577ad1412669947598b206f22e5af4379d4
+  metadata.gz: 1604cdbeed7b9bda178517f7cd7f72e4721523cf222aa6b0a2dcce36fc77c62807641ca32aef349f91c9e5aa86d04e9202e15adff71e4b5e4e29798a3c9dde16
+  data.tar.gz: b0e79372c2111bb823c191595a600c8c4c218e6989249f66c0ec46d66826116abfe2f6c5c761d33ae23f1494e7a74b8299d70b037410570757195115b212dced

data/lib/rails_semantic_logger/action_controller/log_subscriber.rb

@@ -14,10 +14,10 @@ module RailsSemanticLogger
 
           # Unused, but needed for Devise 401 status code monkey patch to still work.
           ::ActionController::Base.log_process_action(payload)
-          
+
           params = payload[:params]
 
-          if params.kind_of?(Hash) || params.kind_of?(::ActionController::Parameters)
+          if params.is_a?(Hash) || params.is_a?(::ActionController::Parameters)
             # According to PR https://github.com/reidmorrison/rails_semantic_logger/pull/37/files
             # params is not always a Hash.
             payload[:params] = params.to_unsafe_h unless params.is_a?(Hash)
@@ -79,7 +79,9 @@ module RailsSemanticLogger
       end
 
       def send_data(event)
-        controller_logger(event).info(message: "Sent data", payload: {file_name: event.payload[:filename]}, duration: event.duration)
+        controller_logger(event).info(message:  "Sent data",
+                                      payload:  {file_name: event.payload[:filename]},
+                                      duration: event.duration)
       end
 
       def unpermitted_parameters(event)

data/lib/rails_semantic_logger/action_mailer/log_subscriber.rb

@@ -9,22 +9,22 @@ module RailsSemanticLogger
         message_id = event.payload[:message_id]
         duration = event.duration.round(1)
         if ex
-          log_with_formatter event: event, log_duration: true, level: :error do |fmt|
+          log_with_formatter event: event, log_duration: true, level: :error do |_fmt|
             {
-              message: "Error delivering mail #{message_id} (#{duration}ms)",
+              message:   "Error delivering mail #{message_id} (#{duration}ms)",
               exception: ex
             }
           end
         else
-          message = begin
+          message =
             if event.payload[:perform_deliveries]
               "Delivered mail #{message_id} (#{duration}ms)"
             else
               "Skipped delivery of mail #{message_id} as `perform_deliveries` is false"
             end
-          end
-          log_with_formatter event: event, log_duration: true do |fmt|
-            { message: message }
+
+          log_with_formatter event: event, log_duration: true do |_fmt|
+            {message: message}
           end
         end
       end
@@ -34,8 +34,8 @@ module RailsSemanticLogger
         mailer   = event.payload[:mailer]
         action   = event.payload[:action]
         duration = event.duration.round(1)
-        log_with_formatter event: event do |fmt|
-          { message: "#{mailer}##{action}: processed outbound mail in #{duration}ms" }
+        log_with_formatter event: event do |_fmt|
+          {message: "#{mailer}##{action}: processed outbound mail in #{duration}ms"}
         end
       end
 
@@ -74,8 +74,6 @@ module RailsSemanticLogger
             event.payload[:date].to_time.utc
           elsif event.payload[:date].is_a?(String)
             Time.parse(date).utc
-          else
-            nil
           end
         end
 
@@ -94,8 +92,8 @@ module RailsSemanticLogger
         def formatted_args
           if defined?(mailer.constantize.log_arguments?) && !mailer.constantize.log_arguments?
             ""
-          else
-            JSON.pretty_generate(event.payload[:args].map { |arg| format(arg) }) if event.payload[:args].present?
+          elsif event.payload[:args].present?
+            JSON.pretty_generate(event.payload[:args].map { |arg| format(arg) })
           end
         end
 

data/lib/rails_semantic_logger/action_view/log_subscriber.rb

@@ -19,7 +19,7 @@ module RailsSemanticLogger
       def render_template(event)
         return unless should_log?
 
-        payload               = {
+        payload = {
           template: from_rails_root(event.payload[:identifier])
         }
         payload[:within]      = from_rails_root(event.payload[:layout]) if event.payload[:layout]
@@ -36,7 +36,7 @@ module RailsSemanticLogger
       def render_partial(event)
         return unless should_log?
 
-        payload               = {
+        payload = {
           partial: from_rails_root(event.payload[:identifier])
         }
         payload[:within]      = from_rails_root(event.payload[:layout]) if event.payload[:layout]
@@ -56,7 +56,7 @@ module RailsSemanticLogger
 
         identifier = event.payload[:identifier] || "templates"
 
-        payload               = {
+        payload = {
           template: from_rails_root(identifier),
           count:    event.payload[:count]
         }
@@ -72,9 +72,9 @@ module RailsSemanticLogger
       end
 
       def start(name, id, payload)
-        if (name == "render_template.action_view" || name == "render_layout.action_view") && should_log?
+        if ["render_template.action_view", "render_layout.action_view"].include?(name) && should_log?
           qualifier        = " layout" if name == "render_layout.action_view"
-          payload          = { template: from_rails_root(payload[:identifier]) }
+          payload          = {template: from_rails_root(payload[:identifier])}
           payload[:within] = from_rails_root(payload[:layout]) if payload[:layout]
 
           logger.send(self.class.rendered_log_level, message: "Rendering#{qualifier}", payload: payload)
@@ -84,18 +84,19 @@ module RailsSemanticLogger
       end
 
       if (Rails::VERSION::MAJOR == 7 && Rails::VERSION::MINOR >= 1) || Rails::VERSION::MAJOR > 7
-        class Start # :nodoc:
-          def start(name, id, payload)
+        class Start
+          def start(name, _id, payload)
             return unless %w[render_template.action_view render_layout.action_view].include?(name)
 
             qualifier        = " layout" if name == "render_layout.action_view"
-            payload          = { template: from_rails_root(payload[:identifier]) }
+            payload          = {template: from_rails_root(payload[:identifier])}
             payload[:within] = from_rails_root(payload[:layout]) if payload[:layout]
 
             logger.debug(message: "Rendering#{qualifier}", payload: payload)
           end
 
-          def finish(name, id, payload) end
+          def finish(name, id, payload)
+          end
 
           private
 
@@ -105,7 +106,7 @@ module RailsSemanticLogger
             string
           end
 
-          def rails_root # :doc:
+          def rails_root
             @root ||= "#{Rails.root}/"
           end
 
@@ -117,8 +118,10 @@ module RailsSemanticLogger
         def self.attach_to(*)
           ActiveSupport::Notifications.unsubscribe("render_template.action_view")
           ActiveSupport::Notifications.unsubscribe("render_layout.action_view")
-          ActiveSupport::Notifications.subscribe("render_template.action_view", RailsSemanticLogger::ActionView::LogSubscriber::Start.new)
-          ActiveSupport::Notifications.subscribe("render_layout.action_view", RailsSemanticLogger::ActionView::LogSubscriber::Start.new)
+          ActiveSupport::Notifications.subscribe("render_template.action_view",
+                                                 RailsSemanticLogger::ActionView::LogSubscriber::Start.new)
+          ActiveSupport::Notifications.subscribe("render_layout.action_view",
+                                                 RailsSemanticLogger::ActionView::LogSubscriber::Start.new)
 
           super
         end

data/lib/rails_semantic_logger/active_job/log_subscriber.rb

@@ -9,17 +9,17 @@ module RailsSemanticLogger
         if ex
           log_with_formatter level: :error, event: event do |fmt|
             {
-              message: "Failed enqueuing #{fmt.job_info} (#{ex.class} (#{ex.message})",
+              message:   "Failed enqueuing #{fmt.job_info} (#{ex.class} (#{ex.message})",
               exception: ex
             }
           end
         elsif event.payload[:aborted]
           log_with_formatter level: :info, event: event do |fmt|
-            { message: "Failed enqueuing #{fmt.job_info}, a before_enqueue callback halted the enqueuing execution." }
+            {message: "Failed enqueuing #{fmt.job_info}, a before_enqueue callback halted the enqueuing execution."}
           end
         else
           log_with_formatter event: event do |fmt|
-            { message: "Enqueued #{fmt.job_info}" }
+            {message: "Enqueued #{fmt.job_info}"}
           end
         end
       end
@@ -30,13 +30,13 @@ module RailsSemanticLogger
         if ex
           log_with_formatter level: :error, event: event do |fmt|
             {
-              message: "Failed enqueuing #{fmt.job_info} (#{ex.class} (#{ex.message})",
+              message:   "Failed enqueuing #{fmt.job_info} (#{ex.class} (#{ex.message})",
               exception: ex
             }
           end
         elsif event.payload[:aborted]
           log_with_formatter level: :info, event: event do |fmt|
-            { message: "Failed enqueuing #{fmt.job_info}, a before_enqueue callback halted the enqueuing execution." }
+            {message: "Failed enqueuing #{fmt.job_info}, a before_enqueue callback halted the enqueuing execution."}
           end
         else
           log_with_formatter event: event do |fmt|
@@ -56,7 +56,7 @@ module RailsSemanticLogger
         if ex
           log_with_formatter event: event, log_duration: true, level: :error do |fmt|
             {
-              message: "Error performing #{fmt.job_info} in #{event.duration.round(2)}ms",
+              message:   "Error performing #{fmt.job_info} in #{event.duration.round(2)}ms",
               exception: ex
             }
           end

data/lib/rails_semantic_logger/active_record/log_subscriber.rb

@@ -169,9 +169,7 @@ module RailsSemanticLogger
       def render_bind_v6_1(attr, value)
         case attr
         when ActiveModel::Attribute
-          if attr.type.binary? && attr.value
-            value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
-          end
+          value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>" if attr.type.binary? && attr.value
         when Array
           attr = attr.first
         else

data/lib/rails_semantic_logger/engine.rb

@@ -77,7 +77,7 @@ module RailsSemanticLogger
           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.",
+            "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed.",
             e
           )
           logger
@@ -111,14 +111,14 @@ module RailsSemanticLogger
       if defined?(Sidekiq)
         if Sidekiq.respond_to?(:logger=)
           Sidekiq.logger = SemanticLogger[Sidekiq]
-        elsif Sidekiq::VERSION[0..1] == '7.'
+        elsif Sidekiq::VERSION[0..1] == "7."
           method = Sidekiq.server? ? :configure_server : :configure_client
           Sidekiq.public_send(method) { |cfg| cfg.logger = SemanticLogger[Sidekiq] }
         end
       end
 
       # Replace the Sidetiq logger
-      Sidetiq.logger       = SemanticLogger[Sidetiq] if defined?(Sidetiq) && Sidetiq.respond_to?(:logger=)
+      Sidetiq.logger = SemanticLogger[Sidetiq] if defined?(Sidetiq) && Sidetiq.respond_to?(:logger=)
 
       # Replace the DelayedJob logger
       if defined?(Delayed::Worker)
@@ -143,7 +143,9 @@ module RailsSemanticLogger
       # Rails Patches
       require("rails_semantic_logger/extensions/action_cable/tagged_logger_proxy") if defined?(::ActionCable)
       require("rails_semantic_logger/extensions/action_controller/live") if defined?(::ActionController::Live)
-      require("rails_semantic_logger/extensions/action_dispatch/debug_exceptions") if defined?(::ActionDispatch::DebugExceptions)
+      if defined?(::ActionDispatch::DebugExceptions)
+        require("rails_semantic_logger/extensions/action_dispatch/debug_exceptions")
+      end
       if defined?(::ActionView::StreamingTemplateRenderer::Body)
         require("rails_semantic_logger/extensions/action_view/streaming_template_renderer")
       end
@@ -222,6 +224,8 @@ module RailsSemanticLogger
             :action_mailer
           )
         end
+
+        require("rails_semantic_logger/extensions/sidekiq/sidekiq") if defined?(::Sidekiq)
       end
 
       #
@@ -237,7 +241,7 @@ module RailsSemanticLogger
       end
 
       # Re-open appenders after Resque has forked a worker
-      Resque.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Resque)
+      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)

data/lib/rails_semantic_logger/extensions/action_dispatch/debug_exceptions.rb

@@ -6,9 +6,17 @@ module ActionDispatch
     private
 
     undef_method :log_error
-    def log_error(_request, wrapper)
-      ActiveSupport::Deprecation.silence do
-        ActionController::Base.logger.fatal(wrapper.exception)
+    if (Rails::VERSION::MAJOR == 7 && Rails::VERSION::MINOR >= 1) || Rails::VERSION::MAJOR > 7
+      def log_error(_request, wrapper)
+        Rails.application.deprecators.silence do
+          ActionController::Base.logger.fatal(wrapper.exception)
+        end
+      end
+    else
+      def log_error(_request, wrapper)
+        ActiveSupport::Deprecation.silence do
+          ActionController::Base.logger.fatal(wrapper.exception)
+        end
       end
     end
   end

data/lib/rails_semantic_logger/extensions/active_support/log_subscriber.rb

@@ -1,11 +1,13 @@
-require "active_support/log_subscriber"
+if ActiveSupport::VERSION::STRING == "7.1.1"
+  require "active_support/log_subscriber"
 
-module ActiveSupport
-  class LogSubscriber
-    # @override Rails 7.1
-    def silenced?(event)
-      native_log_level = @event_levels.fetch(event, ::Logger::Severity::FATAL)
-      logger.nil? || SemanticLogger::Levels.index(logger.level) > SemanticLogger::Levels.index(native_log_level)
+  module ActiveSupport
+    class LogSubscriber
+      # @override Rails 7.1
+      def silenced?(event)
+        native_log_level = @event_levels.fetch(event, ::Logger::Severity::FATAL)
+        logger.nil? || SemanticLogger::Levels.index(logger.level) > SemanticLogger::Levels.index(native_log_level)
+      end
     end
   end
 end

data/lib/rails_semantic_logger/extensions/active_support/logger.rb

@@ -9,18 +9,18 @@ module ActiveSupport
       # Prevent broadcasting since SemanticLogger already supports multiple loggers
       if method_defined?(:broadcast)
         undef :broadcast
-        def broadcast(logger)
+        def broadcast(_logger)
           Module.new
         end
       end
     end
 
     # Prevent Console from trying to merge loggers
-    def self.logger_outputs_to?(*args)
+    def self.logger_outputs_to?(*_args)
       true
     end
 
-    def self.new(*args, **kwargs)
+    def self.new(*_args, **_kwargs)
       SemanticLogger[self]
     end
   end

data/lib/rails_semantic_logger/extensions/rackup/server.rb

@@ -0,0 +1,12 @@
+module RailsSemanticLogger
+  module Rackup
+    module Server
+      def daemonize_app
+        super
+        SemanticLogger.reopen
+      end
+    end
+  end
+end
+
+Rackup::Server.prepend(RailsSemanticLogger::Rackup::Server)

data/lib/rails_semantic_logger/extensions/rails/server.rb

@@ -4,7 +4,7 @@ require "rails"
 module Rails
   class Server
     private
-    
+
     undef_method :log_to_stdout if method_defined?(:log_to_stdout)
     def log_to_stdout
       wrapped_app # touch the app so the logger is set up

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

@@ -0,0 +1,211 @@
+# Sidekiq patches
+#
+# To re-enable stdout logging for sidekiq server processes, add the following snippet to config/initializers/sidekiq.rb:
+#   Sidekiq.configure_server do |config|
+#     SemanticLogger.add_appender(io: $stdout, level: :debug, formatter: :color)
+#   end
+if Sidekiq::VERSION.to_i == 4
+  require "sidekiq/exception_handler"
+  require "sidekiq/logging"
+  require "sidekiq/middleware/server/logging"
+  require "sidekiq/processor"
+  require "sidekiq/worker"
+elsif Sidekiq::VERSION.to_i == 5
+  require "sidekiq/exception_handler"
+  require "sidekiq/job_logger"
+  require "sidekiq/logging"
+  require "sidekiq/worker"
+elsif Sidekiq::VERSION.to_i == 6 && Sidekiq::VERSION.to_f < 6.5
+  require "sidekiq/exception_handler"
+  require "sidekiq/job_logger"
+  require "sidekiq/worker"
+elsif Sidekiq::VERSION.to_i == 6
+  require "sidekiq/job_logger"
+  require "sidekiq/worker"
+else
+  require "sidekiq/config"
+  require "sidekiq/job_logger"
+  require "sidekiq/job"
+end
+
+module Sidekiq
+  # Sidekiq > v4
+  if defined?(::Sidekiq::JobLogger)
+    # Let Semantic Logger handle duration logging
+    class JobLogger
+      def call(item, queue)
+        klass  = item["wrapped"] || item["class"]
+        metric = "Sidekiq/#{klass}/perform" if klass
+        logger = klass ? SemanticLogger[klass] : Sidekiq.logger
+        logger.info("Start #perform")
+        logger.measure_info(
+          "Completed #perform",
+          on_exception_level: :error,
+          log_exception:      :full,
+          metric:             metric
+        ) do
+          yield
+        end
+      end
+
+      def prepare(job_hash, &block)
+        level = job_hash["log_level"]
+        if level
+          SemanticLogger.silence(level) do
+            SemanticLogger.tagged(job_hash_context(job_hash), &block)
+          end
+        else
+          SemanticLogger.tagged(job_hash_context(job_hash), &block)
+        end
+      end
+
+      def job_hash_context(job_hash)
+        h        = {
+          class: job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"],
+          jid:   job_hash["jid"]
+        }
+        h[:bid]  = job_hash["bid"] if job_hash["bid"]
+        h[:tags] = job_hash["tags"] if job_hash["tags"]
+        h
+      end
+    end
+  end
+
+  # Sidekiq <= v6
+  if defined?(::Sidekiq::Logging)
+    # Replace Sidekiq logging context
+    module Logging
+      def self.with_context(msg, &block)
+        SemanticLogger.tagged(msg, &block)
+      end
+
+      def self.job_hash_context(job_hash)
+        klass       = job_hash["wrapped"] || job_hash["class"]
+        event       = { class: klass, jid: job_hash["jid"] }
+        event[:bid] = job_hash["bid"] if job_hash["bid"]
+        event
+      end
+    end
+  end
+
+  # Exception is already logged by Semantic Logger during the perform call
+  # Sidekiq <= v6.5
+  if defined?(::Sidekiq::ExceptionHandler)
+    module ExceptionHandler
+      class Logger
+        def call(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.warn(ctx[:context], ctx) : logger.warn(ctx)
+          end
+        end
+      end
+    end
+  # Sidekiq >= v7
+  elsif defined?(::Sidekiq::Config)
+    class Config
+      remove_const :ERROR_HANDLER
+
+      ERROR_HANDLER = ->(ex, ctx, cfg = Sidekiq.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.warn(ctx[:context], ctx) : logger.warn(ctx)
+        end
+      }
+    end
+  else
+    # Sidekiq >= 6.5
+    # TODO: Not taking effect. See test/sidekiq_test.rb
+    def self.default_error_handler(ex, ctx)
+      binding.irb
+      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.warn(ctx[:context], ctx) : logger.warn(ctx)
+      end
+    end
+  end
+
+  # Logging within each worker should use its own logger
+  if Sidekiq::VERSION.to_i == 4
+    module Worker
+      def self.included(base)
+        raise ArgumentError, "You cannot include Sidekiq::Worker in an ActiveJob: #{base.name}" if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
+
+        base.extend(ClassMethods)
+        base.include(SemanticLogger::Loggable)
+        base.class_attribute :sidekiq_options_hash
+        base.class_attribute :sidekiq_retry_in_block
+        base.class_attribute :sidekiq_retries_exhausted_block
+      end
+    end
+  elsif Sidekiq::VERSION.to_i == 5
+    module Worker
+      def self.included(base)
+        raise ArgumentError, "You cannot include Sidekiq::Worker in an ActiveJob: #{base.name}" if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
+
+        base.extend(ClassMethods)
+        base.include(SemanticLogger::Loggable)
+        base.sidekiq_class_attribute :sidekiq_options_hash
+        base.sidekiq_class_attribute :sidekiq_retry_in_block
+        base.sidekiq_class_attribute :sidekiq_retries_exhausted_block
+      end
+    end
+  elsif Sidekiq::VERSION.to_i == 6
+    module Worker
+      def self.included(base)
+        raise ArgumentError, "Sidekiq::Worker cannot be included in an ActiveJob: #{base.name}" if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
+
+        base.include(Options)
+        base.extend(ClassMethods)
+        base.include(SemanticLogger::Loggable)
+      end
+    end
+  else
+    module Job
+      def self.included(base)
+        raise ArgumentError, "Sidekiq::Job cannot be included in an ActiveJob: #{base.name}" if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
+
+        base.include(Options)
+        base.extend(ClassMethods)
+        base.include(SemanticLogger::Loggable)
+      end
+    end
+  end
+
+  if Sidekiq::VERSION.to_i == 4
+    # Convert string to machine readable format
+    class Processor
+      def log_context(job_hash)
+        klass       = job_hash["wrapped"] || job_hash["class"]
+        event       = { class: klass, jid: job_hash["jid"] }
+        event[:bid] = job_hash["bid"] if job_hash["bid"]
+        event
+      end
+    end
+
+    # Let Semantic Logger handle duration logging
+    module Middleware
+      module Server
+        class Logging
+          def call(worker, item, queue)
+            worker.logger.info("Start #perform")
+            worker.logger.measure_info(
+              "Completed #perform",
+              on_exception_level: :error,
+              log_exception:      :full,
+              metric:             "Sidekiq/#{worker.class.name}/perform"
+            ) do
+              yield
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/rack/logger.rb

@@ -37,7 +37,7 @@ module RailsSemanticLogger
       def call_app(request, env)
         instrumenter        = ActiveSupport::Notifications.instrumenter
         instrumenter_state  = instrumenter.start "request.action_dispatch", request: request
-        instrumenter_finish = -> () {
+        instrumenter_finish = lambda {
           instrumenter.finish_with_state(instrumenter_state, "request.action_dispatch", request: request)
         }
 

data/lib/rails_semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module RailsSemanticLogger
-  VERSION = "4.13.0".freeze
+  VERSION = "4.15.0".freeze
 end

data/lib/rails_semantic_logger.rb

@@ -6,21 +6,27 @@ module RailsSemanticLogger
   module ActionController
     autoload :LogSubscriber, "rails_semantic_logger/action_controller/log_subscriber"
   end
+
   module ActionMailer
     autoload :LogSubscriber, "rails_semantic_logger/action_mailer/log_subscriber"
   end
+
   module ActionView
     autoload :LogSubscriber, "rails_semantic_logger/action_view/log_subscriber"
   end
+
   module ActiveJob
     autoload :LogSubscriber, "rails_semantic_logger/active_job/log_subscriber"
   end
+
   module ActiveRecord
     autoload :LogSubscriber, "rails_semantic_logger/active_record/log_subscriber"
   end
+
   module Rack
     autoload :Logger, "rails_semantic_logger/rack/logger"
   end
+
   module DelayedJob
     autoload :Plugin, "rails_semantic_logger/delayed_job/plugin"
   end
@@ -48,9 +54,11 @@ module RailsSemanticLogger
   end
 
   def self.subscriber_patterns(subscriber)
-    subscriber.patterns.respond_to?(:keys) ?
-      subscriber.patterns.keys :
+    if subscriber.patterns.respond_to?(:keys)
+      subscriber.patterns.keys
+    else
       subscriber.patterns
+    end
   end
 
   private_class_method :subscriber_patterns, :unattach
@@ -59,4 +67,14 @@ end
 require("rails_semantic_logger/extensions/mongoid/config") if defined?(Mongoid)
 require("rails_semantic_logger/extensions/active_support/logger") if defined?(ActiveSupport::Logger)
 require("rails_semantic_logger/extensions/active_support/log_subscriber") if defined?(ActiveSupport::LogSubscriber)
-require("rails_semantic_logger/extensions/rack/server") if defined?(Rack::Server)
+
+begin
+  require 'rackup'
+rescue LoadError
+  # No need to do anything, will fall back to Rack
+end
+if defined?(Rackup::Server)
+  require("rails_semantic_logger/extensions/rackup/server")
+elsif defined?(Rack::Server)
+  require("rails_semantic_logger/extensions/rack/server")
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.13.0
+  version: 4.15.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-09 00:00:00.000000000 Z
+date: 2024-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -80,7 +80,9 @@ files:
 - lib/rails_semantic_logger/extensions/active_support/tagged_logging.rb
 - lib/rails_semantic_logger/extensions/mongoid/config.rb
 - lib/rails_semantic_logger/extensions/rack/server.rb
+- lib/rails_semantic_logger/extensions/rackup/server.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/version.rb
@@ -90,7 +92,7 @@ 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/v4.13.0
+  source_code_uri: https://github.com/reidmorrison/rails_semantic_logger/tree/v4.15.0
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -107,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.9
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Feature rich logging framework that replaces the Rails logger.