mod_wsgi: WSGI error - Resource temporarily unavailable, HTTP status 503

Although WSGI is synchronous and not even driven, that doesn’t mean only one request can run at a time. You still have multiple threads in a process and so you can still have concurrent requests running.

Multithreading only becomes an issue if your application code is heavily CPU intensive, causing contention issues with the Python global interpreter lock.

Another problem you can have is poor design of your code in that you use thread mutex locks to block large sections of code so only one thread can run in that code at the same time. If this is done poorly then multithreading isn’t as effective.

Finally, you could just be trying to handle too much in one process or host and so should if host still has resources, spread across multiple processes, or if host overloaded, use multiple hosts.

Go watch:

• https://www.youtube.com/watch?v=SGleKfigMsk

where I explain these sorts of issues.

Changing the WSGI server will not necessarily change anything if you have a problem in your code. If you aren’t seeing a specific point where things are blocking, it could well be that your code is running, but looping and not returning.

Try adding instead the following code to your wsgi.py file. This will try and identify which URLs are causing long running requests by monitoring them to completion. This will help to confirm whether this is the issue or not. The statistics output can also be used to track capacity utilisation as another way of tracking it.

So try that and see if you do have long running requests and then can dig more into some of the statistics it generates.

import time
import threading
import os
import mod_wsgi

current_requests = {}

def event_handler(name, **kwargs):
    if name == 'request_started':
        environ = kwargs['request_environ']

        request_data = mod_wsgi.request_data()
        request_data['environ'] = environ
        request_data['tracked'] = False

        request_id = environ['mod_wsgi.request_id']

        current_requests[request_id] = (environ, kwargs, request_data)

    elif name == 'request_finished':
        request_data = mod_wsgi.request_data()
        environ = request_data['environ']
        request_id = environ['mod_wsgi.request_id']
        del current_requests[request_id]

        if request_data['tracked']:
            print('FINISHED %s %s %s' % (request_id, kwargs['application_time'], environ['REQUEST_URI']))

mod_wsgi.subscribe_events(event_handler)

last_metrics = None

def monitor(*args):
    global last_metrics

    while True:
        current_metrics = mod_wsgi.process_metrics()

        if last_metrics is not None:
            cpu_user_time = (current_metrics['cpu_user_time'] -
                    last_metrics['cpu_user_time'])
            cpu_system_time = (current_metrics['cpu_system_time'] -
                    last_metrics['cpu_system_time'])

            request_busy_time = (current_metrics['request_busy_time'] -
                    last_metrics['request_busy_time'])

            request_threads = current_metrics['request_threads']

            # report data

            item = {}
            item['time'] = time.time()
            item['measurement'] = 'process'
            item['process_group'] = mod_wsgi.process_group
            item['process_id'] = os.getpid()

            fields = {}

            fields['cpu_user_time'] = cpu_user_time
            fields['cpu_system_time'] = cpu_system_time

            fields['request_busy_time'] = request_busy_time
            fields['request_busy_usage'] = (request_busy_time /
                    mod_wsgi.threads_per_process)

            fields['threads_per_process'] = mod_wsgi.threads_per_process
            fields['request_threads'] = request_threads

            item['fields'] = fields

            now = time.time()

            header = False
            for request_id, (environ, kwargs, request_data) in list(current_requests.items()):
                running_duration = now - kwargs['application_start']
                # Dump data for requests running longer than 2.0 seconds.
                if running_duration > 2.0:
                    if not header:
                        print('STATISTICS', item)
                        header = True
                    request_data['tracked'] = True
                    print('RUNNING %s %s %s' % (request_id, running_duration, environ['REQUEST_URI']))

        last_metrics = current_metrics

        current_time = current_metrics['current_time']
        delay = max(0, (current_time + 1.0) - time.time())
        time.sleep(delay)

thread = threading.Thread(target=monitor)
thread.setDaemon(True)
thread.start()