redis_queued_locks 1.5.0 → 1.7.0

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

@@ -2,10 +2,10 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.7.0
 # rubocop:disable Metrics/ModuleLength, Metrics/BlockNesting
 module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
-  # @since 1.0.0
-  extend RedisQueuedLocks::Utilities
+  require_relative 'try_to_lock/log_visitor'
 
   # @return [String]
   #
@@ -27,13 +27,15 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
   # @param queue_ttl [Integer]
   # @param fail_fast [Boolean]
   # @param conflict_strategy [Symbol]
+  # @param access_strategy [Symbol]
   # @param meta [NilClass,Hash<String|Symbol,Any>]
   # @param log_sampled [Boolean]
+  # @param instr_sampled [Boolean]
   # @return [Hash<Symbol,Any>] Format: { ok: true/false, result: Symbol|Hash<Symbol,Any> }
   #
   # @api private
   # @since 1.0.0
-  # @version 1.5.0
+  # @version 1.7.0
   # rubocop:disable Metrics/MethodLength
   def try_to_lock(
     redis,
@@ -47,37 +49,27 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
     queue_ttl,
     fail_fast,
     conflict_strategy,
+    access_strategy,
     meta,
-    log_sampled
+    log_sampled,
+    instr_sampled
   )
     # Step X: intermediate invocation results
     inter_result = nil
     timestamp = nil
     spc_processed_timestamp = nil
 
-    if log_sampled && log_lock_try
-      run_non_critical do
-        logger.debug do
-          "[redis_queued_locks.try_lock.start] " \
-          "lock_key => '#{lock_key}' " \
-          "queue_ttl => #{queue_ttl} " \
-          "acq_id => '#{acquier_id}'"
-        end
-      end
-    end
+    LogVisitor.start(
+      logger, log_sampled, log_lock_try,
+      lock_key, queue_ttl, acquier_id, access_strategy
+    )
 
     # Step X: start to work with lock acquiring
     result = redis.with do |rconn|
-      if log_sampled && log_lock_try
-        run_non_critical do
-          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
+      LogVisitor.rconn_fetched(
+        logger, log_sampled, log_lock_try,
+        lock_key, queue_ttl, acquier_id, access_strategy
+      )
 
       # Step 0:
       #   watch the lock key changes (and discard acquirement if lock is already
@@ -90,16 +82,10 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
 
         # SP-Conflict Step X1: calculate the current deadlock status
         if current_lock_obtainer != nil && acquier_id == current_lock_obtainer
-          if log_sampled && log_lock_try
-            run_non_critical do
-              logger.debug do
-                "[redis_queued_locks.try_lock.same_process_conflict_detected] " \
-                "lock_key => '#{lock_key}' " \
-                "queue_ttl => #{queue_ttl} " \
-                "acq_id => '#{acquier_id}'"
-              end
-            end
-          end
+          LogVisitor.same_process_conflict_detected(
+            logger, log_sampled, log_lock_try,
+            lock_key, queue_ttl, acquier_id, access_strategy
+          )
 
           # SP-Conflict Step X2: self-process dead lock moment started.
           # SP-Conflict CHECK (Step CHECK): check chosen strategy and flag the current status
@@ -126,17 +112,10 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           end
           # rubocop:enable Lint/DuplicateBranch
 
-          if log_sampled && log_lock_try
-            run_non_critical do
-              logger.debug do
-                "[redis_queued_locks.try_lock.same_process_conflict_analyzed] " \
-                "lock_key => '#{lock_key}' " \
-                "queue_ttl => #{queue_ttl} " \
-                "acq_id => '#{acquier_id}' " \
-                "spc_status => '#{sp_conflict_status}'"
-              end
-            end
-          end
+          LogVisitor.same_process_conflict_analyzed(
+            logger, log_sampled, log_lock_try,
+            lock_key, queue_ttl, acquier_id, access_strategy, sp_conflict_status
+          )
         end
 
         # SP-Conflict-Step X2: switch to conflict-based logic or not
@@ -174,19 +153,11 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           )
           inter_result = :extendable_conflict_work_through
 
