Job retries and failure in Laravel - Performance & Optimization

Performance: Job retries and failure

MEDIUM IMPACT

This affects backend job processing speed and resource usage, indirectly impacting frontend responsiveness and user experience.

Handling failed jobs with automatic retries

Laravel

public function handle() {
  try {
    // job logic
  } catch (\Exception $e) {
    $this->release(30); // retry after 30 seconds delay
  }
}

Delaying retries spaces out job attempts, reducing CPU spikes and queue congestion.

📈 Performance GainReduces CPU spikes and queue pressure by spacing retries, improving overall throughput.

Handling failed jobs with automatic retries

Laravel

public function handle() {
  try {
    // job logic
  } catch (\Exception $e) {
    $this->release(0); // immediate retry without delay
  }
}

Immediate retries cause rapid repeated job executions, increasing CPU load and database contention.

📉 Performance CostTriggers multiple rapid re-executions causing high CPU usage and potential queue congestion.

Performance Comparison

Pattern	CPU Usage	Queue Pressure	Retry Delay	Verdict
Immediate retry on failure	High (CPU spikes)	High (queue congestion)	None	[X] Bad
Delayed retry with backoff	Moderate (smoothed spikes)	Moderate (spaced queue)	Yes (e.g., 30s)	[OK] Good
No failure handling	Wasted CPU on doomed jobs	High (retries continue)	N/A	[X] Bad
Failure logging and alerting	Efficient CPU use	Low (stops retries)	N/A	[OK] Good

Rendering Pipeline

Job retries and failures affect backend processing queues and resource allocation, which indirectly influence frontend responsiveness by controlling how fast backend tasks complete and respond.

→Backend Job Queue Processing

→Database Access

→Network I/O

⚠️ BottleneckBackend queue congestion and CPU spikes caused by immediate or excessive retries

Core Web Vital Affected

INP

This affects backend job processing speed and resource usage, indirectly impacting frontend responsiveness and user experience.

Optimization Tips

1Avoid immediate retries; use delayed retries to reduce CPU spikes.

2Limit max retry attempts to prevent infinite retry loops.

3Log and alert on job failures to stop wasted retries and improve reliability.

Performance Quiz - 3 Questions

What is the main performance problem with retrying a failed job immediately without delay?

A It causes CPU spikes and queue congestion

B It reduces database connections

C It improves job throughput

D It decreases memory usage

DevTools: Laravel Horizon Dashboard

How to check: Open Horizon, monitor job retry counts and failure rates, check job processing times and queue lengths.

What to look for: Look for spikes in retries, long queue wait times, and frequent job failures indicating performance issues.

Practice

1. In Laravel, what does setting the $tries property in a job class control?

easy

A. The number of times the job will be retried if it fails

B. The maximum execution time of the job

C. The priority of the job in the queue

D. The database connection used by the job

Solution

1. Step 1: Understand the role of $tries in Laravel jobs

   The $tries property defines how many times Laravel will attempt to run the job if it fails.

2. Step 2: Differentiate from other job properties

   It does not control execution time, priority, or database connection, only retry attempts.

3. Final Answer:

   The number of times the job will be retried if it fails -> Option A

4. Quick Check:

   $tries controls retry attempts [OK]

Hint: Remember: $tries means retry count for failed jobs [OK]

Common Mistakes:

• Confusing $tries with job timeout
• Thinking $tries sets job priority
• Assuming $tries controls database connection

2. Which of the following is the correct way to define a job retry limit of 5 attempts in a Laravel job class?

easy

A. public $tries = 5;

B. protected $retry = 5;

C. public $retryAttempts = 5;

D. protected $triesCount = 5;

Solution

1. Step 1: Recall the correct property name for retry attempts

   Laravel uses $tries as a public property to set retry limits.

2. Step 2: Check syntax and visibility

   The property should be public and named exactly $tries to work properly.

3. Final Answer:

   public $tries = 5; -> Option A

4. Quick Check:

   Correct property is public $tries [OK]

Hint: Use public $tries = number; to set retries [OK]

Common Mistakes:

• Using protected instead of public
• Using wrong property names like $retry or $triesCount
• Confusing retry limit with timeout

3. Given this Laravel job class snippet:

class SendEmailJob implements ShouldQueue {
    public $tries = 3;
    public function handle() {
        // code that may fail
        throw new \Exception('Failed');
    }
    public function failed() {
        // handle failure
        Log::info('Job failed permanently');
    }
}

How many times will Laravel attempt to run this job before calling failed()?

medium

A. 1 time

B. 3 times

C. 4 times

D. It will retry indefinitely

Solution

1. Step 1: Understand how $tries works

   The $tries property sets the maximum number of times the job will be attempted, including the initial attempt.

2. Step 2: Calculate total attempts

   With $tries = 3, Laravel attempts the job 3 times total before calling failed().

3. Final Answer:

   3 times -> Option B

4. Quick Check:

   Total attempts = $tries = 3 [OK]

Hint: Total attempts = $tries [OK]

Common Mistakes:

• Thinking total attempts = 1 + $tries
• Assuming retries are unlimited
• Confusing failed() call timing

4. Examine this Laravel job code:

class ProcessOrder implements ShouldQueue {
    public $tries = 2;
    public function handle() {
        // some code
        throw new \Exception('Error');
    }
    public function failed() {
        // log failure
        Log::error('Order processing failed');
    }
}

Why might the failed() method never be called after job failures?

medium

A. Because the $tries property is set to 2, so it retries infinitely

B. Because the job is not implementing the ShouldQueue interface

C. Because the job is failing but failed() is not triggered until retries are exhausted

D. Because the failed() method must accept an Exception parameter

Solution

1. Step 1: Check method signature for failed()

   Laravel expects failed() to accept an Exception parameter to receive failure details.

2. Step 2: Understand impact of missing parameter

   If failed() lacks the Exception parameter, Laravel may not call it properly after retries.

3. Final Answer:

   The failed() method must accept an Exception parameter -> Option D

4. Quick Check:

   failed(Exception $exception) required [OK]

Hint: Add Exception parameter to failed() method [OK]

Common Mistakes:

• Assuming $tries = 2 means infinite retries
• Forgetting to implement ShouldQueue interface
• Ignoring method signature requirements

5. You want a Laravel job to retry 3 times on failure, but after the last failure, you want to notify the user by email. Which is the best way to implement this behavior?

hard

A. Set public $tries = 3; and use a separate job to send the email without failed()

B. Set public $tries = 3; and send the email inside the handle() method after catching exceptions

C. Set public $tries = 3; and define a failed(Exception $exception) method to send the email notification

D. Set public $maxAttempts = 3; and send the email in the constructor

Solution

1. Step 1: Use $tries to limit retry attempts

   Setting public $tries = 3; ensures the job retries 3 times on failure.

2. Step 2: Use failed(Exception $exception) to handle final failure

   Defining failed() with the Exception parameter allows sending email after all retries fail.

3. Final Answer:

   Set public $tries = 3; and define a failed(Exception $exception) method to send the email notification -> Option C

4. Quick Check:

   Retries + failed() method for final failure handling [OK]

Hint: Use $tries and failed(Exception $exception) for retries and notification [OK]

Common Mistakes:

• Trying to send email inside handle() ignoring retries
• Using wrong property name like $maxAttempts
• Not using failed() method for final failure