redis_queued_locks 0.0.21 → 0.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ea008491f8c631aea2677c6571a206db919c0ca5d599b58adc37fa82c372145
-  data.tar.gz: 41e5bece44a3b1af1031d28a4d7bfe480641151573b97c89d62841f296cbc3ca
+  metadata.gz: 05a8fc14cae41bf9870bedf4eae9fa298c3704b57d25df428c2e2c8bd9bf0223
+  data.tar.gz: 14a941048edc7679df1d80805a96d3db4019d45acfc80ac5444d99e12cc3eadc
 SHA512:
-  metadata.gz: cf96a4535a3fa8f6c7a62797805263e7957f198997213df65c164b9261d5199526f7dbc6e2a3f5e13a912e79cc7cd718ed193b0f197586cd03f1f3f95d958fca
-  data.tar.gz: 46726b0d18cd73d108b57b34872f1369ab63771a7d6c899aee021ab628ced537e6e0a7e255aecee259b902d682f5d13a12519dcc7033b786ef832c035a61f12a
+  metadata.gz: 292f4ed74242a1a53b96e290e7759db0b1c918070f0875805bedbe78360fac71b6ac81ec09b63836002b2a17ab247ca06f9cf7ff828a4a07f924b2588e24fd3f
+  data.tar.gz: 270749b6a32418e2a57b3995b5ef3b826b6066a97a56efd08f9305f0ed314ed7da13f9f395f891ab619ceea3d4bde53c880278758fbf42fb1e84b98fa5b14690

data/CHANGELOG.md

@@ -1,8 +1,17 @@
 ## [Unreleased]
 
+## [0.0.23] - 2024-03-21
+### Changed
+- Composed redis commands are invoked on the one conenction
+  (instead of mutiple connection fetchiong from redis connection pool on each redis command);
+
+## [0.0.22] - 2024-03-21
+### Added
+- Logging infrastructure. Initial implementation includes the only debugging features.
+
 ## [0.0.21] - 2024-03-19
 ### Changed
-- `RedisQueuedLocks::Acquier` refactirngs;
+- Refactored `RedisQueuedLocks::Acquier`;
 
 ## [0.0.20] - 2024-03-14
 ### Added

data/README.md

@@ -134,6 +134,16 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   # - it is calculated once per `RedisQueudLocks::Client` instance;
   # - expects the proc object;
   config.uniq_identifier = -> { RedisQueuedLocks::Resource.calc_uniq_identity }
