sidekiq-failures 0.4.5 → 1.1.0

data/lib/sidekiq/failures/web_extension.rb

@@ -1,49 +1,130 @@
 module Sidekiq
   module Failures
     module WebExtension
+      LEGACY_SIDEKIQ_VERSION = Gem::Version.new("7.3.9")
+
+      # Helper method to check Sidekiq version
+      def self.legacy_sidekiq?
+        Gem::Version.new(Sidekiq::VERSION) <= LEGACY_SIDEKIQ_VERSION
+      end
+
+      # Helper method to get parameters based on path and parameter name
+      def self.fetch_param_value(path, param_name)
+        if legacy_sidekiq?
+          # For newer Sidekiq, use route_params or url_params based on path
+          lambda { |env| env.params[param_name] }
+        else
+          # For legacy Sidekiq, just use params
+          if path.include?(":#{param_name}")
+            lambda { |env| env.route_params(param_name.to_sym) }
+          else
+            lambda { |env| env.url_params(param_name.to_s) }
+          end
+        end
+      end
+
+      # Helper method to handle parse_params vs parse_key compatibility
+      def self.parse_key_or_params
+        lambda do |env, key|
+          if env.respond_to?(:parse_key)
+            env.parse_key(key)
+          else
+            env.parse_params(key)
+          end
+        end
+      end
+
+      # Define the helper method implementation that will be used in both versions
+      # Instead of a static lambda, we'll return a method that needs to be evaluated in context
+      def self.safe_relative_time_implementation
+        lambda do |time, context|
+          return unless time
+
+          time = if time.is_a?(Numeric)
+            Time.at(time)
+          else
+            Time.parse(time)
+          end
+
+          # Use the context to call relative_time
+          context.relative_time(time)
+        end
+      end
+
+      # Define the helpers module for Sidekiq 8.0+
+      module FailuresHelpers
+        def safe_relative_time(time)
+          # Pass self (the context with relative_time) to the implementation
+          WebExtension.safe_relative_time_implementation.call(time, self)
+        end
+      end
 
       def self.registered(app)
         view_path = File.join(File.expand_path("..", __FILE__), "views")
+        if legacy_sidekiq?
+          failures_view_path = File.join(view_path, "failures_legacy.erb")
+          failure_view_path = File.join(view_path, "failure_legacy.erb")
+        else
+          failures_view_path = File.join(view_path, "failures.erb")
+          failure_view_path = File.join(view_path, "failure.erb")
+        end
 
-        app.helpers do
-          def safe_relative_time(time)
-            time = if time.is_a?(Numeric)
-              Time.at(time)
-            else
-              Time.parse(time)
-            end
+        # Create a parse helper for use in routes
+        parse_helper = parse_key_or_params
 
-            relative_time(time)
+        # Use appropriate helpers implementation based on Sidekiq version
+        if legacy_sidekiq?
+          # Original implementation for older Sidekiq versions
+          app.helpers do
+            define_method(:safe_relative_time) do |time|
+              # Pass self (the context with relative_time) to the implementation
+              WebExtension.safe_relative_time_implementation.call(time, self)
+            end
           end
+        else
+          # New implementation for Sidekiq 8.0+
+          app.helpers(FailuresHelpers)
         end
 
         app.get "/failures" do
