One harsh truth we discover while building backend systems for IoT devices like industrial sensors or electric vehicle (EV) chargers is this: Hardware lies. Your Python WebSocket server works flawlessly on your local machine, but deploy it to production where physical hardware is shoved into underground concrete parking garages, fighting high-voltage electromagnetic interference, and constantly falling back to legacy 2G/3G networks, and your server will quickly fall victim to "Zombie Connections."

I still remember a seminar I attended where a gentleman was explaining how he had deployed their IoT devices on generators in remote mining locations. They were facing this exact issue. The IoT devices were sending all-green signals, but the physical generators were completely offline.

A Zombie Connection happens when an IoT device loses cellular service and drops off the network abruptly, failing to send a standard TCP close frame. The Python server still considers it an open connection.

The Naive (and Dangerous) Approach
Most Python WebSocket tutorials teach you to handle connections like this:

Python
import asyncio
import websockets

async def handle_connection(websocket):
    while True:
        # DANGER: This line blocks forever if the connection drops silently
        data = await websocket.recv() 
        await process_sensor_data(data)

In an IoT application, this code is a ticking time bomb. If 1000 devices drive into tunnels and lose signal silently, you now have 1000 coroutines permanently suspended in your asyncio event loop waiting for data that will never arrive. Eventually, your server runs out of file descriptors or memory, and crashes.

The Fix: Aggressive Heartbeats and Timeouts
To build a fault-tolerant ingestion layer, we must stop trusting the socket state and actively interrogate the connection using asyncio.wait_for and WebSocket Ping/Pong frames.
Here is how you write a non-blocking connection handler:

Python
import asyncio
import websockets

async def process_sensor_data(data):
    # Your business logic goes here
    pass

async def handle_connection(websocket):
    try:
        while True:
            try:
                # 1. Wait for data, but strictly timeout after 30 seconds
                data = await asyncio.wait_for(websocket.recv(), timeout=30.0)
                await process_sensor_data(data)

            except asyncio.TimeoutError:
                # 2. No data received in 30s. The device might be dead, or just idle.
                # We actively send a ping to find out.
                pong_waiter = await websocket.ping()

                try:
                    # Wait 10 seconds for the hardware to reply to the ping
                    await asyncio.wait_for(pong_waiter, timeout=10.0)
                except asyncio.TimeoutError:
                    # 3. No pong received. It's a Zombie. Kill it.
                    print(f"Zombie connection detected. Freeing server resources.")
                    await websocket.close()
                    break # Exit the loop and destroy the coroutine

    except websockets.exceptions.ConnectionClosed:
        print("Connection closed cleanly by the hardware.")

Why This Architecture Wins
By wrapping our asynchronous receives in strict timeouts, we take back control of the event loop. We allow the server to gracefully reap dead connections, free up memory, and prepare for the hardware to eventually regain cellular service and reconnect.

Remember, there are a lot of zombie "connections" out there :)