Task retry and error handling in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a Celery task raises an exception without retry?

Consider a Django project using Celery for background tasks. If a task raises an exception and does not explicitly retry, what will be the outcome?

Django

from celery import shared_task

@shared_task
def send_email(user_id):
    user = User.objects.get(id=user_id)
    if not user.email:
        raise ValueError('No email found')
    # send email logic here
    return 'Email sent'

A The task will automatically retry 3 times before failing.

B The task will fail and be marked as failed in Celery without retrying.

C The task will silently ignore the exception and mark as successful.

D The task will be retried indefinitely until it succeeds.

💡 Hint

Think about default Celery behavior when no retry is specified.

By default, if a Celery task raises an exception and no retry logic is implemented, the task fails immediately and is marked as failed. Celery does not retry automatically unless configured.

📝 Syntax

intermediate

Which option correctly retries a Celery task on failure with exponential backoff?

You want a Celery task to retry up to 3 times with exponential backoff starting at 10 seconds. Which code snippet correctly implements this?

Django

from celery import shared_task
from celery.exceptions import MaxRetriesExceededError

@shared_task(bind=True)
def fetch_data(self):
    try:
        # code that might fail
        pass
    except Exception as exc:
        # retry logic here
        pass

A self.retry(exc=exc, countdown=3, max_retries=10)

B self.retry(exc=exc, countdown=10 * self.request.retries, max_retries=3)

C self.retry(exc=exc, countdown=10 ** self.request.retries, max_retries=3)

D self.retry(exc=exc, countdown=10, max_retries=3)

💡 Hint

Exponential backoff means the wait time grows exponentially with retries.

Using countdown=10 ** self.request.retries causes the delay to grow exponentially (10, 100, 1000 seconds). The max_retries limits retries to 3.

🔧 Debug

advanced

Why does this Celery task retry not work as expected?

This task is supposed to retry on failure but never retries. What is the cause?

Django

from celery import shared_task

@shared_task(bind=True)
def process_order(self, order_id):
    try:
        order = Order.objects.get(id=order_id)
        # process order
    except Order.DoesNotExist as e:
        self.retry(exc=e, countdown=5, max_retries=2)
        raise

A The task is missing the bind=True decorator, so self.retry is undefined.

B The max_retries parameter is invalid and causes retry to be ignored.

C The countdown value must be a string, not an integer.

D The retry is called inside except but the exception is not re-raised or returned, so task ends successfully.

💡 Hint

Check what happens after calling self.retry inside except block.

Calling self.retry() raises a special exception to retry the task. If the exception is caught or the function returns normally, retry does not happen. Here, the retry call is not followed by a raise or return, so the task ends without retry.

❓ state_output

advanced

What is the state of a Celery task after max retries are exceeded?

A Celery task is configured to retry 2 times on failure. After the third failure, what is the task state in the backend?

Django

from celery import shared_task

@shared_task(bind=True, max_retries=2)
def unreliable_task(self):
    raise RuntimeError('Fail')

A The task state is 'FAILURE' and the exception info is stored.

B The task state is 'RETRY' indefinitely.

C The task state is 'SUCCESS' despite failures.

D The task state is 'PENDING' waiting for manual retry.

💡 Hint

What happens when retries are exhausted in Celery?

When max retries are exceeded, Celery marks the task as FAILURE and stores the exception details. It does not retry further.

🧠 Conceptual

expert

How to implement custom error handling and retry logic in Django with Celery?

You want to retry a Celery task only for network-related errors but fail immediately for others. Which approach correctly implements this selective retry?

Django

from celery import shared_task
import requests

@shared_task(bind=True, max_retries=5)
def fetch_api(self, url):
    try:
        response = requests.get(url)
        response.raise_for_status()
        return response.json()
    except Exception as exc:
        # retry only for network errors
        pass

A Check if exc is requests.exceptions.RequestException, then call self.retry(exc=exc), else raise exc.

B Always call self.retry(exc=exc) regardless of exception type.

C Use a try-except with a generic except and ignore all exceptions silently.

D Catch only requests.exceptions.HTTPError and retry, raise others.

💡 Hint

Selective retry means retry only for specific exception types.

To retry selectively, check the exception type. Retry only for network-related exceptions like requests.exceptions.RequestException. For others, raise immediately to fail the task.