Scheduled jobs in Ruby on Rails - Mini Project: Build & Apply

Scheduled Jobs with Rails

📖 Scenario: You are building a simple Rails app that sends daily reminder emails to users. To do this, you need to set up a scheduled job that runs every day and triggers the email sending process.

🎯 Goal: Learn how to create a scheduled job in Rails using Active Job and a scheduler gem. You will set up the job, configure the schedule, and complete the job logic.

📋 What You'll Learn

Create a job class called DailyReminderJob

Set a schedule variable for the job to run daily at 9 AM

Implement the job's perform method to call User.send_daily_reminders

Configure the scheduler to run the job at the specified time

💡 Why This Matters

🌍 Real World

Scheduled jobs are used in real apps to automate tasks like sending emails, cleaning databases, or generating reports without manual intervention.

💼 Career

Understanding scheduled jobs is essential for backend developers and DevOps roles to maintain reliable and automated workflows.

1

Create the job class

Create a job class called DailyReminderJob that inherits from ApplicationJob.

Ruby on Rails

# Create the DailyReminderJob class inheriting from ApplicationJob
# Your code here

Hint

Use class DailyReminderJob < ApplicationJob and set queue_as :default.

2

Set the schedule time

Add a variable called SCHEDULE_TIME in DailyReminderJob and set it to '9:00' to represent 9 AM daily.

Ruby on Rails

class DailyReminderJob < ApplicationJob
  queue_as :default

  # Set the schedule time to 9:00 AM
  # Your code here
end

Hint

Define SCHEDULE_TIME = '9:00' inside the class.

3

Implement the perform method

Inside DailyReminderJob, add a perform method that calls User.send_daily_reminders.

Ruby on Rails

class DailyReminderJob < ApplicationJob
  queue_as :default

  SCHEDULE_TIME = '9:00'

  # Define perform method to call User.send_daily_reminders
  # Your code here
end

Hint

Define def perform and inside call User.send_daily_reminders.

4

Configure the scheduler

In your scheduler configuration file (e.g., config/schedule.rb), add a job to run DailyReminderJob.perform_later every day at DailyReminderJob::SCHEDULE_TIME.

Ruby on Rails

class DailyReminderJob < ApplicationJob
  queue_as :default

  SCHEDULE_TIME = '9:00'

  def perform
    User.send_daily_reminders
  end
end

# Add scheduler config below
# Your code here

Hint

Use every 1.day, at: DailyReminderJob::SCHEDULE_TIME do and inside call runner "DailyReminderJob.perform_later".

Practice

1. What is the main purpose of scheduled jobs in a Rails application?

easy

A. To manage database migrations automatically

B. To handle user authentication and sessions

C. To automate tasks to run at specific times without manual effort

D. To style the user interface dynamically

Solution

1. Step 1: Understand the role of scheduled jobs

   Scheduled jobs are designed to run tasks automatically at set times without needing a user to start them manually.

2. Step 2: Compare with other options

   User authentication, database migrations, and UI styling are handled by other parts of Rails, not scheduled jobs.

3. Final Answer:

   To automate tasks to run at specific times without manual effort -> Option C

4. Quick Check:

   Scheduled jobs automate tasks = C [OK]

Hint: Scheduled jobs run tasks automatically on a schedule [OK]

Common Mistakes:

• Confusing scheduled jobs with user authentication
• Thinking scheduled jobs handle database migrations
• Assuming scheduled jobs style the UI

2. Which of the following is the correct way to define a job class in Rails?

easy

A. def MyJob
# task code
end

B. class MyJob
def perform
# task code
end
end

C. module MyJob
def perform
# task code
end
end

D. class MyJob < ApplicationJob
def perform
# task code
end
end

Solution

1. Step 1: Check the inheritance pattern for jobs

   In Rails, jobs must inherit from ApplicationJob to integrate with Active Job framework.

2. Step 2: Verify the method definition

   The perform method defines the task to run. class MyJob < ApplicationJob def perform # task code end end correctly defines a class inheriting ApplicationJob with perform method.