+
+  # (default: RedisQueuedLocks::Logging::VoidLogger)
+  # - the logger object;
+  # - should implement `debug(progname = nil, &block)` (minimal requirement) or be an instance of Ruby's `::Logger` class/subclass;
+  # - at this moment the only debug logs are realised in 3 cases:
+  #   - start of lock obtaining: "[redis_queud_locks.start_lock_obtaining] lock_key => 'rql:lock:your_lock'"
+  #   - finish of the lock obtaining: "[redis_queued_locks.lock_obtained] lock_key => 'rql:lock:your_lock' acq_time => 123.456 (ms)"
+  #   - start of the lock expiration after `yield`: "[redis_queud_locks.expire_lock] lock_key => 'rql:lock:your_lock'"
+  # - by default uses VoidLogger that does nothing;
+  config.logger = RedisQueuedLocks::Logging::VoidLogger
 end
 ```
 
@@ -581,6 +591,7 @@ Detalized event semantics and payload structure:
   - an ability to add custom metadata to the lock and an ability to read this data;
   - lock prioritization;
   - support for LIFO strategy;
+  - structured logging;
 - **Minor**
   - GitHub Actions CI;
   - `RedisQueuedLocks::Acquier::Try.try_to_lock` - detailed successful result analization;

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

@@ -31,95 +31,101 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
     timestamp = nil
 
     # Step 0: watch the lock key changes (and discard acquirement if lock is already acquired)
-    result = redis.multi(watch: [lock_key]) do |transact|
-      # Fast-Step X0: fail-fast check
-      if fail_fast && redis.call('HGET', lock_key, 'acq_id')
-        # Fast-Step X1: is lock already obtained. fail fast - no try.
-        inter_result = :fail_fast_no_try
-      else
-        # Step 1: add an acquier to the lock acquirement queue
-        res = redis.call('ZADD', lock_key_queue, 'NX', acquier_position, acquier_id)
-
-        RedisQueuedLocks.debug(
-          "Step №1: добавление в очередь (#{acquier_id}). [ZADD to the queue: #{res}]"
-        )
-
-        # Step 2.1: drop expired acquiers from the lock queue
-        res = redis.call(
-          'ZREMRANGEBYSCORE',
-          lock_key_queue,
-          '-inf',
-          RedisQueuedLocks::Resource.acquier_dead_score(queue_ttl)
-        )
-
-        RedisQueuedLocks.debug(
-          "Step №2: дропаем из очереди просроченных ожидающих. [ZREMRANGE: #{res}]"
-        )
-
-        # Step 3: get the actual acquier waiting in the queue
-        waiting_acquier = Array(redis.call('ZRANGE', lock_key_queue, '0', '0')).first
-
-        RedisQueuedLocks.debug(
-          "Step №3: какой процесс в очереди сейчас ждет. " \
-          "[ZRANGE <следующий процесс>: #{waiting_acquier} :: <текущий процесс>: #{acquier_id}]"
-        )
-
-        # Step 4: check the actual acquier: is it ours? are we aready to lock?
-        unless waiting_acquier == acquier_id
-          # Step ROLLBACK 1.1: our time hasn't come yet. retry!
+    result = redis.with do |rconn|
+      rconn.multi(watch: [lock_key]) do |transact|
+        # Fast-Step X0: fail-fast check
+        if fail_fast && rconn.call('HGET', lock_key, 'acq_id')
+          # Fast-Step X1: is lock already obtained. fail fast - no try.
+          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)
 
           RedisQueuedLocks.debug(
-            "Step ROLLBACK №1: не одинаковые ключи. выходим. " \
-            "[Ждет: #{waiting_acquier}. А нужен: #{acquier_id}]"
+            "Step №1: добавление в очередь (#{acquier_id}). [ZADD to the queue: #{res}]"
           )
 
-          inter_result = :acquier_is_not_first_in_queue
-        else
-          # NOTE: our time has come! let's try to acquire the lock!
+          # Step 2.1: drop expired acquiers from the lock queue
+          res = rconn.call(
+            'ZREMRANGEBYSCORE',
+            lock_key_queue,
+            '-inf',
+            RedisQueuedLocks::Resource.acquier_dead_score(queue_ttl)
+          )
+
+          RedisQueuedLocks.debug(
+            "Step №2: дропаем из очереди просроченных ожидающих. [ZREMRANGE: #{res}]"
+          )
 
-          # Step 5: check if the our lock is already acquired
-          locked_by_acquier = redis.call('HGET', lock_key, 'acq_id')
+          # Step 3: get the actual acquier waiting in the queue
+          waiting_acquier = Array(rconn.call('ZRANGE', lock_key_queue, '0', '0')).first
 
           RedisQueuedLocks.debug(
-            "Ste №5: Ищем требуемый лок. " \
-            "[HGET<#{lock_key}>: " \
-            "#{(locked_by_acquier == nil) ? 'не занят' : "занят процессом <#{locked_by_acquier}>"}"
+            "Step №3: какой процесс в очереди сейчас ждет. " \
+            "[ZRANGE <следующий процесс>: #{waiting_acquier} :: <текущий процесс>: #{acquier_id}]"
           )
 
-          if locked_by_acquier
-            # Step ROLLBACK 2: required lock is stil acquired. retry!
+          # Step 4: check the actual acquier: is it ours? are we aready to lock?
+          unless waiting_acquier == acquier_id
+            # Step ROLLBACK 1.1: our time hasn't come yet. retry!
 
             RedisQueuedLocks.debug(
-              "Step ROLLBACK №2: Ключ уже занят. Ничего не делаем. " \
-              "[Занят процессом: #{locked_by_acquier}]"
+              "Step ROLLBACK №1: не одинаковые ключи. выходим. " \
+              "[Ждет: #{waiting_acquier}. А нужен: #{acquier_id}]"
             )
 
-            inter_result = :lock_is_still_acquired
+            inter_result = :acquier_is_not_first_in_queue
           else
-            # NOTE: required lock is free and ready to be acquired! acquire!
+            # NOTE: our time has come! let's try to acquire the lock!
 
-            # Step 6.1: remove our acquier from waiting queue
-            transact.call('ZPOPMIN', lock_key_queue, '1')
+            # Step 5: check if the our lock is already acquired
+            locked_by_acquier = rconn.call('HGET', lock_key, 'acq_id')
 
+            # rubocop:disable Layout/LineLength
             RedisQueuedLocks.debug(
-              'Step №4: Забираем наш текущий процесс из очереди. [ZPOPMIN]'
+              "Ste №5: Ищем требуемый лок. " \
+              "[HGET<#{lock_key}>: " \
+              "#{(locked_by_acquier == nil) ? 'не занят' : "занят процессом <#{locked_by_acquier}>"}"
             )
-
-            RedisQueuedLocks.debug(
-              "===> <FINAL> Step №6: закрепляем лок за процессом [HSET<#{lock_key}>: #{acquier_id}]"
-            )
-
-            # Step 6.2: acquire a lock and store an info about the acquier
-            transact.call(
-              'HSET',
-              lock_key,
-              'acq_id', acquier_id,
-              'ts', (timestamp = Time.now.to_i),
-              'ini_ttl', ttl
-            )
-
-            # Step 6.3: set the lock expiration time in order to prevent "infinite locks"
-            transact.call('PEXPIRE', lock_key, ttl) # NOTE: in milliseconds
+            # rubocop:enable Layout/LineLength
+
+            if locked_by_acquier
+              # Step ROLLBACK 2: required lock is stil acquired. retry!
+
+              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!
+
+              # Step 6.1: remove our acquier from waiting queue
+              transact.call('ZPOPMIN', lock_key_queue, '1')
+
+              RedisQueuedLocks.debug(
+                'Step №4: Забираем наш текущий процесс из очереди. [ZPOPMIN]'
+              )
+
+              # 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',
+                lock_key,
+                'acq_id', acquier_id,
+                'ts', (timestamp = Time.now.to_i),
+                'ini_ttl', ttl
+              )
+
+              # Step 6.3: set the lock expiration time in order to prevent "infinite locks"
+              transact.call('PEXPIRE', lock_key, ttl) # NOTE: in milliseconds
+            end
           end
         end
       end

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

@@ -3,7 +3,11 @@
 # @api private
 # @since 0.1.0
 module RedisQueuedLocks::Acquier::AcquireLock::YieldWithExpire
+  # @since 0.1.0
+  extend RedisQueuedLocks::Utilities
+
   # @param redis [RedisClient] Redis connection manager.
+  # @param logger [#debug] Logger object.
   # @param lock_key [String] Lock key to be expired.
   # @param timed [Boolean] Should the lock be wrapped by Tiemlout with with lock's ttl
   # @param ttl_shift [Float] Lock's TTL shifting. Should affect block's ttl. In millisecodns.
@@ -13,7 +17,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldWithExpire
   #
   # @api private
   # @since 0.1.0
-  def yield_with_expire(redis, lock_key, timed, ttl_shift, ttl, &block)
+  def yield_with_expire(redis, logger, lock_key, timed, ttl_shift, ttl, &block)
     if block_given?
       if timed && ttl != nil
         timeout = ((ttl - ttl_shift) / 1000.0).yield_self { |time| (time < 0) ? 0.0 : time }
@@ -23,6 +27,9 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldWithExpire
       end
     end
   ensure
+    run_non_critical do
+      logger.debug("[redis_queued_locks.expire_lock] lock_key => '#{lock_key}'")
+    end
     redis.call('EXPIRE', lock_key, '0')
   end
 

data/lib/redis_queued_locks/acquier/acquire_lock.rb

@@ -69,6 +69,9 @@ module RedisQueuedLocks::Acquier::AcquireLock
     #   already obtained.
     # @option metadata [NilClass,Any]
     #   - A custom metadata wich will be passed to the instrumenter's payload with :meta key;
+    # @option logger [#debug]
+    #   - Logger object used from `configuration` layer (see config[:logger]);
+    #   - See RedisQueuedLocks::Logging::VoidLogger for example;
     # @param [Block]
     #   A block of code that should be executed after the successfully acquired lock.
     # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>,yield]
@@ -96,6 +99,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
       identity:,
       fail_fast:,
       metadata:,
+      logger:,
       &block
     )
       # Step 1: prepare lock requirements (generate lock name, calc lock ttl, etc).
@@ -127,6 +131,13 @@ module RedisQueuedLocks::Acquier::AcquireLock
       }
       acq_dequeue = -> { dequeue_from_lock_queue(redis, lock_key_queue, acquier_id) }
 
+      run_non_critical do
+        logger.debug(
+          "[redis_queued_locks.start_lock_obtaining] " \
+          "lock_key => '#{lock_key}'"
+        )
+      end
+
       # Step 2: try to lock with timeout
       with_acq_timeout(timeout, lock_key, raise_errors, on_timeout: acq_dequeue) do
         acq_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
@@ -153,15 +164,25 @@ module RedisQueuedLocks::Acquier::AcquireLock
 
           # Step 2.1: analyze an acquirement attempt
           if ok
+            run_non_critical do
+              logger.debug(
+                "[redis_queued_locks.lock_obtained] " \
+                "lock_key => '#{result[:lock_key]}'" \
+                "acq_time => #{acq_time} (ms)"
+              )
+            end
+
             # Step X (instrumentation): lock obtained
-            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,
-              meta: metadata
-            })
+            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,
+                meta: metadata
+              })
+            end
 
             # Step 2.1.a: successfully acquired => build the result
             acq_process[:lock_info] = {
@@ -225,7 +246,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
           begin
             yield_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
             ttl_shift = ((yield_time - acq_process[:acq_end_time]) * 1000).ceil(2)
-            yield_with_expire(redis, lock_key, timed, ttl_shift, ttl, &block)
+            yield_with_expire(redis, logger, lock_key, timed, ttl_shift, ttl, &block)
           ensure
             acq_process[:rel_time] = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
             acq_process[:hold_time] = (

data/lib/redis_queued_locks/acquier/extend_lock_ttl.rb

@@ -7,11 +7,12 @@ module RedisQueuedLocks::Acquier::ExtendLockTTL
     # @param redis_client [RedisClient]
     # @param lock_name [String]
     # @param milliseconds [Integer]
+    # @param logger [#debug]
     # @return [?]
     #
     # @api private
     # @since 0.1.0
-    def extend_lock_ttl(redis_client, lock_name, milliseconds)
+    def extend_lock_ttl(redis_client, lock_name, milliseconds, logger)
       # TODO: realize
     end
   end

data/lib/redis_queued_locks/acquier/release_all_locks.rb

@@ -17,12 +17,15 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     #   The number of lock keys that should be released in a time.
     # @param isntrumenter [#notify]
     #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
+    # @param logger [#debug]
+    #   - Logger object used from `configuration` layer (see config[:logger]);
+    #   - See RedisQueuedLocks::Logging::VoidLogger for example;
     # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>]
     #   Format: { ok: true/false, result: Hash<Symbol,Numeric> }
     #
     # @api private
     # @since 0.1.0
-    def release_all_locks(redis, batch_size, instrumenter)
+    def release_all_locks(redis, batch_size, instrumenter, logger)
       rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       fully_release_all_locks(redis, batch_size) => { ok:, result: }
       time_at = Time.now.to_i
@@ -54,26 +57,28 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     # @api private
     # @since 0.1.0
     def fully_release_all_locks(redis, batch_size)
-      result = redis.pipelined do |pipeline|
-        # Step A: release all queus and their related locks
-        redis.scan(
-          'MATCH',
-          RedisQueuedLocks::Resource::LOCK_QUEUE_PATTERN,
-          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')
-        end
+      result = redis.with do |rconn|
+        rconn.pipelined do |pipeline|
+          # Step A: release all queus and their related locks
+          rconn.scan(
+            'MATCH',
+            RedisQueuedLocks::Resource::LOCK_QUEUE_PATTERN,
+            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')
+          end
 
-        # Step B: release all locks
-        redis.scan(
-          'MATCH',
-          RedisQueuedLocks::Resource::LOCK_PATTERN,
-          count: batch_size
-        ) do |lock_key|
-          # TODO: reduce unnecessary iterations
-          pipeline.call('EXPIRE', lock_key, '0')
+          # Step B: release all locks
+          rconn.scan(
+            'MATCH',
+            RedisQueuedLocks::Resource::LOCK_PATTERN,
+            count: batch_size
+          ) do |lock_key|
+            # TODO: reduce unnecessary iterations
+            pipeline.call('EXPIRE', lock_key, '0')
+          end
         end
       end
 

data/lib/redis_queued_locks/acquier/release_lock.rb

@@ -20,12 +20,15 @@ module RedisQueuedLocks::Acquier::ReleaseLock
     #   The lock name that should be released.
     # @param isntrumenter [#notify]
     #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
+    # @param logger [#debug]
+    #   - Logger object used from `configuration` layer (see config[:logger]);
+    #   - See RedisQueuedLocks::Logging::VoidLogger for example;
     # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>]
     #   Format: { ok: true/false, result: Hash<Symbil,Numeric|String> }
     #
     # @api private
     # @since 0.1.0
-    def release_lock(redis, lock_name, instrumenter)
+    def release_lock(redis, lock_name, instrumenter, logger)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
 
@@ -62,9 +65,11 @@ module RedisQueuedLocks::Acquier::ReleaseLock
     # @api private
     # @since 0.1.0
     def fully_release_lock(redis, lock_key, lock_key_queue)
-      result = redis.multi do |transact|
-        transact.call('ZREMRANGEBYSCORE', lock_key_queue, '-inf', '+inf')
-        transact.call('EXPIRE', lock_key, '0')
+      result = redis.with do |rconn|
+        rconn.multi do |transact|
+          transact.call('ZREMRANGEBYSCORE', lock_key_queue, '-inf', '+inf')
+          transact.call('EXPIRE', lock_key, '0')
+        end
       end
 
       RedisQueuedLocks::Data[ok: true, result:]

data/lib/redis_queued_locks/client.rb

@@ -9,18 +9,16 @@ class RedisQueuedLocks::Client
 
   configuration do
     setting :retry_count, 3
-    setting :retry_delay, 200 # NOTE: milliseconds
-    setting :retry_jitter, 25 # NOTE: milliseconds
-    setting :try_to_lock_timeout, 10 # NOTE: seconds
-    setting :default_lock_ttl, 5_000 # NOTE: milliseconds
-    setting :default_queue_ttl, 15 # NOTE: seconds
+    setting :retry_delay, 200 # NOTE: in milliseconds
+    setting :retry_jitter, 25 # NOTE: in milliseconds
+    setting :try_to_lock_timeout, 10 # NOTE: in seconds
+    setting :default_lock_ttl, 5_000 # NOTE: in milliseconds
+    setting :default_queue_ttl, 15 # NOTE: in seconds
     setting :lock_release_batch_size, 100
     setting :key_extraction_batch_size, 500
     setting :instrumenter, RedisQueuedLocks::Instrument::VoidNotifier
     setting :uniq_identifier, -> { RedisQueuedLocks::Resource.calc_uniq_identity }
-
-    # TODO: setting :logger, Logger.new(IO::NULL)
-    # TODO: setting :debug, true/false
+    setting :logger, RedisQueuedLocks::Logging::VoidLogger
 
     validate('retry_count') { |val| val == nil || (val.is_a?(::Integer) && val >= 0) }
     validate('retry_delay') { |val| val.is_a?(::Integer) && val >= 0 }
@@ -30,6 +28,7 @@ class RedisQueuedLocks::Client
     validate('default_queue_ttl', :integer)
     validate('lock_release_batch_size', :integer)
     validate('instrumenter') { |val| RedisQueuedLocks::Instrument.valid_interface?(val) }
+    validate('logger') { |val| RedisQueuedLocks::Logging.valid_interface?(val) }
     validate('uniq_identifier', :proc)
   end
 
@@ -136,6 +135,7 @@ class RedisQueuedLocks::Client
       identity:,
       fail_fast:,
       metadata:,
+      logger: config[:logger],
       &block
     )
   end
@@ -186,7 +186,8 @@ class RedisQueuedLocks::Client
     RedisQueuedLocks::Acquier::ReleaseLock.release_lock(
       redis_client,
       lock_name,
-      config[:instrumenter]
+      config[:instrumenter],
+      config[:logger]
     )
   end
 
@@ -233,7 +234,12 @@ class RedisQueuedLocks::Client
   # @api public
   # @since 0.1.0
   def extend_lock_ttl(lock_name, milliseconds)
-    RedisQueuedLocks::Acquier::ExtendLockTTL.extend_lock_ttl(redis_client, lock_name)
+    RedisQueuedLocks::Acquier::ExtendLockTTL.extend_lock_ttl(
+      redis_client,
+      lock_name,
+      milliseconds,
+      config[:logger]
+    )
   end
 
   # @option batch_size [Integer]
@@ -246,7 +252,8 @@ class RedisQueuedLocks::Client
     RedisQueuedLocks::Acquier::ReleaseAllLocks.release_all_locks(
       redis_client,
       batch_size,
-      config[:instrumenter]
+      config[:instrumenter],
+      config[:logger]
     )
   end
 

data/lib/redis_queued_locks/instrument/active_support.rb

@@ -8,7 +8,7 @@ module RedisQueuedLocks::Instrument::ActiveSupport
     # @param payload [Hash<String|Symbol,Any>]
     # @return [void]
     #
-    # @api private
+    # @api public
     # @since 0.1.0
     def notify(event, payload = {})
       ::ActiveSupport::Notifications.instrument(event, payload)

data/lib/redis_queued_locks/instrument/void_notifier.rb

@@ -8,7 +8,7 @@ module RedisQueuedLocks::Instrument::VoidNotifier
     # @param payload [Hash<String|Symbol,Any>]
     # @return [void]
     #
-    # @api private
+    # @api public
     # @since 0.1.0
     def notify(event, payload = {}); end
   end

data/lib/redis_queued_locks/instrument.rb

@@ -25,10 +25,10 @@ module RedisQueuedLocks::Instrument
         m_obj = instrumenter.method(:notify)
         m_sig = m_obj.parameters
 
-        f_prm = m_sig[0][0]
-        s_prm = m_sig[1][0]
-
         if m_sig.size == 2
+          f_prm = m_sig[0][0]
+          s_prm = m_sig[1][0]
+
           # rubocop:disable Layout/MultilineOperationIndentation
           # NOTE: check the signature vairants
           f_prm == :req && s_prm == :req ||

data/lib/redis_queued_locks/logging/void_logger.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.1.0
+module RedisQueuedLocks::Logging::VoidLogger
+  class << self
+    # @api public
+    # @since 0.1.0
+    def warn(progname = nil, &block); end
+
+    # @api public
+    # @since 0.1.0
+    def unknown(progname = nil, &block); end
+
+    # @api public
+    # @since 0.1.0
+    def log(progname = nil, &block); end
+
+    # @api public
+    # @since 0.1.0
+    def info(progname = nil, &block); end
+
+    # @api public
+    # @since 0.1.0
+    def error(progname = nil, &block); end
+
+    # @api public
+    # @since 0.1.0
+    def fatal(progname = nil, &block); end
+
+    # @api public
+    # @since 0.1.0
+    def debug(progname = nil, &block); end
+
+    # @api public
+    # @since 0.1.0
+    def add(*, &block); end
+
+    # @api public
+    # @since 0.1.0
+    def <<(message); end
+  end
+end

data/lib/redis_queued_locks/logging.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# @api public
+# @since 0.1.0
+module RedisQueuedLocks::Logging
+  require_relative 'logging/void_logger'
+
+  class << self
+    # @param logger [#debug]
+    # @return [Boolean]
+    #
+    # @api public
+    # @since 0.1.0
+    def valid_interface?(logger)
+      return true if logger.is_a?(::Logger)
+
+      # NOTE: should provide `#debug` method.
+      return false unless logger.respond_to?(:debug)
+
+      # NOTE:
+      #   `#debug` method should have appropriated signature `(progname, &block)`
+      #   Required method signature (progname, &block):
+      #     => [[:opt, :progname], [:block, :block]]
+      #     => [[:req, :progname], [:block, :block]]
+      #     => [[:opt, :progname]]
+      #     => [[:req, :progname]]
+      #     => [[:rest], [:block, :block]]
+      #     => [[:rest]]
+
+      m_obj = logger.method(:debug)
+      m_sig = m_obj.parameters
+
+      if m_sig.size == 2
+        # => [[:opt, :progname], [:block, :block]]
+        # => [[:req, :progname], [:block, :block]]
+        # => [[:rest], [:block, :block]]
+        f_prm = m_sig[0][0]
+        s_prm = m_sig[1][0]
+
+        # rubocop:disable Layout/MultilineOperationIndentation
+        f_prm == :opt && s_prm == :block ||
+        f_prm == :req && s_prm == :block ||
+        f_prm == :rest && s_prm == :block
+        # rubocop:enable Layout/MultilineOperationIndentation
+      elsif m_sig.size == 1
+        # => [[:opt, :progname]]
+        # => [[:req, :progname]]
+        # => [[:rest]]
+        prm = m_sig[0][0]
+
+        prm == :opt || prm == :req || prm == :rest
+      else
+        false
+      end
+    end
+  end
+end

