redis_queued_locks 0.0.38 → 0.0.40

data/Rakefile

@@ -2,11 +2,20 @@
 
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-
+require 'rubocop'
 require 'rubocop/rake_task'
+require 'rubocop-performance'
+require 'rubocop-rspec'
+require 'rubocop-rake'
+
+RuboCop::RakeTask.new(:rubocop) do |t|
+  config_path = File.expand_path(File.join('.rubocop.yml'), __dir__)
+  t.options = ['--config', config_path]
+  t.requires << 'rubocop-rspec'
+  t.requires << 'rubocop-performance'
+  t.requires << 'rubocop-rake'
+end
 
-RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:rspec)
 
-task default: %i[spec rubocop]
+task default: :rspec

data/lib/redis_queued_locks/acquier/acquire_lock/try_to_lock.rb

@@ -42,12 +42,12 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
 
     if log_lock_try
       run_non_critical do
-        logger.debug(
+        logger.debug do
           "[redis_queued_locks.try_lock.start] " \
           "lock_key => '#{lock_key}' " \
           "queue_ttl => #{queue_ttl} " \
           "acq_id => '#{acquier_id}'"
-        )
+        end
       end
     end
 
@@ -55,12 +55,12 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
     result = redis.with do |rconn|
       if log_lock_try
         run_non_critical do
-          logger.debug(
+          logger.debug do
             "[redis_queued_locks.try_lock.rconn_fetched] " \
             "lock_key => '#{lock_key}' " \
             "queue_ttl => #{queue_ttl} " \
             "acq_id => '#{acquier_id}'"
-          )
+          end
         end
       end
 
@@ -74,25 +74,21 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           inter_result = :fail_fast_no_try
         else
           # Step 1: add an acquier to the lock acquirement queue
-          res = rconn.call('ZADD', lock_key_queue, 'NX', acquier_position, acquier_id)
+          rconn.call('ZADD', lock_key_queue, 'NX', acquier_position, acquier_id)
 
           if log_lock_try
             run_non_critical do
-              logger.debug(
+              logger.debug do
                 "[redis_queued_locks.try_lock.acq_added_to_queue] " \
                 "lock_key => '#{lock_key}' " \
                 "queue_ttl => #{queue_ttl} " \
                 "acq_id => '#{acquier_id}'"
-              )
+              end
             end
           end
 
-          RedisQueuedLocks.debug(
-            "Step №1: добавление в очередь (#{acquier_id}). [ZADD to the queue: #{res}]"
-          )
-
           # Step 2.1: drop expired acquiers from the lock queue
