Django随机HTTP 500错误求助：树莓派继电器控制异常及响应延迟

Hey there, let’s tackle this tricky intermittent 500 error in your Django setup—those random, delayed issues are always the worst to track down! Here’s a step-by-step approach to dig into what’s going on:

First off, using tail is probably making you miss the critical stack trace when the 500 hits. Let’s configure Django to log every request and exception with full details on your Raspberry Pi:

• Update your settings.py with this logging setup to capture errors and debug info:

  LOGGING = {
      'version': 1,
      'disable_existing_loggers': False,
      'handlers': {
          'file': {
              'level': 'DEBUG',
              'class': 'logging.FileHandler',
              'filename': '/var/log/django/debug.log',
          },
      },
      'loggers': {
          'django': {
              'handlers': ['file'],
              'level': 'DEBUG',
              'propagate': True,
          },
          'django.request': {
              'handlers': ['file'],
              'level': 'ERROR',
              'propagate': False,
          },
      },
  }
  

• Create the log directory and set proper permissions so Django can write to it:

  sudo mkdir -p /var/log/django && sudo chown pi:pi /var/log/django
  

• Instead of just tail, use tail -f /var/log/django/debug.log to watch logs in real-time, or check the full file as soon as the 500 error pops up. The exception traceback here will tell you exactly what’s failing.

Intermittent issues that get worse over hours almost always point to resource leaks or exhaustion. Run these commands when the system starts acting sluggish:

• htop: Keep an eye on CPU usage (look for processes spiking to 100%) and memory growth (Django/WSGI workers might be leaking memory over time)
• free -m: Check if RAM is maxed out—swap usage can cause massive slowdowns and timeouts that lead to 500s
• df -h: Make sure you haven’t run out of disk space (full disks break log writing, session storage, and temp files)
• iostat: Look for disk I/O bottlenecks—slow SD card storage can delay database queries or script execution

Since the relay control is getting stuck, the issue might be in how Django interacts with your hardware script:

• Wrap your relay control code in a robust try/except block to log every error, even minor ones:

  import logging
  import subprocess
  
  logger = logging.getLogger(__name__)
  
  def control_relay(action):
      try:
          # Add a timeout to prevent hanging scripts
          result = subprocess.run(
              ["your-relay-script.sh", action],
              check=True,
              capture_output=True,
              text=True,
              timeout=5
          )
          logger.debug(f"Relay action '{action}' succeeded: {result.stdout}")
      except subprocess.CalledProcessError as e:
          logger.error(f"Relay script failed with error: {e.stderr}", exc_info=True)
      except subprocess.TimeoutExpired:
          logger.error(f"Relay script timed out after 5 seconds", exc_info=True)
      except Exception as e:
          logger.error(f"Unexpected error in relay control: {str(e)}", exc_info=True)
  

• The timeout=5 here is crucial—it stops a stuck script from blocking Django requests indefinitely, which would cause cascading slowdowns and 500s.

Random errors often come from race conditions or flaky hardware/network connections:

• If you’re using SQLite (common on Raspberry Pi), check for database lock timeouts. SQLite struggles with concurrent writes—enable database logging to see if queries are waiting for locks.
• Add retries with backoff for critical hardware interactions. For example, use the tenacity library to retry relay commands if they fail once (this handles temporary glitches with the hardware).
• Check your web server logs (Gunicorn/Nginx) for messages like "worker died"—crashed WSGI workers can cause delayed 500s as requests wait for new workers to spin up.

Since the problem shows up after hours of running, simulate traffic to trigger it sooner:

• Use Apache Bench (ab) to send concurrent requests:

  ab -n 1000 -c 10 http://your-pi-ip/path-to-relay-endpoint/
  

• Monitor logs and system resources while the load test runs—this might reveal the bottleneck hours before it would happen naturally.

Once you capture the full stack trace from the Django logs, you’ll have a clear starting point to fix the root cause. Let me know if you find something specific in the logs that needs unpacking!

内容的提问来源于stack exchange，提问作者Fernando Miranda