Rails Active Job

Introduction to Active Job and Its Purpose

Rails Active Job is a framework introduced in Rails 4.2 that provides a unified interface for queuing and executing background tasks. It offers an elegant solution by offloading time-consuming tasks to the background, ensuring that your application remains responsive and light.

It provides a powerful abstraction layer, allowing you to write your background tasks once and seamlessly switch between different queuing backends. Whether you choose Sidekiq, Resque, Delayed Job, or any other supported adapter, Active Job provides a consistent interface that remains the same for every adapter configuration.

Purpose

The primary purpose of Active Job is to simplify the process of implementing background processing in Rails applications. Here are some real-world examples:

1. Email Notifications:
   Web applications frequently have to send user notifications via email. The email-sending operation can be offloaded to the background by using Active Job. By doing this, it is made sure that the user won't encounter any delays when carrying out tasks like password reset, account registration, etc., that result in email alerts.
2. Image Processing:
   Resizing, cropping, and adding filters to user-uploaded photographs can be resource-intensive operations. Enqueueing image processing jobs with Active Job enables the application to continue fulfilling user requests without getting stuck by the intensive image processes.
3. Data Import/Export:
   Large datasets from different sources can take a long time to import or export. You can manage data import and export tasks asynchronously by utilizing Active Job. Instead of being forced to wait for the full process to finish, users can use the application as usual while the information is being processed.
4. Batch Processing:
   For activities requiring the systematic processing of lots of items in a batch, Active Job can be used. You can enqueue jobs, for example, to process a queue of video files, create thumbnails, etc. in the background. Due to this, your application can handle massive processing without degrading the real-time user experience.

Setting Up Active Job with Adapters

Before we dive into creating jobs, let's set up rails active jobs with a popular adapter like Sidekiq or Resque. These adapters provide powerful queuing mechanisms and are widely used in Rails applications.

• Sidekiq:

  • Popular background processing framework for Ruby.
  • Works seamlessly with Rails and Active Job.
  • Utilizes Redis server for job queuing.
  • Provides robust, efficient, and scalable job processing.
  • Supports advanced features like job retries, scheduling, and prioritization.

• Resque:

  • Widely used background processing library for Ruby.
  • Operates on a similar principle as Sidekiq.
  • Uses Redis for job queuing.
  • Known for its simplicity and flexibility.
  • Provides a straightforward way to enqueue and process jobs.
  • Popular choice for background processing in Rails applications.

Creating and Enqueuing Jobs

Now that we have Rails Active Job set up with our chosen adapter, let's explore the process of creating and enqueuing jobs.

To create a job, you can run the following generator command:

This will generate a my_job.rb file in the app/jobs directory. Open the generated file and you'll see a basic job class template. You can add your custom logic within the perform method of this class. For example:

Once you've defined your job, you can enqueue it by calling the perform_later method from any part of your application. For instance:

The perform_later method adds the job to the queue and ensures it will be processed by the job backend. The arguments you pass to the method will be available within the perform method of your job class.

Additionally, Active Job provides an optional set parameter that allows you to add additional wait time and specify other parameters for your jobs. For example, you can set a delay for job execution by passing the wait parameter:

Delivering Action Mailer Emails Using ActiveJob

Rails Active Job integrates seamlessly with Action Mailer, allowing you to deliver emails asynchronously using background jobs. By utilizing Active Job's deliver_later method, you can enqueue email deliveries to be processed in the background. This approach improves the responsiveness of your application when sending emails, especially when dealing with large email lists or attachments.

To deliver an email using Active Job:

1. Create a mailer class if you haven't already. You can generate a mailer using the Rails generator:
   This will create a user_mailer.rb file in the app/mailers directory.
2. Inside your mailer class, define a method for the email you want to send. For example:

3. In your controller or any other relevant part of your application, replace the synchronous deliver_now method with the deliver_later method when calling the mailer:
   This enqueues the email delivery as a background job.
4. The job will be processed by the Active Job adapter you've configured, such as Sidekiq or Resque. Ensure that the appropriate job processing worker process is running alongside your Rails application.
   • If you're using Sidekiq, start the Sidekiq process:

   • If you're using Resque, start the Resque worker process:

   • If you're using Delayed Job, ensure that the Delayed Job worker process is running.

By utilizing Active Job's deliver_later method, your application can offload email delivery to the background, improving performance and user experience.

Retrying or Discarding Failed Jobs

Rails Active Job provides mechanisms for handling failed jobs. When a job encounters an error during processing, it can be retried or discarded based on your configured settings.

To customize the retry behavior, you can override the retry_on and discard_on methods in your job class.

Here's an example of how to customize the retry behavior for a job:

In the example above, CustomRetryableError is a custom error class that signals a retryable error condition. The job will be retried three times, with a 5-second wait between each retry. If the job encounters a CustomDiscardableError, it will be discarded and not retried.

You can specify multiple errors in the retry_on and discard_on methods to define different retry or discard behaviors for each error type.

By customizing the retry and discard behavior, you can control how Active Job handles failures and ensure robust error handling in your background job processing.