Module: RedisQueuedLocks::Acquirer::ReleaseLock Private

Extended by:
Utilities
Defined in:
lib/redis_queued_locks/acquirer/release_lock.rb

Overview

This module is part of a private API. You should avoid using this module if possible, as it may be removed or be changed in the future.

Since:

  • 1.0.0

Constant Summary

Constants included from Utilities

Utilities::RACTOR_LIVENESS_PATTERN, Utilities::RACTOR_STATUS_PATTERN, Utilities::RUBY_OVER_4

Class Method Summary collapse

Methods included from Utilities

clock_gettime, ractor_alive?, ractor_status, ruby_over_4?, run_non_critical, thread_state

Class Method Details

.release_lock(redis, lock_name, instrumenter, logger, log_sampling_enabled, log_sampling_percent, log_sampler, log_sample_this, instr_sampling_enabled, instr_sampling_percent, instr_sampler, instr_sample_this) ⇒ Hash<Symbol,Boolean<Hash<Symbol,Numeric|String|Symbol>>] Format: { ok: true/false, result: Hash<Symbol,Numeric|String|Symbol> }

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Release the concrete lock:

    1. clear lock queue: al; related processes released from the lock aquierment and should retry;
    1. delete the lock: drop lock key from Redis; It is safe because the lock obtain logic is transactional and watches the original lock for changes.

rubocop:disable Metrics/MethodLength

Parameters:

  • redis (RedisClient) —

    Redis connection client.

  • lock_name (String) —

    The lock name that should be released.

  • instrumenter (#notify) —

    See RedisQueuedLocks::Instrument::ActiveSupport for example.

  • logger (::Logger, #debug) —
    • Logger object used from configuration layer (see config);
    • See RedisQueuedLocks::Logging::VoidLogger for example;
  • log_sampling_enabled (Boolean) —
    • enables : only the configured percent of RQL cases will be logged;
    • disabled by default;
    • works in tandem with <config> and <config>;
  • log_sampling_percent (Integer) —
    • the percent of cases that should be logged;
    • take an effect when <config> is true;
    • works in tandem with <config> and <config> configs;
  • log_sampler (#sampling_happened?, Module<RedisQueuedLocks::Logging::Sampler>) —
    • percent-based log sampler that decides should be RQL case logged or not;
    • works in tandem with <config> and <config> configs;
    • based on the ultra simple percent-based (weight-based) algorithm that uses SecureRandom.rand method so the algorithm error is ~(0%..13%);
    • you can provide your own log sampler with bettter algorithm that should realize sampling_happened?(percent) => boolean interface (see RedisQueuedLocks::Logging::Sampler for example);
  • log_sample_this (Boolean) —
    • marks the method that everything should be logged despite the enabled log sampling;
    • makes sense when log sampling is enabled;
  • instr_sampling_enabled (Boolean) —
    • enables : only the configured percent of RQL cases will be instrumented;
    • disabled by default;
    • works in tandem with <config> and <config>;
  • instr_sampling_percent (Integer) —
    • the percent of cases that should be instrumented;
    • take an effect when <config> is true;
    • works in tandem with <config> and <config> configs;
  • instr_sampler (#sampling_happened?, Module<RedisQueuedLocks::Instrument::Sampler>) —
    • percent-based log sampler that decides should be RQL case instrumented or not;
    • works in tandem with <config> and <config> configs;
    • based on the ultra simple percent-based (weight-based) algorithm that uses SecureRandom.rand method so the algorithm error is ~(0%..13%);
    • you can provide your own log sampler with bettter algorithm that should realize sampling_happened?(percent) => boolean interface (see RedisQueuedLocks::Instrument::Sampler for example);
  • instr_sample_this (Boolean) —
    • marks the method that everything should be instrumneted despite the enabled instrumentation sampling;
    • makes sense when instrumentation sampling is enabled;

Returns:

  • (Hash<Symbol,Boolean<Hash<Symbol,Numeric|String|Symbol>>] Format: { ok: true/false, result: Hash<Symbol,Numeric|String|Symbol> }) —

    Hash<Symbol,Boolean<Hash<Symbol,Numeric|String|Symbol>>] Format: { ok: true/false, result: Hash<Symbol,Numeric|String|Symbol> }

Since:

  • 1.0.0

Version:

  • 1.14.0



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/redis_queued_locks/acquirer/release_lock.rb', line 76

def release_lock(
  redis,
  lock_name,
  instrumenter,
  logger,
  log_sampling_enabled,
  log_sampling_percent,
  log_sampler,
  log_sample_this,
  instr_sampling_enabled,
  instr_sampling_percent,
  instr_sampler,
  instr_sample_this
)
  lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
  lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)

  rel_start_time = clock_gettime
  fully_release_lock(redis, lock_key, lock_key_queue) => { ok:, result: } # steep:ignore

  # @type var ok: bool
  # @type var result: Hash[Symbol,Symbol]

  time_at = Time.now.to_f
  rel_end_time = clock_gettime
  rel_time = ((rel_end_time - rel_start_time) / 1_000.0).ceil(2)

  instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
    instr_sampling_enabled,
    instr_sample_this,
    instr_sampling_percent,
    instr_sampler
  )

  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
    })
  end if instr_sampled

  {
    ok: true,
    result: {
      rel_time: rel_time,
      rel_key: lock_key,
      rel_queue: lock_key_queue,
      queue_res: result[:queue],
      lock_res: result[:lock]
    }
  }
end