-          if log_sampled && log_lock_try
-            run_non_critical do
-              logger.debug do
-                "[redis_queued_locks.try_lock.reentrant_lock__extend_and_work_through] " \
-                "lock_key => '#{lock_key}' " \
-                "queue_ttl => #{queue_ttl} " \
-                "acq_id => '#{acquier_id}'" \
-                "spc_status => '#{sp_conflict_status} '" \
-                "last_ext_ttl => '#{ttl}' " \
-                "last_ext_ts => '#{spc_processed_timestamp}'"
-              end
-            end
-          end
+          LogVisitor.reentrant_lock__extend_and_work_through(
+            logger, log_sampled, log_lock_try,
+            lock_key, queue_ttl, acquier_id, access_strategy,
+            sp_conflict_status, ttl, spc_processed_timestamp
+          )
         # SP-Conflict-Step X2: switch to dead lock logic or not
         elsif sp_conflict_status == :conflict_work_through
           inter_result = :conflict_work_through
@@ -207,33 +178,21 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
             'l_spc_ts', (spc_processed_timestamp = Time.now.to_f)
           )
 
-          if log_sampled && log_lock_try
-            run_non_critical do
-              logger.debug do
-                "[redis_queued_locks.try_lock.reentrant_lock__work_through] " \
-                "lock_key => '#{lock_key}' " \
-                "queue_ttl => #{queue_ttl} " \
-                "acq_id => '#{acquier_id}' " \
-                "spc_status => '#{sp_conflict_status} ' " \
-                "last_spc_ts => '#{spc_processed_timestamp}'"
-              end
-            end
-          end
+          LogVisitor.reentrant_lock__work_through(
+            logger, log_sampled, log_lock_try,
+            lock_key, queue_ttl, acquier_id, access_strategy,
+            sp_conflict_status, spc_processed_timestamp
+          )
         # SP-Conflict-Step X2: switch to dead lock logic or not
         elsif sp_conflict_status == :conflict_dead_lock
           inter_result = :conflict_dead_lock
           spc_processed_timestamp = Time.now.to_f
 
-          if log_sampled && log_lock_try
-            logger.debug do
-              "[redis_queued_locks.try_lock.single_process_lock_conflict__dead_lock] " \
-              "lock_key => '#{lock_key}' " \
-              "queue_ttl => #{queue_ttl} " \
-              "acq_id => '#{acquier_id}' " \
-              "spc_status => '#{sp_conflict_status}' " \
-              "last_spc_ts => '#{spc_processed_timestamp}'"
-            end
-          end
+          LogVisitor.single_process_lock_conflict__dead_lock(
+            logger, log_sampled, log_lock_try,
+            lock_key, queue_ttl, acquier_id, access_strategy,
+            sp_conflict_status, spc_processed_timestamp
+          )
         # Reached the SP-Non-Conflict Mode (NOTE):
         #   - in other sp-conflict cases we are in <wait_for_lock> (non-conflict) status and should
         #     continue to work in classic way (next lines of code):
@@ -244,16 +203,10 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           # Step 1: add an acquier to the lock acquirement queue
           rconn.call('ZADD', lock_key_queue, 'NX', acquier_position, acquier_id)
 
-          if log_sampled && log_lock_try
-            run_non_critical do
-              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
+          LogVisitor.acq_added_to_queue(
+            logger, log_sampled, log_lock_try,
+            lock_key, queue_ttl, acquier_id, access_strategy
+          )
 
           # Step 2.1: drop expired acquiers from the lock queue
           rconn.call(
@@ -263,66 +216,41 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
             RedisQueuedLocks::Resource.acquier_dead_score(queue_ttl)
           )
 
-          if log_sampled && log_lock_try
-            run_non_critical do
-              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
+          LogVisitor.remove_expired_acqs(
+            logger, log_sampled, log_lock_try,
+            lock_key, queue_ttl, acquier_id, access_strategy
+          )
 
           # Step 3: get the actual acquier waiting in the queue
           waiting_acquier = Array(rconn.call('ZRANGE', lock_key_queue, '0', '0')).first
 
-          if log_sampled && log_lock_try
-            run_non_critical do
-              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
+          LogVisitor.get_first_from_queue(
+            logger, log_sampled, log_lock_try,
+            lock_key, queue_ttl, acquier_id, access_strategy, waiting_acquier
+          )
 
           # 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_sampled && log_lock_try
-              run_non_critical do
-                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
+            LogVisitor.exit__queue_ttl_reached(
+              logger, log_sampled, log_lock_try,
+              lock_key, queue_ttl, acquier_id, access_strategy
+            )
 
             inter_result = :dead_score_reached
