sidekiq-unique-jobs 6.0.25 → 7.0.0.beta2

data/lib/sidekiq_unique_jobs/lock/client_validator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  class Lock
+    #
+    # Validates the sidekiq options for the Sidekiq client process
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    #
+    class ClientValidator
+      #
+      # @return [Array<Symbol>] a collection of invalid conflict resolutions
+      INVALID_ON_CONFLICTS = [:raise, :reject, :reschedule].freeze
+
+      #
+      # Validates the sidekiq options for the Sidekiq client process
+      #
+      #
+      def self.validate(lock_config)
+        on_conflict = lock_config.on_client_conflict
+        return lock_config unless INVALID_ON_CONFLICTS.include?(on_conflict)
+
+        lock_config.errors[:on_client_conflict] = "#{on_conflict} is incompatible with the client process"
+        lock_config
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock/server_validator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  class Lock
+    #
+    # Validates the sidekiq options for the Sidekiq server process
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    #
+    class ServerValidator
+      #
+      # @return [Array<Symbol>] a collection of invalid conflict resolutions
+      INVALID_ON_CONFLICTS = [:replace].freeze
+
+      #
+      # Validates the sidekiq options for the Sidekiq server process
+      #
+      #
+      def self.validate(lock_config)
+        on_conflict = lock_config.on_server_conflict
+        return lock_config unless INVALID_ON_CONFLICTS.include?(on_conflict)
+
+        lock_config.errors[:on_server_conflict] = "#{on_conflict} is incompatible with the server process"
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock/until_and_while_executing.rb

@@ -17,30 +17,21 @@ module SidekiqUniqueJobs
       # @yield to the worker class perform method
       def execute
         if unlock
-          lock_on_failure do
-            runtime_lock.execute { return yield }
-          end
+          runtime_lock.execute { return yield }
         else
-          log_warn "couldn't unlock digest: #{item[UNIQUE_DIGEST_KEY]} #{item[JID_KEY]}"
+          log_warn "couldn't unlock digest: #{item[UNIQUE_DIGEST]} #{item[JID]}"
         end
-      ensure
-        runtime_lock.delete!
       end
 
+      #
+      # Lock only when the server is processing the job
+      #
+      #
+      # @return [SidekiqUniqueJobs::Lock::WhileExecuting] an instance of a lock
+      #
       def runtime_lock
         @runtime_lock ||= SidekiqUniqueJobs::Lock::WhileExecuting.new(item, callback, redis_pool)
       end
-
-      private
-
-      def lock_on_failure
-        yield
-        runtime_lock.delete!
-      rescue Exception # rubocop:disable Lint/RescueException
-        log_error("Failed to execute job, restoring lock")
-        lock
-        raise
-      end
     end
   end
 end

data/lib/sidekiq_unique_jobs/lock/until_executed.rb

@@ -13,11 +13,11 @@ module SidekiqUniqueJobs
       # Executes in the Sidekiq server process
       # @yield to the worker class perform method
       def execute
-        if locked?
-          with_cleanup { yield }
-        else
-          log_warn "the unique_key: #{item[UNIQUE_DIGEST_KEY]} is not locked, allowing job to silently complete"
-          nil
+        lock do
+          yield
+          unlock_with_callback
+          callback_safely
+          item[JID]
         end
       end
     end

data/lib/sidekiq_unique_jobs/lock/until_expired.rb

@@ -2,29 +2,7 @@
 
 module SidekiqUniqueJobs
   class Lock
-    # Locks jobs until the lock has expired
-    # - Locks on perform_in or perform_async
-    # - Unlocks when the expiration is hit
-    #
-    # See {#lock} for more information about the client.
-    # See {#execute} for more information about the server
-    #
-    # @author Mikael Henriksson <mikael@zoolutions.se>
-    class UntilExpired < BaseLock
-      # Prevents these locks from being unlocked
-      # @return [true] always returns true
-      def unlock
-        true
-      end
-
-      # Executes in the Sidekiq server process
-      # @yield to the worker class perform method
-      def execute
-        return unless locked?
-
-        yield
-        # this lock does not handle after_unlock since we don't know when that would happen
-      end
+    class UntilExpired < UntilExecuted
     end
   end
 end

