rubocop-sidekiq_plus 0.1.0

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for retry: 0 usage and suggests retry: false for clarity.
+      #
+      # @example
+      #   # bad
+      #   sidekiq_options retry: 0
+      #
+      #   # good
+      #   sidekiq_options retry: false
+      #
+      class RetryZero < Base
+        MSG = 'Use `retry: false` instead of `retry: 0` for clarity.'
+
+        def on_send(node)
+          sidekiq_options_call?(node) do |args|
+            args.each { |arg| check_hash(arg) }
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_hash(arg)
+          return unless arg.hash_type?
+
+          arg.pairs.each { |pair| check_pair(pair) }
+        end
+
+        def check_pair(pair)
+          return unless retry_key?(pair.key)
+
+          value = pair.value
+          return unless value&.int_type? && value.value.zero?
+
+          add_offense(value)
+        end
+
+        def retry_key?(node)
+          node&.sym_type? && node.value == :retry
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for jobs that reschedule themselves.
+      #
+      # @example
+      #   # bad
+      #   def perform
+      #     self.class.perform_in(1.hour)
+      #   end
+      #
+      class SelfSchedulingJob < Base
+        include ClassNameHelper
+
+        MSG = 'Avoid self-scheduling jobs. Use Sidekiq Cron or scheduler instead.'
+
+        def on_def(node)
+          return unless node.method?(:perform)
+          return unless in_sidekiq_job?(node)
+
+          class_node = node.each_ancestor(:class).first
+          class_name = class_name(class_node)
+
+          node.each_descendant(:send) do |send|
+            next unless PerformMethods.all.include?(send.method_name)
+            next unless self_receiver?(send.receiver, class_name)
+
+            add_offense(send)
+          end
+        end
+
+        private
+
+        def self_receiver?(receiver, class_name)
+          return false unless receiver
+
+          self_class_receiver?(receiver) || const_self_receiver?(receiver, class_name)
+        end
+
+        def self_class_receiver?(receiver)
+          receiver.send_type? &&
+            receiver.method?(:class) &&
+            receiver.receiver&.self_type?
+        end
+
+        def const_self_receiver?(receiver, class_name)
+          receiver.const_type? && class_name && receiver.const_name.split('::').last == class_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for sensitive data passed as Sidekiq job arguments.
+      #
+      # @example
+      #   # bad
+      #   UserJob.perform_async(user_id, password)
+      #
+      #   # good
+      #   UserJob.perform_async(user_id)
+      #
+      class SensitiveDataInArguments < Base
+        include ArgumentTraversal
+
+        MSG = 'Avoid passing sensitive data in Sidekiq job arguments.'
+
+        DEFAULT_PATTERNS = %w[
+          password passwd pwd token api_key secret credit_card card_number cvv ssn
+        ].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 sensitive_name?(arg.value.to_s)
+
+          add_offense(arg)
+        end
+
+        def check_variable(arg)
+          add_offense(arg) if sensitive_name?(arg.name.to_s)
+        end
+
+        def check_send(arg)
+          return unless arg.receiver.nil? && arg.arguments.empty?
+          return unless sensitive_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) && sensitive_name?(key.value.to_s)
+          check_argument(pair.value, allow_literal: false) if pair.value
+        end
+
+        def sensitive_name?(name)
+          patterns.any? { |pattern| name.downcase.include?(pattern) }
+        end
+
+        def patterns
+          Array(cop_config.fetch('SensitivePatterns', DEFAULT_PATTERNS))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Recommends using Sidekiq::Job over ActiveJob.
+      #
+      # @example
+      #   # bad
+      #   class MyJob < ApplicationJob
+      #     def perform; end
+      #   end
+      #
+      #   # good
+      #   class MyJob
+      #     include Sidekiq::Job
+      #   end
+      #
+      class SidekiqOverActiveJob < Base
+        MSG = 'Prefer Sidekiq::Job over ActiveJob for Sidekiq-specific features.'
+
+        def on_class(node)
+          return unless active_job_class?(node)
+
+          add_offense(node.loc.keyword)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for rescue blocks that swallow exceptions in Sidekiq jobs.
+      #
+      # @example
+      #   # bad
+      #   def perform
+      #     do_work
+      #   rescue => e
+      #     Rails.logger.error(e)
+      #   end
+      #
+      #   # good
+      #   def perform
+      #     do_work
+      #   rescue => e
+      #     Rails.logger.error(e)
+      #     raise
+      #   end
+      #
+      class SilentRescue < Base
+        MSG = 'Do not silently swallow exceptions in Sidekiq jobs. Re-raise or handle explicitly.'
+        RERAISE_METHODS = %i[raise fail].freeze
+
+        def on_def(node)
+          return unless node.method?(:perform)
+          return unless in_sidekiq_job?(node)
+
+          node.each_descendant(:resbody) do |resbody|
+            next if allowed_exception?(resbody)
+            next if re_raises?(resbody)
+
+            add_offense(resbody)
+          end
+        end
+
+        private
+
+        def allowed_exception?(resbody)
+          allowed = Array(cop_config.fetch('AllowedExceptions', []))
+          exceptions = resbody.exceptions
+          return false if exceptions.nil? || exceptions.empty?
+
+          exceptions.all? do |exception|
+            exception.const_type? && allowed.include?(exception.const_name)
+          end
+        end
+
+        def re_raises?(resbody)
+          body = resbody.body
+          return false unless body
+
+          body.each_descendant(:send).any? do |send|
+            send.receiver.nil? && RERAISE_METHODS.include?(send.method_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for `sleep` calls inside Sidekiq jobs.
+      #
+      # Using `sleep` in a Sidekiq job blocks the worker thread and prevents
+      # it from processing other jobs. Instead, use `perform_in` or
+      # `perform_at` to schedule the job for later.
+      #
+      # @example
+      #   # bad
+      #   class MyJob
+      #     include Sidekiq::Job
+      #
+      #     def perform
+      #       sleep 5
+      #     end
+      #   end
+      #
+      #   # good - use perform_in instead
+      #   MyJob.perform_in(5.seconds, args)
+      #
+      class SleepInJobs < Base
+        MSG = 'Do not use `sleep` in Sidekiq jobs. ' \
+              'It blocks the worker thread. Use `perform_in` or `perform_at` instead.'
+
+        RESTRICT_ON_SEND = %i[sleep].freeze
+
+        # @!method sleep_call?(node)
+        def_node_matcher :sleep_call?, <<~PATTERN
+          (send {nil? (const {nil? cbase} :Kernel)} :sleep ...)
+        PATTERN
+
+        def on_send(node)
+          return unless sleep_call?(node)
+          return unless in_sidekiq_job?(node)
+
+          add_offense(node)
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for symbol arguments passed to Sidekiq job methods.
+      #
+      # Symbols cannot be properly serialized to JSON and will be converted
+      # to strings. This can lead to unexpected behavior.
+      #
+      # @example
+      #   # bad
+      #   MyJob.perform_async(:status)
+      #   MyJob.perform_async(key: :value)
+      #   MyJob.perform_in(1.hour, :pending)
+      #
+      #   # good
+      #   MyJob.perform_async('status')
+      #   MyJob.perform_async(key: 'value')
+      #   MyJob.perform_in(1.hour, 'pending')
+      #
+      class SymbolArgument < Base
+        extend AutoCorrector
+        include ArgumentTraversal
+
+        MSG = 'Do not pass symbols to Sidekiq jobs. Use strings instead.'
+
+        RESTRICT_ON_SEND = PerformMethods.all
+
+        # @!method sidekiq_perform_call?(node)
+        def_node_matcher :sidekiq_perform_call?, <<~PATTERN
+          (send _ {#{RESTRICT_ON_SEND.map(&:inspect).join(' ')}} $...)
+        PATTERN
+
+        def on_send(node)
+          sidekiq_perform_call?(node) do |args|
+            check_arguments(args)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_argument(arg)
+          case arg.type
+          when :sym
+            register_symbol_offense(arg)
+          when :dsym
+            add_offense(arg)
+          when :hash
+            check_hash_values(arg)
+          when :array
+            check_array_elements(arg)
+          end
+        end
+
+        def register_symbol_offense(node)
+          add_offense(node) do |corrector|
+            corrector.replace(node, symbol_to_string(node))
+          end
+        end
+
+        def symbol_to_string(node)
+          node.value.to_s.inspect
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for thread creation inside Sidekiq jobs.
+      #
+      # Creating threads inside Sidekiq jobs is problematic because:
+      # - Sidekiq already manages its own thread pool
+      # - Threads may not complete before the job finishes
+      # - It can lead to resource leaks and unexpected behavior
+      #
+      # @example
+      #   # bad
+      #   class MyJob
+      #     include Sidekiq::Job
+      #
+      #     def perform
+      #       Thread.new { do_work }
+      #     end
+      #   end
+      #
+      #   # good - use separate jobs instead
+      #   class MyJob
+      #     include Sidekiq::Job
+      #
+      #     def perform
+      #       SubJob.perform_async
+      #     end
+      #   end
+      #
+      class ThreadInJob < Base
+        MSG = 'Do not create threads inside Sidekiq jobs. ' \
+              "Use separate jobs or Sidekiq's built-in concurrency instead."
+
+        RESTRICT_ON_SEND = %i[new fork].freeze
+
+        # @!method thread_creation?(node)
+        def_node_matcher :thread_creation?, <<~PATTERN
+          (send (const {nil? cbase} :Thread) {:new :fork} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless thread_creation?(node)
+          return unless in_sidekiq_job?(node)
+
+          add_offense(node)
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for Sidekiq jobs enqueued inside database transactions.
+      #
+      # Enqueuing jobs inside a transaction can lead to race conditions where
+      # the job runs before the transaction commits, causing the job to see
+      # stale data or fail to find the record.
+      #
+      # @example
+      #   # bad
+      #   ActiveRecord::Base.transaction do
+      #     user.save!
+      #     NotificationJob.perform_async(user.id)
+      #   end
+      #
+      #   # good - enqueue after transaction
+      #   user.save!
+      #   NotificationJob.perform_async(user.id)
+      #
+      #   # good - use after_commit callback
+      #   class User < ApplicationRecord
+      #     after_commit :send_notification, on: :create
+      #
+      #     def send_notification
+      #       NotificationJob.perform_async(id)
+      #     end
+      #   end
+      #
+      class TransactionLeak < Base
+        MSG = 'Do not enqueue Sidekiq jobs inside database transactions. ' \
+              'The job may run before the transaction commits.'
+
+        RESTRICT_ON_SEND = PerformMethods.all
+
+        # @!method perform_call?(node)
+        def_node_matcher :perform_call?, <<~PATTERN
+          (send _ {#{RESTRICT_ON_SEND.map(&:inspect).join(' ')}} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless perform_call?(node)
+          return unless inside_transaction?(node)
+
+          add_offense(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def inside_transaction?(node)
+          node.each_ancestor(:block).any? do |block_node|
+            transaction_block?(block_node)
+          end
+        end
+
+        def transaction_block?(block_node)
+          return false unless block_node.send_node
+
+          transaction_call?(block_node.send_node)
+        end
+
+        # @!method transaction_call?(node)
+        def_node_matcher :transaction_call?, <<~PATTERN
+          (send _ :transaction ...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for unknown or unsupported options passed to sidekiq_options.
+      #
+      # @example
+      #   # bad
+      #   sidekiq_options priorty: :high
+      #   sidekiq_options unique: true
+      #
+      #   # good
+      #   sidekiq_options queue: :critical, retry: 5
+      #
+      class UnknownSidekiqOption < Base
+        MSG = 'Unknown or unsupported Sidekiq option `%<option>s` in `sidekiq_options`.'
+
+        ALLOWED_OPTIONS = %w[queue retry dead backtrace pool tags].freeze
+
+        def on_send(node)
+          sidekiq_options_call?(node) do |args|
+            args.each do |arg|
+              check_options_hash(arg)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_options_hash(node)
+          return unless node.hash_type?
+
+          node.pairs.each do |pair|
+            option = option_name(pair.key)
+            next unless option
+            next if ALLOWED_OPTIONS.include?(option)
+
+            add_offense(pair, message: format(MSG, option: option))
+          end
+        end
+
+        def option_name(node)
+          return node.value.to_s if node.sym_type?
+
+          node.value if node.str_type?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq_cops.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative '../sidekiq/language'
+require_relative 'sidekiq/base'
+require_relative 'sidekiq/mixin/argument_traversal'
+require_relative 'sidekiq/mixin/class_name_helper'
+require_relative 'sidekiq/mixin/processed_source_path'
+require_relative 'sidekiq/active_record_argument'
+require_relative 'sidekiq/find_each_in_job'
+require_relative 'sidekiq/consistent_job_suffix'
+require_relative 'sidekiq/constant_job_class_name'
+require_relative 'sidekiq/database_connection_leak'
+require_relative 'sidekiq/date_time_argument'
+require_relative 'sidekiq/deprecated_default_worker_options'
+require_relative 'sidekiq/deprecated_delay_extension'
+require_relative 'sidekiq/deprecated_worker_module'
+require_relative 'sidekiq/excessive_retry'
+require_relative 'sidekiq/huge_job_arguments'
+require_relative 'sidekiq/enqueue_inefficiency'
+require_relative 'sidekiq/job_dependency'
+require_relative 'sidekiq/job_file_location'
+require_relative 'sidekiq/job_file_naming'
+require_relative 'sidekiq/missing_logging'
+require_relative 'sidekiq/missing_timeout'
+require_relative 'sidekiq/mixed_retry_strategies'
+require_relative 'sidekiq/perform_method_parameters'
+require_relative 'sidekiq/async_in_test'
+require_relative 'sidekiq/pii_in_arguments'
+require_relative 'sidekiq/sidekiq_over_active_job'
+require_relative 'sidekiq/redis_in_job'
+require_relative 'sidekiq/retry_zero'
+require_relative 'sidekiq/self_scheduling_job'
+require_relative 'sidekiq/sensitive_data_in_arguments'
+require_relative 'sidekiq/silent_rescue'
+require_relative 'sidekiq/symbol_argument'
+require_relative 'sidekiq/thread_in_job'
+require_relative 'sidekiq/job_include'
+require_relative 'sidekiq/sleep_in_jobs'
+require_relative 'sidekiq/no_rescue_all'
+require_relative 'sidekiq/perform_inline_usage'
+require_relative 'sidekiq/queue_specified'
+require_relative 'sidekiq/retry_specified'
+require_relative 'sidekiq/transaction_leak'
+require_relative 'sidekiq/unknown_sidekiq_option'
+require_relative 'sidekiq/puts_or_print_usage'
+
+# Sidekiq Pro Cops
+require_relative 'sidekiq_pro/base'
+require_relative 'sidekiq_pro/batch_callback_method'
+require_relative 'sidekiq_pro/batch_retry_in_callback'
+require_relative 'sidekiq_pro/batch_status_polling'
+require_relative 'sidekiq_pro/batch_without_callback'
+require_relative 'sidekiq_pro/empty_batch'
+require_relative 'sidekiq_pro/expiring_job_without_ttl'
+require_relative 'sidekiq_pro/large_argument_in_batch'
+require_relative 'sidekiq_pro/nested_batch_without_parent'
+require_relative 'sidekiq_pro/reliability_not_enabled'
+
+# Sidekiq Enterprise Cops
+require_relative 'sidekiq_ent/base'
+require_relative 'sidekiq_ent/encryption_with_many_arguments'
+require_relative 'sidekiq_ent/encryption_without_secret_bag'
+require_relative 'sidekiq_ent/leader_election_without_block'
+require_relative 'sidekiq_ent/limiter_not_reused'
+require_relative 'sidekiq_ent/limiter_without_lock_timeout'
+require_relative 'sidekiq_ent/limiter_without_wait_timeout'
+require_relative 'sidekiq_ent/periodic_job_invalid_cron'
+require_relative 'sidekiq_ent/periodic_job_with_arguments'
+require_relative 'sidekiq_ent/unique_job_too_short_ttl'
+require_relative 'sidekiq_ent/unique_job_without_ttl'
+require_relative 'sidekiq_ent/unique_until_mismatch'

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqEnt
+      # @abstract
+      # Base class for Sidekiq Enterprise cops.
+      # Provides common functionality for detecting Enterprise-specific patterns.
+      class Base < ::RuboCop::Cop::Base
+        abstract! if respond_to?(:abstract!)
+        include RuboCop::Sidekiq::Language
+
+        # Detect Sidekiq::Limiter.concurrent/bucket/window/leaky
+        # @!method limiter_creation?(node)
+        def_node_matcher :limiter_creation?, <<~PATTERN
+          (send
+            (const (const {nil? cbase} :Sidekiq) :Limiter)
+            ${:concurrent :bucket :window :leaky}
+            $_
+            $_
+            ...
+          )
+        PATTERN
+
+        # Detect sidekiq_options with unique_for
+        # @!method unique_for_option?(node)
+        def_node_matcher :unique_for_option?, <<~PATTERN
+          (send nil? :sidekiq_options
+            (hash <(pair (sym :unique_for) $_) ...>)
+          )
+        PATTERN
+
+        # Detect sidekiq_options with unique_until
+        # @!method unique_until_option?(node)
+        def_node_matcher :unique_until_option?, <<~PATTERN
+          (send nil? :sidekiq_options
+            (hash <(pair (sym :unique_until) $_) ...>)
+          )
+        PATTERN
+      end
+    end
+  end
+end