redis_queued_locks 1.1.0 → 1.3.0

data/lib/redis_queued_locks/acquier/acquire_lock.rb

@@ -1,34 +1,29 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 # rubocop:disable Metrics/ModuleLength
 # rubocop:disable Metrics/MethodLength
 # rubocop:disable Metrics/ClassLength
 # rubocop:disable Metrics/BlockNesting
+# rubocop:disable Style/IfInsideElse
 module RedisQueuedLocks::Acquier::AcquireLock
   require_relative 'acquire_lock/delay_execution'
   require_relative 'acquire_lock/with_acq_timeout'
-  require_relative 'acquire_lock/yield_with_expire'
+  require_relative 'acquire_lock/yield_expire'
   require_relative 'acquire_lock/try_to_lock'
 
-  # @since 0.1.0
+  # @since 1.0.0
   extend TryToLock
-  # @since 0.1.0
+  # @since 1.0.0
   extend DelayExecution
-  # @since 0.1.0
-  extend YieldWithExpire
-  # @since 0.1.0
+  # @since 1.3.0
+  extend YieldExpire
+  # @since 1.0.0
   extend WithAcqTimeout
-  # @since 0.1.0
+  # @since 1.0.0
   extend RedisQueuedLocks::Utilities
 
-  # @return [Integer] Redis time error (in milliseconds).
-  #
-  # @api private
-  # @since 0.1.0
-  REDIS_TIMESHIFT_ERROR = 2
-
   class << self
     # @param redis [RedisClient]
     #   Redis connection client.
@@ -72,14 +67,25 @@ module RedisQueuedLocks::Acquier::AcquireLock
     #   - Metadata can not contain reserved lock data keys;
     # @option logger [::Logger,#debug]
     #   - Logger object used from the configuration layer (see config[:logger]);
-    #   - See RedisQueuedLocks::Logging::VoidLogger for example;
+    #   - See `RedisQueuedLocks::Logging::VoidLogger` for example;
+    #   - Supports `SemanticLogger::Logger` (see "semantic_logger" gem)
     # @option log_lock_try [Boolean]
     #   - should be logged the each try of lock acquiring (a lot of logs can be generated depending
     #     on your retry configurations);
     #   - see `config[:log_lock_try]`;
     # @option instrument [NilClass,Any]
-    #    - Custom instrumentation data wich will be passed to the instrumenter's payload
-    #      with :instrument key;
+    #   - Custom instrumentation data wich will be passed to the instrumenter's payload
+    #     with :instrument key;
+    # @option conflict_strategy [Symbol]
+    #   - The conflict strategy mode for cases when the process that obtained the lock
+    #     want to acquire this lock again;
+    #   - By default uses `:wait_for_lock` strategy;
+    #   - pre-confured in `config[:default_conflict_strategy]`;
+    #   - Supports:
+    #     - `:work_through`;
+    #     - `:extendable_work_through`;
+    #     - `:wait_for_lock`;
+    #     - `:dead_locking`;
     # @param [Block]
     #   A block of code that should be executed after the successfully acquired lock.
     # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>,yield]
@@ -87,7 +93,8 @@ module RedisQueuedLocks::Acquier::AcquireLock
     #  - If block is given the result of block's yeld will be returned.
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
+    # @version 1.3.0
     def acquire_lock(
       redis,
       lock_name,
@@ -110,6 +117,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
       instrument:,
       logger:,
       log_lock_try:,
+      conflict_strategy:,
       &block
     )
       # Step 0: Prevent argument type incompatabilities
@@ -129,12 +137,18 @@ module RedisQueuedLocks::Acquier::AcquireLock
         key == 'ts' ||
         key == 'ini_ttl' ||
         key == 'lock_key' ||