data/lib/sidekiq_unique_jobs/lock/validator.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  class Lock
+    #
+    # Validator base class to avoid some duplication
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    #
+    class Validator
+      #
+      # Shorthand for `new(options).validate`
+      #
+      # @param [Hash] options the sidekiq_options for the worker being validated
+      #
+      # @return [LockConfig] the lock configuration with errors if any
+      #
+      def self.validate(options)
+        new(options).validate
+      end
+
+      #
+      # @!attribute [r] lock_config
+      #   @return [LockConfig] the lock configuration for this worker
+      attr_reader :lock_config
+
+      #
+      # Initialize a new validator
+      #
+      # @param [Hash] options the sidekiq_options for the worker being validated
+      #
+      def initialize(options)
+        @lock_config = LockConfig.new(options)
+      end
+
+      #
+      # Validate the workers lock configuration
+      #
+      #
+      # @return [LockConfig] the lock configuration with errors if any
+      #
+      def validate
+        case lock_config.type
+        when :while_executing
+          validate_server
+        when :until_executing
+          validate_client
+        else
+          validate_client
+          validate_server
+        end
+
+        lock_config
+      end
+
+      def validate_client
+        ClientValidator.validate(lock_config)
+      end
+
+      def validate_server
+        ServerValidator.validate(lock_config)
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock/while_executing.rb

@@ -13,6 +13,9 @@ module SidekiqUniqueJobs
     class WhileExecuting < BaseLock
       RUN_SUFFIX ||= ":RUN"
 
+      include SidekiqUniqueJobs::OptionsWithFallback
+      include SidekiqUniqueJobs::Logging::Middleware
+
       # @param [Hash] item the Sidekiq job hash
       # @param [Proc] callback callback to call after unlock
       # @param [Sidekiq::RedisConnection, ConnectionPool] redis_pool the redis connection
@@ -33,13 +36,14 @@ module SidekiqUniqueJobs
       #   These jobs are locked in the server process not from the client
       # @yield to the worker class perform method
       def execute
-        return strategy&.call unless locksmith.lock(item[LOCK_TIMEOUT_KEY])
-
-        yield
-        unlock_with_callback
-      rescue Exception # rubocop:disable Lint/RescueException
-        delete!
-        raise
+        with_logging_context do
+          return strategy.call unless locksmith.lock do
+            yield
+            callback_safely
+          end
+        end
+      ensure
+        locksmith.unlock
       end
 
       private
@@ -47,7 +51,7 @@ module SidekiqUniqueJobs
       # This is safe as the base_lock always creates a new digest
       #   The append there for needs to be done every time
       def append_unique_key_suffix
-        item[UNIQUE_DIGEST_KEY] = item[UNIQUE_DIGEST_KEY] + RUN_SUFFIX
+        item[UNIQUE_DIGEST] = item[UNIQUE_DIGEST] + RUN_SUFFIX
       end
     end
   end

data/lib/sidekiq_unique_jobs/lock/while_executing_reject.rb

@@ -14,7 +14,7 @@ module SidekiqUniqueJobs
       # Overridden with a forced {OnConflict::Reject} strategy
       # @return [OnConflict::Reject] a reject strategy
       def strategy
-        @strategy ||= OnConflict.find_strategy(:reject).new(item)
+        @strategy ||= OnConflict.find_strategy(:reject).new(item, redis_pool)
       end
     end
   end