3. Final Answer:

   class MyJob < ApplicationJob\n def perform\n # task code\n end\nend -> Option D

4. Quick Check:

   Job class inherits ApplicationJob = A [OK]

Hint: Jobs inherit ApplicationJob and define perform method [OK]

Common Mistakes:

• Defining job without inheriting ApplicationJob
• Using module instead of class for jobs
• Defining job as a method instead of a class

3. Given the following job class, what will be the output when MyJob.perform_now is called?

class MyJob < ApplicationJob
  def perform
    puts 'Job executed'
  end
end

medium

A. Job executed

B. No output, job runs silently

C. Error: perform method missing

D. Job executed asynchronously

Solution

1. Step 1: Understand perform_now behavior

   Calling perform_now runs the job immediately and synchronously, executing the perform method.

2. Step 2: Check the perform method output

   The perform method prints 'Job executed' to the console, so this string will appear as output.

3. Final Answer:

   Job executed -> Option A

4. Quick Check:

   perform_now runs perform immediately = B [OK]

Hint: perform_now runs job immediately and prints output [OK]

Common Mistakes:

• Thinking perform_now runs job silently
• Confusing perform_now with asynchronous perform_later
• Expecting an error due to missing method

4. Identify the error in this job scheduling code snippet:

class CleanupJob < ApplicationJob
  def perform
    User.delete_all
  end
end

# Schedule in config/schedule.rb
every 1.day do
  runner 'CleanupJob.perform_later'
end

medium

A. No error, code is correct

B. perform_later should be perform_now in schedule

C. Using runner instead of calling rake task

D. runner expects a method call, not a class method

Solution

1. Step 1: Examine the job class definition

   The class correctly inherits from ApplicationJob and defines the perform method.

2. Step 2: Verify scheduling syntax

   The config/schedule.rb uses standard Whenever syntax: every 1.day with runner 'CleanupJob.perform_later', which executes Ruby code to enqueue the job asynchronously. No errors present.

3. Final Answer:

   No error, code is correct -> Option A

4. Quick Check:

   runner 'Job.perform_later' in schedule.rb = D [OK]

Hint: runner 'Job.perform_later' correctly enqueues job [OK]

Common Mistakes:

• Thinking runner expects only instance methods
• Confusing runner with rake tasks
• Believing perform_later is invalid in cron schedules

5. You want to schedule a job that runs every day at midnight to archive old records. Which of these is the best way to set this up using the whenever gem?

class ArchiveJob < ApplicationJob
  def perform
    Record.archive_old
  end
end

# config/schedule.rb
?

Which snippet correctly schedules the job?

hard

A. every 1.day, at: '12:00 pm' do
runner 'ArchiveJob.perform_later'
end

B. every :day, at: '00:00' do
runner 'ArchiveJob.perform_later'
end

C. every 24.hours do
rake 'archive:old_records'
end

D. every :midnight do
runner 'ArchiveJob.perform_now'
end

Solution

1. Step 1: Check whenever syntax for daily jobs at midnight

   The whenever gem uses symbols like :day and time strings like '00:00' to schedule jobs at midnight.

2. Step 2: Verify the job call method

   Using perform_later runs the job asynchronously, which is preferred for scheduled jobs to avoid blocking.

3. Step 3: Compare options

   every :day, at: '00:00' do runner 'ArchiveJob.perform_later' end uses correct symbol :day, time '00:00', and perform_later with runner, matching best practice.

4. Final Answer:

   every :day, at: '00:00' do\n runner 'ArchiveJob.perform_later'\nend -> Option B

5. Quick Check:

   whenever daily at midnight with perform_later = D [OK]

Hint: Use :day and '00:00' with perform_later in whenever [OK]

Common Mistakes:

• Using perform_now instead of perform_later for scheduled jobs
• Incorrect time format like '12:00 am' instead of '00:00'
• Using rake task instead of runner for Active Job