Code smells

.reek

@@ -0,0 +1,108 @@
+---
+exclude_paths:
+  - rails_example
+  - redis
+  - spec
+  - tmp
+  - gemfiles
+  - examples
+DuplicateMethodCall:
+  exclude:
+  - SidekiqUniqueJobs::Locksmith#generate_unique_token
+  - SidekiqUniqueJobs::Locksmith#create_expiring_mutex
+  - Sidekiq#self.use_options
+IrresponsibleModule:
+  exclude:
+  - Sidekiq::Simulator
+  - SidekiqUniqueJobs::Cli
+  - SidekiqUniqueJobs::Client::Middleware
+  - SidekiqUniqueJobs
+  - Array
+  - Hash
+  - SidekiqUniqueJobs::JidMissing
+  - SidekiqUniqueJobs::LockTimeout
+  - SidekiqUniqueJobs::MaxLockTimeMissing
+  - SidekiqUniqueJobs::RunLockFailed
+  - SidekiqUniqueJobs::ScriptError
+  - SidekiqUniqueJobs::UnexpectedValue
+  - SidekiqUniqueJobs::UniqueKeyMissing
+  - SidekiqUniqueJobs::UnknownLock
+  - SidekiqUniqueJobs::Lock::BaseLock
+  - SidekiqUniqueJobs::Lock::UntilAndWhileExecuting
+  - SidekiqUniqueJobs::Lock::UntilExecuted
+  - SidekiqUniqueJobs::Lock::UntilExecuting
+  - SidekiqUniqueJobs::Lock::UntilTimeout
+  - SidekiqUniqueJobs::Lock::WhileExecuting
+  - SidekiqUniqueJobs::Lock::WhileExecutingReject
+  - SidekiqUniqueJobs::Lock::WhileExecutingRequeue
+  - SidekiqUniqueJobs::Locksmith
+  - SidekiqUniqueJobs::Middleware
+  - SidekiqUniqueJobs::Normalizer
+  - SidekiqUniqueJobs::Scripts
+  - SidekiqUniqueJobs::Server::Middleware
+  - Sidekiq::Job
+  - Sidekiq::Job::UniqueExtension
+  - Sidekiq::JobSet
+  - Sidekiq::JobSet::UniqueExtension
+  - Sidekiq::Queue
+  - Sidekiq::Queue::UniqueExtension
+  - Sidekiq::ScheduledSet
+  - Sidekiq::ScheduledSet::UniqueExtension
+  - Sidekiq::SortedEntry
+  - Sidekiq::SortedEntry::UniqueExtension
+  - Sidekiq
+  - Sidekiq::Worker
+  - Sidekiq::Worker::ClassMethods
+  - Sidekiq::Worker::Overrides
+  - Sidekiq::Worker::Overrides::Testing
+  - SidekiqUniqueJobs::Timeout::Calculator
+  - SidekiqUniqueJobs::Timeout
+  - SidekiqUniqueJobs::Unlockable
+  - SidekiqUniqueJobs::Util
+TooManyStatements:
+  exclude:
+  - initialize
+  - Hash#slice!
+  - SidekiqUniqueJobs::Locksmith#create_expiring_mutex
+  - SidekiqUniqueJobs::Middleware#configure_server_middleware
+  - SidekiqUniqueJobs::Server::Middleware#call
+  - SidekiqUniqueJobs::UniqueArgs#filtered_args
+  - SidekiqUniqueJobs::Util#del
+UncommunicativeVariableName:
+  exclude:
+  - Hash#slice
+BooleanParameter:
+  exclude:
+  - SidekiqUniqueJobs::Cli#self.banner
+UtilityFunction:
+  enabled: false
+TooManyConstants:
+  exclude:
+  - SidekiqUniqueJobs
+ManualDispatch:
+  enabled: true
+  exclude:
+  - Hash#slice
+  - Hash#slice!
+  - SidekiqUniqueJobs::Lock::WhileExecutingReject#deadset_kill?
+  - SidekiqUniqueJobs::SidekiqWorkerMethods#worker_method_defined?
+PrimaDonnaMethod:
+  exclude:
+  - Array
+NilCheck:
+  enabled: false
+FeatureEnvy:
+  exclude:
+  - SidekiqUniqueJobs::Lock::WhileExecutingReject#push_to_deadset
+  - SidekiqUniqueJobs::Util#batch_delete
+NestedIterators:
+  exclude:
+  - SidekiqUniqueJobs::Middleware#configure_client_middleware
+  - SidekiqUniqueJobs::Middleware#configure_server_middleware
+  - SidekiqUniqueJobs::Util#batch_delete
+TooManyInstanceVariables:
+  exclude:
+  - SidekiqUniqueJobs::Locksmith
+TooManyMethods:
+  exclude:
+  - SidekiqUniqueJobs::Locksmith