data/lib/sidekiq_unique_jobs/lock_config.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  #
+  # Gathers all configuration for a lock
+  #   which helps reduce the amount of instance variables
+  #
+  # @author Mikael Henriksson <mikael@zoolutions.se>
+  #
+  class LockConfig
+    #
+    # @!attribute [r] type
+    #   @return [Symbol] the type of lock
+    attr_reader :type
+    #
+    # @!attribute [r] worker
+    #   @return [Symbol] the worker class
+    attr_reader :worker
+    #
+    # @!attribute [r] limit
+    #   @return [Integer] the number of simultaneous locks
+    attr_reader :limit
+    #
+    # @!attribute [r] timeout
+    #   @return [Integer, nil] the time to wait for a lock
+    attr_reader :timeout
+    #
+    # @!attribute [r] ttl
+    #   @return [Integer, nil] the time (in seconds) to live after successful
+    attr_reader :ttl
+    #
+    # @!attribute [r] ttl
+    #   @return [Integer, nil] the time (in milliseconds) to live after successful
+    attr_reader :pttl
+    #
+    # @!attribute [r] lock_info
+    #   @return [Boolean] indicate wether to use lock_info or not
+    attr_reader :lock_info
+    #
+    # @!attribute [r] on_conflict
+    #   @return [Symbol, Hash<Symbol, Symbol>] the strategies to use as conflict resolution
+    attr_reader :on_conflict
+    #
+    # @!attribute [r] errors
+    #   @return [Array<Hash<Symbol, Array<String>] a collection of configuration errors
+    attr_reader :errors
+
+    def self.from_worker(options)
+      new(options.stringify_keys)
+    end
+
+    def initialize(job_hash = {})
+      @type        = job_hash[LOCK]&.to_sym
+      @worker      = job_hash[CLASS]
+      @limit       = job_hash.fetch(LOCK_LIMIT) { 1 }
+      @timeout     = job_hash.fetch(LOCK_TIMEOUT) { 0 }
+      @ttl         = job_hash.fetch(LOCK_TTL) { job_hash.fetch(LOCK_EXPIRATION) { nil } }.to_i
+      @pttl        = ttl * 1_000
+      @lock_info   = job_hash.fetch(LOCK_INFO) { SidekiqUniqueJobs.config.lock_info }
+      @on_conflict = job_hash.fetch(ON_CONFLICT) { nil }
+      @errors      = job_hash.fetch(ERRORS) { {} }
+
+      @on_client_conflict = job_hash[ON_CLIENT_CONFLICT]
+      @on_server_conflict = job_hash[ON_SERVER_CONFLICT]
+    end
+
+    def wait_for_lock?
+      timeout.nil? || timeout.positive?
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    def errors_as_string
+      @errors_as_string ||= begin
+        error_msg = +"\t"
+        error_msg << lock_config.errors.map { |key, val| "#{key}: :#{val}" }.join("\n\t")
+        error_msg
+      end
+    end
+
+    # the strategy to use as conflict resolution from sidekiq client
+    def on_client_conflict
+      @on_client_conflict ||= on_conflict&.(:[], :client) if on_conflict.is_a?(Hash)
+      @on_client_conflict ||= on_conflict
+    end
+
+    # the strategy to use as conflict resolution from sidekiq server
+    def on_server_conflict
+      @on_client_conflict ||= on_conflict&.(:[], :server) if on_conflict.is_a?(Hash)
+      @on_server_conflict ||= on_conflict
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/lock_info.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  #
+  # Class Info provides information about a lock
+  #
+  # @author Mikael Henriksson <mikael@zoolutions.se>
+  #
+  class LockInfo < Redis::String
+    #
+    # Returns the value for this key as a hash
+    #
+    #
+    # @return [Hash]
+    #
+    def value
+      @value ||= load_json(super)
+    end
+
+    #
+    # Check if this redis string is blank
+    #
+    #
+    # @return [Boolean]
+    #
+    def none?
+      value.nil? || value.empty?
+    end
+
+    #
+    # Check if this redis string has a value
+    #
+    #
+    # @return [Boolean]
+    #
+    def present?
+      !none?
+    end
+
+    #
+    # Quick access to the hash members for the value
+    #
+    # @param [String, Symbol] key the key who's value to retrieve
+    #
+    # @return [Object]
+    #
+    def [](key)
+      value[key.to_s] if value.is_a?(Hash)
+    end
+
+    #
+    # Writes the lock info to redis
+    #
+    # @param [Hash] obj the information to store at key
+    #
+    # @return [Hash]
+    #
+    def set(obj)
+      return unless SidekiqUniqueJobs.config.lock_info
+      raise InvalidArgument, "argument `obj` (#{obj}) needs to be a hash" unless obj.is_a?(Hash)
+
+      json = dump_json(obj)
+      @value = load_json(json)
+      super(json)
+      value
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/locksmith.rb

@@ -4,63 +4,94 @@ module SidekiqUniqueJobs
   # Lock manager class that handles all the various locks
   #
   # @author Mikael Henriksson <mikael@zoolutions.se>
-  # rubocop:disable Metrics/ClassLength
-  class Locksmith
+  class Locksmith # rubocop:disable Metrics/ClassLength
+    # includes "SidekiqUniqueJobs::Connection"
+    # @!parse include SidekiqUniqueJobs::Connection
     include SidekiqUniqueJobs::Connection
 
