| |
| """ |
| LocalNet-Dynamics telemetry collector. |
| |
| Samples the network at a fixed cadence from a single client machine and |
| appends one row per sample to a CSV file in real time. Each sample records: |
| |
| * ICMP round-trip time to a reference target (min/avg/median/max/stddev), |
| inter-packet jitter and packet loss |
| * ICMP round-trip time and loss to the default gateway (first hop) |
| * TCP connect time to the target (sub-millisecond resolution on every OS) |
| * DNS response time of the configured resolver for a fixed name and for a |
| never-before-seen name (forces a full recursive lookup) |
| * HTTP time-to-first-response for a small connectivity-check URL |
| * Wi-Fi link metrics when the machine is on wireless (signal, PHY rate, |
| channel, band, standard) |
| * WAN throughput (Ookla Speedtest) and LAN throughput (iperf3) on their own, |
| slower cadence |
| |
| The collector depends only on the Python standard library and the operating |
| system's `ping` utility. Optional external tools: Ookla `speedtest` CLI or the |
| `speedtest-cli` Python package (WAN throughput), `iperf3` (LAN throughput). |
| |
| Typical use, 30-second cadence for 30 days with an hourly WAN speed test: |
| |
| python collect_data.py --duration 30d --interval 30s --speedtest --speedtest-every 1h |
| |
| Run `python collect_data.py --check` to verify the environment and print one |
| sample without writing any files. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import base64 |
| import contextlib |
| import csv |
| import json |
| import os |
| import platform |
| import random |
| import re |
| import shutil |
| import signal |
| import socket |
| import statistics |
| import struct |
| import subprocess |
| import sys |
| import time |
| import urllib.error |
| import urllib.request |
| from concurrent.futures import ThreadPoolExecutor |
| from dataclasses import asdict, dataclass, fields |
| from datetime import datetime, timezone |
| from pathlib import Path |
| from typing import Optional |
|
|
| COLLECTOR_VERSION = "2.0.1" |
|
|
| IS_WINDOWS = sys.platform.startswith("win") |
| IS_MACOS = sys.platform == "darwin" |
| IS_LINUX = sys.platform.startswith("linux") |
|
|
| ROUTE_REFRESH_S = 900.0 |
| META_REFRESH_S = 300.0 |
| SPEEDTEST_PING_FAILED_MS = 600_000.0 |
| USER_AGENT = f"LocalNet-Dynamics/{COLLECTOR_VERSION}" |
|
|
|
|
| |
| |
| |
|
|
| _DURATION_RE = re.compile(r"^\s*(\d+(?:\.\d+)?)\s*([smhd]?)\s*$", re.IGNORECASE) |
| _UNIT_SECONDS = {"": 1, "s": 1, "m": 60, "h": 3600, "d": 86400} |
|
|
|
|
| def parse_duration(text: str) -> float: |
| """Parse '90', '30s', '10m', '2h', '1.5d' into seconds.""" |
| m = _DURATION_RE.match(str(text)) |
| if not m: |
| raise argparse.ArgumentTypeError( |
| f"invalid duration {text!r} (examples: 30s, 10m, 2h, 7d)" |
| ) |
| value, unit = float(m.group(1)), m.group(2).lower() |
| return value * _UNIT_SECONDS[unit] |
|
|
|
|
| def human_duration(seconds: float) -> str: |
| seconds = int(round(seconds)) |
| parts = [] |
| for label, size in (("d", 86400), ("h", 3600), ("m", 60), ("s", 1)): |
| if seconds >= size: |
| parts.append(f"{seconds // size}{label}") |
| seconds %= size |
| return " ".join(parts) or "0s" |
|
|
|
|
| |
| |
| |
|
|
| @dataclass |
| class Sample: |
| run_id: str = "" |
| host_label: str = "" |
| sample_index: int = 0 |
| timestamp_utc: str = "" |
| timestamp_local: str = "" |
| epoch_s: int = 0 |
| elapsed_s: float = 0.0 |
| link_type: str = "" |
| gateway_ip: str = "" |
| dns_server: str = "" |
| target: str = "" |
| rtt_min_ms: Optional[float] = None |
| rtt_avg_ms: Optional[float] = None |
| rtt_median_ms: Optional[float] = None |
| rtt_max_ms: Optional[float] = None |
| rtt_stddev_ms: Optional[float] = None |
| jitter_ms: Optional[float] = None |
| packets_sent: Optional[int] = None |
| packets_received: Optional[int] = None |
| packet_loss_pct: Optional[float] = None |
| gateway_rtt_min_ms: Optional[float] = None |
| gateway_rtt_avg_ms: Optional[float] = None |
| gateway_rtt_max_ms: Optional[float] = None |
| gateway_jitter_ms: Optional[float] = None |
| gateway_packet_loss_pct: Optional[float] = None |
| tcp_connect_min_ms: Optional[float] = None |
| tcp_connect_median_ms: Optional[float] = None |
| dns_resolve_ms: Optional[float] = None |
| dns_recursive_ms: Optional[float] = None |
| http_ms: Optional[float] = None |
| http_status: Optional[int] = None |
| wifi_ssid: str = "" |
| wifi_signal_pct: Optional[int] = None |
| wifi_rssi_dbm: Optional[float] = None |
| wifi_rx_mbps: Optional[float] = None |
| wifi_tx_mbps: Optional[float] = None |
| wifi_channel: Optional[int] = None |
| wifi_band_ghz: Optional[float] = None |
| wifi_phy: str = "" |
| download_mbps: Optional[float] = None |
| upload_mbps: Optional[float] = None |
| speedtest_ping_ms: Optional[float] = None |
| download_loaded_latency_ms: Optional[float] = None |
| upload_loaded_latency_ms: Optional[float] = None |
| speedtest_server_id: Optional[int] = None |
| speedtest_server: str = "" |
| lan_throughput_mbps: Optional[float] = None |
| lan_retransmits: Optional[int] = None |
| sample_duration_s: Optional[float] = None |
| notes: str = "" |
|
|
|
|
| CSV_FIELDS = [f.name for f in fields(Sample)] |
|
|
| SUMMARY_KEYS = [ |
| "rtt_avg_ms", "rtt_min_ms", "rtt_max_ms", "jitter_ms", "packet_loss_pct", |
| "gateway_rtt_avg_ms", "gateway_packet_loss_pct", |
| "tcp_connect_median_ms", "dns_resolve_ms", "dns_recursive_ms", "http_ms", |
| "wifi_signal_pct", "wifi_rssi_dbm", "wifi_rx_mbps", |
| "download_mbps", "upload_mbps", "speedtest_ping_ms", |
| "download_loaded_latency_ms", "upload_loaded_latency_ms", |
| "lan_throughput_mbps", "sample_duration_s", |
| ] |
|
|
|
|
| |
| |
| |
|
|
| def _console_encoding() -> str: |
| """Encoding used by console tools (OEM code page on Windows).""" |
| if IS_WINDOWS: |
| try: |
| import ctypes |
| cp = ctypes.windll.kernel32.GetOEMCP() |
| if cp: |
| return f"cp{cp}" |
| except Exception: |
| pass |
| return "utf-8" |
|
|
|
|
| def decode_output(data: bytes, encoding: Optional[str] = None) -> str: |
| for enc in ((encoding,) if encoding else ()) + ("utf-8", _console_encoding(), "latin-1"): |
| try: |
| return data.decode(enc) |
| except (UnicodeDecodeError, LookupError): |
| continue |
| return data.decode("utf-8", errors="replace") |
|
|
|
|
| def run_cmd(args: list[str], timeout: float = 20.0, |
| encoding: Optional[str] = None) -> tuple[Optional[int], str]: |
| """Run a command, returning (exit code, combined decoded output). |
| |
| The exit code is None when the command timed out or could not be started. |
| """ |
| try: |
| proc = subprocess.run(args, capture_output=True, timeout=timeout) |
| except subprocess.TimeoutExpired as exc: |
| out = (exc.stdout or b"") + (exc.stderr or b"") |
| return None, decode_output(out, encoding) |
| except (FileNotFoundError, OSError): |
| return None, "" |
| return proc.returncode, decode_output(proc.stdout + proc.stderr, encoding) |
|
|
|
|
| def run_powershell(script: str, timeout: float = 30.0) -> str: |
| """Run a PowerShell script (Windows only) and return its UTF-8 stdout.""" |
| if not IS_WINDOWS: |
| return "" |
| wrapped = "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8\n" + script |
| encoded = base64.b64encode(wrapped.encode("utf-16-le")).decode("ascii") |
| for exe in ("powershell", "pwsh"): |
| if shutil.which(exe) is None: |
| continue |
| code, out = run_cmd( |
| [exe, "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", |
| "-EncodedCommand", encoded], |
| timeout=timeout, encoding="utf-8", |
| ) |
| if code == 0 and out.strip(): |
| return out |
| return "" |
|
|
|
|
| |
| |
| |
|
|
| @dataclass |
| class PingResult: |
| sent: int = 0 |
| received: int = 0 |
| rtts: Optional[list[float]] = None |
| error: Optional[str] = None |
|
|
| @property |
| def loss_pct(self) -> Optional[float]: |
| if self.sent <= 0: |
| return None |
| lost = max(0, self.sent - self.received) |
| return round(100.0 * lost / self.sent, 1) |
|
|
|
|
| |
| |
| |
| |
| |
| _RTT_RE = re.compile(r"\S([=<])\s*(\d+(?:[.,]\d+)?)\s*(?:ms|мс)\b", re.IGNORECASE) |
|
|
|
|
| def parse_ping_output(text: str, sent: int) -> PingResult: |
| """Extract per-reply RTTs from `ping` output in a locale-independent way. |
| |
| Windows prints integer milliseconds and reports sub-millisecond replies as |
| "<1ms"; those are stored as 0.0. |
| """ |
| rtts: list[float] = [] |
| for line in text.splitlines(): |
| if "DUP!" in line: |
| continue |
| m = _RTT_RE.search(line) |
| if not m: |
| continue |
| if m.group(1) == "<": |
| rtts.append(0.0) |
| else: |
| rtts.append(float(m.group(2).replace(",", "."))) |
| return PingResult(sent=sent, received=len(rtts), rtts=rtts) |
|
|
|
|
| _PING_FLAVOR: Optional[str] = None |
|
|
|
|
| def ping_flavor() -> str: |
| """windows | iputils | busybox | bsd (cached).""" |
| global _PING_FLAVOR |
| if _PING_FLAVOR is None: |
| if IS_WINDOWS: |
| _PING_FLAVOR = "windows" |
| elif IS_LINUX: |
| _, out = run_cmd(["ping", "-V"], timeout=5.0) |
| _PING_FLAVOR = "busybox" if "busybox" in out.lower() else "iputils" |
| else: |
| _PING_FLAVOR = "bsd" |
| return _PING_FLAVOR |
|
|
|
|
| def ping_command(host: str, count: int, timeout_s: float, flavor: str) -> list[str]: |
| ipv6 = ":" in host |
| if flavor == "windows": |
| cmd = ["ping", "-n", str(count), "-w", str(int(timeout_s * 1000))] |
| cmd.append("-6" if ipv6 else "-4") |
| return cmd + [host] |
| wait_s = str(max(1, int(round(timeout_s)))) |
| if flavor == "iputils": |
| return ["ping", "-n", "-c", str(count), "-W", wait_s, host] |
| if flavor == "busybox": |
| return ["ping", "-c", str(count), "-W", wait_s, host] |
| |
| return ["ping", "-n", "-c", str(count), "-W", str(int(timeout_s * 1000)), host] |
|
|
|
|
| def ping(host: str, count: int, timeout_s: float) -> PingResult: |
| if shutil.which("ping") is None: |
| return PingResult(sent=0, received=0, rtts=[], error="ping utility not found") |
| budget = count * (1.0 + timeout_s) + 5.0 |
| code, out = run_cmd(ping_command(host, count, timeout_s, ping_flavor()), timeout=budget) |
| result = parse_ping_output(out, sent=count) |
| if code is None and not out: |
| result.error = "ping could not be started" |
| result.sent = 0 |
| elif result.received == 0: |
| result.error = "no replies" |
| return result |
|
|
|
|
| def rtt_stats(rtts: list[float]) -> dict: |
| """min/avg/median/max/stddev/jitter for a burst of RTT samples.""" |
| if not rtts: |
| return {"min": None, "avg": None, "median": None, "max": None, |
| "stddev": None, "jitter": None} |
| jitter = None |
| if len(rtts) > 1: |
| diffs = [abs(rtts[i] - rtts[i - 1]) for i in range(1, len(rtts))] |
| jitter = round(sum(diffs) / len(diffs), 3) |
| return { |
| "min": round(min(rtts), 3), |
| "avg": round(sum(rtts) / len(rtts), 3), |
| "median": round(statistics.median(rtts), 3), |
| "max": round(max(rtts), 3), |
| "stddev": round(statistics.pstdev(rtts), 3) if len(rtts) > 1 else 0.0, |
| "jitter": jitter, |
| } |
|
|
|
|
| |
| |
| |
|
|
| @dataclass |
| class NetworkInfo: |
| gateway: Optional[str] = None |
| interface: Optional[str] = None |
| local_ip: Optional[str] = None |
| link_type: str = "unknown" |
| dns_servers: Optional[list[str]] = None |
| source: str = "" |
|
|
|
|
| _WINDOWS_ROUTE_PS = r""" |
| $ErrorActionPreference = 'SilentlyContinue' |
| $routes = Get-NetRoute -AddressFamily IPv4 -DestinationPrefix '0.0.0.0/0' | |
| Where-Object { $_.NextHop -ne '0.0.0.0' } | |
| Where-Object { (Get-NetAdapter -InterfaceIndex $_.ifIndex).Status -eq 'Up' } |
| $r = $routes | Sort-Object { $_.RouteMetric + $_.InterfaceMetric } | Select-Object -First 1 |
| if ($r) { |
| $a = Get-NetAdapter -InterfaceIndex $r.ifIndex |
| $ip = (Get-NetIPAddress -InterfaceIndex $r.ifIndex -AddressFamily IPv4 | Select-Object -First 1).IPAddress |
| $dns = (Get-DnsClientServerAddress -InterfaceIndex $r.ifIndex -AddressFamily IPv4).ServerAddresses |
| $o = [ordered]@{ gateway = [string]$r.NextHop; ifindex = $r.ifIndex; alias = [string]$a.Name; |
| media = [string]$a.PhysicalMediaType; ip = [string]$ip; dns = @($dns) } |
| $o | ConvertTo-Json -Compress |
| } |
| """ |
|
|
| _ROUTE_PRINT_RE = re.compile( |
| r"^\s*0\.0\.0\.0\s+0\.0\.0\.0\s+([\d.]+)\s+([\d.]+)\s+(\d+)\s*$", re.MULTILINE) |
|
|
|
|
| def parse_route_print(text: str) -> Optional[tuple[str, str]]: |
| """Parse `route print -4 0.0.0.0` output -> (gateway, interface_ip).""" |
| best = None |
| for gw, iface_ip, metric in _ROUTE_PRINT_RE.findall(text): |
| m = int(metric) |
| if best is None or m < best[0]: |
| best = (m, gw, iface_ip) |
| return (best[1], best[2]) if best else None |
|
|
|
|
| def _link_type_from_media(media: str) -> str: |
| media = (media or "").lower() |
| if "802.11" in media or "wireless" in media or "wi-fi" in media: |
| return "wifi" |
| if "802.3" in media or "ethernet" in media: |
| return "ethernet" |
| if not media or media == "unspecified": |
| return "unknown" |
| return "other" |
|
|
|
|
| def detect_network_windows() -> NetworkInfo: |
| info = NetworkInfo() |
| out = run_powershell(_WINDOWS_ROUTE_PS, timeout=40.0) |
| if out.strip(): |
| try: |
| data = json.loads(out.strip().splitlines()[-1]) |
| info.gateway = data.get("gateway") or None |
| info.interface = data.get("alias") or None |
| info.local_ip = data.get("ip") or None |
| info.link_type = _link_type_from_media(data.get("media", "")) |
| dns = data.get("dns") or [] |
| if isinstance(dns, str): |
| dns = [dns] |
| info.dns_servers = [d for d in dns if d and ":" not in d] or None |
| info.source = "powershell" |
| if info.gateway: |
| return info |
| except (ValueError, AttributeError): |
| pass |
| code, out = run_cmd(["route", "print", "-4", "0.0.0.0"], timeout=20.0) |
| parsed = parse_route_print(out) |
| if parsed: |
| info.gateway, info.local_ip = parsed |
| info.source = "route print" |
| return info |
|
|
|
|
| def parse_ip_route_get(text: str) -> dict: |
| """Parse `ip -o route get <ip>` output into via/dev/src.""" |
| out = {} |
| for key in ("via", "dev", "src"): |
| m = re.search(rf"\b{key}\s+(\S+)", text) |
| if m: |
| out[key] = m.group(1) |
| return out |
|
|
|
|
| def _linux_is_wireless(dev: str) -> bool: |
| base = Path("/sys/class/net") / dev |
| return (base / "wireless").exists() or (base / "phy80211").exists() |
|
|
|
|
| def parse_resolv_conf(text: str) -> list[str]: |
| servers = [] |
| for line in text.splitlines(): |
| line = line.split("#", 1)[0].strip() |
| if line.startswith("nameserver"): |
| parts = line.split() |
| if len(parts) >= 2: |
| servers.append(parts[1]) |
| return servers |
|
|
|
|
| def detect_network_linux(target: str) -> NetworkInfo: |
| info = NetworkInfo(source="ip route") |
| code, out = run_cmd(["ip", "-o", "route", "get", target], timeout=10.0) |
| parsed = parse_ip_route_get(out) if code == 0 else {} |
| if not parsed.get("via"): |
| code, out = run_cmd(["ip", "-o", "route", "show", "default"], timeout=10.0) |
| parsed = parse_ip_route_get(out) if code == 0 else {} |
| info.gateway = parsed.get("via") |
| info.interface = parsed.get("dev") |
| info.local_ip = parsed.get("src") |
| if info.interface: |
| info.link_type = "wifi" if _linux_is_wireless(info.interface) else "ethernet" |
| if info.interface.startswith(("tun", "tap", "wg", "ppp")): |
| info.link_type = "other" |
| servers: list[str] = [] |
| try: |
| servers = parse_resolv_conf(Path("/etc/resolv.conf").read_text(encoding="utf-8")) |
| except OSError: |
| pass |
| if servers and servers[0].startswith("127.") and shutil.which("resolvectl"): |
| code, out = run_cmd(["resolvectl", "dns"], timeout=10.0) |
| upstream = [] |
| for line in out.splitlines(): |
| if info.interface and f"({info.interface})" in line: |
| upstream += re.findall(r"\b(\d{1,3}(?:\.\d{1,3}){3})\b", line.split(":", 1)[-1]) |
| if not upstream: |
| upstream = re.findall(r":\s*(\d{1,3}(?:\.\d{1,3}){3})", out) |
| if upstream: |
| servers = upstream |
| info.dns_servers = [s for s in servers if ":" not in s] or None |
| return info |
|
|
|
|
| def parse_route_get_default(text: str) -> dict: |
| out = {} |
| for key in ("gateway", "interface"): |
| m = re.search(rf"^\s*{key}:\s*(\S+)", text, re.MULTILINE) |
| if m: |
| out[key] = m.group(1) |
| return out |
|
|
|
|
| def parse_hardware_ports(text: str) -> dict: |
| """`networksetup -listallhardwareports` -> {device: port name}.""" |
| mapping = {} |
| port = None |
| for line in text.splitlines(): |
| line = line.strip() |
| if line.startswith("Hardware Port:"): |
| port = line.split(":", 1)[1].strip() |
| elif line.startswith("Device:") and port: |
| mapping[line.split(":", 1)[1].strip()] = port |
| return mapping |
|
|
|
|
| def detect_network_macos() -> NetworkInfo: |
| info = NetworkInfo(source="route get") |
| code, out = run_cmd(["route", "-n", "get", "default"], timeout=10.0) |
| parsed = parse_route_get_default(out) |
| info.gateway = parsed.get("gateway") |
| info.interface = parsed.get("interface") |
| if info.interface: |
| code, out = run_cmd(["networksetup", "-listallhardwareports"], timeout=10.0) |
| port = parse_hardware_ports(out).get(info.interface, "") |
| if "wi-fi" in port.lower() or "airport" in port.lower(): |
| info.link_type = "wifi" |
| elif "ethernet" in port.lower() or "lan" in port.lower(): |
| info.link_type = "ethernet" |
| elif port: |
| info.link_type = "other" |
| code, out = run_cmd(["scutil", "--dns"], timeout=10.0) |
| servers = re.findall(r"nameserver\[\d+\]\s*:\s*(\d{1,3}(?:\.\d{1,3}){3})", out) |
| info.dns_servers = list(dict.fromkeys(servers)) or None |
| return info |
|
|
|
|
| def local_ip_for(target: str) -> Optional[str]: |
| """Local address the OS would use to reach `target` (no packet is sent).""" |
| family = socket.AF_INET6 if ":" in target else socket.AF_INET |
| try: |
| with socket.socket(family, socket.SOCK_DGRAM) as s: |
| s.connect((target, 53)) |
| return s.getsockname()[0] |
| except OSError: |
| return None |
|
|
|
|
| def detect_network(target: str) -> NetworkInfo: |
| try: |
| if IS_WINDOWS: |
| info = detect_network_windows() |
| elif IS_MACOS: |
| info = detect_network_macos() |
| else: |
| info = detect_network_linux(target) |
| except Exception as exc: |
| info = NetworkInfo(source=f"failed: {exc}") |
| if not info.local_ip: |
| info.local_ip = local_ip_for(target) |
| return info |
|
|
|
|
| |
| |
| |
|
|
| def build_dns_query(name: str, qid: int, qtype: int = 1) -> bytes: |
| header = struct.pack(">HHHHHH", qid, 0x0100, 1, 0, 0, 0) |
| qname = b"" |
| for label in name.strip(".").split("."): |
| raw = label.encode("idna") if label else b"" |
| qname += struct.pack("B", len(raw)) + raw |
| return header + qname + b"\x00" + struct.pack(">HH", qtype, 1) |
|
|
|
|
| def parse_dns_response(data: bytes, qid: int) -> Optional[int]: |
| """Return the response code, or None if the datagram does not match.""" |
| if len(data) < 12: |
| return None |
| rid, flags = struct.unpack(">HH", data[:4]) |
| if rid != qid or not flags & 0x8000: |
| return None |
| return flags & 0x000F |
|
|
|
|
| def dns_query(server: str, name: str, timeout_s: float = 3.0) -> tuple[Optional[float], Optional[int], Optional[str]]: |
| """Time one UDP DNS query. Returns (milliseconds, rcode, error).""" |
| qid = random.randint(0, 0xFFFF) |
| packet = build_dns_query(name, qid) |
| family = socket.AF_INET6 if ":" in server else socket.AF_INET |
| try: |
| with socket.socket(family, socket.SOCK_DGRAM) as s: |
| s.settimeout(timeout_s) |
| start = time.perf_counter() |
| s.sendto(packet, (server, 53)) |
| deadline = start + timeout_s |
| while True: |
| remaining = deadline - time.perf_counter() |
| if remaining <= 0: |
| return None, None, "timeout" |
| s.settimeout(remaining) |
| data, _ = s.recvfrom(4096) |
| elapsed = (time.perf_counter() - start) * 1000.0 |
| rcode = parse_dns_response(data, qid) |
| if rcode is None: |
| continue |
| if rcode in (0, 3): |
| return round(elapsed, 3), rcode, None |
| return None, rcode, f"rcode {rcode}" |
| except socket.timeout: |
| return None, None, "timeout" |
| except OSError as exc: |
| return None, None, f"{exc.__class__.__name__}" |
|
|
|
|
| def random_label() -> str: |
| return "%012x" % random.getrandbits(48) |
|
|
|
|
| |
| |
| |
|
|
| def tcp_connect_times(host: str, port: int, count: int = 5, timeout_s: float = 3.0, |
| gap_s: float = 0.2) -> tuple[list[float], Optional[str]]: |
| try: |
| addr = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM)[0] |
| except (socket.gaierror, IndexError) as exc: |
| return [], f"resolve failed ({exc.__class__.__name__})" |
| family, _, _, _, sockaddr = addr |
| times: list[float] = [] |
| error = None |
| for i in range(count): |
| s = socket.socket(family, socket.SOCK_STREAM) |
| s.settimeout(timeout_s) |
| try: |
| start = time.perf_counter() |
| s.connect(sockaddr) |
| times.append((time.perf_counter() - start) * 1000.0) |
| except socket.timeout: |
| error = "timeout" |
| except OSError as exc: |
| error = exc.__class__.__name__ |
| finally: |
| try: |
| s.close() |
| except OSError: |
| pass |
| if i < count - 1: |
| time.sleep(gap_s) |
| return times, (error if not times else None) |
|
|
|
|
| def http_probe(url: str, timeout_s: float = 5.0) -> tuple[Optional[float], Optional[int], Optional[str]]: |
| """Time-to-first-response for a small URL, bypassing any system proxy.""" |
| opener = urllib.request.build_opener(urllib.request.ProxyHandler({})) |
| req = urllib.request.Request(url, headers={ |
| "User-Agent": USER_AGENT, "Cache-Control": "no-cache", "Pragma": "no-cache", |
| }) |
| start = time.perf_counter() |
| try: |
| with opener.open(req, timeout=timeout_s) as resp: |
| elapsed = (time.perf_counter() - start) * 1000.0 |
| resp.read(4096) |
| return round(elapsed, 3), resp.status, None |
| except urllib.error.HTTPError as exc: |
| elapsed = (time.perf_counter() - start) * 1000.0 |
| return round(elapsed, 3), exc.code, None |
| except (urllib.error.URLError, socket.timeout, OSError, ValueError) as exc: |
| reason = getattr(exc, "reason", exc) |
| return None, None, f"{reason}"[:80] |
|
|
|
|
| |
| |
| |
|
|
| @dataclass |
| class WifiInfo: |
| connected: bool = False |
| ssid: Optional[str] = None |
| signal_pct: Optional[int] = None |
| rssi_dbm: Optional[float] = None |
| rx_mbps: Optional[float] = None |
| tx_mbps: Optional[float] = None |
| channel: Optional[int] = None |
| band_ghz: Optional[float] = None |
| phy: Optional[str] = None |
|
|
|
|
| def rssi_from_quality(pct: int) -> float: |
| """Windows WLAN mapping: quality 0 -> -100 dBm, 100 -> -50 dBm (linear).""" |
| return round(pct / 2.0 - 100.0, 1) |
|
|
|
|
| def quality_from_rssi(rssi: float) -> int: |
| return int(max(0, min(100, round((rssi + 100.0) * 2.0)))) |
|
|
|
|
| def channel_from_freq_mhz(freq: int) -> tuple[Optional[int], Optional[float]]: |
| if 2412 <= freq <= 2472: |
| return (freq - 2407) // 5, 2.4 |
| if freq == 2484: |
| return 14, 2.4 |
| if 5000 <= freq <= 5900: |
| return (freq - 5000) // 5, 5.0 |
| if 5925 <= freq <= 7125: |
| return (freq - 5950) // 5, 6.0 |
| if 57000 <= freq <= 71000: |
| return None, 60.0 |
| return None, None |
|
|
|
|
| def band_from_channel(channel: int) -> Optional[float]: |
| if 1 <= channel <= 14: |
| return 2.4 |
| if 32 <= channel <= 177: |
| return 5.0 |
| return None |
|
|
|
|
| _NETSH_KV_RE = re.compile(r"^\s*([^:]+?)\s*:\s*(.*?)\s*$") |
| _PCT_RE = re.compile(r"^(\d{1,3})\s*%$") |
| _INT_RE = re.compile(r"^\d{1,3}$") |
| _GHZ_RE = re.compile(r"^(\d+(?:\.\d+)?)\s*GHz$", re.IGNORECASE) |
| _PHY_RE = re.compile(r"^802\.11[a-z]{1,2}$", re.IGNORECASE) |
| _MBPS_KEY_RE = re.compile(r"\(\s*Mbps\s*\)", re.IGNORECASE) |
|
|
|
|
| def parse_netsh_wlan(text: str) -> WifiInfo: |
| """Parse `netsh wlan show interfaces` output without relying on localized labels. |
| |
| Only the SSID/BSSID keys are language independent; every other field is |
| recognised by the shape of its value (a percentage, "(Mbps)" in the key, |
| "802.11xx", "x GHz", a bare channel number). |
| """ |
| blocks: list[list[tuple[str, str]]] = [[]] |
| for line in text.splitlines(): |
| if not line.strip(): |
| if blocks[-1]: |
| blocks.append([]) |
| continue |
| m = _NETSH_KV_RE.match(line) |
| if m: |
| blocks[-1].append((m.group(1), m.group(2))) |
| info = WifiInfo() |
| for block in blocks: |
| kv = dict(block) |
| ssid = kv.get("SSID") |
| if not ssid or not any(_PCT_RE.match(v) for _, v in block): |
| continue |
| info.connected = True |
| info.ssid = ssid |
| rates: list[tuple[str, float]] = [] |
| for key, value in block: |
| if key in ("SSID", "BSSID"): |
| continue |
| if info.signal_pct is None and _PCT_RE.match(value): |
| info.signal_pct = int(_PCT_RE.match(value).group(1)) |
| elif _MBPS_KEY_RE.search(key): |
| try: |
| rates.append((key.lower(), float(value.replace(",", ".")))) |
| except ValueError: |
| pass |
| elif info.phy is None and _PHY_RE.match(value): |
| info.phy = value.lower() |
| elif info.band_ghz is None and _GHZ_RE.match(value): |
| info.band_ghz = float(_GHZ_RE.match(value).group(1)) |
| elif info.channel is None and _INT_RE.match(value): |
| info.channel = int(value) |
| for key, rate in rates: |
| if "transmit" in key or "tx" in key.split(): |
| info.tx_mbps = rate |
| elif "receive" in key or "rx" in key.split(): |
| info.rx_mbps = rate |
| if info.rx_mbps is None and rates: |
| info.rx_mbps = rates[0][1] |
| if info.tx_mbps is None and len(rates) > 1: |
| info.tx_mbps = rates[1][1] |
| if info.signal_pct is not None: |
| info.rssi_dbm = rssi_from_quality(info.signal_pct) |
| if info.band_ghz is None and info.channel is not None: |
| info.band_ghz = band_from_channel(info.channel) |
| break |
| return info |
|
|
|
|
| def wifi_info_windows() -> WifiInfo: |
| code, out = run_cmd(["netsh", "wlan", "show", "interfaces"], timeout=15.0) |
| return parse_netsh_wlan(out) if out else WifiInfo() |
|
|
|
|
| _IW_PHY = (("EHT", "802.11be"), ("HE", "802.11ax"), ("VHT", "802.11ac"), ("HT", "802.11n")) |
|
|
|
|
| def parse_iw_link(text: str) -> WifiInfo: |
| info = WifiInfo() |
| if "Not connected" in text or "SSID:" not in text: |
| return info |
| info.connected = True |
| m = re.search(r"^\s*SSID:\s*(.+?)\s*$", text, re.MULTILINE) |
| info.ssid = m.group(1) if m else None |
| m = re.search(r"^\s*freq:\s*(\d+)", text, re.MULTILINE) |
| if m: |
| info.channel, info.band_ghz = channel_from_freq_mhz(int(m.group(1))) |
| m = re.search(r"^\s*signal:\s*(-?\d+(?:\.\d+)?)\s*dBm", text, re.MULTILINE) |
| if m: |
| info.rssi_dbm = float(m.group(1)) |
| info.signal_pct = quality_from_rssi(info.rssi_dbm) |
| for key, attr in (("rx bitrate", "rx_mbps"), ("tx bitrate", "tx_mbps")): |
| m = re.search(rf"^\s*{key}:\s*(\d+(?:\.\d+)?)\s*MBit/s(.*)$", text, re.MULTILINE | re.IGNORECASE) |
| if m: |
| setattr(info, attr, float(m.group(1))) |
| if info.phy is None: |
| rest = m.group(2).upper() |
| for token, phy in _IW_PHY: |
| if re.search(rf"\b{token}-", rest): |
| info.phy = phy |
| break |
| if info.phy is None and re.search(r"\bMCS\b", rest): |
| info.phy = "802.11n" |
| return info |
|
|
|
|
| def parse_proc_net_wireless(text: str, iface: str) -> WifiInfo: |
| info = WifiInfo() |
| for line in text.splitlines(): |
| if line.strip().startswith(iface + ":"): |
| parts = line.split() |
| try: |
| level = float(parts[3].rstrip(".")) |
| except (IndexError, ValueError): |
| break |
| info.connected = True |
| info.rssi_dbm = level |
| info.signal_pct = quality_from_rssi(level) |
| break |
| return info |
|
|
|
|
| def wifi_info_linux(iface: Optional[str]) -> WifiInfo: |
| if not iface or not _linux_is_wireless(iface): |
| return WifiInfo() |
| if shutil.which("iw"): |
| code, out = run_cmd(["iw", "dev", iface, "link"], timeout=10.0) |
| if code == 0 and out: |
| return parse_iw_link(out) |
| try: |
| return parse_proc_net_wireless(Path("/proc/net/wireless").read_text(), iface) |
| except OSError: |
| return WifiInfo() |
|
|
|
|
| def parse_system_profiler_airport(data: dict) -> WifiInfo: |
| info = WifiInfo() |
| try: |
| interfaces = data["SPAirPortDataType"][0]["spairport_airport_interfaces"] |
| except (KeyError, IndexError, TypeError): |
| return info |
| for entry in interfaces: |
| net = entry.get("spairport_current_network_information") |
| if not isinstance(net, dict): |
| continue |
| info.connected = True |
| info.ssid = net.get("_name") |
| m = re.search(r"(-?\d+)\s*dBm", str(net.get("spairport_signal_noise", ""))) |
| if m: |
| info.rssi_dbm = float(m.group(1)) |
| info.signal_pct = quality_from_rssi(info.rssi_dbm) |
| m = re.search(r"(\d+)\s*\((\d+(?:\.\d+)?)\s*GHz", str(net.get("spairport_network_channel", ""))) |
| if m: |
| info.channel = int(m.group(1)) |
| info.band_ghz = float(m.group(2)) |
| phy = str(net.get("spairport_network_phymode", "")).lower() |
| info.phy = phy if phy.startswith("802.11") else None |
| rate = net.get("spairport_network_rate") |
| try: |
| info.rx_mbps = float(rate) if rate is not None else None |
| info.tx_mbps = info.rx_mbps |
| except (TypeError, ValueError): |
| pass |
| break |
| return info |
|
|
|
|
| def wifi_info_macos() -> WifiInfo: |
| code, out = run_cmd(["system_profiler", "SPAirPortDataType", "-json"], timeout=25.0) |
| if code != 0 or not out: |
| return WifiInfo() |
| try: |
| return parse_system_profiler_airport(json.loads(out)) |
| except ValueError: |
| return WifiInfo() |
|
|
|
|
| def wifi_info(net: NetworkInfo) -> WifiInfo: |
| try: |
| if IS_WINDOWS: |
| return wifi_info_windows() |
| if IS_MACOS: |
| return wifi_info_macos() |
| return wifi_info_linux(net.interface) |
| except Exception: |
| return WifiInfo() |
|
|
|
|
| |
| |
| |
|
|
| def _ookla_cli_path() -> Optional[str]: |
| """Path of the official Ookla CLI, distinguishing it from speedtest-cli.""" |
| exe = shutil.which("speedtest") |
| if not exe: |
| return None |
| code, out = run_cmd([exe, "--version"], timeout=15.0) |
| return exe if "ookla" in out.lower() else None |
|
|
|
|
| def parse_ookla_json(data: dict) -> dict: |
| result = {} |
| down = data.get("download") or {} |
| up = data.get("upload") or {} |
| if "bandwidth" in down: |
| result["download_mbps"] = round(down["bandwidth"] * 8 / 1e6, 2) |
| if "bandwidth" in up: |
| result["upload_mbps"] = round(up["bandwidth"] * 8 / 1e6, 2) |
| ping_info = data.get("ping") or {} |
| if ping_info.get("latency") is not None: |
| result["speedtest_ping_ms"] = round(float(ping_info["latency"]), 3) |
| for key, col in (("download", "download_loaded_latency_ms"), |
| ("upload", "upload_loaded_latency_ms")): |
| lat = (data.get(key) or {}).get("latency") or {} |
| if lat.get("iqm") is not None: |
| result[col] = round(float(lat["iqm"]), 3) |
| server = data.get("server") or {} |
| if server.get("id") is not None: |
| result["speedtest_server_id"] = int(server["id"]) |
| name = ", ".join(str(server[k]) for k in ("name", "location") if server.get(k)) |
| if name: |
| result["speedtest_server"] = name |
| return result |
|
|
|
|
| def run_speedtest(server_id: Optional[int] = None, timeout_s: float = 180.0) -> dict: |
| exe = _ookla_cli_path() |
| if exe: |
| cmd = [exe, "--accept-license", "--accept-gdpr", "--format=json", "--progress=no"] |
| if server_id: |
| cmd += ["--server-id", str(server_id)] |
| code, out = run_cmd(cmd, timeout=timeout_s, encoding="utf-8") |
| for line in out.splitlines(): |
| line = line.strip() |
| if line.startswith("{"): |
| try: |
| data = json.loads(line) |
| except ValueError: |
| continue |
| if data.get("type") == "result": |
| return parse_ookla_json(data) |
| return {"error": "speedtest (ookla) failed: " + (out.strip().splitlines() or ["no output"])[-1][:80]} |
| try: |
| import speedtest |
| except ImportError: |
| return {"error": "no speedtest tool (install the Ookla CLI or `pip install speedtest-cli`)"} |
| try: |
| st = speedtest.Speedtest(secure=True) |
| if server_id: |
| st.get_servers([server_id]) |
| st.get_best_server() |
| down = st.download() / 1e6 |
| up = st.upload(pre_allocate=False) / 1e6 |
| res = st.results |
| out = {"download_mbps": round(down, 2), "upload_mbps": round(up, 2)} |
| if res.ping is not None and float(res.ping) < SPEEDTEST_PING_FAILED_MS: |
| out["speedtest_ping_ms"] = round(float(res.ping), 3) |
| elif res.ping is not None: |
| out["error"] = "speedtest-cli: server latency probe failed" |
| server = res.server or {} |
| if server.get("id"): |
| out["speedtest_server_id"] = int(server["id"]) |
| name = ", ".join(str(server[k]) for k in ("sponsor", "name") if server.get(k)) |
| if name: |
| out["speedtest_server"] = name |
| return out |
| except Exception as exc: |
| return {"error": f"speedtest-cli failed: {exc}"[:120]} |
|
|
|
|
| def run_iperf3(server: str, port: int, duration_s: int, reverse: bool) -> dict: |
| if not shutil.which("iperf3"): |
| return {"error": "iperf3 not found"} |
| cmd = ["iperf3", "-c", server, "-p", str(port), "-t", str(duration_s), "-J"] |
| if reverse: |
| cmd.append("-R") |
| code, out = run_cmd(cmd, timeout=duration_s + 30, encoding="utf-8") |
| try: |
| data = json.loads(out) |
| except ValueError: |
| return {"error": "iperf3 failed: " + (out.strip().splitlines() or ["no output"])[-1][:80]} |
| if data.get("error"): |
| return {"error": f"iperf3 failed: {data['error']}"[:120]} |
| try: |
| end = data["end"] |
| received = end.get("sum_received") or end.get("sum") or {} |
| result = {"lan_throughput_mbps": round(received["bits_per_second"] / 1e6, 2)} |
| sent = end.get("sum_sent") or {} |
| if sent.get("retransmits") is not None: |
| result["lan_retransmits"] = int(sent["retransmits"]) |
| return result |
| except (KeyError, TypeError): |
| return {"error": "iperf3 failed: unexpected JSON"} |
|
|
|
|
| |
| |
| |
|
|
| class KeepAwake: |
| """System sleep inhibitor (display may still turn off).""" |
|
|
| ES_CONTINUOUS = 0x80000000 |
| ES_SYSTEM_REQUIRED = 0x00000001 |
|
|
| def __init__(self) -> None: |
| self.proc: Optional[subprocess.Popen] = None |
| self.active = False |
|
|
| def __enter__(self) -> "KeepAwake": |
| try: |
| if IS_WINDOWS: |
| import ctypes |
| ok = ctypes.windll.kernel32.SetThreadExecutionState( |
| self.ES_CONTINUOUS | self.ES_SYSTEM_REQUIRED) |
| self.active = bool(ok) |
| elif IS_MACOS and shutil.which("caffeinate"): |
| self.proc = subprocess.Popen(["caffeinate", "-i", "-w", str(os.getpid())]) |
| self.active = True |
| elif IS_LINUX and shutil.which("systemd-inhibit"): |
| self.proc = subprocess.Popen( |
| ["systemd-inhibit", "--what=sleep:idle", "--who=LocalNet-Dynamics", |
| "--why=telemetry collection in progress", "--mode=block", |
| "sleep", "infinity"], |
| stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) |
| self.active = True |
| except Exception: |
| self.active = False |
| return self |
|
|
| def __exit__(self, *exc) -> None: |
| try: |
| if IS_WINDOWS: |
| import ctypes |
| ctypes.windll.kernel32.SetThreadExecutionState(self.ES_CONTINUOUS) |
| if self.proc: |
| self.proc.terminate() |
| except Exception: |
| pass |
|
|
|
|
| |
| |
| |
|
|
| def now_timestamps() -> tuple[str, str, int]: |
| utc = datetime.now(timezone.utc) |
| local = utc.astimezone() |
| return (utc.strftime("%Y-%m-%dT%H:%M:%SZ"), |
| local.isoformat(timespec="seconds"), |
| int(utc.timestamp())) |
|
|
|
|
| def collect_sample(cfg: argparse.Namespace, net: NetworkInfo, dns_server: Optional[str], |
| pool: ThreadPoolExecutor, run_speed: bool, run_lan: bool) -> Sample: |
| s = Sample(run_id=cfg.run_id, host_label=cfg.host_label, target=cfg.target, |
| link_type=net.link_type, gateway_ip=net.gateway or "", |
| dns_server=dns_server or "") |
| s.timestamp_utc, s.timestamp_local, s.epoch_s = now_timestamps() |
| t0 = time.perf_counter() |
| notes: list[str] = [] |
|
|
| futures = { |
| "ping": pool.submit(ping, cfg.target, cfg.ping_count, cfg.ping_timeout), |
| } |
| if net.gateway: |
| futures["gw"] = pool.submit(ping, net.gateway, cfg.gateway_ping_count, cfg.ping_timeout) |
| if cfg.tcp_port: |
| futures["tcp"] = pool.submit(tcp_connect_times, cfg.target, cfg.tcp_port, |
| cfg.tcp_count, cfg.ping_timeout) |
| if dns_server: |
| futures["dns"] = pool.submit(dns_query, dns_server, cfg.dns_host, cfg.dns_timeout) |
| futures["dnsr"] = pool.submit(dns_query, dns_server, |
| f"{random_label()}.{cfg.dns_host}", cfg.dns_timeout) |
| if cfg.http_url: |
| futures["http"] = pool.submit(http_probe, cfg.http_url, cfg.http_timeout) |
| if cfg.wifi and net.link_type in ("wifi", "unknown"): |
| futures["wifi"] = pool.submit(wifi_info, net) |
|
|
| p: PingResult = futures["ping"].result() |
| st = rtt_stats(p.rtts or []) |
| s.rtt_min_ms, s.rtt_avg_ms, s.rtt_median_ms = st["min"], st["avg"], st["median"] |
| s.rtt_max_ms, s.rtt_stddev_ms, s.jitter_ms = st["max"], st["stddev"], st["jitter"] |
| s.packets_sent, s.packets_received = p.sent, p.received |
| s.packet_loss_pct = p.loss_pct |
| if p.error: |
| notes.append(f"ping: {p.error}") |
|
|
| if "gw" in futures: |
| g: PingResult = futures["gw"].result() |
| gst = rtt_stats(g.rtts or []) |
| s.gateway_rtt_min_ms, s.gateway_rtt_avg_ms = gst["min"], gst["avg"] |
| s.gateway_rtt_max_ms, s.gateway_jitter_ms = gst["max"], gst["jitter"] |
| s.gateway_packet_loss_pct = g.loss_pct |
| if g.error: |
| notes.append(f"gateway ping: {g.error}") |
|
|
| if "tcp" in futures: |
| times, err = futures["tcp"].result() |
| if times: |
| s.tcp_connect_min_ms = round(min(times), 3) |
| s.tcp_connect_median_ms = round(statistics.median(times), 3) |
| if err: |
| notes.append(f"tcp: {err}") |
|
|
| if "dns" in futures: |
| ms, rcode, err = futures["dns"].result() |
| s.dns_resolve_ms = ms |
| if err: |
| notes.append(f"dns: {err}") |
| ms, rcode, err = futures["dnsr"].result() |
| s.dns_recursive_ms = ms |
| if err: |
| notes.append(f"dns recursive: {err}") |
|
|
| if "http" in futures: |
| ms, status, err = futures["http"].result() |
| s.http_ms, s.http_status = ms, status |
| if err: |
| notes.append(f"http: {err}") |
|
|
| if "wifi" in futures: |
| w: WifiInfo = futures["wifi"].result() |
| if w.connected: |
| s.wifi_ssid = w.ssid if (cfg.record_ssid and w.ssid) else "" |
| s.wifi_signal_pct, s.wifi_rssi_dbm = w.signal_pct, w.rssi_dbm |
| s.wifi_rx_mbps, s.wifi_tx_mbps = w.rx_mbps, w.tx_mbps |
| s.wifi_channel, s.wifi_band_ghz = w.channel, w.band_ghz |
| s.wifi_phy = w.phy or "" |
|
|
| |
| if run_speed: |
| r = run_speedtest(cfg.speedtest_server) |
| for key, value in r.items(): |
| if key != "error": |
| setattr(s, key, value) |
| if r.get("error"): |
| notes.append(r["error"]) |
| if run_lan: |
| r = run_iperf3(cfg.iperf_server, cfg.iperf_port, cfg.iperf_duration, cfg.iperf_reverse) |
| for key, value in r.items(): |
| if key != "error": |
| setattr(s, key, value) |
| if r.get("error"): |
| notes.append(r["error"]) |
|
|
| s.sample_duration_s = round(time.perf_counter() - t0, 2) |
| s.notes = "; ".join(notes) |
| return s |
|
|
|
|
| |
| |
| |
|
|
| def column_stats(values: list) -> Optional[dict]: |
| vals = [float(v) for v in values if v is not None and v != ""] |
| if not vals: |
| return None |
| vals_sorted = sorted(vals) |
| p95 = vals_sorted[min(len(vals_sorted) - 1, int(0.95 * len(vals_sorted)))] |
| return { |
| "count": len(vals), |
| "mean": round(statistics.mean(vals), 3), |
| "median": round(statistics.median(vals), 3), |
| "min": round(vals_sorted[0], 3), |
| "max": round(vals_sorted[-1], 3), |
| "p95": round(p95, 3), |
| "stddev": round(statistics.pstdev(vals), 3) if len(vals) > 1 else 0.0, |
| } |
|
|
|
|
| class RunningSummary: |
| """Keeps per-column value lists so the JSON summary can be refreshed cheaply.""" |
|
|
| def __init__(self) -> None: |
| self.values: dict[str, list] = {k: [] for k in SUMMARY_KEYS} |
| self.count = 0 |
| self.first_utc = "" |
| self.last_utc = "" |
| self.link_types: dict[str, int] = {} |
|
|
| def add(self, s: Sample) -> None: |
| self.count += 1 |
| self.first_utc = self.first_utc or s.timestamp_utc |
| self.last_utc = s.timestamp_utc |
| self.link_types[s.link_type] = self.link_types.get(s.link_type, 0) + 1 |
| for k in SUMMARY_KEYS: |
| v = getattr(s, k) |
| if v is not None: |
| self.values[k].append(v) |
|
|
| def summary(self) -> dict: |
| out = {k: column_stats(v) for k, v in self.values.items()} |
| return {k: v for k, v in out.items() if v is not None} |
|
|
|
|
| def timezone_name() -> str: |
| local = datetime.now(timezone.utc).astimezone() |
| return local.tzname() or "" |
|
|
|
|
| def write_meta(path: Path, cfg: argparse.Namespace, net: NetworkInfo, dns_server: Optional[str], |
| summary: RunningSummary, status: str, started_utc: str, |
| elapsed_s: float, csv_name: str) -> None: |
| local = datetime.now(timezone.utc).astimezone() |
| payload = { |
| "run_id": cfg.run_id, |
| "host_label": cfg.host_label, |
| "collector_version": COLLECTOR_VERSION, |
| "status": status, |
| "started_utc": started_utc, |
| "updated_utc": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), |
| "planned_duration_s": cfg.duration, |
| "elapsed_s": round(elapsed_s, 1), |
| "interval_s": cfg.interval, |
| "sample_count": summary.count, |
| "first_sample_utc": summary.first_utc, |
| "last_sample_utc": summary.last_utc, |
| "csv_file": csv_name, |
| "config": { |
| "target": cfg.target, |
| "ping_count": cfg.ping_count, |
| "gateway_ping_count": cfg.gateway_ping_count, |
| "ping_timeout_s": cfg.ping_timeout, |
| "tcp_port": cfg.tcp_port, |
| "tcp_count": cfg.tcp_count, |
| "dns_host": cfg.dns_host, |
| "dns_server": dns_server, |
| "dns_timeout_s": cfg.dns_timeout, |
| "http_url": cfg.http_url, |
| "http_timeout_s": cfg.http_timeout, |
| "wifi": cfg.wifi, |
| "record_ssid": cfg.record_ssid, |
| "speedtest": cfg.speedtest, |
| "speedtest_every_s": cfg.speedtest_every if cfg.speedtest else None, |
| "speedtest_server_id": cfg.speedtest_server, |
| "iperf_server": cfg.iperf_server, |
| "iperf_port": cfg.iperf_port, |
| "iperf_every_s": cfg.iperf_every if cfg.iperf_server else None, |
| "iperf_duration_s": cfg.iperf_duration, |
| "iperf_reverse": cfg.iperf_reverse, |
| }, |
| "environment": { |
| "os": platform.platform(), |
| "python": platform.python_version(), |
| "machine": platform.machine(), |
| "timezone": timezone_name(), |
| "utc_offset_s": int(local.utcoffset().total_seconds()) if local.utcoffset() else 0, |
| "ping_resolution_ms": 1.0 if IS_WINDOWS else 0.001, |
| }, |
| "network": { |
| "gateway_ip": net.gateway, |
| "interface": net.interface, |
| "local_ip": net.local_ip, |
| "link_type": net.link_type, |
| "link_types_seen": summary.link_types, |
| "detection_source": net.source, |
| }, |
| "summary": summary.summary(), |
| } |
| tmp = path.with_suffix(".json.tmp") |
| tmp.write_text(json.dumps(payload, indent=2), encoding="utf-8") |
| os.replace(tmp, path) |
|
|
|
|
| def print_summary(summary: RunningSummary, elapsed: float) -> None: |
| stats = summary.summary() |
| print() |
| print("=" * 72) |
| print(f" SUMMARY: {summary.count} samples over {human_duration(elapsed)}") |
| print("=" * 72) |
| header = f"{'metric':<28}{'n':>7}{'median':>10}{'mean':>10}{'p95':>10}{'max':>10}" |
| print(header) |
| print("-" * len(header)) |
| for key in SUMMARY_KEYS: |
| st = stats.get(key) |
| if not st: |
| continue |
| print(f"{key:<28}{st['count']:>7}{st['median']:>10}{st['mean']:>10}" |
| f"{st['p95']:>10}{st['max']:>10}") |
| print("=" * 72) |
|
|
|
|
| def format_progress(s: Sample) -> str: |
| def f(v, suffix="", nd=1): |
| return "-" if v is None else f"{v:.{nd}f}{suffix}" |
| parts = [ |
| f"[{s.sample_index + 1:>5}] {s.timestamp_utc}", |
| f"rtt={f(s.rtt_avg_ms, 'ms')}", |
| f"jit={f(s.jitter_ms, 'ms')}", |
| f"loss={f(s.packet_loss_pct, '%', 0)}", |
| f"gw={f(s.gateway_rtt_avg_ms, 'ms')}", |
| f"tcp={f(s.tcp_connect_median_ms, 'ms')}", |
| f"dns={f(s.dns_resolve_ms, '', 0)}/{f(s.dns_recursive_ms, 'ms', 0)}", |
| f"http={f(s.http_ms, 'ms', 0)}", |
| ] |
| if s.wifi_signal_pct is not None: |
| parts.append(f"wifi={s.wifi_signal_pct}%/{f(s.wifi_rx_mbps, 'Mbps', 0)}") |
| if s.download_mbps is not None: |
| parts.append(f"down={f(s.download_mbps, '', 1)} up={f(s.upload_mbps, 'Mbps', 1)}") |
| if s.lan_throughput_mbps is not None: |
| parts.append(f"lan={f(s.lan_throughput_mbps, 'Mbps', 0)}") |
| if s.notes: |
| parts.append(f"! {s.notes}") |
| return " ".join(parts) |
|
|
|
|
| |
| |
| |
|
|
| def build_parser() -> argparse.ArgumentParser: |
| p = argparse.ArgumentParser( |
| description="LocalNet-Dynamics: continuous network telemetry collector.", |
| formatter_class=argparse.ArgumentDefaultsHelpFormatter, |
| ) |
| default_out = Path(__file__).resolve().parent.parent / "dataset" / "raw" |
|
|
| g = p.add_argument_group("schedule") |
| g.add_argument("--duration", type=parse_duration, default="24h", |
| help="total run time (e.g. 6h, 7d, 30d)") |
| g.add_argument("--interval", type=parse_duration, default="30s", |
| help="time between sample starts (e.g. 30s, 1m, 5m)") |
|
|
| g = p.add_argument_group("latency probes") |
| g.add_argument("--target", default="8.8.8.8", |
| help="reference host for ICMP and TCP probes") |
| g.add_argument("--ping-count", type=int, default=10, |
| help="ICMP echo requests per sample (sent 1 s apart)") |
| g.add_argument("--gateway-ping-count", type=int, default=5, |
| help="ICMP echo requests to the default gateway per sample") |
| g.add_argument("--ping-timeout", type=float, default=2.0, |
| help="seconds to wait for each ICMP reply / TCP connect") |
| g.add_argument("--tcp-port", type=int, default=443, |
| help="TCP port on the target for connect-time probes (0 disables)") |
| g.add_argument("--tcp-count", type=int, default=5, |
| help="TCP connections per sample") |
| g.add_argument("--dns-host", default="example.com", |
| help="name queried for DNS timing; the recursive probe queries a " |
| "random subdomain of it") |
| g.add_argument("--dns-server", default=None, |
| help="resolver IP to query (default: the system resolver of the " |
| "default-route interface, then the gateway)") |
| g.add_argument("--dns-timeout", type=float, default=3.0, help="DNS query timeout (s)") |
| g.add_argument("--http-url", default="http://www.msftconnecttest.com/connecttest.txt", |
| help="small URL for the HTTP time-to-first-response probe " |
| "('' disables)") |
| g.add_argument("--http-timeout", type=float, default=5.0, help="HTTP probe timeout (s)") |
|
|
| g = p.add_argument_group("wireless") |
| g.add_argument("--no-wifi", dest="wifi", action="store_false", |
| help="do not query Wi-Fi link metrics") |
| g.add_argument("--record-ssid", action="store_true", |
| help="store the Wi-Fi network name in the dataset (off by default " |
| "because it can identify the collection site)") |
|
|
| g = p.add_argument_group("throughput tests") |
| g.add_argument("--speedtest", action="store_true", |
| help="run a WAN speed test periodically (Ookla CLI or speedtest-cli)") |
| g.add_argument("--speedtest-every", type=parse_duration, default="30m", |
| help="interval between WAN speed tests") |
| g.add_argument("--speedtest-server", type=int, default=None, |
| help="Ookla server id to pin (recommended for consistency)") |
| g.add_argument("--iperf-server", default=None, |
| help="address of an `iperf3 -s` host on the LAN") |
| g.add_argument("--iperf-port", type=int, default=5201, help="iperf3 server port") |
| g.add_argument("--iperf-every", type=parse_duration, default="30m", |
| help="interval between LAN throughput tests") |
| g.add_argument("--iperf-duration", type=int, default=10, help="seconds per iperf3 test") |
| g.add_argument("--iperf-reverse", action="store_true", |
| help="measure server-to-client (download) direction instead") |
|
|
| g = p.add_argument_group("output") |
| g.add_argument("--output-dir", default=str(default_out), |
| help="directory for the run's CSV and JSON files") |
| g.add_argument("--run-id", default=None, |
| help="run identifier and file stem (default: <label_>YYYYMMDD_HHMMSS)") |
| g.add_argument("--host-label", default="", |
| help="free-text label for this vantage point, e.g. desktop-eth or " |
| "laptop-wifi (stored in every row)") |
| g.add_argument("--no-keep-awake", dest="keep_awake", action="store_false", |
| help="do not inhibit system sleep while collecting") |
| g.add_argument("--quiet", action="store_true", help="print only the summary") |
| g.add_argument("--check", action="store_true", |
| help="detect the environment, take one sample, print it as JSON " |
| "and exit without writing files") |
| return p |
|
|
|
|
| def resolve_dns_server(cfg: argparse.Namespace, net: NetworkInfo) -> Optional[str]: |
| if cfg.dns_server: |
| return cfg.dns_server |
| if net.dns_servers: |
| return net.dns_servers[0] |
| return net.gateway |
|
|
|
|
| def sanitize_label(text: str) -> str: |
| return re.sub(r"[^A-Za-z0-9_-]+", "-", text.strip()).strip("-") |
|
|
|
|
| def install_sigterm_handler() -> None: |
| def handler(signum, frame): |
| raise KeyboardInterrupt |
| try: |
| signal.signal(signal.SIGTERM, handler) |
| except (ValueError, OSError, AttributeError): |
| pass |
|
|
|
|
| def main(argv: Optional[list[str]] = None) -> int: |
| for stream in (sys.stdout, sys.stderr): |
| try: |
| stream.reconfigure(errors="replace") |
| except (AttributeError, ValueError): |
| pass |
| cfg = build_parser().parse_args(argv) |
| cfg.duration = float(cfg.duration) |
| cfg.interval = float(cfg.interval) |
| cfg.speedtest_every = float(cfg.speedtest_every) |
| cfg.iperf_every = float(cfg.iperf_every) |
| cfg.host_label = sanitize_label(cfg.host_label) |
| if cfg.interval <= 0: |
| print("error: --interval must be positive", file=sys.stderr) |
| return 2 |
| if cfg.ping_count < 1 or cfg.gateway_ping_count < 1: |
| print("error: ping counts must be at least 1", file=sys.stderr) |
| return 2 |
| stamp = f"{datetime.now():%Y%m%d_%H%M%S}" |
| cfg.run_id = sanitize_label(cfg.run_id) if cfg.run_id else \ |
| (f"{cfg.host_label}_{stamp}" if cfg.host_label else stamp) |
|
|
| net = detect_network(cfg.target) |
| dns_server = resolve_dns_server(cfg, net) |
| pool = ThreadPoolExecutor(max_workers=8) |
|
|
| if cfg.check: |
| print(json.dumps({ |
| "collector_version": COLLECTOR_VERSION, |
| "os": platform.platform(), |
| "python": platform.python_version(), |
| "ping_utility": shutil.which("ping"), |
| "ookla_cli": _ookla_cli_path(), |
| "iperf3": shutil.which("iperf3"), |
| "network": asdict(net), |
| "dns_server": dns_server, |
| }, indent=2)) |
| s = collect_sample(cfg, net, dns_server, pool, run_speed=cfg.speedtest, |
| run_lan=bool(cfg.iperf_server)) |
| print(json.dumps(asdict(s), indent=2)) |
| pool.shutdown(wait=False) |
| return 0 |
|
|
| out_dir = Path(cfg.output_dir) |
| out_dir.mkdir(parents=True, exist_ok=True) |
| csv_path = out_dir / f"localnet_{cfg.run_id}.csv" |
| json_path = out_dir / f"localnet_{cfg.run_id}.json" |
| if csv_path.exists(): |
| print(f"error: {csv_path} already exists; choose another --run-id", file=sys.stderr) |
| return 2 |
|
|
| light_budget = max(cfg.ping_count, cfg.gateway_ping_count) * max(1.0, cfg.ping_timeout) + 2.0 |
| print(f"LocalNet-Dynamics collector {COLLECTOR_VERSION}") |
| print(f"run id : {cfg.run_id}") |
| print(f"target : {cfg.target} (ICMP x{cfg.ping_count}, TCP :{cfg.tcp_port} x{cfg.tcp_count})") |
| print(f"gateway : {net.gateway or 'not detected'} link: {net.link_type}" |
| f" interface: {net.interface or '?'} local ip: {net.local_ip or '?'}") |
| print(f"dns server : {dns_server or 'none (DNS probes disabled)'} name: {cfg.dns_host}") |
| print(f"http probe : {cfg.http_url or 'disabled'}") |
| print(f"schedule : every {human_duration(cfg.interval)} for {human_duration(cfg.duration)}" |
| f" (~{int(cfg.duration // cfg.interval) + 1} samples)") |
| if cfg.speedtest: |
| print(f"wan speed : every {human_duration(cfg.speedtest_every)}" |
| f" ({'ookla cli' if _ookla_cli_path() else 'speedtest-cli module'})") |
| if cfg.iperf_server: |
| print(f"lan iperf3 : {cfg.iperf_server}:{cfg.iperf_port} every " |
| f"{human_duration(cfg.iperf_every)}, {cfg.iperf_duration}s per test") |
| print(f"output : {csv_path}") |
| if cfg.interval < light_budget: |
| print(f"warning: the worst-case probe time ({light_budget:.0f}s) exceeds the interval;" |
| f" samples will be skipped during outages") |
| if not net.gateway: |
| print("warning: default gateway not detected; gateway metrics will be empty") |
| print("Press Ctrl-C to stop; every completed sample is already on disk.\n") |
|
|
| install_sigterm_handler() |
| started_utc = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") |
| summary = RunningSummary() |
| status = "completed" |
|
|
| csv_file = csv_path.open("w", newline="", encoding="utf-8") |
| writer = csv.DictWriter(csv_file, fieldnames=CSV_FIELDS) |
| writer.writeheader() |
| csv_file.flush() |
| write_meta(json_path, cfg, net, dns_server, summary, "running", started_utc, 0.0, csv_path.name) |
|
|
| start_mono = time.monotonic() |
| next_speed = start_mono if cfg.speedtest else None |
| next_lan = start_mono if cfg.iperf_server else None |
| next_route = start_mono + ROUTE_REFRESH_S |
| next_meta = start_mono + META_REFRESH_S |
| tick = 0 |
| index = 0 |
|
|
| try: |
| with (KeepAwake() if cfg.keep_awake else contextlib.nullcontext()) as awake: |
| if cfg.keep_awake and not (awake and awake.active): |
| print("note: could not inhibit system sleep; disable sleep in the OS power settings") |
| while True: |
| due = start_mono + tick * cfg.interval |
| if due - start_mono >= cfg.duration: |
| break |
| now = time.monotonic() |
| if due > now: |
| time.sleep(due - now) |
| elapsed = time.monotonic() - start_mono |
|
|
| if time.monotonic() >= next_route: |
| fresh = detect_network(cfg.target) |
| if fresh.gateway: |
| net = fresh |
| dns_server = resolve_dns_server(cfg, net) |
| next_route = time.monotonic() + ROUTE_REFRESH_S |
|
|
| run_speed = next_speed is not None and time.monotonic() >= next_speed |
| run_lan = next_lan is not None and time.monotonic() >= next_lan |
| s = collect_sample(cfg, net, dns_server, pool, run_speed, run_lan) |
| s.sample_index = index |
| s.elapsed_s = round(elapsed, 1) |
| if run_speed: |
| next_speed += cfg.speedtest_every |
| if run_lan: |
| next_lan += cfg.iperf_every |
| if s.gateway_packet_loss_pct == 100.0: |
| next_route = min(next_route, time.monotonic() + 60.0) |
|
|
| writer.writerow(asdict(s)) |
| csv_file.flush() |
| summary.add(s) |
| index += 1 |
| if not cfg.quiet: |
| print(format_progress(s), flush=True) |
|
|
| if time.monotonic() >= next_meta: |
| write_meta(json_path, cfg, net, dns_server, summary, "running", |
| started_utc, time.monotonic() - start_mono, csv_path.name) |
| next_meta = time.monotonic() + META_REFRESH_S |
|
|
| tick += 1 |
| finished = time.monotonic() |
| if finished > start_mono + tick * cfg.interval: |
| skipped = int((finished - start_mono) // cfg.interval) - tick + 1 |
| tick += skipped |
| if not cfg.quiet: |
| print(f" sample took {s.sample_duration_s}s; skipping {skipped} tick(s)") |
| except KeyboardInterrupt: |
| status = "interrupted" |
| print("\nStopping; finalizing files...") |
| finally: |
| csv_file.close() |
| pool.shutdown(wait=False) |
|
|
| elapsed = time.monotonic() - start_mono |
| write_meta(json_path, cfg, net, dns_server, summary, status, started_utc, elapsed, csv_path.name) |
| if summary.count: |
| print_summary(summary, elapsed) |
| print(f"\n{summary.count} samples written to {csv_path}\nrun metadata: {json_path}") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
