Que VS Sucker Punch

> Can you define "low throughput"?

<1000 messages per minute

Not saying SKIP LOCKED can't work with that many. But you'll probably want to do something better.

FWIW, Que uses advisory locks [1]

[1] https://github.com/que-rb/que

Probably worth mentioning that aside from delayed_job there are at least two more modern alternatives backed by the DB: Que and good_job.

Good article. Sidekiq is a good, well respected too. However if you are starting out I would recommend not using it, and instead choosing a DB based queue system. We have great success with que, but there are others like good_job.

(not sure why this comment was dead, I vouched for it)

There are a lot of ways to implement a queue in an RDBMS and a lot of those ways are naive to locking behavior. That said, with PostgreSQL specifically, there are some techniques that result in an efficient queue without locking problems. The article doesn't really talk about their implementation so we can't know what they did, but one open source example is Que[1]. Que uses a combination of advisory locking rather than row-level locks and notification channels to great effect, as you can read in the README.

[1]: https://github.com/que-rb/que

https://github.com/que-rb/que

This one seems to be the most performant. By a lot too, from my understanding (haven't ran any benchmark myself, but the readme shows some good postgres knowledge)

Que seems like a good alternative if one doesn't want to use Reids. However, given that most apps need Redis (and have it within their infrastructure) nowadays, I still think that Sidekiq is the better option in the generic case.

Implementations that use advisory locks like https://github.com/que-rb/que are much more efficient (atleast when I last tested) and will easily reach 10k job/s on even very modest hardware.

There is a Go port of Que but you can also easily port it to any language you like. I have a currently non-OSS implementation in Rust that I might OSS someday when I have time to clean it up.

It’s also possible to use advisory locks to implement a job queue in Postgres. See e.g. Que[1]. Note there are a fair number of corner cases, so studying Que is wise if trying to implement something like this, as well as some (a bit older) elaboration[2].

We implemented a similar design to Que for a specific use case in our application that has a known low volume of jobs and for a variety of reasons benefits from this design over other solutions.

[1]: https://github.com/que-rb/que

Do also take into consideration que-scheduler (disclaimer, am author). It is built on top of the robust que async job system.

I would suggest you use something like sucker punch to do this https://github.com/brandonhilkert/sucker_punch

Ever since writing this post last year on Using New Relic APM with Rails on AWS Lambda, I have always wanted to find a way to send APM data in a way that did not add extra milliseconds to the application's response times. Likewise, for smaller projects it would be nice to have a lightweight alternative to Lambdakiq for ActiveJob similar to Brandon Hilkert's popular SuckerPunch gem. Today we have both with the LambdaPunch gem.