redis_queued_locks 1.19.0 → 1.21.0

data/lib/redis_queued_locks/acquirer/release_all_locks.rb

@@ -2,20 +2,29 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.20.0
+# rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Acquirer::ReleaseAllLocks
   # @since 1.0.0
   extend RedisQueuedLocks::Utilities
 
+  # rubocop:disable Metrics/ClassLength
   class << self
-    # Release all locks:
-    # - 1. clear all lock queus: drop them all from Redis database by the lock queue pattern;
-    # - 2. delete all locks: drop lock keys from Redis by the lock key pattern;
-    # - 3. (RW) clear all read lock queues and drop all read locks (readers registries and data);
+    # Release all locks: delete the keys of all lock families (write locks, lock queues,
+    # readers registries, read lock queues and read lock data):
+    #   - the disabled lock index: the keys found in one SCAN pass, with one `DEL` per batch of
+    #     keys;
+    #   - the enabled lock index: the keys of the locks of the lock index (one ZSCAN pass), their
+    #     lock names are dropped from the lock index, with one transaction (`DEL` + `ZREM`) per
+    #     batch of lock names;
     #
     # @param redis [RedisClient]
     #   Redis connection client.
     # @param batch_size [Integer]
-    #   The number of lock keys that should be released in a time.
+    #   The number of lock keys (the disabled lock index) or locks (lock names, the enabled lock
+    #   index) that should be released in a time.
+    # @param lock_index_enabled [Boolean]
+    #   Find locks via the lock index instead of the keyspace SCAN.
     # @param logger [::Logger,#debug]
     #   - Logger object used from `configuration` layer (see config['logger']);
     #   - See RedisQueuedLocks::Logging::VoidLogger for example;
@@ -30,7 +39,7 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
     #   - works in tandem with <config['log_sampling_percent']> and <config['log_sampler']>;
     # @param log_sampling_percent [Integer]
     #   - the percent of cases that should be logged;
-    #   - take an effect when <config['log_sampling_enalbed']> is true;
+    #   - take an effect when <config['log_sampling_enabled']> is true;
     #   - works in tandem with <config['log_sampling_enabled']> and <config['log_sampler']> configs;
     # @param log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
     #   - percent-based log sampler that decides should be RQL case logged or not;
@@ -51,7 +60,7 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
     #   - works in tandem with <config['instr_sampling_percent']> and <config['instr_sampler']>;
     # @param instr_sampling_percent [Integer]
     #   - the percent of cases that should be instrumented;
-    #   - take an effect when <config['instr_sampling_enalbed']> is true;
+    #   - take an effect when <config['instr_sampling_enabled']> is true;
     #   - works in tandem with <config['instr_sampling_enabled']>
     #     and <config['instr_sampler']> configs;
     # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
@@ -72,10 +81,12 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
     #
     # @api private
     # @since 1.0.0
-    # @version 1.18.0
+    # @version 1.21.0
+    # rubocop:disable Metrics/MethodLength
     def release_all_locks(
       redis,
       batch_size,
+      lock_index_enabled,
       logger,
       instrumenter,
       instrument,
@@ -88,8 +99,19 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
       instr_sampler,
       instr_sample_this
     )
+      # NOTE: (arguments) the same ranges as the config keys: zero/negative sizes fail SCAN/ZSCAN
+      #   (`COUNT 0`) and the batching (`each_slice(0)`);
+      if !batch_size.is_a?(::Integer) || batch_size <= 0
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`:batch_size` argument should be a positive Integer, got #{batch_size.inspect}."
+        )
+      end
+
       rel_start_time = clock_gettime
-      fully_release_all_locks(redis, batch_size) => { ok:, result: } # steep:ignore
+      # steep:ignore:start
+      fully_release_all_locks(redis, batch_size, lock_index_enabled) => { ok:, result: }
+      # steep:ignore:end
 
       # @type var ok: bool
       # @type var result: Hash[Symbol,Integer]
@@ -98,6 +120,12 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
       rel_end_time = clock_gettime
       rel_time = ((rel_end_time - rel_start_time) / 1_000.0).ceil(2)
 
+      log_sampled = RedisQueuedLocks::Logging.should_log?(
+        log_sampling_enabled,
+        log_sample_this,
+        log_sampling_percent,
+        log_sampler
+      )
       instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
         instr_sampling_enabled,
         instr_sample_this,
@@ -105,11 +133,21 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
         instr_sampler
       )
 
