如何设置Django Debugger超时？避免部署后调试器致页面挂起

Great question! I’ve run into this exact headache before—forgetting to remove a pdb.set_trace() and having a production request hang indefinitely is such a frustrating mistake. Here are several practical solutions to prevent this from happening:

1. Use Django's DEBUG Mode to Gate the Debugger #

The simplest and most reliable fix is to only enable the debugger when Django is running in debug mode. Since production environments should always have DEBUG = False, this ensures the debugger never runs there:

from django.conf import settings

# Only trigger pdb if we're in debug mode
if settings.DEBUG:
    import pdb; pdb.set_trace()

This eliminates the risk entirely—even if you forget to remove the line, it won't execute in production. Just double-check your production settings to make sure DEBUG isn't accidentally set to True.

2. Create a Custom Timed PDB Function #

If you need the debugger to auto-expire (even in development/testing environments), you can wrap pdb.set_trace() with a timeout mechanism. Here are two approaches:

Option A: Using Signals (Single-Threaded Environments) #

This uses the signal module to trigger a timeout after a set number of seconds:

import pdb
import signal

def timed_pdb(timeout=300):  # 5 minutes default
    def timeout_handler(signum, frame):
        raise TimeoutError("PDB session timed out after {} seconds".format(timeout))
    
    # Set up the alarm signal
    signal.signal(signal.SIGALRM, timeout_handler)
    signal.alarm(timeout)
    
    try:
        pdb.set_trace()
    finally:
        # Cancel the alarm if we exit the debugger normally
        signal.alarm(0)

Use it like this instead of the standard pdb call:

timed_pdb()  # Will timeout after 5 minutes

Note: This works best in single-threaded environments. If your Django server uses multiple threads (like most WSGI servers), signals might not behave as expected.

Option B: Using Threading (Multi-Threaded Friendly) #

For multi-threaded setups, use a timer thread to interrupt the debugger session:

import pdb
import threading
import os
import signal

def timed_pdb(timeout=300):
    def terminate_session():
        # Send an interrupt signal to break out of pdb
        os.kill(os.getpid(), signal.SIGINT)
    
    # Start the timer
    timer = threading.Timer(timeout, terminate_session)
    timer.start()
    
    try:
        pdb.set_trace()
    finally:
        # Cancel the timer if we exit normally
        timer.cancel()

This will send an interrupt to the process after the timeout, ending the pdb session and allowing the request to proceed (with an error, but at least it won't hang forever).

3. Add Code Checks to Your Workflow #

To catch forgotten debuggers before deployment, use a linter plugin like flake8-debugger. This tool scans your code for pdb.set_trace() and similar statements and throws errors if it finds them.

• Install it with pip install flake8-debugger
• Run it as part of your pre-commit hook or CI/CD pipeline:

flake8 your_django_project/

This adds an extra layer of safety—you'll get a warning before deploying code with leftover debuggers.

Final Recommendation #

I’d recommend combining the DEBUG-mode gating (solution 1) with the flake8 check (solution 3) for maximum safety. The timed debugger (solution 2) is useful for edge cases where you need temporary, auto-expiring debugging in non-debug environments.

内容的提问来源于stack exchange，提问作者Mr Singh