Fix Sidekiq cross version issues

Author: reidmorrison

lib/rails_semantic_logger/engine.rb

@@ -128,7 +128,7 @@ class Engine < ::Rails::Engine
           config.error_handlers << RailsSemanticLogger::Sidekiq::Defaults::ERROR_HANDLER if existing
         end
 
-        if defined?(::Sidekiq::Job)
+        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)

lib/rails_semantic_logger/extensions/sidekiq/sidekiq.rb

@@ -41,6 +41,7 @@ def log_context(job_hash)
     module Middleware
       module Server
         class Logging
+          # rubocop:disable Style/ExplicitBlockArgument
           def call(worker, item, queue)
             SemanticLogger.tagged(queue: queue) do
               worker.logger.info(

lib/rails_semantic_logger/sidekiq/defaults.rb

@@ -2,26 +2,27 @@ module RailsSemanticLogger
   module Sidekiq
     module Defaults
       # Prevent exception logging during standard error handling since the Job Logger below already logs the exception.
-      if ::Sidekiq::VERSION.to_f < 7.1 ||
-         (::Sidekiq::VERSION.to_f == 7.1 && ::Sidekiq::VERSION.split(".").last.to_i < 6)
-        ERROR_HANDLER = ->(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)
+      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
-        end
-      else
-        ERROR_HANDLER = ->(ex, ctx, _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)
+        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
-      end
 
       # Returns the default logger after removing from the supplied list.
       # Returns [nil] when the default logger was not present.
@@ -30,8 +31,9 @@ def self.delete_default_error_handler(error_handlers)
         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) }
-        return error_handlers.delete(existing) if existing
+        error_handlers.delete(existing) if existing
       end
     end
   end

lib/rails_semantic_logger/sidekiq/loggable.rb

@@ -2,8 +2,8 @@ module RailsSemanticLogger
   module Sidekiq
     module Loggable
       def included(base)
-        base.include(SemanticLogger::Loggable)
         super
+        base.include(SemanticLogger::Loggable)
       end
     end
   end

test/dummy/config/initializers/sidekiq.rb

@@ -1,7 +1,5 @@
 # In tests we force Sidekiq into thinking it is running as a server,
 # so it creates a stdout logger. Remove it here:
 Rails.application.config.after_initialize do
-  if Rails.env.test?
-    SemanticLogger.appenders.delete_if { |appender| appender.is_a?(SemanticLogger::Appender::IO) }
-  end
+  SemanticLogger.appenders.delete_if { |appender| appender.is_a?(SemanticLogger::Appender::IO) } if Rails.env.test?
 end

test/sidekiq_test.rb

@@ -8,6 +8,7 @@ class SidekiqTest < Minitest::Test
 
     describe "#logger" do
       it "has its own logger with the same name as the job" do
+        assert_kind_of SemanticLogger::Logger, SimpleJob.logger
         assert_kind_of SemanticLogger::Logger, job.logger
         assert_equal job.logger.name, job.name
         refute_same Sidekiq.logger, job.logger
@@ -21,22 +22,23 @@ class SidekiqTest < Minitest::Test
       if Sidekiq::VERSION.to_i == 6 && Sidekiq::VERSION.to_f < 6.5
         let(:processor) do
           mgr          = Minitest::Mock.new
-          opts         = {queues: ["default"]}
+          opts         = Sidekiq.options
           opts[:fetch] = Sidekiq::BasicFetch.new(opts)
           Sidekiq::Processor.new(mgr, opts)
         end
       elsif Sidekiq::VERSION.to_i == 6
         let(:processor) do
-          config = Sidekiq
+          config         = Sidekiq
           config[:fetch] = Sidekiq::BasicFetch.new(config)
           Sidekiq::Processor.new(config) { |*args| }
         end
       elsif Sidekiq::VERSION.to_i < 7
         let(:processor) do
-          mgr = Minitest::Mock.new
-          mgr.expect(:options, {queues: ["default"]})
-          mgr.expect(:options, {queues: ["default"]})
-          mgr.expect(:options, {queues: ["default"]})
+          opts = Sidekiq.options
+          mgr  = Minitest::Mock.new
+          mgr.expect(:options, opts)
+          mgr.expect(:options, opts)
+          mgr.expect(:options, opts)
           Sidekiq::Processor.new(mgr)
         end
       else
@@ -53,21 +55,21 @@ class SidekiqTest < Minitest::Test
 
         assert_semantic_logger_event(
           messages[0],
-          level:            :info,
-          name:             "SimpleJob",
-          message_includes: "Start #perform",
-          metric:           "sidekiq.queue.latency",
-          named_tags:       {jid: nil, queue: "default"}
+          level:      :info,
+          name:       "SimpleJob",
+          message:    "Start #perform",
+          metric:     "sidekiq.queue.latency",
+          named_tags: {jid: nil, queue: "default"}
         )
         assert messages[0].metric_amount.is_a?(Float)
 
         assert_semantic_logger_event(
           messages[1],
-          level:            :info,
-          name:             "SimpleJob",
-          message_includes: "Completed #perform",
-          metric:           "sidekiq.job.perform",
-          named_tags:       {jid: nil, queue: "default"}
+          level:      :info,
+          name:       "SimpleJob",
+          message:    "Completed #perform",
+          metric:     "sidekiq.job.perform",
+          named_tags: {jid: nil, queue: "default"}
         )
         assert messages[1].duration.is_a?(Float)
       end