lib/sidekiq/simulator.rb

@@ -7,9 +7,7 @@
 
 module Sidekiq
   class Simulator
-    extend Forwardable
-    def_delegator SidekiqUniqueJobs, :logger
-
+    include SidekiqUniqueJobs::Logging
     include SidekiqUniqueJobs::Timeout
 
     attr_reader :queues, :launcher
@@ -19,28 +17,31 @@ def self.process_queue(queue)
     end
 
     def initialize(queue)
-      @queues = [queue].flatten.uniq
+      @queues = Array(queue).uniq
       @launcher = Sidekiq::Launcher.new(sidekiq_options(queues))
     end
 
     def process_queue
-      run_launcher { yield }
+      run_launcher
+      yield
     ensure
       terminate_launcher
     end
 
     private
 
     def run_launcher
+      run_launcher!
+    rescue Timeout::Error => exception
+      log_warn('Timeout while starting Sidekiq')
+      log_warn(exception)
+    end
+
+    def run_launcher!
       using_timeout(15) do
         launcher.run
         sleep 0.001 until alive?
       end
-    rescue Timeout::Error => e
-      logger.warn { "Timeout while running #{__method__}" }
-      logger.warn { e }
-    ensure
-      yield
     end
 
     def terminate_launcher

lib/sidekiq_unique_jobs.rb

@@ -7,6 +7,9 @@
 
 require 'sidekiq_unique_jobs/version'
 require 'sidekiq_unique_jobs/constants'
+require 'sidekiq_unique_jobs/logging'
+require 'sidekiq_unique_jobs/sidekiq_worker_methods'
+require 'sidekiq_unique_jobs/connection'
 require 'sidekiq_unique_jobs/exceptions'
 require 'sidekiq_unique_jobs/util'
 require 'sidekiq_unique_jobs/cli'
@@ -21,34 +24,34 @@
 require 'sidekiq_unique_jobs/sidekiq_unique_ext'
 
 module SidekiqUniqueJobs
+  include SidekiqUniqueJobs::Connection
+
   module_function
 
   Concurrent::MutableStruct.new(
     'Config',
     :default_lock_timeout,
-    :default_lock,
     :enabled,
-    :raise_unique_args_errors,
     :unique_prefix,
+    :logger,
   )
 
   def config
     # Arguments here need to match the definition of the new class (see above)
     @config ||= Concurrent::MutableStruct::Config.new(
       0,
-      :while_executing,
       true,
-      false,
       'uniquejobs',
+      Sidekiq.logger,
     )
   end
 
-  def default_lock
-    config.default_lock
+  def logger
+    config.logger
   end
 
-  def logger
-    Sidekiq.logger
+  def logger=(other)
+    config.logger = other
   end
 
   def use_config(tmp_config)
@@ -70,31 +73,7 @@ def configure(options = {})
     end
   end
 
-  # Attempt to constantize a string worker_class argument, always
-  # failing back to the original argument when the constant can't be found
-  #
-  # raises an error for other errors
-  def worker_class_constantize(worker_class)
-    return worker_class unless worker_class.is_a?(String)
-    Object.const_get(worker_class)
-  rescue NameError => ex
-    case ex.message
-    when /uninitialized constant/
-      worker_class
-    else
-      raise
-    end
-  end
-
   def redis_version
-    @redis_version ||= connection { |conn| conn.info('server')['redis_version'] }
-  end
-
-  def connection(redis_pool = nil)
-    if redis_pool
-      redis_pool.with { |conn| yield conn }
-    else
-      Sidekiq.redis { |conn| yield conn }
-    end
+    @redis_version ||= redis { |conn| conn.info('server')['redis_version'] }
   end
 end

lib/sidekiq_unique_jobs/cli.rb

