Scaling Your Rails App with Resque: A Practical Approach
Published: 2023-02-25 10:57:18

Resque is a powerful and popular Redis-backed library for creating background jobs, placing those jobs on multiple queues, and processing them later. It is widely used in Ruby on Rails applications to perform tasks asynchronously and offload heavy processing to the background. In this article, we will explore how to use Resque in Ruby on Rails, from installation and setup to creating jobs and processing them.

## Installation and Setup
To use Resque in your Ruby on Rails application, you first need to install the gem. You can do this by adding the following line to your Gemfile:

```
gem 'resque'
```
Then, run bundle install to install the gem and its dependencies. Once the gem is installed, you need to configure Resque to use Redis as its backend. You can do this by creating an initializer file `config/initializers/resque.rb` and adding the following lines:
```
Resque.redis = Redis.new(url: ENV['REDIS_URL'])
```
Make sure to replace `ENV['REDIS_URL']` with the URL of your Redis server. You can also customize the Redis connection settings by passing additional options to the Redis.new method.

## Creating Jobs
Once you have set up Resque, you can start creating background jobs. A job is simply a Ruby class that defines a perform method. For example, let's create a job that sends an email:
```
class SendEmailJob
  @queue = :email

  def self.perform(to, subject, body)
    # send email here
  end
end
```
In this example, we define a class `SendEmailJob` that includes a perform method, which takes three arguments: to, subject, and body. We also set the `@queue` instance variable to :email, which indicates that this job should be placed on the email queue.

To enqueue this job, you can call the `Resque.enqueue` method and pass in the job class and its arguments:

```
Resque.enqueue(SendEmailJob, 'user@example.com', 'Hello', 'World')
```

This will add the job to the email queue, which can be processed later.

## Processing Jobs
To process jobs in the background, you need to run a Resque worker. A worker is a process that listens to one or more queues and processes jobs as they are enqueued. You can start a worker by running the following command:

```
$ QUEUE=* rake resque:workers
```

This will start a worker that listens to all queues (*). You can also specify specific queues by separating them with commas:

```
$ QUEUE=email,logs rake resque:workers
```

Once the worker is running, it will process jobs from the specified queues as they are enqueued. If a job fails, Resque will automatically retry it a certain number of times (by default, 5 times) before giving up and moving it to the failed queue.

## Monitoring and Administration
Resque provides a web interface that allows you to monitor the status of your queues, view processed and failed jobs, and perform administrative tasks. To enable the web interface, you need to add the following line to your `config/routes.rb` file:

```
mount Resque::Server.new, at: '/resque'
```

This will mount the Resque web interface at /resque. You can then access the interface by visiting `http://localhost:3000/resque` in your web browser (assuming your Rails application is running on port 3000).
In the Resque web interface, you can view the status of your queues, search for specific jobs.