-          # Step 4: check the actual acquier: is it ours? are we aready to lock?
-          elsif waiting_acquier != acquier_id
+            # Step STRATEGY: check the stragegy and corresponding preventing factor
+            # Step STRATEGY (queued): check the actual acquier: is it ours? are we aready to lock?
+          elsif access_strategy == :queued && waiting_acquier != acquier_id
             # Step ROLLBACK 1.1: our time hasn't come yet. retry!
-
-            if log_sampled && log_lock_try
-              run_non_critical do
-                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
-
+            LogVisitor.exit__no_first(
+              logger, log_sampled, log_lock_try,
+              lock_key, queue_ttl, acquier_id, access_strategy, waiting_acquier,
+              rconn.call('HGETALL', lock_key).to_h
+            )
             inter_result = :acquier_is_not_first_in_queue
-          else
+            # Step STRAGEY: successfull (:queued OR :random)
+          elsif (access_strategy == :queued && waiting_acquier == acquier_id) ||
+                (access_strategy == :random)
             # NOTE: our time has come! let's try to acquire the lock!
 
             # Step 5: find the lock -> check if the our lock is already acquired
@@ -331,20 +259,12 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
             if locked_by_acquier
               # Step ROLLBACK 2: required lock is stil acquired. retry!
 
-              if log_sampled && log_lock_try
-                run_non_critical do
-                  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
-
+              LogVisitor.exit__lock_still_obtained(
+                logger, log_sampled, log_lock_try,
+                lock_key, queue_ttl, acquier_id, access_strategy,
+                waiting_acquier, locked_by_acquier,
+                rconn.call('HGETALL', lock_key).to_h
+              )
               inter_result = :lock_is_still_acquired
             else
               # NOTE: required lock is free and ready to be acquired! acquire!
@@ -365,16 +285,10 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
               # Step 6.3: set the lock expiration time in order to prevent "infinite locks"
               transact.call('PEXPIRE', lock_key, ttl) # NOTE: in milliseconds
 
-              if log_sampled && log_lock_try
-                run_non_critical do
-                  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
+              LogVisitor.obtain__free_to_acquire(
+                logger, log_sampled, log_lock_try,
+                lock_key, queue_ttl, acquier_id, access_strategy
+              )
             end
           end
         end
@@ -477,40 +391,5 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
     # rubocop:enable Lint/DuplicateBranch
   end
   # 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]
-  # @param log_sampled [Boolean]
-  # @return [Hash<Symbol,Any>] Format: { ok: true/false, result: Any }
-  #
-  # @api private
-  # @since 1.0.0
-  # @version 1.5.0
-  def dequeue_from_lock_queue(
-    redis,
-    logger,
-    lock_key,
-    lock_key_queue,
-    queue_ttl,
-    acquier_id,
-    log_sampled
-  )
-    result = redis.call('ZREM', lock_key_queue, acquier_id)
-
-    run_non_critical do
-      logger.debug do
-        "[redis_queued_locks.fail_fast_or_limits_reached_or_deadlock__dequeue] " \
-        "lock_key => '#{lock_key}' " \
-        "queue_ttl => '#{queue_ttl}' " \
-        "acq_id => '#{acquier_id}'"
-      end
-    end if log_sampled
-
-    RedisQueuedLocks::Data[ok: true, result: result]
-  end
 end
 # rubocop:enable Metrics/ModuleLength, Metrics/BlockNesting

data/lib/redis_queued_locks/acquier/acquire_lock/yield_expire/log_visitor.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 1.7.0
+module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire::LogVisitor
+  extend self
+
+  # @param logger [::Logger,#debug]
+  # @param log_sampled [Boolean]
+  # @param lock_key [String]
+  # @param queue_ttl [Integer]
+  # @param acquier_id [String]
+  # @param access_strategy [Symbol]
+  # @return [void]
+  #
+  # @api private
+  # @since 1.7.0
+  def expire_lock(
+    logger,
+    log_sampled,
+    lock_key,
+    queue_ttl,
+    acquier_id,
+    access_strategy
+  )
+    return unless log_sampled
+
+    logger.debug do
+      "[redis_queued_locks.expire_lock] " \
+      "lock_key => '#{lock_key}' " \
+      "queue_ttl => #{queue_ttl} " \
+      "acq_id => '#{acquier_id}' " \
+      "acs_strat => '#{access_strategy}'"
+    end rescue nil
+  end
+
+  # @param logger [::Logger,#debug]
+  # @param log_sampled [Boolean]
+  # @param lock_key [String]
+  # @param decreased_ttl [Integer]
+  # @param queue_ttl [Integer]
+  # @param acquier_id [String]
+  # @param access_strategy [Symbol]
+  # @return [void]
+  #
+  # @api private
+  # @since 1.7.0
+  def decrease_lock(
+    logger,
+    log_sampled,
+    lock_key,
+    decreased_ttl,
+    queue_ttl,
+    acquier_id,
+    access_strategy
+  )
+    return unless log_sampled
+
+    logger.debug do
+      "[redis_queued_locks.decrease_lock] " \
+      "lock_key => '#{lock_key}' " \
+      "decreased_ttl => #{decreased_ttl} " \
+      "queue_ttl => #{queue_ttl} " \
+      "acq_id => '#{acquier_id}' " \
+      "acs_strat => '#{access_strategy}'"
+    end rescue nil
+  end
+end

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