@@ -4,10 +4,6 @@
 
 module SidekiqUniqueJobs
   class Cli < Thor
-    # def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = Kernel)
-    #   @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
-    # end
-
     def self.banner(command, _namespace = nil, _subcommand = false)
       "jobs #{@package_name} #{command.usage}"
     end
@@ -24,8 +20,14 @@ def keys(pattern = '*')
     option :dry_run, aliases: :d, type: :boolean, desc: 'set to false to perform deletion'
     option :count, aliases: :c, type: :numeric, default: 1000, desc: 'The max number of keys to return'
     def del(pattern)
-      deleted_count = Util.del(pattern, options[:count], options[:dry_run])
-      say "Deleted #{deleted_count} keys matching '#{pattern}'"
+      max_count = options[:count]
+      if options[:dry_run]
+        keys = Util.keys(pattern, max_count)
+        say "Would delete #{keys.size} keys matching '#{pattern}'"
+      else
+        deleted_count = Util.del(pattern, max_count)
+        say "Deleted #{deleted_count} keys matching '#{pattern}'"
+      end
     end
 
     desc 'console', 'drop into a console with easy access to helper methods'

lib/sidekiq_unique_jobs/client/middleware.rb

@@ -5,37 +5,36 @@
 module SidekiqUniqueJobs
   module Client
     class Middleware
-      extend Forwardable
-      def_delegators :SidekiqUniqueJobs, :connection, :config, :worker_class_constantize
-      def_delegators :Sidekiq, :logger
-
+      include SidekiqUniqueJobs::Logging
       include OptionsWithFallback
 
+      # :reek:LongParameterList { max_params: 4 }
       def call(worker_class, item, queue, redis_pool = nil)
-        @worker_class = worker_class_constantize(worker_class)
-        @item = item
-        @queue = queue
-        @redis_pool = redis_pool
+        @worker_class = worker_class
+        @item         = item
+        @queue        = queue
+        @redis_pool   = redis_pool
 
-        yield if successfully_locked?
+        yield if success?
       end
 
       private
 
-      attr_reader :item, :worker_class, :redis_pool, :queue
+      attr_reader :item
 
-      def successfully_locked?
-        unique_disabled? || acquire_lock
+      def success?
+        unique_disabled? || locked?
       end
 
-      def acquire_lock
+      def locked?
         locked = lock.lock
-        warn_about_duplicate(item) unless locked
+        warn_about_duplicate unless locked
         locked
       end
 
-      def warn_about_duplicate(item)
-        logger.warn "payload is not unique #{item}" if log_duplicate_payload?
+      def warn_about_duplicate
+        return unless log_duplicate_payload?
+        log_warn "payload is not unique #{item}"
       end
     end
   end

lib/sidekiq_unique_jobs/connection.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Connection
+    def self.included(base)
+      base.send(:extend, self)
+    end
+
+    # :reek:UtilityFunction { enabled: false }
+    def redis(redis_pool = nil)
+      if redis_pool
+        redis_pool.with { |conn| yield conn }
+      else
+        Sidekiq.redis { |conn| yield conn }
+      end
+    end
+  end
+end

lib/sidekiq_unique_jobs/constants.rb

@@ -10,9 +10,7 @@ module SidekiqUniqueJobs
   LOCK_TIMEOUT_KEY ||= 'lock_timeout'
   LOG_DUPLICATE_KEY ||= 'log_duplicate_payload'
   QUEUE_KEY ||= 'queue'
-  QUEUE_LOCK_EXPIRATION_KEY ||= 'unique_expiration'
   RESCHEDULE_KEY ||= 'reschedule'
-  RUN_LOCK_EXPIRATION_KEY ||= 'run_lock_expiration'
   STALE_CLIENT_TIMEOUT_KEY ||= 'stale_client_timeout'
   TESTING_CONSTANT ||= 'Testing'
   UNIQUE_ACROSS_WORKERS_KEY ||= 'unique_across_workers'

lib/sidekiq_unique_jobs/exceptions.rb

@@ -8,6 +8,9 @@ class RunLockFailed < StandardError
   end
 
   class ScriptError < StandardError
+    def initialize(file_name:, source_exception:)
+      super("Problem compiling #{file_name}. Message: #{source_exception.message}")
+    end
   end
 
   class UniqueKeyMissing < ArgumentError