System Health Monitor Desktop App using Python

Operating systems ship a task manager, but it forgets everything: no history, no alerts, no export, and no way to say "tell me when this server's disk fills up." This project builds the missing tool — a native desktop application in Python that continuously samples CPU, memory, disk and network counters, draws them as live updating graphs, and watches them against alert rules the user defines. The architecture is a clean producer/consumer split: a sampler thread polls psutil at the configured interval and pushes samples into a ring buffer; the Qt event loop renders the charts and evaluates thresholds without blocking. History persists in SQLite so graphs can be reviewed across restarts and exported to CSV. Because every reading comes from real OS counters on the machine it runs on, the demo is live and un-fakeable — the CPU graph spikes the moment you open another program — which makes reviews and vivas easy to carry.

1. A background QThread samples psutil.cpu_percent (percpu), virtual_memory, disk_usage, disk_io_counters and net_io_counters every N seconds (default 1 s).
2. Samples land in a fixed-size ring buffer in memory and are flushed to SQLite in batches, keeping the UI thread free for rendering.
3. Matplotlib canvases embedded in PyQt6 widgets redraw from the buffer on a Qt timer, giving smooth live graphs with a trailing time window.
4. The alert engine evaluates each rule against the buffered window each cycle; on trigger it posts a Qt system-tray/desktop notification and writes an alert row to the database.
5. The process view refreshes from psutil.process_iter with oneshot CPU/memory reads, sorted by the clicked column; kill requests go through psutil's terminate with confirmation.
6. The history view queries SQLite by metric and time range, renders the replay chart, and exports the selection to CSV.

Tech stack:

• Python 3.11, PyQt6 (desktop UI, system tray, notifications)
• psutil (cross-platform CPU, memory, disk, network and process counters)
• matplotlib (live and history charts embedded in Qt)
• SQLite (metric history, alert rules, alert log)
• PyInstaller build spec for a one-click Windows executable

• [Live metric dashboards] CPU (overall + per-core), memory, swap, disk usage and network up/down rendered as continuously updating line and area charts with a configurable sampling interval.
• [Process manager] Sortable process table with PID, name, user, CPU%, memory and status; refresh, kill and priority views with a search filter.
• [Threshold alert rules] User-defined rules such as "CPU > 85% for 120 s" or "disk C: > 90%" that trigger desktop notifications and log to the alert history.
• [History logging] Every sample persisted to SQLite; the history view replays any metric over the last hour/day with zoomable charts and CSV export.
• [System information panel] OS, hostname, CPU model and core count, total RAM, disk partitions, network interfaces and boot time in one reference view.
• [Dark and light themes] Two polished themes; the layout adapts to window resizing and remembers its geometry between runs.
• [Configurable and honest] All thresholds, intervals and retention periods are user settings — nothing is hard-coded; readings are always labeled with their source counter.

• Complete Python source (sampler thread, alert engine, Qt views, SQLite layer)
• PyInstaller build spec for packaging a standalone executable
• Project report PDF (architecture, threading model, psutil counter reference, testing)
• PPT presentation for final review
• Viva Q&A preparation document (threads vs processes, Qt signals/slots, psutil, SQLite, OS counters)
• Setup guide (virtualenv, pip install, running from source, building the exe)

• It monitors the machine it runs on — there is no remote-agent or fleet dashboard; one instance watches one host.
• Killing processes requires the OS privileges of the logged-in user; system processes may refuse and the app reports that honestly.
• Readings are OS counters, not calibrated instruments — brief sampling jitter on busy systems is normal and documented.
• Alert delivery is a local desktop notification; there is no SMS/email/push channel in this build.
• Historical depth is bounded by the retention setting (default 7 days) to keep the SQLite file small.