Scheduled jobs in Ruby on Rails - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a basic Active Job class in Rails.

Ruby on Rails

class MyJob < ApplicationJob
  queue_as :default

  def [1]
    puts "Job is running"
  end
end

Drag options to blanks, or click blank then click option'

Aperform

Brun

Cexecute

Dstart

Attempts:

3 left

💡 Hint

Common Mistakes

Using method names like 'run' or 'execute' which Rails does not recognize automatically.

The perform method is the standard method that Rails calls when running a job.

2fill in blank

medium

Complete the code to enqueue a job to run asynchronously.

Ruby on Rails

MyJob.[1]

Drag options to blanks, or click blank then click option'

Arun_later

Benqueue_now

Cperform_later

Dstart_async

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-existent methods like 'run_later' or 'start_async'.

The perform_later method enqueues the job to run asynchronously in Rails.

3fill in blank

hard

Fix the error in scheduling a job to run 5 minutes from now.

Ruby on Rails

MyJob.[1](wait: 5.minutes)

Drag options to blanks, or click blank then click option'

Aperform_later

Bperform_now

Cperform_in

Dperform_at

Attempts:

3 left

💡 Hint

Common Mistakes

Using perform_now which runs the job immediately without delay.

To schedule a job with a delay, use perform_later with the wait option.

4fill in blank

hard

Fill both blanks to create a scheduled job that runs at a specific time.

Ruby on Rails

MyJob.[1](wait_until: [2])

Drag options to blanks, or click blank then click option'

Aperform_later

Bperform_now

CTime.current + 1.hour

DTime.now

Attempts:

3 left

💡 Hint

Common Mistakes

Using perform_now which does not support scheduling.

Using Time.now which is less preferred than Time.current in Rails.

Use perform_later with wait_until set to a future time like Time.current + 1.hour to schedule the job.

5fill in blank

hard

Fill all three blanks to define a job class with a custom queue and perform method.

Ruby on Rails

class CustomJob < ApplicationJob
  queue_as [1]

  def [2]
    puts [3]
  end
end

Drag options to blanks, or click blank then click option'

A:mailers

Bperform

C"Running CustomJob"

D:default

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect queue names or method names.

Forgetting to quote the string to print.

The queue_as sets the queue name, perform is the method Rails calls, and the string is printed inside the method.

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