+    # includes "SidekiqUniqueJobs::Logging"
+    # @!parse include SidekiqUniqueJobs::Logging
+    include SidekiqUniqueJobs::Logging
+
+    # includes "SidekiqUniqueJobs::Timing"
+    # @!parse include SidekiqUniqueJobs::Timing
+    include SidekiqUniqueJobs::Timing
+
+    # includes "SidekiqUniqueJobs::Script::Caller"
+    # @!parse include SidekiqUniqueJobs::Script::Caller
+    include SidekiqUniqueJobs::Script::Caller
+
+    # includes "SidekiqUniqueJobs::JSON"
+    # @!parse include SidekiqUniqueJobs::JSON
+    include SidekiqUniqueJobs::JSON
+
+    CLOCK_DRIFT_FACTOR = 0.01
+
+    #
+    # @!attribute [r] key
+    #   @return [Key] the key used for locking
+    attr_reader :key
+    #
+    # @!attribute [r] job_id
+    #   @return [String] a sidekiq JID
+    attr_reader :job_id
+    #
+    # @!attribute [r] config
+    #   @return [LockConfig] the configuration for this lock
+    attr_reader :config
+    #
+    # @!attribute [r] item
+    #   @return [Hash] a sidekiq job hash
+    attr_reader :item
+
+    #
+    # Initialize a new Locksmith instance
+    #
     # @param [Hash] item a Sidekiq job hash
-    # @option item [Integer] :lock_expiration the configured expiration
+    # @option item [Integer] :lock_ttl the configured expiration
     # @option item [String] :jid the sidekiq job id
     # @option item [String] :unique_digest the unique digest (See: {UniqueArgs#unique_digest})
     # @param [Sidekiq::RedisConnection, ConnectionPool] redis_pool the redis connection
+    #
     def initialize(item, redis_pool = nil)
-      # @concurrency   = 1 # removed in a0cff5bc42edbe7190d6ede7e7f845074d2d7af6
-      @ttl           = item[LOCK_EXPIRATION_KEY] || item[LOCK_TTL_KEY]
-      @jid           = item[JID_KEY]
-      @unique_digest = item[UNIQUE_DIGEST_KEY] || item[LOCK_DIGEST_KEY]
-      @lock_type     = item[LOCK_KEY] || item[UNIQUE_KEY]
-      @lock_type   &&= @lock_type.to_sym
-      @redis_pool    = redis_pool
+      @item        = item
+      @key         = Key.new(item[UNIQUE_DIGEST])
+      @job_id      = item[JID]
+      @config      = LockConfig.new(item)
+      @redis_pool  = redis_pool
     end
 
     #
-    # Deletes the lock unless it has a ttl set
+    # Deletes the lock unless it has a pttl set
     #
     #
     def delete
-      return if ttl
+      return if config.pttl.positive?
 
       delete!
     end
 
-    # Deletes the lock regardless of if it has a ttl set
+    #
+    # Deletes the lock regardless of if it has a pttl set
+    #
     def delete!
-      Scripts.call(
-        :delete,
-        redis_pool,
-        keys: [exists_key, grabbed_key, available_key, version_key, UNIQUE_SET, unique_digest],
-      )
+      call_script(:delete, key.to_a, [job_id, config.pttl, config.type, config.limit]).positive?
     end
 
     #
-    # Create a lock for the item
-    #
-    # @param [Integer] timeout the number of seconds to wait for a lock.
+    # Create a lock for the Sidekiq job
     #
-    # @return [String] the Sidekiq job_id (jid)
+    # @return [String] the Sidekiq job_id that was locked/queued
     #
-    #
-    def lock(timeout = nil, &block)
-      Scripts.call(:lock, redis_pool,
-                   keys: [exists_key, grabbed_key, available_key, UNIQUE_SET, unique_digest],
-                   argv: [jid, ttl, lock_type])
+    def lock(&block)
+      redis(redis_pool) do |conn|
+        return lock_async(conn, &block) if block_given?
 
-      grab_token(timeout) do |token|
-        touch_grabbed_token(token)
-        return_token_or_block_value(token, &block)
+        lock_sync(conn) do
+          return job_id
+        end
       end
     end
-    alias wait lock
 
     #
     # Removes the lock keys from Redis if locked by the provided jid/token
@@ -68,122 +99,247 @@ module SidekiqUniqueJobs
     # @return [false] unless locked?
     # @return [String] Sidekiq job_id (jid) if successful
     #
-    def unlock(token = nil)
-      token ||= jid
-      return false unless locked?(token)
+    def unlock(conn = nil)
+      return false unless locked?(conn)
 
-      unlock!(token)
+      unlock!(conn)
     end
 
     #
     # Removes the lock keys from Redis
     #
