sneak
ef3c373a12
Linux runs exactly as before when both bridge interfaces exist. When they do not, the lone default-route interface is monitored, and a single interface now draws a single UI pane instead of an empty second one. macOS is newly supported: a running VPN tunnel (utun) is monitored as the primary pane alongside the physical default-route interface, or the physical interface alone when no VPN is up. Detection lives in internal/netdetect: interface/route data types, pure selection logic keyed on OS name, and route parsers, all unit-tested on Linux for both platforms. Only the real route query and the per-platform TCP dial binding (source address on Linux, IP_BOUND_IF on macOS) are build-tagged. Ping argument construction is a pure, OS-keyed function. NewMonitor now takes a list of interfaces. Model: opus-4-8
5.8 KiB
rtnetmon
Real-time network monitoring dashboard for Linux and macOS, with one- or two-interface support.
Overview
rtnetmon is a terminal-based network monitoring tool that provides real-time visibility into network health, packet loss, and latency across one or two network interfaces simultaneously. It runs on Linux and macOS and uses a terminal dashboard interface.
Features
- Interface Monitoring: Monitor one or two network interfaces simultaneously
- Real-time Updates: Live dashboard with sub-second updates
- Comprehensive Metrics:
- ICMP reachability tests
- Packet loss percentage
- TCP connection latency
- Interface health status
- Visual Indicators: Color-coded status, spinners, and meters for quick
status assessment
- Packet loss meter uses reverse coloring (empty/green = good, full/red = bad)
- Detailed Logging: Optional logging to file for debugging and analysis
Requirements
- Linux or macOS
- Go 1.21 or later
- Root/sudo access (for raw ICMP packets)
pingcommand available in PATH- On Linux:
ip(with/proc/net/routeas a fallback) - On macOS:
netstat
Platform support and interface detection
rtnetmon monitors either one or two interfaces, chosen automatically for the platform it runs on. When only one interface is detected, the dashboard shows a single pane.
Linux. The two named interfaces (--ifaceA/--ifaceB, default
gu0/backhaul0) are used when both exist — this is the original dual-bridge
setup, unchanged. When neither exists, the single default-route interface is
monitored instead.
macOS. The physical internet interface is found from the default route. When
a VPN client is running (Mullvad and similar clients create a utun tunnel that
carries a default route or holds a routable address), that tunnel is monitored
as the primary pane alongside the physical interface. With no VPN running, only
the physical interface is monitored. Interface names are detected on macOS; the
--ifaceA/--ifaceB flags are not used there, but --labelA/--labelB still
set the pane labels.
Supported matrix
| OS | Interfaces monitored |
|---|---|
| Linux | gu0 + backhaul0 when both exist (two panes) |
| Linux | the single default-route interface otherwise (one pane) |
| macOS | VPN tunnel + physical default-route interface (two panes) |
| macOS | the physical default-route interface with no VPN (one pane) |
Anything outside this matrix — on Linux, only one of the named pair present, or no/multiple default routes when neither is present; on macOS, no default route or more than one physical default route — exits with a clear error.
Installation
git clone https://git.eeqj.de/sneak/rtnetmon.git
cd rtnetmon
make build
Usage
sudo ./rtnetmon --ifaceA eth0 --labelA "Primary WAN" --ifaceB wlan0 --labelB "Backup WiFi"
Command Line Options
--ifaceA: Primary network interface (default: "gu0")--labelA: Label for primary interface (default: "gu LAN - VPN outbound")--ifaceB: Secondary network interface (default: "backhaul0")--labelB: Label for secondary interface (default: "Cox cable direct")--hosts: Comma-separated list of hosts to monitor--logfile: Path to log file (default: "/tmp/rtnetmon.log")
Keyboard Controls
qorCtrl+C: Quit the application
Project Structure
rtnetmon/
├── cmd/rtnetmon/ # Main entry point
│ └── main.go
├── internal/
│ ├── cli/ # Command-line interface using Cobra
│ │ └── root.go
│ ├── netdetect/ # Per-platform interface/route detection and selection
│ │ ├── netdetect.go # Selection logic and route parsers (pure)
│ │ ├── routes_linux.go # Linux default-route query (build-tagged)
│ │ └── routes_darwin.go # macOS default-route query (build-tagged)
│ └── monitor/ # Core monitoring functionality
│ ├── monitor.go # Main monitoring types and functions
│ ├── loops.go # Monitoring loops (reachability, loss, TCP)
│ ├── styles.go # Terminal color styles
│ ├── ui.go # User interface rendering
│ ├── dial_linux.go # TCP source binding (build-tagged)
│ └── dial_darwin.go # TCP IP_BOUND_IF binding (build-tagged)
├── go.mod
├── go.sum
├── Makefile
└── README.md
Development
Building
make build # Build the binary
make test # Run tests
make lint # Run linter
make fmt # Format code
make all # Format, lint, test, and build
Testing
The project includes unit tests for core functionality. Run tests with:
make test
Using the Monitor API
The monitor package provides an object-oriented API for programmatic use:
import "git.eeqj.de/sneak/rtnetmon/internal/monitor"
// Create a new monitor for one or two interfaces
mon := monitor.NewMonitor([]monitor.IfaceSpec{
{Name: "eth0", Label: "Primary"},
{Name: "wlan0", Label: "Backup"},
}, "/tmp/monitor.log")
// Configure timing parameters (optional - defaults are sensible)
mon.ICMPTimeout = 1 * time.Second
mon.PacketLossPings = 10
mon.PacketLossPeriod = 10 * time.Second
// Add hosts to monitor
mon.AddReachabilityHost("8.8.8.8")
mon.AddReachabilityHost("google.com")
mon.AddPacketLossHost("github.com")
mon.AddPacketLossHost("8.8.8.8")
mon.AddTCPHost("google.com:443")
mon.AddTCPHost("github.com:443")
// Run the monitor
ctx := context.Background()
if err := mon.Run(ctx); err != nil {
log.Fatal(err)
}
License
WTFPL - Do What The Fuck You Want To Public License