+      run_non_critical do
+        logger.debug do
+          "[redis_queued_locks.explicit_all_locks_release] " \
+          "at => #{time_at} " \
+          "rel_time => #{rel_time} " \
+          "rel_key_cnt => #{result[:rel_key_cnt]}"
+        end
+      end if log_sampled
+
       run_non_critical do
         instrumenter.notify('redis_queued_locks.explicit_all_locks_release', {
           at: time_at,
           rel_time: rel_time,
-          rel_key_cnt: result[:rel_key_cnt]
+          rel_key_cnt: result[:rel_key_cnt],
+          instrument: instrument
         })
       end if instr_sampled
 
@@ -118,77 +156,155 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
         result: { rel_key_cnt: result[:rel_key_cnt], rel_time: rel_time }
       }
     end
+    # rubocop:enable Metrics/MethodLength
 
     private
 
-    # Release all locks: clear all lock queus and expire all locks.
+    # Release all locks:
+    #   - the disabled lock index: one SCAN pass over the RQL keys (`KEY_PATTERN`); the keys of all
+    #     lock families are deleted with one `DEL` per batch of `batch_size` keys (the keys are
+    #     deleted during the scan: no list of all keys is kept in memory);
+    #   - the enabled lock index: one ZSCAN pass over the lock index (`LOCK_INDEX_KEY`: lock names,
+    #     the keyspace is never scanned); the keys of all lock families of each batch of
+    #     `batch_size` lock names are deleted with one `DEL` in one transaction with the `ZREM` of
+    #     the lock names from the lock index (two round trips per batch: the read lock acquirers,
+    #     then the transaction):
+    #     - expired lock names are dropped from the lock index first (all their keys are expired);
+    #     - lock names of the lock requests queued (or the locks obtained) after the transaction of
+    #       their batch are indexed again by the lock acquirement;
     #
     # @param redis [RedisClient]
     # @param batch_size [Integer]
+    #   SCAN count and the number of keys in one `DEL` (the disabled lock index) or ZSCAN count and
+    #   the number of lock names in one transaction (the enabled lock index).
+    # @param lock_index_enabled [Boolean]
     # @return [Hash<Symbol,Boolean|Hash<Symbol,Integer>>]
     #   - Exmaple: { ok: true, result: { rel_key_cnt: 12345 } }
     #
     # @api private
     # @since 1.0.0
-    # @version 1.18.0
-    # rubocop:disable Metrics/MethodLength
-    def fully_release_all_locks(redis, batch_size)
-      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('EXPIRE', lock_queue, '0')
-          end
+    # @version 1.20.0
+    def fully_release_all_locks(redis, batch_size, lock_index_enabled)
+      rel_key_cnt = 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
+      redis.with do |rconn|
+        if lock_index_enabled
+          # Step 1 (lock index): drop the expired lock names from the lock index
+          #   (all their keys are expired);
+          rconn.call(
+            'ZREMRANGEBYSCORE', RedisQueuedLocks::Resource::LOCK_INDEX_KEY,
+            '-inf', RedisQueuedLocks::Resource.lock_index_time - 1
+          )
 
-          # Step C (RW): release all read lock queues
-          rconn.scan(
-            'MATCH',
-            RedisQueuedLocks::Resource::READ_LOCK_QUEUE_PATTERN,
-            count: batch_size
-          ) do |read_lock_queue|
-            # TODO: reduce unnecessary iterations
-            pipeline.call('EXPIRE', read_lock_queue, '0')
+          # Step 2 (lock index): release the locks of the lock index in batches of lock names
+          each_lock_name_batch(rconn, batch_size) do |lock_names|
+            rel_key_cnt += release_locks(rconn, lock_names)
           end
+        else
+          # Step 1 (keyspace): delete the RQL keys of the lock families during one SCAN pass
+          # @type var lock_keys: Array[String]
+          lock_keys = []
 
-          # Step D (RW): release all read locks
-          rconn.scan(
-            'MATCH',
-            RedisQueuedLocks::Resource::LOCK_READERS_PATTERN,
-            count: batch_size
-          ) do |lock_readers|
-            # TODO: reduce unnecessary iterations
-            pipeline.call('EXPIRE', lock_readers, '0')
-          end
+          rconn.scan('MATCH', RedisQueuedLocks::Resource::KEY_PATTERN, count: batch_size) do |key|
+            # NOTE: lock families only (KEY_PATTERN matches any `rql:lock*` key)
+            next if RedisQueuedLocks::Resource.lock_key_family(key) == nil
+
+            lock_keys << key
+            next if lock_keys.size < batch_size
 