-    # @param [String] token the token to unlock (defaults to jid)
-    #
     # @return [false] unless locked?
     # @return [String] Sidekiq job_id (jid) if successful
     #
-    def unlock!(token = nil)
-      token ||= jid
+    def unlock!(conn = nil)
+      call_script(:unlock, key.to_a, argv, conn)
+    end
 
-      Scripts.call(
-        :unlock,
-        redis_pool,
-        keys: [exists_key, grabbed_key, available_key, version_key, UNIQUE_SET, unique_digest],
-        argv: [token, ttl, lock_type],
-      )
+    # Checks if this instance is considered locked
+    #
+    # @return [true, false] true when the :LOCKED hash contains the job_id
+    #
+    def locked?(conn = nil)
+      return taken?(conn) if conn
+
+      redis { |rcon| taken?(rcon) }
     end
 
     #
-    # @param [String] token the unique token to check for a lock.
-    #   nil will default to the jid provided in the initializer
-    # @return [true, false]
+    # Nicely formatted string with information about self
     #
-    # Checks if this instance is considered locked
     #
-    # @param [<type>] token <description>
+    # @return [String]
     #
-    # @return [<type>] <description>
+    def to_s
+      "Locksmith##{object_id}(digest=#{key} job_id=#{job_id}, locked=#{locked?})"
+    end
+
+    #
+    # @see to_s
     #
-    def locked?(token = nil)
-      token ||= jid
+    def inspect
+      to_s
+    end
 
-      convert_legacy_lock(token)
-      redis(redis_pool) { |conn| conn.hexists(grabbed_key, token) }
+    #
+    # Compare this locksmith with another
+    #
+    # @param [Locksmith] other the locksmith to compare with
+    #
+    # @return [true, false]
+    #
+    def ==(other)
+      key == other.key && job_id == other.job_id
     end
 
     private
 
-    attr_reader :unique_digest, :ttl, :jid, :redis_pool, :lock_type
+    attr_reader :redis_pool
 
-    def convert_legacy_lock(token)
-      Scripts.call(
-        :convert_legacy_lock,
-        redis_pool,
-        keys: [grabbed_key, unique_digest],
-        argv: [token, current_time.to_f],
-      )
+    def argv
+      [job_id, config.pttl, config.type, config.limit]
     end
 
-    def grab_token(timeout = nil)
-      redis(redis_pool) do |conn|
-        if timeout.nil? || timeout.positive?
-          # passing timeout 0 to blpop causes it to block
-          _key, token = conn.blpop(available_key, timeout || 0)
-        else
-          token = conn.lpop(available_key)
-        end
+    #
+    # Used for runtime locks that need automatic unlock after yielding
+    #
+    # @param [Redis] conn a redis connection
+    #
+    # @return [nil] when lock was not possible
+    # @return [Object] whatever the block returns when lock was acquired
+    #
+    # @yieldparam [String] job_id a Sidekiq JID
+    #
+    def lock_async(conn)
+      return yield job_id if locked?(conn)
 
-        return yield jid if token
+      enqueue(conn) do
+        primed_async(conn) do
+          locked_token = call_script(:lock, key.to_a, argv, conn)
+          return yield job_id if locked_token == job_id
+        end
       end
+    ensure
+      unlock!(conn)
     end
 
-    def touch_grabbed_token(token)
-      redis(redis_pool) do |conn|
-        conn.hset(grabbed_key, token, current_time.to_f)
-        conn.expire(grabbed_key, ttl) if ttl && lock_type == :until_expired
+    #
+    # Pops an enqueued token
+    # @note Used for runtime locks to avoid problems with blocking commands
+    #   in current thread
+    #
+    # @param [Redis] conn a redis connection
+    #
+    # @return [nil] when lock was not possible
+    # @return [Object] whatever the block returns when lock was acquired
+    #
+    def primed_async(conn)
+      return yield if Concurrent::Promises.future(conn) { |red_con| pop_queued(red_con) }.value
+
+      warn_about_timeout
+    end
+
+    #
+    # Used for non-runtime locks (no block was given)
+    #
+    # @param [Redis] conn a redis connection
+    #
+    # @return [nil] when lock was not possible
+    # @return [Object] whatever the block returns when lock was acquired
+    #
+    # @yieldparam [String] job_id a Sidekiq JID
+    #
+    def lock_sync(conn)
+      return yield job_id if locked?(conn)
+
+      enqueue(conn) do
+        primed_sync(conn) do
+          locked_token = call_script(:lock, key.to_a, argv, conn)
+          return yield job_id if locked_token == job_id
+        end
       end
     end
 
