Scheduled jobs in Ruby on Rails - Performance & Optimization

Performance: Scheduled jobs

MEDIUM IMPACT

Scheduled jobs affect background processing speed and server resource usage, indirectly impacting user experience by offloading work from request cycles.

Running periodic data cleanup without blocking user requests

Ruby on Rails

class CleanupJob < ApplicationJob
  queue_as :default

  def perform(batch_size: 100)
    User.find_in_batches(batch_size: batch_size) do |users|
      users.each { |user| user.posts.destroy_all }
    end
  end
end

# Scheduled with cron and uses batch processing with Sidekiq concurrency

Processes users in small batches asynchronously, reducing memory spikes and freeing workers quickly.

📈 Performance GainReduces blocking time by 80%, improves worker availability, and lowers request latency

Running periodic data cleanup without blocking user requests

Ruby on Rails

class CleanupJob < ApplicationJob
  queue_as :default

  def perform
    User.all.each do |user|
      user.posts.destroy_all
    end
  end
end

# Scheduled with cron to run every hour synchronously

This job loads all users and deletes posts in a single run, causing high memory use and long execution blocking resources.

📉 Performance CostBlocks worker threads for minutes, increasing request latency and risking timeouts

Performance Comparison

Pattern	Server Load	Blocking Time	Resource Usage	Verdict
Synchronous large batch job	High	Long blocking	High memory spikes	[X] Bad
Asynchronous batched job	Moderate	Short blocking	Controlled memory use	[OK] Good

Rendering Pipeline

Scheduled jobs run outside the browser rendering pipeline but affect server response times and resource availability, which influence interaction responsiveness (INP).

→Server Processing

→Request Handling

⚠️ BottleneckLong-running jobs block worker threads, delaying request processing.

Core Web Vital Affected

INP

Scheduled jobs affect background processing speed and server resource usage, indirectly impacting user experience by offloading work from request cycles.

Optimization Tips

1Avoid running large scheduled jobs synchronously to prevent blocking server threads.

2Use batching and asynchronous queues to reduce memory spikes and improve concurrency.

3Monitor job duration and queue latency to keep background processing efficient.

Performance Quiz - 3 Questions

What is a main performance risk of running large scheduled jobs synchronously in Rails?

A They increase CSS rendering time in the browser

B They block worker threads causing slower user request handling

C They cause layout shifts on the page

D They reduce JavaScript bundle size

DevTools: Rails logs and Sidekiq Web UI

How to check: Monitor job execution times and queue latency in Sidekiq Web UI; check Rails logs for request delays during job runs.

What to look for: Look for long job durations and increased request response times indicating blocking.

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