-          @count = (params[:count] || 25).to_i
-          (@current_page, @total_size, @failures) = page(LIST_KEY, params[:page], @count)
+          page_param = Sidekiq::Failures::WebExtension.fetch_param_value("/failures", "page").call(self)
+          count_param = Sidekiq::Failures::WebExtension.fetch_param_value("/failures", "count").call(self)
+          @count = (count_param || 25).to_i
+
+          (@current_page, @total_size, @failures) = page(LIST_KEY, page_param, @count, :reverse => true)
           @failures = @failures.map {|msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
 
-          render(:erb, File.read(File.join(view_path, "failures.erb")))
+          render(:erb, File.read(failures_view_path))
         end
 
         app.get "/failures/:key" do
-          halt 404 unless params['key']
-
-          @failure = FailureSet.new.fetch(*parse_params(params['key'])).first
-          redirect "#{root_path}failures" if @failure.nil?
-          render(:erb, File.read(File.join(view_path, "failure.erb")))
+          key_param = Sidekiq::Failures::WebExtension.fetch_param_value("/failures/:key", "key").call(self)
+          halt 404 unless key_param
+
+          @failure = FailureSet.new.fetch(*parse_helper.call(self, key_param)).first
+          if @failure.nil?
+            redirect "#{root_path}failures"
+          else
+            render(:erb, File.read(failure_view_path))
+          end
         end
 
         app.post "/failures" do
-          halt 404 unless params['key']
+          key_param = Sidekiq::Failures::WebExtension.fetch_param_value("/failures", "key").call(self)
+          halt 404 unless key_param
 
-          params['key'].each do |key|
-            job = FailureSet.new.fetch(*parse_params(key)).first
+          key_param.each do |key|
+            job = FailureSet.new.fetch(*parse_helper.call(self, key)).first
             next unless job
 
-            if params['retry']
+            retry_param = Sidekiq::Failures::WebExtension.fetch_param_value("/failures", "retry").call(self)
+            if retry_param
               job.retry_failure
-            elsif params['delete']
-              job.delete
+            else
+              delete_param = Sidekiq::Failures::WebExtension.fetch_param_value("/failures", "delete").call(self)
+              if delete_param
+                job.delete
+              end
             end
           end
 
@@ -51,21 +132,26 @@ module Sidekiq
         end
 
         app.post "/failures/:key" do
-          halt 404 unless params['key']
+          key_param = Sidekiq::Failures::WebExtension.fetch_param_value("/failures/:key", "key").call(self)
+          halt 404 unless key_param
 
-          job = FailureSet.new.fetch(*parse_params(params['key'])).first
+          job = FailureSet.new.fetch(*parse_helper.call(self, key_param)).first
           if job
-            if params['retry']
+            retry_param = Sidekiq::Failures::WebExtension.fetch_param_value("/failures/:key", "retry").call(self)
+            if retry_param
               job.retry_failure
-            elsif params['delete']
-              job.delete
+            else
+              delete_param = Sidekiq::Failures::WebExtension.fetch_param_value("/failures/:key", "delete").call(self)
+              if delete_param
+                job.delete
+              end
             end
           end
           redirect_with_query("#{root_path}failures")
         end
 
         app.post "/failures/all/reset" do
-          Sidekiq::Failures.reset_failures
+          Sidekiq::Failures.reset_failure_count
           redirect "#{root_path}failures"
         end
 
@@ -78,6 +164,18 @@ module Sidekiq
           FailureSet.new.retry_all_failures
           redirect "#{root_path}failures"
         end
+
+        app.get '/filter/failures' do
+          redirect "#{root_path}failures"
+        end
+
+        app.post '/filter/failures' do
+          substr_param = Sidekiq::Failures::WebExtension.fetch_param_value("/filter/failures", "substr").call(self)
+          @failures = Sidekiq::Failures::FailureSet.new.scan("*#{substr_param}*")
+          @current_page = 1
+          @count = @total_size = @failures.count
+          render(:erb, File.read(failures_view_path))
+        end
       end
     end
   end

data/lib/sidekiq/failures.rb

@@ -5,6 +5,7 @@ rescue LoadError
 end
 
 require "sidekiq/api"
+require "sidekiq/version"
 require "sidekiq/failures/version"
 require "sidekiq/failures/sorted_entry"
 require "sidekiq/failures/failure_set"
@@ -47,33 +48,63 @@ module Sidekiq
 
   # Fetches the failures max count value
   def self.failures_max_count
-    return 1000 if @failures_max_count.nil?
-
-    @failures_max_count
+    if !instance_variable_defined?(:@failures_max_count) || @failures_max_count.nil?
+      1000
+    else
+      @failures_max_count
+    end
   end
 
   module Failures
     LIST_KEY = :failed
 
     def self.reset_failures
+      warn "NOTE: Sidekiq::Failures.reset_failures is deprecated; use Sidekiq::Failures.reset_failure_count instead."
+
+      reset_failure_count
+    end
+
+    def self.reset_failure_count
       Sidekiq.redis { |c| c.set("stat:failed", 0) }
     end
 
+    def self.clear_failures
+      FailureSet.new.clear
+    end
+
     def self.count
       Sidekiq.redis {|r| r.zcard(LIST_KEY) }
     end
+
+    def self.retry_middleware_class
+      if Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('5.0.0')
+        require 'sidekiq/job_retry'
+        Sidekiq::JobRetry
+      else
+        require 'sidekiq/middleware/server/retry_jobs'
+        Sidekiq::Middleware::Server::RetryJobs
+      end
+    end
+
   end
 end
 
 Sidekiq.configure_server do |config|
   config.server_middleware do |chain|
-    chain.insert_before Sidekiq::Middleware::Server::RetryJobs,
+    chain.insert_before Sidekiq::Failures.retry_middleware_class,
                         Sidekiq::Failures::Middleware
   end
 end
 
 if defined?(Sidekiq::Web)
-  Sidekiq::Web.register Sidekiq::Failures::WebExtension
-  Sidekiq::Web.tabs["Failures"] = "failures"
-  Sidekiq::Web.settings.locales << File.join(File.dirname(__FILE__), "failures/locales")
+  if Sidekiq::Failures::WebExtension.legacy_sidekiq?
+    Sidekiq::Web.register Sidekiq::Failures::WebExtension
+    Sidekiq::Web.tabs["Failures"] = "failures"
+    Sidekiq::Web.settings.locales << File.join(File.dirname(__FILE__), "failures/locales")
+  else
+    Sidekiq::Web.configure do |config|
+      config.locales << File.join(File.dirname(__FILE__), "failures/locales")
+      config.register(Sidekiq::Failures::WebExtension, name: "failures", tab: ["Failures"], index: ["failures"])
+    end
+  end
 end

data/sidekiq-failures.gemspec

@@ -7,16 +7,23 @@ Gem::Specification.new do |gem|
   gem.description   = %q{Keep track of Sidekiq failed jobs}
   gem.summary       = %q{Keeps track of Sidekiq failed jobs and adds a tab to the Web UI to let you browse them. Makes use of Sidekiq's custom tabs and middleware chain.}
   gem.homepage      = "https://github.com/mhfs/sidekiq-failures/"
+  gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "sidekiq-failures"
   gem.require_paths = ["lib"]
   gem.version       = Sidekiq::Failures::VERSION
 
-  gem.add_dependency "sidekiq", ">= 2.16.0"
+  gem.add_dependency "sidekiq", ">= 4.0.0"
 
+  # Redis 4.X is incompatible with Ruby < 2.3, but the Ruby version constraint
+  # wasn't added until 4.1.2, meaning you can get an incompatible version of the
+  # redis gem when running Ruby 2.2 without this constraint.
+  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.3.0")
+    gem.add_dependency "redis", "< 4.0"
+  end
+
+  gem.add_development_dependency "minitest"
   gem.add_development_dependency "rake"
   gem.add_development_dependency "rack-test"
   gem.add_development_dependency "sprockets"

data/test/failures_test.rb

@@ -0,0 +1,16 @@
+require "test_helper"
+
+module Sidekiq
+  describe Failures do
+    describe '.retry_middleware_class' do
+      it 'returns based on Sidekiq::VERSION' do
+        case Sidekiq::VERSION[0]
+        when '5'
+          assert_equal Failures.retry_middleware_class, Sidekiq::JobRetry
+        when '4'
+          assert_equal Failures.retry_middleware_class, Sidekiq::Middleware::Server::RetryJobs
+        end
+      end
+    end
+  end
+end

data/test/middleware_test.rb

@@ -1,19 +1,84 @@
 require "test_helper"
 
+class SidekiqPre6
+  def new_processor(boss)
+    num_options_calls.times { boss.expect(:options, {:queues => ['default'] }, []) }
+    ::Sidekiq::Processor.new(boss)
+  end
+
+  private
+
+  def num_options_calls
+    if Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('5.0.3')
+      3
+    else
+      2
+    end
+  end
+end
+
+class SidekiqPre63
+  def new_processor(boss)
+    opts = {
+      queues: ['default'],
+    }
+    opts[:fetch] = Sidekiq::BasicFetch.new(opts)
+    ::Sidekiq::Processor.new(boss, opts)
+  end
+end
+
+class SidekiqPost63
+  def new_processor(boss)
+    config = ::Sidekiq
+    config[:queues] = ['default']
+    config[:fetch] = ::Sidekiq::BasicFetch.new(config)
+    config[:error_handlers] << Sidekiq.method(:default_error_handler)
+    ::Sidekiq::Processor.new(config) { |processor, reason = nil| }
+  end
+end
+
+class SidekiqPost7
+  def new_processor(boss)
+    config = ::Sidekiq.default_configuration
+    ::Sidekiq::Processor.new(config.default_capsule) { |*args| }
+  end
+end
+
 module Sidekiq
   module Failures
     describe "Middleware" do
+      def new_provider
+        version = Gem::Version.new(Sidekiq::VERSION)
+        if version >= Gem::Version.new('7')
+          SidekiqPost7
+        elsif version >= Gem::Version.new('6.4.0')
+          SidekiqPost63
+        elsif version >= Gem::Version.new('6.0')
+          SidekiqPre63
+        else
+          SidekiqPre6
+        end.new
+      end
+
       before do
-        Celluloid.boot
         $invokes = 0
-        @boss = MiniTest::Mock.new
-        @processor = ::Sidekiq::Processor.new(@boss)
-        Sidekiq.server_middleware {|chain| chain.add Sidekiq::Failures::Middleware }
-        Sidekiq.redis = REDIS
-        Sidekiq.redis { |c| c.flushdb }
+        @boss = Minitest::Mock.new
+        @provider = new_provider
+        @processor = @provider.new_processor(@boss)
+
+        Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add Sidekiq::Failures::Middleware
+          end
+        end
+        Sidekiq.redis(&:flushdb)
         Sidekiq.instance_eval { @failures_default_mode = nil }
       end
 
+      after do
+        @boss.verify
+      end
+
       TestException = Class.new(Exception)
       ShutdownException = Class.new(Sidekiq::Shutdown)
 
@@ -42,13 +107,8 @@ module Sidekiq
 
         assert_equal 0, failures_count
 
-        actor = MiniTest::Mock.new
-        actor.expect(:processor_done, nil, [@processor])
-        actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-        2.times { @boss.expect(:async, actor, []) }
-
         assert_raises TestException do
-          @processor.process(msg)
+          @processor.send(:process, msg)
         end
 
         assert_equal 1, failures_count
@@ -60,13 +120,8 @@ module Sidekiq
 
         assert_equal 0, failures_count
 
-        actor = MiniTest::Mock.new
-        actor.expect(:processor_done, nil, [@processor])
-        actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-        2.times { @boss.expect(:async, actor, []) }
-
         assert_raises TestException do
-          @processor.process(msg)
+          @processor.send(:process, msg)
         end
 
         assert_equal 1, failures_count
@@ -78,13 +133,7 @@ module Sidekiq
 
         assert_equal 0, failures_count
 
-        actor = MiniTest::Mock.new
-        actor.expect(:processor_done, nil, [@processor])
-        actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-        2.times { @boss.expect(:async, actor, []) }
-
-        @processor.process(msg)
-        @boss.verify
+        @processor.send(:process, msg)
 
         assert_equal 0, failures_count
         assert_equal 1, $invokes
@@ -95,13 +144,8 @@ module Sidekiq
 
         assert_equal 0, failures_count
 
-        actor = MiniTest::Mock.new
-        actor.expect(:processor_done, nil, [@processor])
-        actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-        2.times { @boss.expect(:async, actor, []) }
-
         assert_raises TestException do
-          @processor.process(msg)
+          @processor.send(:process, msg)
         end
 
         assert_equal 0, failures_count
@@ -115,32 +159,21 @@ module Sidekiq
 
         assert_equal 0, failures_count
 
-        actor = MiniTest::Mock.new
-        actor.expect(:processor_done, nil, [@processor])
-        actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-        2.times { @boss.expect(:async, actor, []) }
-
         assert_raises TestException do
-          @processor.process(msg)
+          @processor.send(:process, msg)
         end
 
         assert_equal 0, failures_count
         assert_equal 1, $invokes
       end
 
-
       it "doesn't record failure if going to be retired again and configured to track exhaustion" do
         msg = create_work('class' => MockWorker.to_s, 'args' => ['myarg'], 'retry' => true, 'failures' => 'exhausted')
 
         assert_equal 0, failures_count
 
-        actor = MiniTest::Mock.new
-        actor.expect(:processor_done, nil, [@processor])
-        actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-        2.times { @boss.expect(:async, actor, []) }
-
         assert_raises TestException do
-          @processor.process(msg)
+          @processor.send(:process, msg)
         end
 
         assert_equal 0, failures_count
@@ -152,13 +185,8 @@ module Sidekiq
 
         assert_equal 0, failures_count
 
-        actor = MiniTest::Mock.new
-        actor.expect(:processor_done, nil, [@processor])
-        actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-        2.times { @boss.expect(:async, actor, []) }
-
         assert_raises TestException do
-          @processor.process(msg)
+          @processor.send(:process, msg)
         end
 
         assert_equal 1, failures_count
@@ -170,13 +198,8 @@ module Sidekiq
 
         assert_equal 0, failures_count
 
-        actor = MiniTest::Mock.new
-        actor.expect(:processor_done, nil, [@processor])
-        actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-        2.times { @boss.expect(:async, actor, []) }
-
         assert_raises TestException do
-          @processor.process(msg)
+          @processor.send(:process, msg)
         end
 
         assert_equal 1, failures_count
@@ -190,13 +213,8 @@ module Sidekiq
 
         assert_equal 0, failures_count
 
-        actor = MiniTest::Mock.new
-        actor.expect(:processor_done, nil, [@processor])
-        actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-        2.times { @boss.expect(:async, actor, []) }
-
         assert_raises TestException do
-          @processor.process(msg)
+          @processor.send(:process, msg)
         end
 
         assert_equal 1, failures_count
@@ -210,13 +228,8 @@ module Sidekiq
 
         assert_equal 0, failures_count
 
-        actor = MiniTest::Mock.new
-        actor.expect(:processor_done, nil, [@processor])
-        actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-        2.times { @boss.expect(:async, actor, []) }
-
         assert_raises TestException do
-          @processor.process(msg)
+          @processor.send(:process, msg)
         end
 
         assert_equal 1, failures_count
@@ -232,17 +245,14 @@ module Sidekiq
         assert_equal 0, failures_count
 
         3.times do
-          boss = MiniTest::Mock.new
-          processor = ::Sidekiq::Processor.new(boss)
-
-          actor = MiniTest::Mock.new
-          actor.expect(:processor_done, nil, [processor])
-          actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-          2.times { boss.expect(:async, actor, []) }
+          boss = Minitest::Mock.new
+          processor = @provider.new_processor(boss)
 
           assert_raises TestException do
-            processor.process(msg)
+            processor.send(:process, msg)
           end
+
+          boss.verify
         end
 
         assert_equal 2, failures_count
@@ -259,13 +269,8 @@ module Sidekiq
 
         assert_equal 0, Sidekiq::Failures.count
 
-        actor = MiniTest::Mock.new
-        actor.expect(:processor_done, nil, [@processor])
-        actor.expect(:real_thread, nil, [nil, Celluloid::Thread])
-        @boss.expect(:async, actor, [])
-
         assert_raises TestException do
-          @processor.process(msg)
+          @processor.send(:process, msg)
         end
 
         assert_equal 1, Sidekiq::Failures.count

data/test/test_helper.rb

@@ -1,5 +1,6 @@
-Encoding.default_external = Encoding::UTF_8
-Encoding.default_internal = Encoding::UTF_8
+$TESTING = true
+
+ENV["MT_CPU"] = "1" # Disable parallel testing to avoid flaky tests, force a single CPU for minitest
 
 require "minitest/autorun"
 require "minitest/spec"
@@ -7,14 +8,13 @@ require "minitest/mock"
 
 require "rack/test"
 
-require "celluloid"
 require "sidekiq"
+require "sidekiq-pro" if ENV['SIDEKIQ_PRO_VERSION']
 require "sidekiq-failures"
 require "sidekiq/processor"
 require "sidekiq/fetch"
 require "sidekiq/cli"
 
-Celluloid.logger = nil
 Sidekiq.logger.level = Logger::ERROR
 
-REDIS = Sidekiq::RedisConnection.create(:url => "redis://localhost/15", :namespace => 'sidekiq_failures_test')
+REDIS = Sidekiq::RedisConnection.create(url: "redis://127.0.0.1:6379/15") # Use DB 15 for testing