@@ -2,9 +2,9 @@
 
 # @api private
 # @since 1.3.0
+# @version 1.7.0
 module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
-  # @since 1.3.0
-  extend RedisQueuedLocks::Utilities
+  require_relative 'yield_expire/log_visitor'
 
   # @return [String]
   #
@@ -19,12 +19,14 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
   # @param logger [::Logger,#debug] Logger object.
   # @param lock_key [String] Obtained lock key that should be expired.
   # @param acquier_id [String] Acquier identifier.
+  # @param access_strategy [Symbol] Lock obtaining strategy.
   # @param timed [Boolean] Should the lock be wrapped by Timeout with with lock's ttl
   # @param ttl_shift [Float] Lock's TTL shifting. Should affect block's ttl. In millisecodns.
   # @param ttl [Integer,NilClass] Lock's time to live (in ms). Nil means "without timeout".
   # @param queue_ttl [Integer] Lock request lifetime.
   # @param block [Block] Custom logic that should be invoked unter the obtained lock.
-  # @param log_sampled [Boolean] Should the logic be logged or not (is log sample happened?).
+  # @param log_sampled [Boolean] Should the logic be logged or not.
+  # @param instr_sampled [Boolean] Should the logic be instrumented or not.
   # @param should_expire [Boolean] Should the lock be expired after the block invocation.
   # @param should_decrease [Boolean]
   #   - Should decrease the lock TTL after the lock invocation;
@@ -33,18 +35,20 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
   #
   # @api private
   # @since 1.3.0
-  # @version 1.5.0
+  # @version 1.7.0
   # rubocop:disable Metrics/MethodLength
   def yield_expire(
     redis,
     logger,
     lock_key,
     acquier_id,
+    access_strategy,
     timed,
     ttl_shift,
     ttl,
     queue_ttl,
     log_sampled,
+    instr_sampled,
     should_expire,
     should_decrease,
     &block
@@ -65,29 +69,21 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
     end
   ensure
     if should_expire
-      run_non_critical do
-        logger.debug do
-          "[redis_queued_locks.expire_lock] " \
-          "lock_key => '#{lock_key}' " \
-          "queue_ttl => #{queue_ttl} " \
-          "acq_id => '#{acquier_id}'"
-        end
-      end if log_sampled
+      LogVisitor.expire_lock(
+        logger, log_sampled,
+        lock_key, queue_ttl, acquier_id, access_strategy
+      )
       redis.call('EXPIRE', lock_key, '0')
     elsif should_decrease
       finish_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
       spent_time = (finish_time - initial_time)
       decreased_ttl = ttl - spent_time - RedisQueuedLocks::Resource::REDIS_TIMESHIFT_ERROR
+
       if decreased_ttl > 0
-        run_non_critical do
-          logger.debug do
-            "[redis_queued_locks.decrease_lock] " \
-            "lock_key => '#{lock_key}' " \
-            "decreased_ttl => '#{decreased_ttl} " \
-            "queue_ttl => #{queue_ttl} " \
-            "acq_id => '#{acquier_id}' " \
-          end
-        end if log_sampled
+        LogVisitor.decrease_lock(
+          logger, log_sampled,
+          lock_key, decreased_ttl, queue_ttl, acquier_id, access_strategy
+        )
         # NOTE:# NOTE: EVAL signature -> <lua script>, (number of keys), *(keys), *(arguments)
         redis.call('EVAL', DECREASE_LOCK_PTTL, 1, lock_key, decreased_ttl)
         # TODO: upload scripts to the redis