Rails Advisory Locks

Advisory Lock: Imagine multiple processes trying to update a row in database. An advisory lock can be used to ensure only one process can modify the row at a time.

Even rails use postgres advisory locks when running migrations, If two processes at a same time try to migrate rails will throw ActiveRecord::ConcurrentMigrationError. We are using pgbouncer a connection pooler for PostgreSQL. So we are unable to use postgres advisory lock.

There is also another gem call Redlock which is also like advisory lock but for our case we were unable to use it.

Our case is simple, We have two models Invoice::Item and Invoice::TaxItem

Here amount 50,000 will be stored in invoice_items and amount 4,500 will be stored in tax_items table. Here when user changes amount to 60000 we have to calculate tax value and store it(We have to store tax value because GST percentage will be changed anytime in future). Same invoice can be edited by multiple users or In some rare cases when user edits amount to 60K and then changes to 70K in next second 70K request finishes first and then 60K request finished second. So in invoice_item table amount will be 70k but in tax_items table tax value will be for 60K. So we need a straight forward way to calculate tax amount, If one request starts to save the invoice_item next process should wait until the current request is finished, tax should be calculated in FIFO method.

We are going to use redis, and create a class RedisUn with four arguments lock_name, expires_in, wait_time, &block

RedisUniqueProcess will accept block, when block is called by multiple processes one by one it will get executed. How much time other process should wait can be given wait_time argument. For example we use counter cache to save invoice or purchase orders count based on users and count will be based on users permissions. When doing counter cache multiple processes try to access lock only one needs to be executed others can be skipped at that time we have to give wait_time as zero, If wait_time is nil process will wait indefinitely until the lock automatically expires.

RedisUniqueProcess.wait_until_execution("update_item_#{id}_lock") do
  calculate_new_tax_items
end123

	# frozen_string_literal: true

	class RedisUniqueProcess

	class AxbWaitingError < StandardError
	end

	# lock_name: The name of the lock key in the cache.
	# expires_in: The expiration time for the lock key in seconds, automatically release the lock on expiration.
	# wait_time: The maximum time to wait for the lock key to become available. if wait time is nil it will wait indefinitely
	# &block: The block of code to be executed when the lock key is available.
	def self.wait_until_execution(lock_name, expires_in: 30.seconds, wait_time: nil, &block)
	lock_name = "axb_lock_#{lock_name}"
	start_time = Time.now

	begin
	while Rails.cache.redis.with { \|r\| r.get(lock_name) }.present?
	if wait_time.present? && (Time.now - start_time) > wait_time
	raise AxbWaitingError, "Timeout waiting for lock"
	end
	puts "waiting lock #{lock_name}"
	sleep 1
	end

	lock_script = <<-lua
	local key = KEYS[1]
	local value = ARGV[1]
	local expiration = ARGV[2]

	if redis.call('SETNX', key, value) == 1 then
	redis.call('EXPIRE', key, expiration)
	return 1
	else
	return 0
	end
	lua

	# Use Redis transaction to ensure atomicity
	lock_acquired = Rails.cache.redis.with do \|r\|
	r.eval(lock_script, keys: [lock_name], argv: ['locked', expires_in.to_i])
	end

	puts lock_acquired

	if lock_acquired.positive?
	begin
	value = block.call
	ensure
	# Ensure the lock is released
	Rails.cache.redis.with { \|r\| r.del(lock_name) }
	end
	value
	else
	raise AxbWaitingError, "Failed to acquire lock"
	end
	rescue AxbWaitingError => e
	nil
	end
	end

	end

view raw redis_unique_process.rb hosted with ❤ by GitHub

We tried many gems, things which were very complex and most of them never worked when scaling. Above code is so far working good.

Thanks for reading, If you like this share this post.