rubocop-sidekiq_plus 0.1.0

data/lib/rubocop/cop/sidekiq_ent/unique_job_without_ttl.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqEnt
+      # Checks that unique jobs specify the unique_for option.
+      #
+      # Sidekiq Enterprise unique jobs require a TTL (unique_for) to be specified.
+      # Without it, uniqueness locks may persist indefinitely if jobs fail.
+      #
+      # @example
+      #   # bad - unique_until without unique_for
+      #   class MyJob
+      #     include Sidekiq::Job
+      #     sidekiq_options unique_until: :start
+      #   end
+      #
+      #   # good - both unique_for and unique_until specified
+      #   class MyJob
+      #     include Sidekiq::Job
+      #     sidekiq_options unique_for: 1.hour, unique_until: :start
+      #   end
+      #
+      class UniqueJobWithoutTTL < Base
+        MSG = 'Specify `unique_for` option when using unique jobs.'
+
+        # @!method sidekiq_options_with_unique?(node)
+        def_node_matcher :sidekiq_options_with_unique?, <<~PATTERN
+          (send nil? :sidekiq_options (hash $...))
+        PATTERN
+
+        def on_send(node)
+          sidekiq_options_with_unique?(node) do |pairs|
+            has_unique_until = pairs.any? { |pair| option_key?(pair, :unique_until) }
+            has_unique_for = pairs.any? { |pair| option_key?(pair, :unique_for) }
+
+            add_offense(node) if has_unique_until && !has_unique_for
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def option_key?(pair, key)
+          return false unless pair.pair_type?
+
+          pair.key.sym_type? && pair.key.value == key
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq_ent/unique_until_mismatch.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqEnt
+      # Checks that unique_until option has an appropriate value.
+      #
+      # Using unique_until: :start may cause unexpected behavior as the lock
+      # is released when the job starts, allowing concurrent execution
+      # of identical jobs.
+      #
+      # @example
+      #   # bad - lock released on start
+      #   class MyJob
+      #     include Sidekiq::Job
+      #     sidekiq_options unique_for: 600, unique_until: :start
+      #   end
+      #
+      #   # good - default behavior (success)
+      #   class MyJob
+      #     include Sidekiq::Job
+      #     sidekiq_options unique_for: 600
+      #   end
+      #
+      #   # good - explicit success
+      #   class MyJob
+      #     include Sidekiq::Job
+      #     sidekiq_options unique_for: 600, unique_until: :success
+      #   end
+      #
+      class UniqueUntilMismatch < Base
+        MSG = 'Avoid `unique_until: :%<value>s`. ' \
+              'Prefer `unique_until: :success` (default) to prevent concurrent execution.'
+
+        ALLOWED_VALUES = %i[success].freeze
+
+        # @!method unique_until_value(node)
+        def_node_matcher :unique_until_value, <<~PATTERN
+          (send nil? :sidekiq_options (hash <(pair (sym :unique_until) (sym $_)) ...>))
+        PATTERN
+
+        def on_send(node)
+          unique_until_value(node) do |value|
+            return if allowed_values.include?(value)
+
+            add_offense(node, message: format(MSG, value: value))
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def allowed_values
+          Array(cop_config.fetch('AllowedValues', ALLOWED_VALUES)).map(&:to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq_pro/base.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqPro
+      # @abstract
+      # Base class for Sidekiq Pro cops.
+      # Provides common functionality for detecting Pro-specific patterns.
+      class Base < ::RuboCop::Cop::Base
+        abstract! if respond_to?(:abstract!)
+        include RuboCop::Sidekiq::Language
+
+        # Detect Sidekiq::Batch.new
+        # @!method batch_new?(node)
+        def_node_matcher :batch_new?, <<~PATTERN
+          (send (const (const {nil? cbase} :Sidekiq) :Batch) :new ...)
+        PATTERN
+
+        # Detect batch.jobs block
+        # @!method batch_jobs_block?(node)
+        def_node_matcher :batch_jobs_block?, <<~PATTERN
+          (block (send $_ :jobs) _ $_)
+        PATTERN
+
+        # Detect batch.on callback registration
+        # @!method batch_on_callback?(node)
+        def_node_matcher :batch_on_callback?, <<~PATTERN
+          (send $_ :on (sym $_) $...)
+        PATTERN
+
+        # Detect batch.description= assignment
+        # @!method batch_description_set?(node)
+        def_node_matcher :batch_description_set?, <<~PATTERN
+          (send $_ :description= $_)
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq_pro/batch_callback_method.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqPro
+      # Checks that batch callback methods are named correctly.
+      #
+      # Sidekiq Pro batch callbacks require specific method names:
+      # - `:complete` callback requires `on_complete` method
+      # - `:success` callback requires `on_success` method
+      # - `:death` callback requires `on_death` method
+      #
+      # @example
+      #   # bad - callback method name is incorrect
+      #   class MyCallback
+      #     def complete(status, options)
+      #     end
+      #   end
+      #   batch.on(:complete, MyCallback)
+      #
+      #   # good
+      #   class MyCallback
+      #     def on_complete(status, options)
+      #     end
+      #   end
+      #   batch.on(:complete, MyCallback)
+      #
+      #   # good - method specified as string
+      #   batch.on(:complete, 'MyCallback#handle_complete')
+      #
+      class BatchCallbackMethod < Base
+        CALLBACK_METHODS = {
+          complete: :on_complete,
+          success: :on_success,
+          death: :on_death
+        }.freeze
+
+        MSG = 'Batch callback method should be named `%<expected>s`, not `%<actual>s`.'
+
+        def on_def(node)
+          return unless potential_callback_method?(node)
+
+          method_name = node.method_name
+          expected_name = expected_method_name_for(method_name)
+          return unless expected_name
+
+          add_offense(node.loc.name, message: format(MSG, expected: expected_name, actual: method_name))
+        end
+
+        private
+
+        def potential_callback_method?(node)
+          CALLBACK_METHODS.key?(node.method_name) && callback_like_signature?(node)
+        end
+
+        def callback_like_signature?(node)
+          node.arguments.size == 2
+        end
+
+        def expected_method_name_for(method_name)
+          CALLBACK_METHODS[method_name]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq_pro/batch_retry_in_callback.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqPro
+      # Checks that jobs enqueued in batch callbacks have retry enabled.
+      #
+      # When a batch succeeds but the callback job fails without retry,
+      # the overall workflow may be incomplete without any automatic recovery.
+      #
+      # @example
+      #   # bad - callback enqueues a job without retry
+      #   class MyCallback
+      #     def on_success(status, options)
+      #       FinalizeJob.perform_async(options['order_id'])
+      #     end
+      #   end
+      #
+      #   class FinalizeJob
+      #     include Sidekiq::Job
+      #     sidekiq_options retry: false
+      #   end
+      #
+      #   # good - callback enqueues a job with retry enabled
+      #   class FinalizeJob
+      #     include Sidekiq::Job
+      #     sidekiq_options retry: 5
+      #   end
+      #
+      class BatchRetryInCallback < Base
+        MSG = 'Jobs enqueued in batch callbacks should have retry enabled.'
+
+        # @!method callback_method?(node)
+        def_node_matcher :callback_method?, <<~PATTERN
+          (def {:on_complete :on_success :on_death} (args _ _) ...)
+        PATTERN
+
+        # @!method perform_async_call?(node)
+        def_node_matcher :perform_async_call?, <<~PATTERN
+          (send (const ...) {:perform_async :perform_in :perform_at} ...)
+        PATTERN
+
+        def on_def(node)
+          return unless callback_method?(node)
+
+          node.each_descendant(:send) do |send_node|
+            add_offense(send_node) if perform_async_call?(send_node)
+          end
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq_pro/batch_status_polling.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqPro
+      # Checks for batch status polling anti-patterns.
+      #
+      # Polling batch status in a loop wastes resources and can cause
+      # issues. Use batch callbacks instead.
+      #
+      # @example
+      #   # bad - polling for status
+      #   loop do
+      #     status = Sidekiq::Batch::Status.new(bid)
+      #     break if status.complete?
+      #     sleep 5
+      #   end
+      #
+      #   # good - use callbacks
+      #   batch = Sidekiq::Batch.new
+      #   batch.on(:complete, MyCallback)
+      #   batch.jobs do
+      #     SomeJob.perform_async
+      #   end
+      #
+      class BatchStatusPolling < Base
+        MSG = 'Avoid polling batch status. Use batch callbacks instead.'
+
+        # @!method batch_status_new?(node)
+        def_node_matcher :batch_status_new?, <<~PATTERN
+          (send (const (const (const {nil? cbase} :Sidekiq) :Batch) :Status) :new ...)
+        PATTERN
+
+        # @!method status_complete_check?(node)
+        def_node_matcher :status_complete_check?, <<~PATTERN
+          (send _ {:complete? :pending :failures :total} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless batch_status_new?(node)
+          return unless inside_loop?(node)
+
+          add_offense(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def inside_loop?(node)
+          node.each_ancestor.any? do |ancestor|
+            loop_node?(ancestor)
+          end
+        end
+
+        def loop_node?(node)
+          return true if node.type?(:while, :until)
+          return true if node.block_type? && loop_method?(node.send_node)
+
+          false
+        end
+
+        def loop_method?(send_node)
+          %i[loop each times].include?(send_node.method_name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq_pro/batch_without_callback.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqPro
+      # Checks that batches have callbacks or descriptions for tracking.
+      #
+      # Batches without callbacks or descriptions are difficult to track
+      # and monitor. Consider adding at least one callback or a description.
+      #
+      # @example
+      #   # bad - no callback or description
+      #   batch = Sidekiq::Batch.new
+      #   batch.jobs do
+      #     SomeJob.perform_async
+      #   end
+      #
+      #   # good - has callback
+      #   batch = Sidekiq::Batch.new
+      #   batch.on(:complete, MyCallback)
+      #   batch.jobs do
+      #     SomeJob.perform_async
+      #   end
+      #
+      #   # good - has description
+      #   batch = Sidekiq::Batch.new
+      #   batch.description = "Import users"
+      #   batch.jobs do
+      #     SomeJob.perform_async
+      #   end
+      #
+      class BatchWithoutCallback < Base
+        MSG = 'Batch should have a callback or description for tracking.'
+
+        CALLBACK_METHODS = %i[on description=].freeze
+        private_constant :CALLBACK_METHODS
+
+        def on_block(node)
+          return unless batch_jobs_block?(node)
+
+          batch_receiver = node.receiver
+          return unless batch_receiver
+
+          batch_var_name = extract_variable_name(batch_receiver)
+          return unless batch_var_name
+
+          add_offense(node.send_node) unless callback_or_description?(node, batch_var_name)
+        end
+        alias on_numblock on_block
+
+        private
+
+        def extract_variable_name(node)
+          case node.type
+          when :lvar
+            node.children.first
+          when :send
+            node.method_name if node.receiver.nil?
+          end
+        end
+
+        def callback_or_description?(jobs_block, batch_var_name)
+          parent_scope = find_parent_scope(jobs_block)
+          return false unless parent_scope
+
+          parent_scope.each_descendant(:send).any? do |send_node|
+            receiver_matches?(send_node, batch_var_name) &&
+              CALLBACK_METHODS.include?(send_node.method_name)
+          end
+        end
+
+        def receiver_matches?(send_node, batch_var_name)
+          return false unless send_node.receiver
+
+          case send_node.receiver.type
+          when :lvar
+            send_node.receiver.children.first == batch_var_name
+          when :send
+            send_node.receiver.method?(batch_var_name)
+          else
+            false
+          end
+        end
+
+        def find_parent_scope(node)
+          node.each_ancestor(:any_def, :block, :begin).first ||
+            node.each_ancestor.find(&:begin_type?)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq_pro/empty_batch.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqPro
+      # Checks for batch.jobs blocks that might be empty.
+      #
+      # Empty batches cause errors in Sidekiq Pro versions before 7.1.
+      # Even in newer versions, creating empty batches is often unintentional.
+      #
+      # @example
+      #   # bad - block might add no jobs
+      #   batch = Sidekiq::Batch.new
+      #   batch.jobs do
+      #     items.each do |item|
+      #       ProcessJob.perform_async(item.id) if item.active?
+      #     end
+      #   end
+      #
+      #   # good - ensure at least one job is added or check before creating batch
+      #   active_items = items.select(&:active?)
+      #   if active_items.any?
+      #     batch = Sidekiq::Batch.new
+      #     batch.jobs do
+      #       active_items.each do |item|
+      #         ProcessJob.perform_async(item.id)
+      #       end
+      #     end
+      #   end
+      #
+      class EmptyBatch < Base
+        MSG = 'Batch jobs block may be empty. Ensure jobs are added or guard against empty batches.'
+
+        CONDITIONAL_METHODS = %i[if unless case].freeze
+
+        def on_block(node)
+          batch_jobs_block?(node) do |_receiver, body|
+            add_offense(node) if potentially_empty_block?(body)
+          end
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def potentially_empty_block?(body)
+          return true if body.nil?
+          return false if contains_unconditional_perform?(body)
+
+          all_perform_calls_conditional?(body)
+        end
+
+        def contains_unconditional_perform?(node)
+          return false unless node
+
+          case node.type
+          when :send
+            check_send_node_for_perform(node)
+          when :begin
+            node.children.any? { |child| contains_unconditional_perform?(child) }
+          else
+            false
+          end
+        end
+
+        def check_send_node_for_perform(node)
+          return true if perform_call?(node)
+
+          node.children.any? { |child| child.is_a?(::Parser::AST::Node) && contains_unconditional_perform?(child) }
+        end
+
+        def all_perform_calls_conditional?(node)
+          return false unless node
+
+          perform_calls = find_perform_calls(node)
+          return false if perform_calls.empty?
+
+          perform_calls.all? { |call| inside_conditional?(call) || inside_iterator_with_condition?(call) }
+        end
+
+        def find_perform_calls(node, calls = [])
+          return calls unless node.is_a?(::Parser::AST::Node)
+
+          calls << node if node.send_type? && perform_call?(node)
+          node.children.each { |child| find_perform_calls(child, calls) }
+          calls
+        end
+
+        def inside_conditional?(node)
+          node.each_ancestor.any? do |ancestor|
+            ancestor.type?(:if, :case, :case_match)
+          end
+        end
+
+        def inside_iterator_with_condition?(node)
+          node.each_ancestor(:block, :numblock).any? do |block|
+            iterator_with_potential_empty_collection?(block)
+          end
+        end
+
+        def iterator_with_potential_empty_collection?(block)
+          send_node = block.send_node
+          %i[each map select filter find_each find_in_batches].include?(send_node.method_name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq_pro/expiring_job_without_ttl.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqPro
+      # Checks that expiring jobs have appropriate TTL values.
+      #
+      # A TTL that is too short may cause jobs to expire before processing,
+      # while a TTL that is too long defeats the purpose of expiring jobs.
+      #
+      # @example
+      #   # bad - TTL too short
+      #   class MyJob
+      #     include Sidekiq::Job
+      #     sidekiq_options expires_in: 1.minute
+      #   end
+      #
+      #   # bad - TTL too long
+      #   class MyJob
+      #     include Sidekiq::Job
+      #     sidekiq_options expires_in: 30.days
+      #   end
+      #
+      #   # good - appropriate TTL
+      #   class MyJob
+      #     include Sidekiq::Job
+      #     sidekiq_options expires_in: 1.hour
+      #   end
+      #
+      class ExpiringJobWithoutTTL < Base
+        MSG_TOO_SHORT = 'Expiring job TTL is too short (minimum: %<minimum>s seconds). ' \
+                        'Jobs may expire before processing.'
+        MSG_TOO_LONG = 'Expiring job TTL is too long (maximum: %<maximum>s seconds). ' \
+                       'Consider a shorter TTL for expiring jobs.'
+
+        MINIMUM_TTL = 300
+        MAXIMUM_TTL = 604_800
+
+        # @!method expires_in_value(node)
+        def_node_matcher :expires_in_value, <<~PATTERN
+          (send nil? :sidekiq_options (hash <(pair (sym :expires_in) $_) ...>))
+        PATTERN
+
+        def on_send(node)
+          expires_in_value(node) do |value_node|
+            ttl = extract_seconds(value_node)
+            return unless ttl
+
+            check_ttl_range(value_node, ttl)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_ttl_range(node, ttl)
+          if ttl < minimum_ttl
+            add_offense(node, message: format(MSG_TOO_SHORT, minimum: minimum_ttl))
+          elsif ttl > maximum_ttl
+            add_offense(node, message: format(MSG_TOO_LONG, maximum: maximum_ttl))
+          end
+        end
+
+        def minimum_ttl
+          cop_config.fetch('MinimumTTL', MINIMUM_TTL)
+        end
+
+        def maximum_ttl
+          cop_config.fetch('MaximumTTL', MAXIMUM_TTL)
+        end
+
+        def extract_seconds(node)
+          case node.type
+          when :int
+            node.value
+          when :float
+            node.value.to_i
+          when :send
+            extract_duration_seconds(node)
+          end
+        end
+
+        def extract_duration_seconds(node)
+          return unless node.receiver&.type?(:int, :float)
+
+          value = node.receiver.value.to_f
+          duration_multiplier(node.method_name, value)&.to_i
+        end
+
+        def duration_multiplier(method_name, value)
+          case method_name
+          when :seconds, :second then value
+          when :minutes, :minute then value * 60
+          when :hours, :hour then value * 3600
+          when :days, :day then value * 86_400
+          end
+        end
+      end
+    end
+  end
+end