How to Fix System.Threading.Tasks.TaskCanceledException exception

Question

I am deploying a Django application on Azure using App Service. While it works fine locally, I face an issue of System.Threading.Tasks.TaskCanceledException exception when I deploy it to the production subscription. Here are the details of the exact issue:

Failed to forward request to http://***.**.0.4:8000.
Encountered a System.Threading.Tasks.TaskCanceledException exception after 300001.542ms with message:
The request was canceled due to the configured HttpClient.Timeout of 300 seconds elapsing.
Check application logs to verify the application is properly handling HTTP traffic.

The API and other data are taking more than 5 minutes to return a response, causing a timeout issue. How can I resolve this?

Answer

Hello Mishal Singhai,

Welcome to the Microsoft Q&A and thank you for posting your questions here.

Problem

Sequel to your questions, I understand that you are setting up your Django app on Azure with App Service. Everything seems smooth when they test it locally, but once it's deployed to the production subscription, trouble brews. You hit a snag with a System.Threading.Tasks.TaskCanceledException popping up. This happens when requests are sent out, and it's because the HttpClient.Timeout is set to 300 seconds, but the API and other stuff are dragging their feet, taking over 5 minutes to respond. You need of some help to fix this timeout issue and make sure your app runs seamlessly in the production environment.

Scenario

You are working on a Django app that you would want to launch on Azure through App Service. You tested it out locally and it's been smooth sailing. But when he goes to deploy it to the production subscription, he runs into a snag. There's this pesky System.Threading.Tasks.TaskCanceledException that keeps popping up when you tries to send requests to the deployed app. It turns out, the HttpClient.Timeout is set to 300 seconds, but the API and other bits of data are taking more than 5 minutes to get back.

Solution

This prescribed solution will be based on the scenario given and your questions, while focusing on the problem statement.

Three major things to do are the followings:

Optimize Django Application.
Adjust HttpClient.Timeout Setting.
Implement Error Handling.

However, before proceeding to the above; you will need to identify the Root Cause of Slow Response by**:**

Checking the timeout settings in your application code and configuration.
Ensure that timeouts are appropriately configured and allow sufficient time for requests to complete.

Use logging and diagnostics to identify which parts of the Django application are taking longer than expected to respond.

How to do the above

Ensure timeout settings in your application code and configurations are appropriate.
Make sure that timeouts allow sufficient time for requests to complete without prematurely cancelling them.
Check database queries, external API calls, and any other potential bottlenecks in the application code.
Use logging to record timestamps before and after critical sections of code in your Django application.
Implement diagnostics tools such as Django's built-in logging framework or third-party libraries like Django Debug Toolbar to gather detailed information about the execution flow.
Analyze the logged data to identify which parts of your Django application are taking longer than expected to respond.
Focus on database queries, external API calls, or any other potentially slow operations.

Now! Back to major things.

How to Optimize Django Application
- Review the codebase to identify and address any inefficient operations or long-running tasks.
- Utilize Django's built-in caching mechanisms to cache frequently accessed data and reduce response times.
- Consider implementing asynchronous programming techniques using Django's async views or libraries like asyncio to handle long-running tasks efficiently.
- NOTE: If possible, you can provide code area that is given you issue, the community experts can help as much as you want.
How to Adjust HttpClient.Timeout Setting.
- In the Azure App Service configuration, adjust the HttpClient.Timeout setting to a higher value than the default 300 seconds.
- Update the timeout value in the application code where HttpClient instances are created, ensuring it aligns with the App Service configuration.
- The below is an example code you can use to adjust HttpClient.Timeout Setting:
```
    # Assuming HttpClient configuration in Django views
    import requests
    # Set timeout value (in seconds)
    timeout_seconds = 600  # 10 minutes
    # Create HttpClient instance with adjusted timeout
    http_client = requests.Session()
    http_client.timeout = timeout_seconds
    
```

Finally

How to Implement Error Handling.

Implement proper error handling and exception management in your code to gracefully handle timeouts and other unexpected issues by considering retry logic or fallback mechanisms to handle transient errors.
My advice for your scenario is to introduce retry logic in the application code to handle transient errors and timeouts gracefully.
Use libraries like retrying or implement custom retry mechanisms to automatically retry failed requests with exponential backoff.

The below is an example code you can use to implement retry logic:

    import requests
    from requests.exceptions import RequestException
    from retrying import retry
    # Define retry decorator with exponential backoff
    @retry(wait_exponential_multiplier=1000, wait_exponential_max=10000, stop_max_attempt_number=5)
    def make_request(url):
        try:
            response = requests.get(url)
            response.raise_for_status()
            return response.json()
        except RequestException as e:
            print(f"Request failed: {e}")
            raise
    # Example usage
    try:
        data = make_request("http://example.com/api")
        print(data)
    except Exception as e:
        print(f"Error: {e}")

By following the above steps and incorporating appropriate code adjustments, you should be able to resolve the timeout issue and optimize the performance of your Django application deployed on Azure App Service.

References

To read more and for appropriate information check the additional resources by the right side of this page.

Accept Answer

I hope this is helpful! Do not hesitate to let me know if you have any other questions.

** Please don't forget to close up the thread here by upvoting and accept it as an answer if it is helpful ** so that others in the community facing similar issues can easily find the solution.

Best Regards,

Sina Salam

Answer

What kind of Django web app is it? "The API and other data are taking more than 5 minutes to return a response" is the actual culprit, and the exception is just the facade.

All web pages and API calls should return within a reasonable amount of time (less than several seconds). So, if the app currently has any part that might require several minutes to respond, the design is flawed and you should ask the developers to revise that. They should convert all such calls to state machine queries or bi-directional communication.