-        key == 'rem_ttl'
+        key == 'rem_ttl' ||
+        key == 'spc_ext_ttl' ||
+        key == 'spc_cnt' ||
+        key == 'l_spc_ext_ini_ttl' ||
+        key == 'l_spc_ext_ts' ||
+        key == 'l_spc_ts'
       end)
         raise(
           RedisQueuedLocks::ArgumentError,
-          '`:meta` keys can not overlap reserved lock data keys' \
-          '"acq_id", "ts", "ini_ttl", "lock_key", "rem_ttl"'
+          '`:meta` keys can not overlap reserved lock data keys ' \
+          '"acq_id", "ts", "ini_ttl", "lock_key", "rem_ttl", "spc_cnt", ' \
+          '"spc_ext_ttl", "l_spc_ext_ini_ttl", "l_spc_ext_ts", "l_spc_ts"'
         )
       end
 
@@ -223,6 +237,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
             lock_ttl,
             queue_ttl,
             fail_fast,
+            conflict_strategy,
             meta
           ) => { ok:, result: }
 
@@ -235,26 +250,75 @@ module RedisQueuedLocks::Acquier::AcquireLock
 
           # Step 2.1: analyze an acquirement attempt
           if ok
-            run_non_critical do
-              logger.debug do
-                "[redis_queued_locks.lock_obtained] " \
-                "lock_key => '#{result[:lock_key]}' " \
-                "queue_ttl => #{queue_ttl} " \
-                "acq_id => '#{acquier_id}' " \
-                "acq_time => #{acq_time} (ms)"
+            # Step X: (instrumentation)
+            if acq_process[:result][:process] == :extendable_conflict_work_through
+              # instrumetnation: (reentrant lock with ttl extension)
+              run_non_critical do
+                logger.debug do
+                  "[redis_queued_locks.extendable_reentrant_lock_obtained] " \
+                  "lock_key => '#{result[:lock_key]}' " \
+                  "queue_ttl => #{queue_ttl} " \
+                  "acq_id => '#{acquier_id}' " \
+                  "acq_time => #{acq_time} (ms)"
+                end
               end
-            end
 
-            # Step X (instrumentation): lock obtained
-            run_non_critical do
-              instrumenter.notify('redis_queued_locks.lock_obtained', {
-                lock_key: result[:lock_key],
-                ttl: result[:ttl],
-                acq_id: result[:acq_id],
-                ts: result[:ts],
-                acq_time: acq_time,
-                instrument:
-              })
+              run_non_critical do
+                instrumenter.notify('redis_queued_locks.extendable_reentrant_lock_obtained', {
+                  lock_key: result[:lock_key],
+                  ttl: result[:ttl],
+                  acq_id: result[:acq_id],
+                  ts: result[:ts],
+                  acq_time: acq_time,
+                  instrument:
+                })
+              end
+            elsif acq_process[:result][:process] == :conflict_work_through
+              # instrumetnation: (reentrant lock without ttl extension)
+              run_non_critical do
+                logger.debug do
+                  "[redis_queued_locks.reentrant_lock_obtained] " \
+                  "lock_key => '#{result[:lock_key]}' " \
+                  "queue_ttl => #{queue_ttl} " \
+                  "acq_id => '#{acquier_id}' " \
+                  "acq_time => #{acq_time} (ms)"
+                end
+              end
+
+              run_non_critical do
+                instrumenter.notify('redis_queued_locks.reentrant_lock_obtained', {
+                  lock_key: result[:lock_key],
+                  ttl: result[:ttl],
+                  acq_id: result[:acq_id],
+                  ts: result[:ts],
+                  acq_time: acq_time,
+                  instrument:
+                })
+              end
+            else
+              # instrumentation: (classic lock obtain)
+              # NOTE: classic is: acq_process[:result][:process] == :lock_obtaining
+              run_non_critical do
+                logger.debug do
+                  "[redis_queued_locks.lock_obtained] " \
+                  "lock_key => '#{result[:lock_key]}' " \
+                  "queue_ttl => #{queue_ttl} " \
+                  "acq_id => '#{acquier_id}' " \
+                  "acq_time => #{acq_time} (ms)"
+                end
+              end
+
+              # Step X (instrumentation): lock obtained
+              run_non_critical do
+                instrumenter.notify('redis_queued_locks.lock_obtained', {
+                  lock_key: result[:lock_key],
+                  ttl: result[:ttl],
+                  acq_id: result[:acq_id],
+                  ts: result[:ts],
+                  acq_time: acq_time,
+                  instrument:
+                })
+              end
             end
 
             # Step 2.1.a: successfully acquired => build the result