-    def return_token_or_block_value(token)
-      return token unless block_given?
+    #
+    # Pops an enqueued token
+    # @note Used for non-runtime locks
+    #
+    # @param [Redis] conn a redis connection
+    #
+    # @return [nil] when lock was not possible
+    # @return [Object] whatever the block returns when lock was acquired
+    #
+    def primed_sync(conn)
+      return yield if pop_queued(conn)
+
+      warn_about_timeout
+    end
 
-      # The reason for begin is to only signal when we have a block
-      begin
-        yield token
-      ensure
-        unlock(token)
+    #
+    # Does the actual popping of the enqueued token
+    #
+    # @param [Redis] conn a redis connection
+    #
+    # @return [String] a previously enqueued token (now taken off the queue)
+    #
+    def pop_queued(conn)
+      if config.wait_for_lock?
+        brpoplpush(conn)
+      else
+        rpoplpush(conn)
       end
     end
 
-    def available_key
-      @available_key ||= namespaced_key("AVAILABLE")
+    #
+    # @api private
+    #
+    def brpoplpush(conn)
+      # passing timeout 0 to brpoplpush causes it to block indefinitely
+      conn.brpoplpush(key.queued, key.primed, timeout: config.timeout || 0)
+    end
+
+    #
+    # @api private
+    #
+    def rpoplpush(conn)
+      conn.rpoplpush(key.queued, key.primed)
     end
 
-    def exists_key
-      @exists_key ||= namespaced_key("EXISTS")
+    #
+    # Prepares all the various lock data
+    #
+    # @param [Redis] conn a redis connection
+    #
+    # @return [nil] when redis was already prepared for this lock
+    # @return [yield<String>] when successfully enqueued
+    #
+    def enqueue(conn)
+      queued_token, elapsed = timed do
+        call_script(:queue, key.to_a, argv, conn)
+      end
+
+      validity = config.pttl - elapsed - drift(config.pttl)
+
+      return unless queued_token && (validity >= 0 || config.pttl.zero?)
+
+      write_lock_info(conn)
+      yield queued_token
     end
 
-    def grabbed_key
-      @grabbed_key ||= namespaced_key("GRABBED")
+    #
+    # Writes lock information to redis.
+    #   The lock information contains information about worker, queue, limit etc.
+    #
+    #
+    # @return [void]
+    #
+    def write_lock_info(conn)
+      return unless config.lock_info
+
+      conn.set(key.info, lock_info)
     end
 
-    def version_key
-      @version_key ||= namespaced_key("VERSION")
+    #
+    # Used to combat redis imprecision with ttl/pttl
+    #
+    # @param [Integer] val the value to compute drift for
+    #
+    # @return [Integer] a computed drift value
+    #
+    def drift(val)
+      # Add 2 milliseconds to the drift to account for Redis expires
+      # precision, which is 1 millisecond, plus 1 millisecond min drift
+      # for small TTLs.
+      (val.to_i * CLOCK_DRIFT_FACTOR).to_i + 2
     end
 
-    def namespaced_key(variable)
-      "#{unique_digest}:#{variable}"
+    #
+    # Checks if the lock has been taken
+    #
+    # @param [Redis] conn a redis connection
+    #
+    # @return [true, false]
+    #
+    def taken?(conn)
+      conn.hexists(key.locked, job_id)
     end
 
-    def current_time
-      seconds, microseconds_with_frac = redis_time
-      Time.at(seconds, microseconds_with_frac)
+    def warn_about_timeout
+      log_warn("Timed out after #{config.timeout}s while waiting for primed token (digest: #{key}, job_id: #{job_id})")
     end
 
-    def redis_time
-      redis(&:time)
+    def lock_info
+      @lock_info ||= dump_json(
+        WORKER => item[CLASS],
+        QUEUE => item[QUEUE],
+        LIMIT => item[LOCK_LIMIT],
+        TIMEOUT => item[LOCK_TIMEOUT],
+        TTL => item[LOCK_TTL],
+        LOCK => config.type,
+        UNIQUE_ARGS => item[UNIQUE_ARGS],
+        TIME => now_f,
+      )
     end
   end
-  # rubocop:enable Metrics/ClassLength
 end