rails_semantic_logger 4.16.0 → 4.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7da18e2122c13f2b4325a6f3000dd74d22517608b3a32355ca3d2bf4e5f08789
-  data.tar.gz: b0503c3227cb0bfa5faa1c6f00b408968783c8d09092a960497ab9f004798875
+  metadata.gz: 9a96d9dc4eb844eb8561d52f66dc27e2e07edb6b61da2163b0351ce3b12759ff
+  data.tar.gz: 34145d723bd89d14e5377200862df57829739b2ee5e5422a58f1d0edd4cbff0f
 SHA512:
-  metadata.gz: 30446e6a7553868e37cb56550d0a3e5c15b137991609e2cbb7aee84c7c7f5a75abe0bdd7f5e6263418546645f7a0892472e042ee09e0764be9f0ff9d90311917
-  data.tar.gz: 051ff94e24b1d9a4231f01d4148a966333b8d7b57539f7fa15ab953ad0a2fc9c998b61413ae2350716763f323eafa6d7302893b0c7b691e165c2200f7a8f3ef1
+  metadata.gz: e99c63ad9e4d02377d5ea25ba528f5de4fa8f83a2aadd7ef19ef2e3b8f52fc67cd2d08130ec18478ab4e5a2785657928f4e863024d8214a76de3bff4618b6891
+  data.tar.gz: 2d6ccc0cb9e385a2ca3a0fdc65023948f968a83b044768fc9bc9ccfb78452d7d4325731cdc4c5397bb097efa1ad72a1ce05d5576429cb2eb05b8c984fa7f06bb

data/README.md

@@ -87,7 +87,7 @@ The queue latency is the time between when the job was enqueued and when it was
 filter environment = "production"
 filter level = "info"
 filter metric = "sidekiq.queue.latency"
-timechart duration:avg(duration), group_by(name)
+timechart latency:avg(metric_amount/1000), group_by(string(named_tags.queue))
 ~~~
 
 * http://github.com/reidmorrison/rails_semantic_logger
@@ -100,8 +100,12 @@ For complete documentation see: https://logger.rocketjob.io/rails
 
 Rails Semantic Logger now supports Sidekiq metrics. 
 Below are the metrics that are now available when the JSON logging format is used:
-- `sidekiq.job.perform` - The duration of each Sidekiq job.
-- `sidekiq.queue.latency` - The time between when a Sidekiq job was enqueued and when it was started.
+- `sidekiq.job.perform`
+  - The duration of each Sidekiq job.
+  - `duration` contains the time in milliseconds that the job took to run.
+- `sidekiq.queue.latency` 
+  - The time between when a Sidekiq job was enqueued and when it was started.
+  - `metric_amount` contains the time in milliseconds that the job was waiting in the queue.
 
 ## Upgrading to Semantic Logger v4.15 & V4.16 - Sidekiq Support
 

data/lib/rails_semantic_logger/engine.rb

@@ -108,12 +108,31 @@ module RailsSemanticLogger
       Resque.logger        = SemanticLogger[Resque] if defined?(Resque) && Resque.respond_to?(:logger=)
 
       # Replace the Sidekiq logger
-      if defined?(Sidekiq)
-        if Sidekiq.respond_to?(:logger=)
-          Sidekiq.logger = SemanticLogger[Sidekiq]
-        elsif Sidekiq::VERSION[0..1] == "7."
-          method = Sidekiq.server? ? :configure_server : :configure_client
-          Sidekiq.public_send(method) { |cfg| cfg.logger = SemanticLogger[Sidekiq] }
+      if 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)
+            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?
+
+          # Replace default error handler when present
+          existing = RailsSemanticLogger::Sidekiq::Defaults.delete_default_error_handler(config.error_handlers)
+          config.error_handlers << RailsSemanticLogger::Sidekiq::Defaults::ERROR_HANDLER if existing
+        end
+
+        if defined?(::Sidekiq::Job) && (::Sidekiq::VERSION.to_i != 5)
+          ::Sidekiq::Job.singleton_class.prepend(RailsSemanticLogger::Sidekiq::Loggable)
+        else
+          ::Sidekiq::Worker.singleton_class.prepend(RailsSemanticLogger::Sidekiq::Loggable)
         end
       end
 