@@ -262,54 +326,73 @@ module RedisQueuedLocks::Acquier::AcquireLock
               lock_key: result[:lock_key],
               acq_id: result[:acq_id],
               ts: result[:ts],
-              ttl: result[:ttl]
+              ttl: result[:ttl],
+              process: result[:process]
             }
             acq_process[:acquired] = true
             acq_process[:should_try] = false
             acq_process[:acq_time] = acq_time
             acq_process[:acq_end_time] = acq_end_time
-          elsif fail_fast && acq_process[:result] == :fail_fast_no_try
-            acq_process[:should_try] = false
-            if raise_errors
-              raise(
-                RedisQueuedLocks::LockAlreadyObtainedError,
-                "Lock \"#{lock_key}\" is already obtained."
-              )
-            end
           else
-            # Step 2.1.b: failed acquirement => retry
-            acq_process[:tries] += 1
-
-            if (retry_count != nil && acq_process[:tries] >= retry_count) || fail_fast
-              # NOTE:
-              #   - reached the retry limit => quit from the loop
-              #   - should fail fast => quit from the loop
+            # Step 2.2: failed to acquire. anylize each case and act in accordance
+            if acq_process[:result] == :fail_fast_no_try # Step 2.2.a: fail without try
               acq_process[:should_try] = false
-              acq_process[:result] = fail_fast ? :fail_fast_after_try : :retry_limit_reached
 
-              # NOTE:
-              #   - reached the retry limit => dequeue from the lock queue
-              #   - should fail fast => dequeue from the lock queue
-              acq_dequeue.call
-
-              # NOTE: check and raise an error
-              if fail_fast && raise_errors
+              if raise_errors
                 raise(
                   RedisQueuedLocks::LockAlreadyObtainedError,
                   "Lock \"#{lock_key}\" is already obtained."
                 )
-              elsif raise_errors
+              end
+            elsif acq_process[:result] == :conflict_dead_lock # Step 2.2.b: fail after dead lock
+              acq_process[:tries] += 1
+              acq_process[:should_try] = false
+              acq_process[:result] = :conflict_dead_lock
+              acq_dequeue.call
+
+              if raise_errors
                 raise(
-                  RedisQueuedLocks::LockAcquiermentRetryLimitError,
-                  "Failed to acquire the lock \"#{lock_key}\" " \
-                  "for the given retry_count limit (#{retry_count} times)."
+                  RedisQueuedLock::ConflictLockObtainError,
+                  "Lock Conflict: trying to acquire the lock \"#{lock_key}\" " \
+                  "that is already acquired by the current acquier (acq_id: \"#{acquired_id}\")."
                 )
               end
             else
-              # NOTE:
-              #   delay the exceution in order to prevent chaotic lock-acquire attempts
-              #   and to allow other processes and threads to obtain the lock too.
-              delay_execution(retry_delay, retry_jitter)
+              acq_process[:tries] += 1 # Step RETRY: possible retry case
+
+              if fail_fast # Step RETRY.A: fail after try
+                acq_process[:should_try] = false
+                acq_process[:result] = :fail_fast_after_try
+                acq_dequeue.call
+
+                if raise_errors
+                  raise(
+                    RedisQueuedLocks::LockAlreadyObtainedError,
+                    "Lock \"#{lock_key}\" is already obtained."
+                  )
+                end
+              else
+                # Step RETRY.B: fail cuz the retry count is reached
+                if retry_count != nil && acq_process[:tries] >= retry_count
+                  acq_process[:should_try] = false
+                  acq_process[:result] = :retry_limit_reached
+                  acq_dequeue.call
+
+                  if raise_errors
+                    raise(
+                      RedisQueuedLocks::LockAcquiermentRetryLimitError,
+                      "Failed to acquire the lock \"#{lock_key}\" " \
+                      "for the given retry_count limit (#{retry_count} times)."
+                    )
+                  end
+                else
+                  # Step RETRY.X: no significant failures => retry easily :)
+                  # NOTE:
+                  #   delay the exceution in order to prevent chaotic lock-acquire attempts
+                  #   and to allow other processes and threads to obtain the lock too.
+                  delay_execution(retry_delay, retry_jitter)
+                end
+              end
             end
           end
         end
