Sidekiq queue for specify object - ruby-on-rails-4

Question

I use this worker for process
class CreateOrUpdateContactWorker
include Sidekiq::Worker
sidekiq_options retry: 2, queue: 'contact_updater', concurrency: 1
sidekiq_retries_exhausted do |msg|
Airbrake.notify(error_message: "Contact update failed", session: { msg: msg })
end
def perform(user_id, changed_fields, update_address = false)
ContactUpdater.create_or_update_contact(user_id, changed_fields, update_address: update_address)
end
end
In the user model I have after_commit callback
def update_mautic_contact
CreateOrUpdateContactWorker.perform_async(id, previous_changes.keys, ship_address_changed || false)
end
The problem is when user updated twice at the same time, because to create_or_update_contact need some time. How can I limit threads only for specify user? That each task will be executed one by one for specify user_id.

Answer 1

I don't know if you have redis as part of your infrastructure but what you are describing is a race condition. To solve it you need mutex/locks to your critical path create_or_update_contact.
The race condition here is happening between two async workers/processes so you can't just use simple ruby mutex/lock. You need a distributed mutex that uses a central lock storage/keeper. This: https://github.com/kenn/redis-mutex should do it for you but you will need redis database.
Basically your code will something like:
class CreateOrUpdateContactWorker
include Sidekiq::Worker
sidekiq_options retry: 2, queue: 'contact_updater', concurrency: 1
sidekiq_retries_exhausted do |msg|
Airbrake.notify(error_message: "Contact update failed", session: { msg: msg })
end
def perform(user_id, changed_fields, update_address = false)
RedisMutex.with_lock("#{user_id}_create_or_update_contact") do
ContactUpdater.create_or_update_contact(user_id, changed_fields, update_address: update_address)
end
end
end
So if you have 2 user updates for user_id=1 at the same time the first to acquire the lock/mutex called 1_create_or_update_contact will execute first and will block the other call till it finishes and then the second call will start.
This will fix your problem :) I think redis is needed, useful and handful. I hardly can think of any of my rails projects without having to use redis.

Answer 2

I realised it with Redis, but without any gems. I used condition before execute worker:
def update_mautic_contact
if Rails.current.get("CreateOrUpdateContactWorkerIsRunning_#{id}")
Redis.current.set("CreateOrUpdateContactWorkerIsRunning_#{id}", true)
CreateOrUpdateContactWorker.perform_in(1.minutes, id, changed_fields)
else
Redis.current.set("CreateOrUpdateContactWorkerIsRunning_#{id}", true)
CreateOrUpdateContactWorker.perform_async(id, changed_fields)
end
end
and inside worker:
class CreateOrUpdateContactWorker
include Sidekiq::Worker
sidekiq_options retry: 2, queue: 'contact_updater', concurrency: 1
sidekiq_retries_exhausted do |msg|
Airbrake.notify(error_message: "Contact update failed", session: { msg: msg })
end
def perform(user_id, changed_fields, update_address = false)
ContactUpdater.create_or_update_contact(user_id, changed_fields, update_address: update_address)
Redis.current.del("CreateOrUpdateContactWorkerIsRunning_#{user_id}")
end
end