-          # Step E (RW): release all read lock data
-          rconn.scan(
-            'MATCH',
-            RedisQueuedLocks::Resource::READ_LOCK_PATTERN,
-            count: batch_size
-          ) do |read_lock|
-            # TODO: reduce unnecessary iterations
-            pipeline.call('EXPIRE', read_lock, '0')
+            rel_key_cnt += rconn.call('DEL', *lock_keys)
+            lock_keys.clear
           end
+
+          rel_key_cnt += rconn.call('DEL', *lock_keys) unless lock_keys.empty?
         end
       end
 
-      { ok: true, result: { rel_key_cnt: result.sum } }
+      { ok: true, result: { rel_key_cnt: } }
+    end
+
+    # (lock index) Releases the locks of the given batch of lock names: deletes all their keys and
+    # drops the lock names from the lock index in one transaction.
+    #   - (RW) read lock data keys are found via the readers registries (one more round trip
+    #     before the transaction); the data of a read lock obtained between the registry read and
+    #     the transaction stays till its ttl (the read lock itself is released with the registry);
+    #
+    # @param redis_client [RedisClient]
+    # @param lock_names [Array<String>]
+    # @return [Integer] The number of the deleted keys.
+    #
+    # @api private
+    # @since 1.20.0
+    def release_locks(redis_client, lock_names)
+      # Step A: (RW) read lock acquirers of the readers registries (their read lock data keys)
+      # NOTE: (pipeline layout) one reply per lock name in the batch order
+      # @type var read_lock_acquirers: Array[Array[String]]
+      read_lock_acquirers = redis_client.pipelined do |pipeline|
+        lock_names.each do |lock_name|
+          pipeline.call(
+            'ZRANGE', RedisQueuedLocks::Resource.prepare_lock_readers(lock_name), '0', '-1'
+          )
+        end
+      end
+
+      # @type var lock_keys: Array[String]
+      lock_keys = []
+      lock_names.each_with_index do |lock_name, index|
+        lock_keys << RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
+        lock_keys << RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
+        lock_keys << RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
+        lock_keys << RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name)
+        read_lock_acquirers[index].each do |acquirer_id|
+          lock_keys << RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+        end
+      end
+
+      # Step B: delete the keys and drop the lock names from the lock index in one transaction
+      #   (a lock obtained after the transaction indexes its lock name again);
+      # NOTE: (transaction layout) [0] DEL (the number of the deleted keys), [1] ZREM (not read)
+      # @type var released: [Integer, Integer]
+      released = redis_client.multi do |transact|
+        transact.call('DEL', *lock_keys)
+        transact.call('ZREM', RedisQueuedLocks::Resource::LOCK_INDEX_KEY, *lock_names)
+      end
+      released[0]
+    end
+
+    # Iterates over the lock names of the lock index (one ZSCAN pass) in batches of `scan_size`
+    # lock names (batches are collected across ZSCAN pages). Expired lock names (not dropped from
+    # the index yet) are skipped: all their keys are expired.
+    #
+    # NOTE: each operation module iterates over the lock index by itself (duplicated on purpose:
+    #   operation modules are independent of each other, see `Locks.each_lock_name_batch`);
+    #
+    # @param redis_client [RedisClient]
+    # @param scan_size [Integer] ZSCAN count and the number of lock names in one batch.
+    # @yield [lock_names]
+    # @yieldparam lock_names [Array<String>] The batch of lock names (reused between batches).
+    # @return [void]
+    #
+    # @api private
+    # @since 1.20.0
+    def each_lock_name_batch(redis_client, scan_size)
+      lock_index_time = RedisQueuedLocks::Resource.lock_index_time
+      # @type var lock_names: Array[String]
+      lock_names = []
+
+      redis_client.zscan(
+        RedisQueuedLocks::Resource::LOCK_INDEX_KEY, count: scan_size
+      ) do |lock_name, lock_index_score|
+        next if lock_index_score.to_f < lock_index_time
+
+        lock_names << lock_name
+        next if lock_names.size < scan_size
+
+        yield(lock_names)
+        lock_names.clear
+      end
+
+      yield(lock_names) unless lock_names.empty?
     end
-    # rubocop:enable Metrics/MethodLength
   end
+  # rubocop:enable Metrics/ClassLength
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/redis_queued_locks/acquirer/release_lock.rb

