rubocop-sidekiq_plus 0.1.0

data/lib/rubocop/cop/sidekiq/missing_timeout.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for network calls without explicit timeouts in Sidekiq jobs.
+      #
+      # @example
+      #   # bad
+      #   Net::HTTP.get(URI(url))
+      #
+      #   # good
+      #   http.open_timeout = 5
+      #   http.read_timeout = 10
+      #
+      class MissingTimeout < Base
+        MSG = 'Configure explicit timeouts for network calls in Sidekiq jobs.'
+
+        HTTP_METHODS = %i[get post put delete].freeze
+        TIMEOUT_METHODS = %i[timeout= open_timeout= read_timeout=].freeze
+
+        def on_def(node)
+          return unless node.method?(:perform)
+          return unless in_sidekiq_job?(node)
+          return if timeout_configured?(node)
+
+          node.each_descendant(:send) do |send|
+            next unless network_call?(send)
+
+            add_offense(send)
+          end
+        end
+
+        private
+
+        def timeout_configured?(def_node)
+          def_node.each_descendant(:send).any? do |send|
+            TIMEOUT_METHODS.include?(send.method_name)
+          end
+        end
+
+        def network_call?(send)
+          receiver = send.receiver
+          const_name = receiver&.const_name
+          return false unless const_name
+
+          return %i[get get_response start].include?(send.method_name) if const_name == 'Net::HTTP'
+
+          library_http_methods?(const_name, send.method_name)
+        end
+
+        def library_http_methods?(const_name, method_name)
+          return method_name == :new if const_name == 'Faraday'
+          return HTTP_METHODS.include?(method_name) if http_libraries.include?(const_name)
+
+          false
+        end
+
+        def http_libraries
+          %w[HTTParty RestClient HTTP Typhoeus].freeze
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/mixed_retry_strategies.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for mixed ActiveJob and Sidekiq retry strategies in the same job.
+      #
+      # @example
+      #   # bad
+      #   class MyJob < ApplicationJob
+      #     retry_on SomeError
+      #     sidekiq_options retry: 5
+      #   end
+      #
+      class MixedRetryStrategies < Base
+        MSG = 'Avoid mixing ActiveJob retry_on with Sidekiq retry options.'
+
+        def on_class(node)
+          return unless active_job_class?(node)
+          return unless retry_on_call?(node)
+
+          sidekiq_retry_option_nodes(node).each do |send|
+            add_offense(send)
+          end
+        end
+
+        private
+
+        def retry_on_call?(class_node)
+          class_node.each_descendant(:send).any? { |send| send.method?(:retry_on) }
+        end
+
+        def sidekiq_retry_option_nodes(class_node)
+          class_node.each_descendant(:send).select do |send|
+            sidekiq_options_call?(send) { |args| retry_option?(args) }
+          end
+        end
+
+        def retry_option?(args)
+          args.any? do |arg|
+            next false unless arg.hash_type?
+
+            arg.pairs.any? do |pair|
+              key = pair.key
+              next false unless key&.sym_type? && key.value == :retry
+
+              value = pair.value
+              !value.false_type?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/mixin/argument_traversal.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Shared helpers for traversing Sidekiq job arguments.
+      module ArgumentTraversal
+        private
+
+        def check_arguments(args, **kwargs)
+          args.each { |arg| check_argument(arg, **kwargs) }
+        end
+
+        def check_hash_values(hash_node, **kwargs)
+          hash_node.each_pair do |_key, value|
+            check_argument(value, **kwargs)
+          end
+        end
+
+        def check_array_elements(array_node, **kwargs)
+          array_node.each_child_node do |element|
+            check_argument(element, **kwargs)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/mixin/class_name_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Shared helpers for extracting class names and file-friendly names.
+      module ClassNameHelper
+        private
+
+        def class_name(node)
+          identifier = node&.identifier
+          return unless identifier&.const_type?
+
+          identifier.const_name.split('::').last
+        end
+
+        def underscore(name)
+          name.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/mixin/processed_source_path.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Shared helpers for working with the current file path.
+      module ProcessedSourcePath
+        private
+
+        def processed_file_path
+          file_path = processed_source.file_path
+          return if file_path.nil? || file_path == '(string)'
+
+          file_path
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/no_rescue_all.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for bare `rescue` or `rescue Exception` in Sidekiq jobs.
+      #
+      # Rescuing all exceptions can hide bugs and prevent Sidekiq's retry
+      # mechanism from working properly. If you need to handle errors,
+      # rescue specific exception classes and consider re-raising.
+      #
+      # @example
+      #   # bad
+      #   class MyJob
+      #     include Sidekiq::Job
+      #
+      #     def perform
+      #       do_work
+      #     rescue
+      #       log_error
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class MyJob
+      #     include Sidekiq::Job
+      #
+      #     def perform
+      #       do_work
+      #     rescue Exception
+      #       log_error
+      #     end
+      #   end
+      #
+      #   # good
+      #   class MyJob
+      #     include Sidekiq::Job
+      #
+      #     def perform
+      #       do_work
+      #     rescue NetworkError => e
+      #       log_error(e)
+      #       raise
+      #     end
+      #   end
+      #
+      class NoRescueAll < Base
+        MSG = 'Avoid rescuing all exceptions in Sidekiq jobs. ' \
+              'Rescue specific exceptions and consider re-raising.'
+
+        # @!method bare_rescue?(node)
+        def_node_matcher :bare_rescue?, <<~PATTERN
+          (resbody nil? ...)
+        PATTERN
+
+        # @!method rescue_exception?(node)
+        def_node_matcher :rescue_exception?, <<~PATTERN
+          (resbody (array (const {nil? cbase} :Exception)) ...)
+        PATTERN
+
+        def on_resbody(node)
+          return unless in_sidekiq_job?(node)
+          return unless bare_rescue?(node) || rescue_exception?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/perform_inline_usage.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for usage of `perform_inline` in production code.
+      #
+      # `perform_inline` executes the job synchronously, bypassing the
+      # job queue. This can be useful in tests but should generally be
+      # avoided in production code.
+      #
+      # @example AllowedInTests: true (default)
+      #   # bad (in app/services/user_service.rb)
+      #   MyJob.perform_inline(user.id)
+      #
+      #   # good (in spec/jobs/my_job_spec.rb)
+      #   MyJob.perform_inline(user.id)
+      #
+      # @example AllowedInTests: false
+      #   # bad (in any file)
+      #   MyJob.perform_inline(user.id)
+      #
+      class PerformInlineUsage < Base
+        MSG = 'Avoid using `perform_inline` in production code. ' \
+              'Use `perform_async` instead.'
+
+        RESTRICT_ON_SEND = %i[perform_inline].freeze
+
+        def on_send(node)
+          return if allowed_in_tests? && in_test_file?
+
+          add_offense(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def allowed_in_tests?
+          cop_config.fetch('AllowedInTests', true)
+        end
+
+        def in_test_file?
+          file_path = processed_source.file_path
+          test_file_pattern.any? { |pattern| file_path.include?(pattern) }
+        end
+
+        def test_file_pattern
+          %w[_spec.rb _test.rb /spec/ /test/]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/perform_method_parameters.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks that the perform method does not use keyword arguments.
+      #
+      # Sidekiq serializes job arguments to JSON, which does not support
+      # Ruby keyword arguments. Using keyword arguments will cause errors
+      # or unexpected behavior.
+      #
+      # @example
+      #   # bad
+      #   def perform(user_id:, status:)
+      #   end
+      #
+      #   # bad
+      #   def perform(id, status: 'pending')
+      #   end
+      #
+      #   # good
+      #   def perform(user_id, status)
+      #   end
+      #
+      class PerformMethodParameters < Base
+        MSG = 'Do not use keyword arguments in the `perform` method. ' \
+              'Sidekiq cannot serialize keyword arguments to JSON.'
+
+        # @!method perform_method?(node)
+        def_node_matcher :perform_method?, <<~PATTERN
+          (def :perform ...)
+        PATTERN
+
+        def on_def(node)
+          return unless perform_method?(node)
+          return unless in_sidekiq_job?(node)
+
+          node.arguments.each do |arg|
+            next unless keyword_argument?(arg)
+
+            add_offense(arg)
+          end
+        end
+
+        private
+
+        def keyword_argument?(arg)
+          arg.type?(:kwarg, :kwoptarg, :kwrestarg)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/pii_in_arguments.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for PII passed as Sidekiq job arguments.
+      #
+      # @example
+      #   # bad
+      #   NotifyJob.perform_async(email: 'user@example.com')
+      #
+      #   # good
+      #   NotifyJob.perform_async(user_id)
+      #
+      class PiiInArguments < Base
+        include ArgumentTraversal
+
+        MSG = 'Avoid passing PII in Sidekiq job arguments.'
+
+        DEFAULT_PATTERNS = %w[email phone address].freeze
+
+        RESTRICT_ON_SEND = PerformMethods.all
+
+        def on_send(node)
+          perform_call?(node) do
+            check_arguments(node.arguments, allow_literal: true)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_argument(arg, allow_literal:)
+          return check_literal(arg, allow_literal) if literal_node?(arg)
+          return check_variable(arg) if var_node?(arg)
+          return check_send(arg) if arg.send_type?
+          return check_hash(arg) if arg.hash_type?
+
+          check_array_elements(arg, allow_literal: allow_literal) if arg.array_type?
+        end
+
+        def literal_node?(arg)
+          arg.type?(:sym, :str)
+        end
+
+        def var_node?(arg)
+          %i[lvar ivar gvar cvar].include?(arg.type)
+        end
+
+        def check_literal(arg, allow_literal)
+          return unless allow_literal
+          return unless pii_name?(arg.value.to_s)
+
+          add_offense(arg)
+        end
+
+        def check_variable(arg)
+          add_offense(arg) if pii_name?(arg.name.to_s)
+        end
+
+        def check_send(arg)
+          return unless arg.receiver.nil? && arg.arguments.empty?
+          return unless pii_name?(arg.method_name.to_s)
+
+          add_offense(arg)
+        end
+
+        def check_hash(arg)
+          arg.pairs.each do |pair|
+            check_hash_pair(pair)
+          end
+        end
+
+        def check_hash_pair(pair)
+          key = pair.key
+          add_offense(key) if key&.type?(:sym, :str) && pii_name?(key.value.to_s)
+          check_argument(pair.value, allow_literal: false) if pair.value
+        end
+
+        def pii_name?(name)
+          patterns.any? { |pattern| name.downcase.include?(pattern) }
+        end
+
+        def patterns
+          Array(cop_config.fetch('PiiPatterns', DEFAULT_PATTERNS))
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/puts_or_print_usage.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for puts/print usage inside Sidekiq jobs.
+      #
+      # @example
+      #   # bad
+      #   puts 'Processing...'
+      #
+      #   # good
+      #   logger.info 'Processing...'
+      #
+      class PutsOrPrintUsage < Base
+        MSG = 'Use logger instead of puts/print in Sidekiq jobs.'
+
+        RESTRICT_ON_SEND = %i[puts print].freeze
+
+        def on_send(node)
+          return unless node.receiver.nil?
+          return unless in_perform_in_sidekiq_job?(node)
+
+          add_offense(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def in_perform_in_sidekiq_job?(node)
+          node.each_ancestor(:def).any? { |def_node| def_node.method?(:perform) } &&
+            in_sidekiq_job?(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/queue_specified.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks that Sidekiq jobs have an explicit queue specified.
+      #
+      # Without an explicit queue, jobs go to the `default` queue.
+      # Specifying queues helps with job organization and prioritization.
+      #
+      # @example
+      #   # bad
+      #   class MyJob
+      #     include Sidekiq::Job
+      #   end
+      #
+      #   # good
+      #   class MyJob
+      #     include Sidekiq::Job
+      #     sidekiq_options queue: :critical
+      #   end
+      #
+      class QueueSpecified < Base
+        MSG = 'Specify a queue for this Sidekiq job using `sidekiq_options queue: :queue_name`.'
+
+        # @!method sidekiq_include?(node)
+        def_node_matcher :sidekiq_include?, <<~PATTERN
+          (send nil? :include (const (const {nil? cbase} :Sidekiq) {:Job :Worker}))
+        PATTERN
+
+        # @!method sidekiq_options_with_queue?(node)
+        def_node_matcher :sidekiq_options_with_queue?, <<~PATTERN
+          (send nil? :sidekiq_options (hash <(pair (sym :queue) _) ...>))
+        PATTERN
+
+        def on_class(node)
+          return unless sidekiq_job_class?(node)
+          return if queue_option?(node)
+
+          include_node = find_sidekiq_include(node)
+          add_offense(include_node) if include_node
+        end
+
+        private
+
+        def sidekiq_job_class?(class_node)
+          return false unless class_node.body
+
+          find_sidekiq_include(class_node)
+        end
+
+        def find_sidekiq_include(class_node)
+          return nil unless class_node.body
+
+          if class_node.body.begin_type?
+            class_node.body.each_child_node.find { |n| sidekiq_include?(n) }
+          elsif sidekiq_include?(class_node.body)
+            class_node.body
+          end
+        end
+
+        def queue_option?(class_node)
+          return false unless class_node.body
+
+          if class_node.body.begin_type?
+            class_node.body.each_child_node.any? { |n| sidekiq_options_with_queue?(n) }
+          else
+            sidekiq_options_with_queue?(class_node.body)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/redis_in_job.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for direct Redis connections inside Sidekiq jobs.
+      #
+      # @example
+      #   # bad
+      #   redis = Redis.new
+      #
+      #   # good
+      #   Sidekiq.redis { |conn| conn.get('key') }
+      #
+      class RedisInJob < Base
+        MSG = 'Use Sidekiq.redis instead of creating a new Redis connection in jobs.'
+
+        def on_def(node)
+          return unless node.method?(:perform)
+          return unless in_sidekiq_job?(node)
+
+          node.each_descendant(:send) do |send|
+            receiver = send.receiver
+            next unless receiver&.const_name == 'Redis' && send.method?(:new)
+
+            add_offense(send)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/retry_specified.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks that Sidekiq jobs have explicit retry configuration.
+      #
+      # Without explicit retry configuration, jobs use the default retry
+      # setting (25 retries). Being explicit about retry behavior makes
+      # the job's error handling clearer.
+      #
+      # @example
+      #   # bad
+      #   class MyJob
+      #     include Sidekiq::Job
+      #   end
+      #
+      #   # good
+      #   class MyJob
+      #     include Sidekiq::Job
+      #     sidekiq_options retry: 5
+      #   end
+      #
+      #   # good
+      #   class MyJob
+      #     include Sidekiq::Job
+      #     sidekiq_options retry: false
+      #   end
+      #
+      class RetrySpecified < Base
+        MSG = 'Specify retry configuration for this Sidekiq job using `sidekiq_options retry: ...`.'
+
+        # @!method sidekiq_include?(node)
+        def_node_matcher :sidekiq_include?, <<~PATTERN
+          (send nil? :include (const (const {nil? cbase} :Sidekiq) {:Job :Worker}))
+        PATTERN
+
+        # @!method sidekiq_options_with_retry?(node)
+        def_node_matcher :sidekiq_options_with_retry?, <<~PATTERN
+          (send nil? :sidekiq_options (hash <(pair (sym :retry) _) ...>))
+        PATTERN
+
+        def on_class(node)
+          return unless sidekiq_job_class?(node)
+          return if retry_option?(node)
+
+          include_node = find_sidekiq_include(node)
+          add_offense(include_node) if include_node
+        end
+
+        private
+
+        def sidekiq_job_class?(class_node)
+          return false unless class_node.body
+
+          find_sidekiq_include(class_node)
+        end
+
+        def find_sidekiq_include(class_node)
+          return nil unless class_node.body
+
+          if class_node.body.begin_type?
+            class_node.body.each_child_node.find { |n| sidekiq_include?(n) }
+          elsif sidekiq_include?(class_node.body)
+            class_node.body
+          end
+        end
+
+        def retry_option?(class_node)
+          return false unless class_node.body
+
+          if class_node.body.begin_type?
+            class_node.body.each_child_node.any? { |n| sidekiq_options_with_retry?(n) }
+          else
+            sidekiq_options_with_retry?(class_node.body)
+          end
+        end
+      end
+    end
+  end
+end