data/lib/redis_queued_locks/version.rb

@@ -5,6 +5,6 @@ module RedisQueuedLocks
   #
   # @api public
   # @since 0.0.1
-  # @version 0.0.21
-  VERSION = '0.0.21'
+  # @version 0.0.23
+  VERSION = '0.0.23'
 end

data/lib/redis_queued_locks.rb

@@ -4,6 +4,7 @@ require 'redis-client'
 require 'qonfig'
 require 'timeout'
 require 'securerandom'
+require 'logger'
 
 # @api public
 # @since 0.1.0
@@ -11,6 +12,7 @@ module RedisQueuedLocks
   require_relative 'redis_queued_locks/version'
   require_relative 'redis_queued_locks/errors'
   require_relative 'redis_queued_locks/utilities'
+  require_relative 'redis_queued_locks/logging'
   require_relative 'redis_queued_locks/data'
   require_relative 'redis_queued_locks/debugger'
   require_relative 'redis_queued_locks/resource'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 0.0.21
+  version: 0.0.23
 platform: ruby
 authors:
 - Rustam Ibragimov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-19 00:00:00.000000000 Z
+date: 2024-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -79,6 +79,8 @@ files:
 - lib/redis_queued_locks/instrument.rb
 - lib/redis_queued_locks/instrument/active_support.rb
 - lib/redis_queued_locks/instrument/void_notifier.rb
+- lib/redis_queued_locks/logging.rb
+- lib/redis_queued_locks/logging/void_logger.rb
 - lib/redis_queued_locks/resource.rb
 - lib/redis_queued_locks/utilities.rb
 - lib/redis_queued_locks/version.rb