@@ -154,7 +173,7 @@ module RailsSemanticLogger
 
       if config.rails_semantic_logger.semantic
         # Active Job
-        if defined?(::ActiveJob) && defined?(::ActiveJob::Logging::LogSubscriber)
+        if defined?(::ActiveJob::Logging::LogSubscriber)
           RailsSemanticLogger.swap_subscriber(
             ::ActiveJob::Logging::LogSubscriber,
             RailsSemanticLogger::ActiveJob::LogSubscriber,
@@ -162,7 +181,7 @@ module RailsSemanticLogger
           )
         end
 
-        if defined?(::ActiveJob) && defined?(::ActiveJob::LogSubscriber)
+        if defined?(::ActiveJob::LogSubscriber)
           RailsSemanticLogger.swap_subscriber(
             ::ActiveJob::LogSubscriber,
             RailsSemanticLogger::ActiveJob::LogSubscriber,

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

@@ -1,89 +1,14 @@
 # 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, &block)
-        klass  = item["wrapped"] || item["class"]
-        logger = klass ? SemanticLogger[klass] : Sidekiq.logger
-
-        SemanticLogger.tagged(queue: queue) do
-          # Latency is the time between when the job was enqueued and when it started executing.
-          logger.info(
-            "Start #perform",
-            metric:        "sidekiq.queue.latency",
-            metric_amount: job_latency_ms(item)
-          )
-
-          # Measure the duration of running the job
-          logger.measure_info(
-            "Completed #perform",
-            on_exception_level: :error,
-            log_exception:      :full,
-            metric:             "sidekiq.job.perform",
-            &block
-          )
-        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         = {jid: job_hash["jid"]}
-        h[:bid]   = job_hash["bid"] if job_hash["bid"]
-        h[:tags]  = job_hash["tags"] if job_hash["tags"]
-        h[:queue] = job_hash["queue"] if job_hash["queue"]
-        h
-      end
-
-      def job_latency_ms(job)
-        return unless job && job["enqueued_at"]
-
-        (Time.now.to_f - job["enqueued_at"].to_f) * 1000
-      end
-    end
-  end
-
-  # Sidekiq <= v6
+  # Sidekiq v4 & v5
   if defined?(::Sidekiq::Logging)
     # Replace Sidekiq logging context
     module Logging
@@ -100,106 +25,8 @@ module Sidekiq
     end
   end
 
-  # Exception is already logged by Semantic Logger during the perform call
-  if defined?(::Sidekiq::ExceptionHandler)
-    # Sidekiq <= v6.5
-    module ExceptionHandler
-      class Logger
-        def call(_exception, ctx)
-          return if 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
-  elsif defined?(::Sidekiq::Config)
-    # Sidekiq >= v7
-    class Config
-      remove_const :ERROR_HANDLER
-
-      ERROR_HANDLER = ->(ex, ctx, cfg = Sidekiq.default_configuration) do
-        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
-  else
-    # Sidekiq >= 6.5
-    Sidekiq.error_handlers.delete(Sidekiq::DEFAULT_ERROR_HANDLER)
-    Sidekiq.error_handlers << ->(ex, ctx) do
-      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
-  case Sidekiq::VERSION.to_i
-  when 4
-    module Worker
-      def self.included(base)
-        if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
-          raise ArgumentError, "You cannot include Sidekiq::Worker in an ActiveJob: #{base.name}"
-        end
-
-        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
-  when 5
-    module Worker
-      def self.included(base)
-        if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
-          raise ArgumentError, "You cannot include Sidekiq::Worker in an ActiveJob: #{base.name}"
-        end
-
-        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
-  when 6
-    module Worker
-      def self.included(base)
-        if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
-          raise ArgumentError, "Sidekiq::Worker cannot be included in an ActiveJob: #{base.name}"
-        end
-
-        base.include(Options)
-        base.extend(ClassMethods)
-        base.include(SemanticLogger::Loggable)
-      end
-    end
-  else
-    module Job
-      def self.included(base)
-        if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
-          raise ArgumentError, "Sidekiq::Job cannot be included in an ActiveJob: #{base.name}"
-        end
-
-        base.include(Options)
-        base.extend(ClassMethods)
-        base.include(SemanticLogger::Loggable)
-      end
-    end
-  end
-
+  # Sidekiq v4
   if defined?(::Sidekiq::Middleware::Server::Logging)
-    # Sidekiq v4
     # Convert string to machine readable format
     class Processor
       def log_context(job_hash)
@@ -214,6 +41,7 @@ module Sidekiq
     module Middleware
       module Server
         class Logging
+          # rubocop:disable Style/ExplicitBlockArgument
           def call(worker, item, queue)
             SemanticLogger.tagged(queue: queue) do
               worker.logger.info(

data/lib/rails_semantic_logger/sidekiq/defaults.rb

@@ -0,0 +1,40 @@
+module RailsSemanticLogger
+  module Sidekiq
+    module Defaults
+      # Prevent exception logging during standard error handling since the Job Logger below already logs the exception.
+      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.warn(ctx[:context], ctx) : logger.warn(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.warn(ctx[:context], ctx) : logger.warn(ctx)
+            end
+          end
+        end
+
+      # Returns the default logger after removing from the supplied list.
+      # Returns [nil] when the default logger 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
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/sidekiq/job_logger.rb

@@ -0,0 +1,59 @@
+module RailsSemanticLogger
+  module Sidekiq
+    class JobLogger
+      # Sidekiq 6.5 does not take any arguments, whereas v7 is given a logger
+      def initialize(*_args)
+      end
+
+      def call(item, queue, &block)
+        klass  = item["wrapped"] || item["class"]
+        logger = klass ? SemanticLogger[klass] : Sidekiq.logger
+
+        SemanticLogger.tagged(queue: queue) do
+          # Latency is the time between when the job was enqueued and when it started executing.
+          logger.info(
+            "Start #perform",
+            metric:        "sidekiq.queue.latency",
+            metric_amount: job_latency_ms(item)
+          )
+
+          # Measure the duration of running the job
+          logger.measure_info(
+            "Completed #perform",
+            on_exception_level: :error,
+            log_exception:      :full,
+            metric:             "sidekiq.job.perform",
+            &block
+          )
+        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
+
+      private
+
+      def job_hash_context(job_hash)
+        h         = {jid: job_hash["jid"]}
+        h[:bid]   = job_hash["bid"] if job_hash["bid"]
+        h[:tags]  = job_hash["tags"] if job_hash["tags"]
+        h[:queue] = job_hash["queue"] if job_hash["queue"]
+        h
+      end
+
+      def job_latency_ms(job)
+        return unless job && job["enqueued_at"]
+
+        (Time.now.to_f - job["enqueued_at"].to_f) * 1000
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/sidekiq/loggable.rb

@@ -0,0 +1,10 @@
+module RailsSemanticLogger
+  module Sidekiq
+    module Loggable
+      def included(base)
+        super
+        base.include(SemanticLogger::Loggable)
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module RailsSemanticLogger
-  VERSION = "4.16.0".freeze
+  VERSION = "4.17.0".freeze
 end

data/lib/rails_semantic_logger.rb

@@ -31,6 +31,12 @@ module RailsSemanticLogger
     autoload :Plugin, "rails_semantic_logger/delayed_job/plugin"
   end
 
+  module Sidekiq
+    autoload :Defaults, "rails_semantic_logger/sidekiq/defaults"
+    autoload :JobLogger, "rails_semantic_logger/sidekiq/job_logger"
+    autoload :Loggable, "rails_semantic_logger/sidekiq/loggable"
+  end
+
   autoload :Options, "rails_semantic_logger/options"
 
   # Swap an existing subscriber with a new one

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.16.0
+  version: 4.17.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-01 00:00:00.000000000 Z
+date: 2024-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.13'
+        version: '4.16'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.13'
+        version: '4.16'
 description:
 email:
 executables: []
@@ -85,6 +85,9 @@ files:
 - 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
+- lib/rails_semantic_logger/sidekiq/job_logger.rb
+- lib/rails_semantic_logger/sidekiq/loggable.rb
 - lib/rails_semantic_logger/version.rb
 homepage: https://logger.rocketjob.io
 licenses:
@@ -92,7 +95,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.16.0
+  source_code_uri: https://github.com/reidmorrison/rails_semantic_logger/tree/v4.17.0
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []