rubocop-sidekiq_plus 0.1.0

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqPro
+      # Checks for large arguments passed to jobs within a batch.
+      #
+      # When using batches, passing large arguments to jobs is especially
+      # problematic because it can exhaust Redis memory when many jobs
+      # are enqueued simultaneously.
+      #
+      # @example
+      #   # bad
+      #   batch.jobs do
+      #     items.each do |item|
+      #       ProcessJob.perform_async(item.attributes)
+      #     end
+      #   end
+      #
+      #   # good
+      #   batch.jobs do
+      #     items.each do |item|
+      #       ProcessJob.perform_async(item.id)
+      #     end
+      #   end
+      #
+      class LargeArgumentInBatch < Base
+        MSG = 'Avoid passing large arguments to jobs within a batch. Pass IDs instead.'
+
+        DEFAULT_MAX_ARRAY_SIZE = 10
+        DEFAULT_MAX_HASH_SIZE = 10
+
+        def on_block(node)
+          batch_jobs_block?(node) do |_receiver, body|
+            check_body_for_large_arguments(body)
+          end
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def check_body_for_large_arguments(body)
+          return unless body
+
+          find_perform_calls(body).each do |call|
+            call.arguments.each do |arg|
+              add_offense(arg) if large_argument?(arg)
+            end
+          end
+        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 large_argument?(arg)
+          large_array?(arg) || large_hash?(arg) || attributes_call?(arg)
+        end
+
+        def large_array?(arg)
+          return false unless arg.array_type?
+
+          arg.values.size > max_array_size
+        end
+
+        def large_hash?(arg)
+          return false unless arg.hash_type?
+
+          arg.pairs.size > max_hash_size
+        end
+
+        def attributes_call?(arg)
+          return false unless arg.send_type?
+
+          %i[attributes as_json to_h to_hash].include?(arg.method_name)
+        end
+
+        def max_array_size
+          cop_config.fetch('MaxArraySize', DEFAULT_MAX_ARRAY_SIZE)
+        end
+
+        def max_hash_size
+          cop_config.fetch('MaxHashSize', DEFAULT_MAX_HASH_SIZE)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqPro
+      # Checks that nested batches have proper parent relationship.
+      #
+      # When creating nested batches inside a batch.jobs block,
+      # the child batch should reference the parent for proper tracking.
+      #
+      # @example
+      #   # bad - nested batch without parent reference
+      #   class ProcessBatchJob
+      #     include Sidekiq::Job
+      #
+      #     def perform
+      #       batch.jobs do
+      #         child_batch = Sidekiq::Batch.new
+      #         child_batch.jobs do
+      #           SomeJob.perform_async
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      #   # good - explicit parent reference
+      #   class ProcessBatchJob
+      #     include Sidekiq::Job
+      #
+      #     def perform
+      #       parent_batch = batch
+      #       parent_batch.jobs do
+      #         child_batch = Sidekiq::Batch.new(parent_batch.bid)
+      #         child_batch.jobs do
+      #           SomeJob.perform_async
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      class NestedBatchWithoutParent < Base
+        MSG = 'Nested batch should reference parent batch for proper tracking.'
+
+        def on_block(node)
+          return unless batch_jobs_block?(node)
+
+          node.body&.each_descendant(:send) do |send_node|
+            add_offense(send_node) if batch_new?(send_node) && send_node.arguments.empty?
+          end
+        end
+        alias on_numblock on_block
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqPro
+      # Checks that Sidekiq Pro reliability features are enabled.
+      #
+      # Sidekiq Pro provides `super_fetch!` and `reliable_push!` for
+      # improved job reliability. These should be enabled in production.
+      #
+      # @example
+      #   # bad - reliability features not enabled
+      #   Sidekiq.configure_server do |config|
+      #     config.redis = { url: ENV['REDIS_URL'] }
+      #   end
+      #
+      #   # good - reliability features enabled
+      #   Sidekiq.configure_server do |config|
+      #     config.redis = { url: ENV['REDIS_URL'] }
+      #     config.super_fetch!
+      #     config.reliable_push!
+      #   end
+      #
+      class ReliabilityNotEnabled < Base
+        MSG_SUPER_FETCH = 'Consider enabling `super_fetch!` for reliable job fetching.'
+        MSG_RELIABLE_PUSH = 'Consider enabling `reliable_push!` for reliable job pushing.'
+
+        # @!method configure_server_block?(node)
+        def_node_matcher :configure_server_block?, <<~PATTERN
+          (block
+            (send (const {nil? cbase} :Sidekiq) :configure_server)
+            (args (arg $_))
+            $_
+          )
+        PATTERN
+
+        def on_block(node)
+          configure_server_block?(node) do |config_var, body|
+            return unless body
+
+            check_reliability_features(node, config_var, body)
+          end
+        end
+        alias on_numblock on_block
+
+        private
+
+        def check_reliability_features(node, config_var, body)
+          has_super_fetch = method_call?(body, config_var, :super_fetch!)
+          has_reliable_push = method_call?(body, config_var, :reliable_push!)
+
+          add_offense(node.send_node, message: MSG_SUPER_FETCH) unless has_super_fetch
+          add_offense(node.send_node, message: MSG_RELIABLE_PUSH) unless has_reliable_push
+        end
+
+        def method_call?(body, config_var, method_name)
+          nodes_to_check = body.send_type? ? [body] : body.each_descendant(:send).to_a
+          nodes_to_check.any? do |send_node|
+            send_node.method?(method_name) &&
+              send_node.receiver&.lvar_type? &&
+              send_node.receiver.children.first == config_var
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/sidekiq/config_formatter.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module RuboCop
+  module Sidekiq
+    # Builds a YAML config file from two config hashes
+    class ConfigFormatter
+      EXTENSION_ROOT_DEPARTMENT = %r{^(Sidekiq(?:Pro|Ent)?/)}.freeze
+      SUBDEPARTMENTS = %w[].freeze
+      AMENDMENTS = [].freeze
+      COP_DOC_BASE_URL = 'https://www.rubydoc.info/gems/rubocop-sidekiq_plus/RuboCop/Cop/'
+
+      def initialize(config, descriptions)
+        @config       = config
+        @descriptions = descriptions
+      end
+
+      def dump
+        YAML.dump(unified_config)
+            .gsub(EXTENSION_ROOT_DEPARTMENT, "\n\\1")
+            .gsub(/^(SidekiqPro:|SidekiqEnt:)/, "\n\\1")
+            .gsub(/^(\s+)- /, '\1  - ')
+            .gsub('"~"', '~')
+        # .gsub(*AMENDMENTS, "\n\\0")
+      end
+
+      private
+
+      def unified_config
+        cops.each_with_object(config.dup) do |cop, unified|
+          next if SUBDEPARTMENTS.include?(cop) || AMENDMENTS.include?(cop)
+
+          unified[cop] ||= {}
+          replace_nil(unified[cop])
+          unified[cop].merge!(descriptions.fetch(cop, {}))
+          unified[cop]['Reference'] = reference(cop)
+        end
+      end
+
+      def cops
+        (descriptions.keys | config.keys).grep(EXTENSION_ROOT_DEPARTMENT)
+      end
+
+      def replace_nil(config)
+        return unless config
+
+        config.each do |key, value|
+          config[key] = '~' if value.nil?
+        end
+      end
+
+      def reference(cop)
+        COP_DOC_BASE_URL + cop
+      end
+
+      attr_reader :config, :descriptions
+    end
+  end
+end

data/lib/rubocop/sidekiq/description_extractor.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Sidekiq
+    # Extracts cop descriptions from YARD docstrings
+    class DescriptionExtractor
+      def initialize(yardocs)
+        @code_objects = yardocs.map(&CodeObject.public_method(:new))
+      end
+
+      def to_h
+        configs = code_objects.select(&:cop?).map(&:configuration)
+        return {} if configs.empty?
+
+        configs.reduce(:merge)
+      end
+
+      private
+
+      attr_reader :code_objects
+
+      # Decorator of a YARD code object for working with documented cops
+      class CodeObject
+        RUBOCOP_COP_CLASS_NAME = 'RuboCop::Cop::Base'
+
+        def initialize(yardoc)
+          @yardoc = yardoc
+        end
+
+        # Test if the YARD code object documents a concrete cop class
+        #
+        # @return [Boolean]
+        def cop?
+          cop_subclass? && !abstract?
+        end
+
+        # Configuration for the documented cop that would live in default.yml
+        #
+        # @return [Hash]
+        def configuration
+          { cop_name => { 'Description' => description } }
+        end
+
+        private
+
+        def cop_name
+          Object.const_get(documented_constant).cop_name
+        end
+
+        def description
+          yardoc.docstring.split("\n\n").first.to_s
+        end
+
+        def documented_constant
+          yardoc.to_s
+        end
+
+        def cop_subclass?
+          yardoc.superclass.path == RUBOCOP_COP_CLASS_NAME
+        end
+
+        def abstract?
+          yardoc.tags.any? { |tag| tag.tag_name.eql?('abstract') }
+        end
+
+        attr_reader :yardoc
+      end
+    end
+  end
+end

data/lib/rubocop/sidekiq/language.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Sidekiq
+    # Centralized Sidekiq API definitions used by cops.
+    module Language
+      extend RuboCop::NodePattern::Macros
+
+      module PerformMethods # :nodoc:
+        ALL = %i[perform_async perform_in perform_at perform_bulk].freeze
+
+        class << self
+          def all
+            ALL
+          end
+
+          def include?(method)
+            ALL.include?(method)
+          end
+        end
+      end
+
+      module JobModules # :nodoc:
+        ALL = %i[Job Worker].freeze
+
+        class << self
+          def all
+            ALL
+          end
+
+          def include?(name)
+            ALL.include?(name)
+          end
+        end
+      end
+
+      # @!method sidekiq_include?(node)
+      #   Matches `include Sidekiq::Job` or `include Sidekiq::Worker`
+      #   Also matches when included with other modules: `include Sidekiq::Job, OtherModule`
+      def_node_matcher :sidekiq_include?, <<~PATTERN
+        (send nil? :include <(const (const {nil? cbase} :Sidekiq)
+          {#{JobModules.all.map(&:inspect).join(' ')}}) ...>)
+      PATTERN
+
+      # @!method sidekiq_options_call?(node)
+      def_node_matcher :sidekiq_options_call?, <<~PATTERN
+        (send nil? :sidekiq_options $...)
+      PATTERN
+
+      # @!method active_job_class?(node)
+      def_node_matcher :active_job_class?, <<~PATTERN
+        (class _ (const {nil? cbase} :ApplicationJob) ...)
+      PATTERN
+
+      # @!method perform_call?(node)
+      def_node_matcher :perform_call?, <<~PATTERN
+        (send $_ {#{PerformMethods.all.map(&:inspect).join(' ')}} ...)
+      PATTERN
+
+      private
+
+      def in_sidekiq_job?(node)
+        node.each_ancestor(:class).any? do |class_node|
+          sidekiq_job_class?(class_node)
+        end
+      end
+
+      def sidekiq_job_class?(class_node)
+        return false unless class_node.body
+
+        if class_node.body.begin_type?
+          class_node.body.each_child_node.any? { |n| sidekiq_include?(n) }
+        else
+          sidekiq_include?(class_node.body)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/sidekiq/plugin.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+
+module RuboCop
+  module Sidekiq
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-sidekiq_plus',
+          version: VERSION,
+          homepage: 'https://github.com/ydah/rubocop-sidekiq_plus',
+          description: 'Code style checking for Sidekiq.'
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: CONFIG_DEFAULT.to_s
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/sidekiq/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Sidekiq
+    VERSION = '0.1.0'
+  end
+end

data/lib/rubocop/sidekiq.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Sidekiq
+    class Error < StandardError; end
+
+    PROJECT_ROOT = Pathname.new(__dir__).parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
+  end
+end

data/lib/rubocop-sidekiq.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'rubocop-sidekiq_plus'
+
+Gem.loaded_specs['rubocop-sidekiq'] ||= Gem.loaded_specs['rubocop-sidekiq_plus']

data/lib/rubocop-sidekiq_plus.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+require_relative 'rubocop/sidekiq'
+require_relative 'rubocop/sidekiq/version'
+require_relative 'rubocop/sidekiq/plugin'
+
+require_relative 'rubocop/cop/sidekiq_cops'

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-sidekiq_plus
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lint_roller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.81'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.81'
+description: A RuboCop extension focused on enforcing Sidekiq best practices and coding
+  conventions.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- config/default.yml
+- lib/rubocop-sidekiq.rb
+- lib/rubocop-sidekiq_plus.rb
+- lib/rubocop/cop/sidekiq/active_record_argument.rb
+- lib/rubocop/cop/sidekiq/async_in_test.rb
+- lib/rubocop/cop/sidekiq/base.rb
+- lib/rubocop/cop/sidekiq/consistent_job_suffix.rb
+- lib/rubocop/cop/sidekiq/constant_job_class_name.rb
+- lib/rubocop/cop/sidekiq/database_connection_leak.rb
+- lib/rubocop/cop/sidekiq/date_time_argument.rb
+- lib/rubocop/cop/sidekiq/deprecated_default_worker_options.rb
+- lib/rubocop/cop/sidekiq/deprecated_delay_extension.rb
+- lib/rubocop/cop/sidekiq/deprecated_worker_module.rb
+- lib/rubocop/cop/sidekiq/enqueue_inefficiency.rb
+- lib/rubocop/cop/sidekiq/excessive_retry.rb
+- lib/rubocop/cop/sidekiq/find_each_in_job.rb
+- lib/rubocop/cop/sidekiq/huge_job_arguments.rb
+- lib/rubocop/cop/sidekiq/job_dependency.rb
+- lib/rubocop/cop/sidekiq/job_file_location.rb
+- lib/rubocop/cop/sidekiq/job_file_naming.rb
+- lib/rubocop/cop/sidekiq/job_include.rb
+- lib/rubocop/cop/sidekiq/missing_logging.rb
+- lib/rubocop/cop/sidekiq/missing_timeout.rb
+- lib/rubocop/cop/sidekiq/mixed_retry_strategies.rb
+- lib/rubocop/cop/sidekiq/mixin/argument_traversal.rb
+- lib/rubocop/cop/sidekiq/mixin/class_name_helper.rb
+- lib/rubocop/cop/sidekiq/mixin/processed_source_path.rb
+- lib/rubocop/cop/sidekiq/no_rescue_all.rb
+- lib/rubocop/cop/sidekiq/perform_inline_usage.rb
+- lib/rubocop/cop/sidekiq/perform_method_parameters.rb
+- lib/rubocop/cop/sidekiq/pii_in_arguments.rb
+- lib/rubocop/cop/sidekiq/puts_or_print_usage.rb
+- lib/rubocop/cop/sidekiq/queue_specified.rb
+- lib/rubocop/cop/sidekiq/redis_in_job.rb
+- lib/rubocop/cop/sidekiq/retry_specified.rb
+- lib/rubocop/cop/sidekiq/retry_zero.rb
+- lib/rubocop/cop/sidekiq/self_scheduling_job.rb
+- lib/rubocop/cop/sidekiq/sensitive_data_in_arguments.rb
+- lib/rubocop/cop/sidekiq/sidekiq_over_active_job.rb
+- lib/rubocop/cop/sidekiq/silent_rescue.rb
+- lib/rubocop/cop/sidekiq/sleep_in_jobs.rb
+- lib/rubocop/cop/sidekiq/symbol_argument.rb
+- lib/rubocop/cop/sidekiq/thread_in_job.rb
+- lib/rubocop/cop/sidekiq/transaction_leak.rb
+- lib/rubocop/cop/sidekiq/unknown_sidekiq_option.rb
+- lib/rubocop/cop/sidekiq_cops.rb
+- lib/rubocop/cop/sidekiq_ent/base.rb
+- lib/rubocop/cop/sidekiq_ent/encryption_with_many_arguments.rb
+- lib/rubocop/cop/sidekiq_ent/encryption_without_secret_bag.rb
+- lib/rubocop/cop/sidekiq_ent/leader_election_without_block.rb
+- lib/rubocop/cop/sidekiq_ent/limiter_not_reused.rb
+- lib/rubocop/cop/sidekiq_ent/limiter_without_lock_timeout.rb
+- lib/rubocop/cop/sidekiq_ent/limiter_without_wait_timeout.rb
+- lib/rubocop/cop/sidekiq_ent/periodic_job_invalid_cron.rb
+- lib/rubocop/cop/sidekiq_ent/periodic_job_with_arguments.rb
+- lib/rubocop/cop/sidekiq_ent/unique_job_too_short_ttl.rb
+- lib/rubocop/cop/sidekiq_ent/unique_job_without_ttl.rb
+- lib/rubocop/cop/sidekiq_ent/unique_until_mismatch.rb
+- lib/rubocop/cop/sidekiq_pro/base.rb
+- lib/rubocop/cop/sidekiq_pro/batch_callback_method.rb
+- lib/rubocop/cop/sidekiq_pro/batch_retry_in_callback.rb
+- lib/rubocop/cop/sidekiq_pro/batch_status_polling.rb
+- lib/rubocop/cop/sidekiq_pro/batch_without_callback.rb
+- lib/rubocop/cop/sidekiq_pro/empty_batch.rb
+- lib/rubocop/cop/sidekiq_pro/expiring_job_without_ttl.rb
+- lib/rubocop/cop/sidekiq_pro/large_argument_in_batch.rb
+- lib/rubocop/cop/sidekiq_pro/nested_batch_without_parent.rb
+- lib/rubocop/cop/sidekiq_pro/reliability_not_enabled.rb
+- lib/rubocop/sidekiq.rb
+- lib/rubocop/sidekiq/config_formatter.rb
+- lib/rubocop/sidekiq/description_extractor.rb
+- lib/rubocop/sidekiq/language.rb
+- lib/rubocop/sidekiq/plugin.rb
+- lib/rubocop/sidekiq/version.rb
+homepage: https://github.com/ydah/rubocop-sidekiq_plus
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ydah/rubocop-sidekiq_plus
+  source_code_uri: https://github.com/ydah/rubocop-sidekiq_plus
+  changelog_uri: https://github.com/ydah/rubocop-sidekiq_plus/blob/main/CHANGELOG.md
+  default_lint_roller_plugin: RuboCop::Sidekiq::Plugin
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.4
+specification_version: 4
+summary: Code style checking for Sidekiq
+test_files: []