-          res = rconn.call(
+          rconn.call(
             'ZREMRANGEBYSCORE',
             lock_key_queue,
             '-inf',
@@ -101,58 +97,44 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
 
           if log_lock_try
             run_non_critical do
-              logger.debug(
+              logger.debug do
                 "[redis_queued_locks.try_lock.remove_expired_acqs] " \
                 "lock_key => '#{lock_key}' " \
                 "queue_ttl => #{queue_ttl} " \
                 "acq_id => '#{acquier_id}'"
-              )
+              end
             end
           end
 
-          RedisQueuedLocks.debug(
-            "Step №2: дропаем из очереди просроченных ожидающих. [ZREMRANGE: #{res}]"
-          )
-
           # Step 3: get the actual acquier waiting in the queue
           waiting_acquier = Array(rconn.call('ZRANGE', lock_key_queue, '0', '0')).first
 
           if log_lock_try
             run_non_critical do
-              logger.debug(
+              logger.debug do
                 "[redis_queued_locks.try_lock.get_first_from_queue] " \
                 "lock_key => '#{lock_key}' " \
                 "queue_ttl => #{queue_ttl} " \
                 "acq_id => '#{acquier_id}' " \
                 "first_acq_id_in_queue => '#{waiting_acquier}'"
-              )
+              end
             end
           end
 
-          RedisQueuedLocks.debug(
-            "Step №3: какой процесс в очереди сейчас ждет. " \
-            "[ZRANGE <следующий процесс>: #{waiting_acquier} :: <текущий процесс>: #{acquier_id}]"
-          )
-
           # Step PRE-4.x: check if the request time limit is reached
           #   (when the current try self-removes itself from queue (queue ttl has come))
           if waiting_acquier == nil
             if log_lock_try
               run_non_critical do
-                logger.debug(
+                logger.debug do
                   "[redis_queued_locks.try_lock.exit__queue_ttl_reached] " \
                   "lock_key => '#{lock_key}' " \
                   "queue_ttl => #{queue_ttl} " \
                   "acq_id => '#{acquier_id}'"
-                )
+                end
               end
             end
 
-            RedisQueuedLocks.debug(
-              "Step PRE-ROLLBACK №0: достигли лимита времени эквайра лока (queue ttl). выходим. " \
-              "[Наша позиция: #{acquier_id}. queue_ttl: #{queue_ttl}]"
-            )
-
             inter_result = :dead_score_reached
           # Step 4: check the actual acquier: is it ours? are we aready to lock?
           elsif waiting_acquier != acquier_id
@@ -160,59 +142,41 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
 
             if log_lock_try
               run_non_critical do
-                logger.debug(
+                logger.debug do
                   "[redis_queued_locks.try_lock.exit__no_first] " \
                   "lock_key => '#{lock_key}' " \
                   "queue_ttl => #{queue_ttl} " \
                   "acq_id => '#{acquier_id}' " \
                   "first_acq_id_in_queue => '#{waiting_acquier}' " \
                   "<current_lock_data> => <<#{rconn.call('HGETALL', lock_key).to_h}>>"
-                )
+                end
               end
             end
 
-            RedisQueuedLocks.debug(
-              "Step ROLLBACK №1: не одинаковые ключи. выходим. " \
-              "[Ждет: #{waiting_acquier}. А нужен: #{acquier_id}]"
-            )
-
             inter_result = :acquier_is_not_first_in_queue
           else
             # NOTE: our time has come! let's try to acquire the lock!
 
-            # Step 5: check if the our lock is already acquired
+            # Step 5: find the lock -> check if the our lock is already acquired
             locked_by_acquier = rconn.call('HGET', lock_key, 'acq_id')
 
-            # rubocop:disable Layout/LineLength
-            RedisQueuedLocks.debug(
-              "Ste №5: Ищем требуемый лок. " \
-              "[HGET<#{lock_key}>: " \
-              "#{(locked_by_acquier == nil) ? 'не занят' : "занят процессом <#{locked_by_acquier}>"}"
-            )
-            # rubocop:enable Layout/LineLength
-
             if locked_by_acquier
               # Step ROLLBACK 2: required lock is stil acquired. retry!
 
               if log_lock_try
                 run_non_critical do
-                  logger.debug(
-                    "[redis_queued_locks.try_lock.exit__still_obtained] " \
+                  logger.debug do
+                    "[redis_queued_locks.try_lock.exit__lock_still_obtained] " \
                     "lock_key => '#{lock_key}' " \
                     "queue_ttl => #{queue_ttl} " \
                     "acq_id => '#{acquier_id}' " \
                     "first_acq_id_in_queue => '#{waiting_acquier}' " \
                     "locked_by_acq_id => '#{locked_by_acquier}' " \
                     "<current_lock_data> => <<#{rconn.call('HGETALL', lock_key).to_h}>>"
-                  )
+                  end
                 end
               end
 
-              RedisQueuedLocks.debug(
-                "Step ROLLBACK №2: Ключ уже занят. Ничего не делаем. " \
-                "[Занят процессом: #{locked_by_acquier}]"
-              )
-
               inter_result = :lock_is_still_acquired
             else
               # NOTE: required lock is free and ready to be acquired! acquire!
@@ -220,16 +184,6 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
               # Step 6.1: remove our acquier from waiting queue
               transact.call('ZREM', lock_key_queue, acquier_id)
 
-              RedisQueuedLocks.debug(
-                'Step №4: Забираем наш текущий процесс из очереди. [ZREM]'
-              )
-
-              # rubocop:disable Layout/LineLength
-              RedisQueuedLocks.debug(
-                "===> <FINAL> Step №6: закрепляем лок за процессом [HSET<#{lock_key}>: #{acquier_id}]"
-              )
-              # rubocop:enable Layout/LineLength
-
               # Step 6.2: acquire a lock and store an info about the acquier
               transact.call(
                 'HSET',
@@ -245,12 +199,12 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
 
               if log_lock_try
                 run_non_critical do
-                  logger.debug(
-                    "[redis_queued_locks.try_lock.run__free_to_acquire] " \
+                  logger.debug do
+                    "[redis_queued_locks.try_lock.obtain__free_to_acquire] " \
                     "lock_key => '#{lock_key}' " \
                     "queue_ttl => #{queue_ttl} " \
                     "acq_id => '#{acquier_id}'"
-                  )
+                  end
                 end
               end
             end
@@ -297,18 +251,26 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
   # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
 
   # @param redis [RedisClient]
+  # @param logger [::Logger,#debug]
+  # @param lock_key [String]
   # @param lock_key_queue [String]
+  # @param queue_ttl [Integer]
   # @param acquier_id [String]
   # @return [Hash<Symbol,Any>] Format: { ok: true/false, result: Any }
   #
   # @api private
   # @since 0.1.0
-  def dequeue_from_lock_queue(redis, lock_key_queue, acquier_id)
+  def dequeue_from_lock_queue(redis, logger, lock_key, lock_key_queue, queue_ttl, acquier_id)
     result = redis.call('ZREM', lock_key_queue, acquier_id)
 
-    RedisQueuedLocks.debug(
-      "Step ~ [СМЕРТЬ ПРОЦЕССА]: [#{acquier_id} :: #{lock_key_queue}] РЕЗУЛЬТАТ: #{result}"
-    )
+    run_non_critical do
+      logger.debug do
+        "[redis_queued_locks.fail_fast_or_limits_reached__dequeue] " \
+        "lock_key => '#{lock_key}' " \
+        "queue_ttl => '#{queue_ttl}' " \
+        "acq_id => '#{acquier_id}'"
+      end
+    end
 
     RedisQueuedLocks::Data[ok: true, result: result]
   end

data/lib/redis_queued_locks/acquier/acquire_lock/yield_with_expire.rb

@@ -40,12 +40,12 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldWithExpire
     end
   ensure
     run_non_critical do
-      logger.debug(
+      logger.debug do
         "[redis_queued_locks.expire_lock] " \
         "lock_key => '#{lock_key}' " \
         "queue_ttl => #{queue_ttl} " \
         "acq_id => '#{acquier_id}'"
-      )
+      end
     end
     redis.call('EXPIRE', lock_key, '0')
   end

data/lib/redis_queued_locks/acquier/acquire_lock.rb

@@ -23,11 +23,11 @@ module RedisQueuedLocks::Acquier::AcquireLock
   # @since 0.1.0
   extend RedisQueuedLocks::Utilities
 
-  # @return [Integer] Redis expiration error (in milliseconds).
+  # @return [Integer] Redis time error (in milliseconds).
   #
   # @api private
   # @since 0.1.0
-  REDIS_EXPIRE_ERROR = 1
+  REDIS_TIMESHIFT_ERROR = 2
 
   class << self
     # @param redis [RedisClient]
@@ -146,9 +146,6 @@ module RedisQueuedLocks::Acquier::AcquireLock
         ractor_id,
         identity
       )
-      # NOTE:
-      #   - think aobut the redis expiration error
-      #   - (ttl - REDIS_EXPIRE_ERROR).yield_self { |val| (val == 0) ? ttl : val }
       lock_ttl = ttl
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
@@ -165,15 +162,24 @@ module RedisQueuedLocks::Acquier::AcquireLock
         hold_time: nil, # NOTE: in milliseconds
         rel_time: nil # NOTE: in milliseconds
       }
-      acq_dequeue = -> { dequeue_from_lock_queue(redis, lock_key_queue, acquier_id) }
+
+      acq_dequeue = proc do
+        dequeue_from_lock_queue(
+          redis, logger,
+          lock_key,
+          lock_key_queue,
+          queue_ttl,
+          acquier_id
+        )
+      end
 
       run_non_critical do
-        logger.debug(
+        logger.debug do
           "[redis_queued_locks.start_lock_obtaining] " \
           "lock_key => '#{lock_key}' " \
           "queue_ttl => #{queue_ttl} " \
           "acq_id => '#{acquier_id}'"
-        )
+        end
       end
 
       # Step 2: try to lock with timeout
@@ -183,12 +189,12 @@ module RedisQueuedLocks::Acquier::AcquireLock
         # Step 2.1: caclically try to obtain the lock
         while acq_process[:should_try]
           run_non_critical do
-            logger.debug(
+            logger.debug do
               "[redis_queued_locks.start_try_to_lock_cycle] " \
               "lock_key => '#{lock_key}' " \
               "queue_ttl => #{queue_ttl} " \
               "acq_id => '{#{acquier_id}'"
-            )
+            end
           end
 
           # Step 2.X: check the actual score: is it in queue ttl limit or not?
@@ -197,12 +203,12 @@ module RedisQueuedLocks::Acquier::AcquireLock
             acquier_position = RedisQueuedLocks::Resource.calc_initial_acquier_position
 
             run_non_critical do
-              logger.debug(
+              logger.debug do
                 "[redis_queued_locks.dead_score_reached__reset_acquier_position] " \
                 "lock_key => '#{lock_key} " \
                 "queue_ttl => #{queue_ttl} " \
                 "acq_id => '#{acquier_id}'"
-              )
+              end
             end
           end
 
@@ -230,13 +236,13 @@ module RedisQueuedLocks::Acquier::AcquireLock
           # Step 2.1: analyze an acquirement attempt
           if ok
             run_non_critical do
-              logger.debug(
+              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
@@ -315,7 +321,11 @@ module RedisQueuedLocks::Acquier::AcquireLock
         if block_given?
           begin
             yield_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-            ttl_shift = ((yield_time - acq_process[:acq_end_time]) * 1000).ceil(2)
+
+            ttl_shift = (
+              (yield_time - acq_process[:acq_end_time]) * 1000 - REDIS_TIMESHIFT_ERROR
+            ).ceil(2)
+
             yield_with_expire(
               redis,
               logger,

data/lib/redis_queued_locks/acquier/clear_dead_requests.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module RedisQueuedLocks::Acquier::ClearDeadRequests
+  class << self
+    # @param redis_client [RedisClient]
+    # @param scan_size [Integer]
+    # @param dead_ttl [Integer] In milliseconds
+    # @param logger [::Logger,#debug]
+    # @param instrumenter [#notify]
+    # @param instrument [NilClass,Any]
+    # @return [Hash<Symbol,Boolean|Hash<Symbol,Set<String>>>]
+    #
+    # @api private
+    # @since 0.1.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)
+
+      result = Set.new.tap do |processed_queues|
+        redis_client.with do |rconn|
+          each_lock_queue(rconn, scan_size) do |lock_queue|
+            rconn.call('ZREMRANGEBYSCORE', lock_queue, '-inf', dead_score)
+            processed_queues << lock_queue
+          end
+        end
+      end
+
+      RedisQueuedLocks::Data[ok: true, result: { processed_queues: result }]
+    end
+
+    private
+
+    # @param redis_client [RedisClient]
+    # @param scan_size [Integer]
+    # @yield [lock_queue]
+    # @yieldparam lock_queue [String]
+    # @yieldreturn [void]
+    # @return [Enumerator]
+    #
+    # @api private
+    # @since 0.1.0
+    def each_lock_queue(redis_client, scan_size, &block)
+      redis_client.scan(
+        'MATCH',
+        RedisQueuedLocks::Resource::LOCK_QUEUE_PATTERN,
+        count: scan_size,
+        &block
+      )
+    end
+  end
+end

data/lib/redis_queued_locks/acquier/extend_lock_ttl.rb

@@ -3,17 +3,36 @@
 # @api private
 # @since 0.1.0
 module RedisQueuedLocks::Acquier::ExtendLockTTL
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.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);
+  LUA_SCRIPT
+
   class << self
     # @param redis_client [RedisClient]
     # @param lock_name [String]
     # @param milliseconds [Integer]
     # @param logger [::Logger,#debug]
-    # @return [?]
+    # @return [Hash<Symbol,Boolean|Symbol>]
     #
     # @api private
     # @since 0.1.0
     def extend_lock_ttl(redis_client, lock_name, milliseconds, logger)
-      # TODO: realize
+      lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
+
+      # NOTE: EVAL signature -> <lua script>, (number of keys), *(keys), *(arguments)
+      result = redis_client.call('EVAL', EXTEND_LOCK_PTTL, 1, lock_key, milliseconds)
+      # TODO: upload scripts to the redis
+
+      if result == 1
+        RedisQueuedLocks::Data[ok: true, result: :ttl_extended]
+      else
+        RedisQueuedLocks::Data[ok: false, result: :async_expire_or_no_lock]
+      end
     end
   end
 end

data/lib/redis_queued_locks/acquier/lock_info.rb

@@ -21,9 +21,9 @@ module RedisQueuedLocks::Acquier::LockInfo
     def lock_info(redis_client, lock_name)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
 
-      result = redis_client.multi(watch: [lock_key]) do |transact|
-        transact.call('HGETALL', lock_key)
-        transact.call('PTTL', lock_key)
+      result = redis_client.pipelined do |pipeline|
+        pipeline.call('HGETALL', lock_key)
+        pipeline.call('PTTL', lock_key)
       end
 
       if result == nil

data/lib/redis_queued_locks/acquier/locks.rb

@@ -12,8 +12,10 @@ module RedisQueuedLocks::Acquier::Locks
     # @api private
     # @since 0.1.0
     def locks(redis_client, scan_size:, with_info:)
-      lock_keys = scan_locks(redis_client, scan_size)
-      with_info ? extract_locks_info(redis_client, lock_keys) : lock_keys
+      redis_client.with do |rconn|
+        lock_keys = scan_locks(rconn, scan_size)
+        with_info ? extract_locks_info(rconn, lock_keys) : lock_keys
+      end
     end
 
     private
@@ -50,9 +52,9 @@ module RedisQueuedLocks::Acquier::Locks
         # Step X: iterate each lock and extract their info
         lock_keys.each do |lock_key|
           # Step 1: extract lock info from redis
-          lock_info = redis_client.multi(watch: [lock_key]) do |transact|
-            transact.call('HGETALL', lock_key)
-            transact.call('PTTL', lock_key)
+          lock_info = redis_client.pipelined do |pipeline|
+            pipeline.call('HGETALL', lock_key)
+            pipeline.call('PTTL', lock_key)
           end.yield_self do |result| # Step 2: format the result
             # Step 2.X: lock is released
             if result == nil

data/lib/redis_queued_locks/acquier/queues.rb

@@ -12,8 +12,10 @@ module RedisQueuedLocks::Acquier::Queues
     # @api private
     # @since 0.1.0
     def queues(redis_client, scan_size:, with_info:)
-      lock_queues = scan_queues(redis_client, scan_size)
-      with_info ? extract_queues_info(redis_client, lock_queues) : lock_queues
+      redis_client.with do |rconn|
+        lock_queues = scan_queues(rconn, scan_size)
+        with_info ? extract_queues_info(rconn, lock_queues) : lock_queues
+      end
     end
 
     private

data/lib/redis_queued_locks/acquier/release_all_locks.rb

@@ -15,20 +15,23 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     #   Redis connection client.
     # @param batch_size [Integer]
     #   The number of lock keys that should be released in a time.
-    # @param isntrumenter [#notify]
-    #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
     # @param logger [::Logger,#debug]
     #   - Logger object used from `configuration` layer (see config[:logger]);
     #   - See RedisQueuedLocks::Logging::VoidLogger for example;
+    # @param isntrumenter [#notify]
+    #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
+    # @option instrument [NilClass,Any]
+    #    - Custom instrumentation data wich will be passed to the instrumenter's payload
+    #      with :instrument key;
     # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>]
-    #   Format: { ok: true/false, result: Hash<Symbol,Numeric> }
+    #   Format: { ok: true, result: Hash<Symbol,Numeric> }
     #
     # @api private
     # @since 0.1.0
-    def release_all_locks(redis, batch_size, instrumenter, logger)
+    def release_all_locks(redis, batch_size, logger, instrumenter, instrument)
       rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       fully_release_all_locks(redis, batch_size) => { ok:, result: }
-      time_at = Time.now.to_i
+      time_at = Time.now.to_f
       rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       rel_time = ((rel_end_time - rel_start_time) * 1_000).ceil(2)
 
@@ -36,13 +39,13 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
         instrumenter.notify('redis_queued_locks.explicit_all_locks_release', {
           at: time_at,
           rel_time: rel_time,
-          rel_keys: result[:rel_keys]
+          rel_key_cnt: result[:rel_key_cnt]
         })
       end
 
       RedisQueuedLocks::Data[
         ok: true,
-        result: { rel_key_cnt: result[:rel_keys], rel_time: rel_time }
+        result: { rel_key_cnt: result[:rel_key_cnt], rel_time: rel_time }
       ]
     end
 
@@ -52,7 +55,8 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     #
     # @param redis [RedisClient]
     # @param batch_size [Integer]
-    # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>] Format: { ok: true/false, result: Any }
+    # @return [RedisQueuedLocks::Data,Hash<Symbol,Boolean|Hash<Symbol,Integer>>]
+    #   - Exmaple: { ok: true, result: { rel_key_cnt: 12345 } }
     #
     # @api private
     # @since 0.1.0
@@ -66,8 +70,7 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
             count: batch_size
           ) do |lock_queue|
             # TODO: reduce unnecessary iterations
-            pipeline.call('ZREMRANGEBYSCORE', lock_queue, '-inf', '+inf')
-            pipeline.call('EXPIRE', RedisQueuedLocks::Resource.lock_key_from_queue(lock_queue), '0')
+            pipeline.call('EXPIRE', lock_queue, '0')
           end
 
           # Step B: release all locks
@@ -82,9 +85,7 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
         end
       end
 
-      rel_keys = result.count { |red_res| red_res == 0 }
-
-      RedisQueuedLocks::Data[ok: true, result: { rel_keys: rel_keys }]
+      RedisQueuedLocks::Data[ok: true, result: { rel_key_cnt: result.sum }]
     end
   end
 end