@@ -323,10 +406,18 @@ module RedisQueuedLocks::Acquier::AcquireLock
             yield_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
 
             ttl_shift = (
-              (yield_time - acq_process[:acq_end_time]) * 1000 - REDIS_TIMESHIFT_ERROR
+              (yield_time - acq_process[:acq_end_time]) * 1000 -
+              RedisQueuedLocks::Resource::REDIS_TIMESHIFT_ERROR
             ).ceil(2)
 
-            yield_with_expire(
+            should_expire =
+              acq_process[:result][:process] != :extendable_conflict_work_through &&
+              acq_process[:result][:process] != :conflict_work_through
+
+            should_decrease =
+              acq_process[:result][:process] == :extendable_conflict_work_through
+
+            yield_expire(
               redis,
               logger,
               lock_key,
@@ -335,6 +426,8 @@ module RedisQueuedLocks::Acquier::AcquireLock
               ttl_shift,
               ttl,
               queue_ttl,
+              should_expire, # NOTE: should expire the lock after the block execution
+              should_decrease, # NOTE: should decrease the lock ttl in reentrant locks?
               &block
             )
           ensure
@@ -343,17 +436,33 @@ module RedisQueuedLocks::Acquier::AcquireLock
               (acq_process[:rel_time] - acq_process[:acq_end_time]) * 1000
             ).ceil(2)
 
-            # Step X (instrumentation): lock_hold_and_release
-            run_non_critical do
-              instrumenter.notify('redis_queued_locks.lock_hold_and_release', {
-                hold_time: acq_process[:hold_time],
-                ttl: acq_process[:lock_info][:ttl],
-                acq_id: acq_process[:lock_info][:acq_id],
-                ts: acq_process[:lock_info][:ts],
-                lock_key: acq_process[:lock_info][:lock_key],
-                acq_time: acq_process[:acq_time],
-                instrument:
-              })
+            if acq_process[:result][:process] == :extendable_conflict_work_through ||
+               acq_process[:result][:process] == :conflict_work_through
+              # Step X (instrumentation): reentrant_lock_hold_completes
+              run_non_critical do
+                instrumenter.notify('redis_queued_locks.reentrant_lock_hold_completes', {
+                  hold_time: acq_process[:hold_time],
+                  ttl: acq_process[:lock_info][:ttl],
+                  acq_id: acq_process[:lock_info][:acq_id],
+                  ts: acq_process[:lock_info][:ts],
+                  lock_key: acq_process[:lock_info][:lock_key],
+                  acq_time: acq_process[:acq_time],
+                  instrument:
+                })
+              end
+            else
+              # Step X (instrumentation): lock_hold_and_release
+              run_non_critical do
+                instrumenter.notify('redis_queued_locks.lock_hold_and_release', {
+                  hold_time: acq_process[:hold_time],
+                  ttl: acq_process[:lock_info][:ttl],
+                  acq_id: acq_process[:lock_info][:acq_id],
+                  ts: acq_process[:lock_info][:ts],
+                  lock_key: acq_process[:lock_info][:lock_key],
+                  acq_time: acq_process[:acq_time],
+                  instrument:
+                })
+              end
             end
           end
         else
@@ -362,11 +471,12 @@ module RedisQueuedLocks::Acquier::AcquireLock
       else
         if acq_process[:result] != :retry_limit_reached &&
            acq_process[:result] != :fail_fast_no_try &&
-           acq_process[:result] != :fail_fast_after_try
-          # NOTE: we have only two situations if lock is not acquired withou fast-fail flag:
-          #   - time limit is reached
-          #   - retry count limit is reached
-          #   In other cases the lock obtaining time and tries count are infinite.
+           acq_process[:result] != :fail_fast_after_try &&
+           acq_process[:result] != :conflict_dead_lock
+          # NOTE: we have only two situations if lock is not acquired without explicit failures:
+          #   - time limit is reached;
+          #   - retry count limit is reached;
+          #   - **(notice: in other cases the lock obtaining time and tries count are infinite)
           acq_process[:result] = :timeout_reached
         end
         # Step 3.b: lock is not acquired (acquier is dequeued by timeout callback)