@@ -2,16 +2,20 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.21.0
+# rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Acquirer::ReleaseLock
   # @since 1.0.0
   extend RedisQueuedLocks::Utilities
 
+  # rubocop:disable Metrics/ClassLength
   class << self
     # Release the concrete lock:
     # - 1. clear lock queue: al; related processes released
     #      from the lock aquierment and should retry;
     # - 2. delete the lock: drop lock key from Redis;
     # - 3. (RW) clear the read lock queue and drop all read locks (the readers registry);
+    # - 4. (lock index) drop the lock name from the lock index (the enabled lock index only);
     # It is safe because the lock obtain logic is transactional and
     # watches the original lock for changes.
     #
@@ -19,18 +23,23 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
     #   Redis connection client.
     # @param lock_name [String]
     #   The lock name that should be released.
-    # @param instrumenter [#notify]
-    #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
+    # @param lock_index_enabled [Boolean]
+    #   Drop the lock name from the lock index (the enabled lock index).
     # @param logger [::Logger,#debug]
     #   - Logger object used from `configuration` layer (see config['logger']);
     #   - See RedisQueuedLocks::Logging::VoidLogger for example;
+    # @param instrumenter [#notify]
+    #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
+    # @param instrument [NilClass,Any]
+    #    - Custom instrumentation data wich will be passed to the instrumenter's payload
+    #      with :instrument key;
     # @param log_sampling_enabled [Boolean]
     #   - enables <log sampling>: only the configured percent of RQL cases will be logged;
     #   - disabled by default;
     #   - works in tandem with <config['log_sampling_percent']> and <config['log_sampler']>;
     # @param log_sampling_percent [Integer]
     #   - the percent of cases that should be logged;
-    #   - take an effect when <config['log_sampling_enalbed']> is true;
+    #   - take an effect when <config['log_sampling_enabled']> is true;
     #   - works in tandem with <config['log_sampling_enabled']> and <config['log_sampler']> configs;
     # @param log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
     #   - percent-based log sampler that decides should be RQL case logged or not;
@@ -51,7 +60,7 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
     #   - works in tandem with <config['instr_sampling_percent']> and <config['instr_sampler']>;
     # @param instr_sampling_percent [Integer]
     #   - the percent of cases that should be instrumented;
-    #   - take an effect when <config['instr_sampling_enalbed']> is true;
+    #   - take an effect when <config['instr_sampling_enabled']> is true;
     #   - works in tandem with <config['instr_sampling_enabled']>
     #     and <config['instr_sampler']> configs;
     # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
@@ -72,13 +81,15 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.18.0
+    # @version 1.21.0
     # rubocop:disable Metrics/MethodLength
     def release_lock(
       redis,
       lock_name,
-      instrumenter,
+      lock_index_enabled,
       logger,
+      instrumenter,
+      instrument,
       log_sampling_enabled,
       log_sampling_percent,
       log_sampler,
@@ -96,7 +107,8 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
       rel_start_time = clock_gettime
       # steep:ignore:start
       fully_release_lock(
-        redis, lock_name, lock_key, lock_key_queue, read_lock_key_queue, lock_readers_key
+        redis, lock_name, lock_key, lock_key_queue, read_lock_key_queue, lock_readers_key,
+        lock_index_enabled
       ) => { ok:, result: }
       # steep:ignore:end
 
@@ -107,6 +119,12 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
       rel_end_time = clock_gettime
       rel_time = ((rel_end_time - rel_start_time) / 1_000.0).ceil(2)
 
+      log_sampled = RedisQueuedLocks::Logging.should_log?(
+        log_sampling_enabled,
+        log_sample_this,
+        log_sampling_percent,
+        log_sampler
+      )
       instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
         instr_sampling_enabled,
         instr_sample_this,
@@ -114,12 +132,23 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
         instr_sampler
       )
 
+      run_non_critical do
+        logger.debug do
+          "[redis_queued_locks.explicit_lock_release] " \
+          "lock_key => '#{lock_key}' " \
+          "lock_key_queue => '#{lock_key_queue}' " \
+          "rel_time => #{rel_time} " \
+          "at => #{time_at}"
+        end
+      end if log_sampled
+
       run_non_critical do
         instrumenter.notify('redis_queued_locks.explicit_lock_release', {
           lock_key: lock_key,
           lock_key_queue: lock_key_queue,
           rel_time: rel_time,
-          at: time_at
+          at: time_at,
+          instrument: instrument
         })
       end if instr_sampled
 