@@ -379,3 +489,4 @@ end
 # rubocop:enable Metrics/MethodLength
 # rubocop:enable Metrics/ClassLength
 # rubocop:enable Metrics/BlockNesting
+# rubocop:enable Style/IfInsideElse

data/lib/redis_queued_locks/acquier/clear_dead_requests.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::ClearDeadRequests
   class << self
     # @param redis_client [RedisClient]
@@ -13,7 +13,7 @@ module RedisQueuedLocks::Acquier::ClearDeadRequests
     # @return [Hash<Symbol,Boolean|Hash<Symbol,Set<String>>>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def clear_dead_requests(redis_client, scan_size, dead_ttl, logger, instrumenter, instrument)
       dead_score = RedisQueuedLocks::Resource.acquier_dead_score(dead_ttl / 1000.0)
 
@@ -39,7 +39,7 @@ module RedisQueuedLocks::Acquier::ClearDeadRequests
     # @return [Enumerator]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def each_lock_queue(redis_client, scan_size, &block)
       redis_client.scan(
         'MATCH',

data/lib/redis_queued_locks/acquier/extend_lock_ttl.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::ExtendLockTTL
   # @return [String]
   #
   # @api private
-  # @since 0.1.0
+  # @since 1.0.0
   EXTEND_LOCK_PTTL = <<~LUA_SCRIPT.strip.tr("\n", '').freeze
     local new_lock_pttl = redis.call("PTTL", KEYS[1]) + ARGV[1];
     return redis.call("PEXPIRE", KEYS[1], new_lock_pttl);
@@ -20,7 +20,7 @@ module RedisQueuedLocks::Acquier::ExtendLockTTL
     # @return [Hash<Symbol,Boolean|Symbol>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def extend_lock_ttl(redis_client, lock_name, milliseconds, logger)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
 

data/lib/redis_queued_locks/acquier/is_locked.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::IsLocked
   class << self
     # @param redis_client [RedisClient]
@@ -9,7 +9,7 @@ module RedisQueuedLocks::Acquier::IsLocked
     # @return [Boolean]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def locked?(redis_client, lock_name)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
       redis_client.call('EXISTS', lock_key) == 1

data/lib/redis_queued_locks/acquier/is_queued.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::IsQueued
   class << self
     # @param redis_client [RedisClient]
@@ -9,7 +9,7 @@ module RedisQueuedLocks::Acquier::IsQueued
     # @return [Boolean]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def queued?(redis_client, lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
       redis_client.call('EXISTS', lock_key_queue) == 1

data/lib/redis_queued_locks/acquier/keys.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::Keys
   class << self
     # @param redis_client [RedisClient]
@@ -9,7 +9,7 @@ module RedisQueuedLocks::Acquier::Keys
     # @return [Array<String>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def keys(redis_client, scan_size:)
       Set.new.tap do |keys|
         redis_client.scan(

data/lib/redis_queued_locks/acquier/lock_info.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::LockInfo
   class << self
     # @param redis_client [RedisClient]
@@ -12,12 +12,20 @@ module RedisQueuedLocks::Acquier::LockInfo
     #     'lock_key' => "rql:lock:your_lockname", # acquired lock key
     #     'acq_id' => "rql:acq:process_id/thread_id", # lock acquier identifier
     #     'ts' => 123456789.2649841, # <locked at> time stamp (epoch, seconds.microseconds)
-    #     'ini_ttl' => 123456789, # initial lock key ttl (milliseconds),
+    #     'ini_ttl' => 123456789, # initial lock key ttl (milliseconds)
     #     'rem_ttl' => 123456789, # remaining lock key ttl (milliseconds)
+    #     <additional keys for reentrant locks>:
+    #     'spc_cnt' => 2, # lock reentreing count (if lock was used as reentrant lock)
+    #     'l_spc_ts' => 123456.1234 # (epoch) <non-extendable reentrant lock obtained at> timestamp
+    #     'spc_ext_ttl' => 14500, # (milliseconds) the sum of all ttl extensions
+    #     'l_spc_ext_ini_ttl' => 5000, # (milliseconds) the last ttl of reentrant lock
+    #     'l_spc_ext_ts' => 123456.789 # (epoch) <extendable reentrant lock obtained at> timestamp
     #   }
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
+    # @version 1.3.0
+    # rubocop:disable Metrics/MethodLength
     def lock_info(redis_client, lock_name)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
 
@@ -48,9 +56,17 @@ module RedisQueuedLocks::Acquier::LockInfo
             lock_data['ts'] = Float(lock_data['ts'])
             lock_data['ini_ttl'] = Integer(lock_data['ini_ttl'])
             lock_data['rem_ttl'] = ((pttl_cmd_res == -1) ? Infinity : pttl_cmd_res)
+            lock_data['spc_cnt'] = Integer(lock_data['spc_cnt']) if lock_data['spc_cnt']
+            lock_data['l_spc_ts'] = Float(lock_data['l_spc_ts']) if lock_data['l_spc_ts']
+            lock_data['spc_ext_ttl'] = Integer(lock_data['spc_ext_ttl']) if lock_data['spc_ext_ttl']
+            lock_data['l_spc_ext_ini_ttl'] =
+              Integer(lock_data['l_spc_ext_ini_ttl']) if lock_data.key?('l_spc_ext_ini_ttl')
+            lock_data['l_spc_ext_ts'] =
+              Float(lock_data['l_spc_ext_ts']) if lock_data['l_spc_ext_ts']
           end
         end
       end
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/redis_queued_locks/acquier/locks.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::Locks
   class << self
     # @param redis_client [RedisClient]
@@ -10,7 +10,7 @@ module RedisQueuedLocks::Acquier::Locks
     # @return [Set<String>,Set<Hash<Symbol,Any>>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def locks(redis_client, scan_size:, with_info:)
       redis_client.with do |rconn|
         lock_keys = scan_locks(rconn, scan_size)
@@ -25,7 +25,7 @@ module RedisQueuedLocks::Acquier::Locks
     # @return [Set<String>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def scan_locks(redis_client, scan_size)
       Set.new.tap do |lock_keys|
         redis_client.scan(
@@ -44,7 +44,8 @@ module RedisQueuedLocks::Acquier::Locks
     # @return [Set<Hash<Symbol,Any>>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
+    # @version 1.3.0
     # rubocop:disable Metrics/MethodLength
     def extract_locks_info(redis_client, lock_keys)
       # TODO: refactor with RedisQueuedLocks::Acquier::LockInfo
@@ -72,6 +73,14 @@ module RedisQueuedLocks::Acquier::Locks
                   lock_data['ts'] = Float(lock_data['ts'])
                   lock_data['ini_ttl'] = Integer(lock_data['ini_ttl'])
                   lock_data['rem_ttl'] = ((pttl_cmd_res == -1) ? Infinity : pttl_cmd_res)
+                  lock_data['spc_cnt'] = Integer(lock_data['spc_cnt']) if lock_data['spc_cnt']
+                  lock_data['l_spc_ts'] = Float(lock_data['l_spc_ts']) if lock_data['l_spc_ts']
+                  lock_data['spc_ext_ttl'] =
+                    Integer(lock_data['spc_ext_ttl']) if lock_data['spc_ext_ttl']
+                  lock_data['l_spc_ext_ini_ttl'] =
+                    Integer(lock_data['l_spc_ext_ini_ttl']) if lock_data.key?('l_spc_ext_ini_ttl')
+                  lock_data['l_spc_ext_ts'] =
+                    Float(lock_data['l_spc_ext_ts']) if lock_data['l_spc_ext_ts']
                 end
               end
             end

data/lib/redis_queued_locks/acquier/queue_info.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::QueueInfo
   class << self
     # Returns an information about the required lock queue by the lock name. The result
@@ -23,7 +23,7 @@ module RedisQueuedLocks::Acquier::QueueInfo
     #   }
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def queue_info(redis_client, lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)