@@ -138,7 +167,8 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
 
     private
 
-    # Realease the lock: clear the lock queues and expire the lock (write lock and read locks).
+    # Realease the lock: clear the lock queues and expire the lock (write lock and read locks),
+    # drop the lock name from the lock index (the enabled lock index).
     #
     # @param redis [RedisClient]
     # @param lock_name [String]
@@ -146,6 +176,7 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
     # @param lock_key_queue [String]
     # @param read_lock_key_queue [String]
     # @param lock_readers_key [String]
+    # @param lock_index_enabled [Boolean]
     # @return [Hash<Symbol,Boolean|Hash<Symbol,Symbol>>]
     #   Format: {
     #     ok: true/false,
@@ -157,43 +188,71 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.18.0
+    # @version 1.20.0
+    # rubocop:disable Metrics/MethodLength
     def fully_release_lock(
       redis,
       lock_name,
       lock_key,
       lock_key_queue,
       read_lock_key_queue,
-      lock_readers_key
+      lock_readers_key,
+      lock_index_enabled
     )
-      # @type var result: [Integer,Integer,Integer,Integer]
+      # @type var result: [Array[String],Integer,Integer,Integer,Integer]
       result = redis.with do |rconn|
-        # NOTE: (RW) data of read locks (it is a data carrier only: read locks are released via
-        #   the readers registry, so the data of concurrently obtained read locks expires itself)
-        # @type var read_lock_acquirers: Array[String]
-        read_lock_acquirers = rconn.call('ZRANGE', lock_readers_key, '0', '-1')
-
-        rconn.multi do |transact|
+        # Step 1: release the lock in one transaction (one round trip):
+        #   - (RW) the readers registry is read in the same transaction: the snapshot of all
+        #     released read locks (their data is dropped in Step 2);
+        #   - (lock index) the enabled lock index: all the indexed keys of the lock are dropped,
+        #     so the lock name is dropped from the lock index in the same transaction (a lock
+        #     request queued or a lock obtained after this transaction indexes the lock name again);
+        # NOTE: (transaction layout) replies are read by their positions:
+        #   [0] ZRANGE (released read locks), [1] write lock queue, [2] write lock,
+        #   [3] read lock queue, [4] readers registry, [5] lock index (the enabled lock index
+        #   only, the last command: not read);
+        released = rconn.multi do |transact|
+          transact.call('ZRANGE', lock_readers_key, '0', '-1')
           transact.call('ZREMRANGEBYSCORE', lock_key_queue, '-inf', '+inf')
           transact.call('EXPIRE', lock_key, '0')
           transact.call('ZREMRANGEBYSCORE', read_lock_key_queue, '-inf', '+inf')
           transact.call('EXPIRE', lock_readers_key, '0')
-          read_lock_acquirers.each do |acquirer_id|
-            transact.call(
-              'DEL',
-              RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
-            )
+          if lock_index_enabled
+            transact.call('ZREM', RedisQueuedLocks::Resource::LOCK_INDEX_KEY, lock_name)
           end
         end
+
+        # Step 2: (RW) drop the data of the released read locks (only when read locks existed)
+        # NOTE:
+        #   - the read lock data is a data carrier only: read locks are released via the readers
+        #     registry (Step 1);
+        #   - (trade-off) a reader of the snapshot that obtains a new read lock between Step 1 and
+        #     Step 2 loses the data of the new read lock (meta, timestamps); the read lock itself is
+        #     not affected (the readers registry is the source of truth);
+        # @type var read_lock_acquirers: Array[String]
+        read_lock_acquirers = released[0]
+        unless read_lock_acquirers.empty?
+          rconn.call(
+            'DEL',
+            *read_lock_acquirers.map do |acquirer_id|
+              RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+            end
+          )
+        end
+
+        released
       end
 
       {
         ok: true,
         result: {
-          queue: (result[0] != 0 || result[2] != 0) ? :released : :nothing_to_release,
-          lock: (result[1] != 0 || result[3] != 0) ? :released : :nothing_to_release
+          queue: (result[1] != 0 || result[3] != 0) ? :released : :nothing_to_release,
+          lock: (result[2] != 0 || result[4] != 0) ? :released : :nothing_to_release
         }
       }
     end
+    # rubocop:enable Metrics/MethodLength
   end
+  # rubocop:enable Metrics/ClassLength
 end
+# rubocop:enable Metrics/ModuleLength