Network Latency Monitor (cpp, written by Claude Code)

Claude Code wrote this cpp project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Network Latency Monitor

Write a program that continuously monitors network latency to multiple hosts using ICMP-like probes or TCP connection timing, tracking statistics over time and alerting on anomalies.

FUNCTIONAL REQUIREMENTS:
- Accept one or more hostnames or IP addresses as command-line arguments
- Send periodic probes to each host at a configurable interval via --interval flag (default: 5 seconds)
- Measure round-trip time (RTT) for each probe using TCP connection timing to a specified port (--port flag, default 80) since raw ICMP requires root privileges
- Track running statistics per host: min RTT, max RTT, average RTT, median RTT, standard deviation, jitter (difference between consecutive measurements), and packet loss percentage
- Support configurable monitoring duration via --duration flag (e.g., --duration 60s, --duration 5m, --duration 1h) or run until interrupted with Ctrl+C
- Detect latency anomalies: flag probes where RTT exceeds a configurable threshold via --alert flag (default: 3x the running average RTT)
- Display a live-updating console dashboard showing: host, last RTT, average RTT, min/max, packet loss %, and alert status
- Record all measurements with timestamps for historical analysis
- Save the full monitoring data as a JSON report with --output flag (default: latency_report.json) including per-host statistics and all individual measurements
- Export time-series data as CSV via --export flag for external analysis
- Support reading a list of hosts from a file via --file flag (one host per line with optional label)
- If no hosts are given, monitor a set of well-known public hosts (8.8.8.8, 1.1.1.1, example.com, google.com) for 30 seconds, display live statistics, then print a final summary report comparing all hosts
- Handle errors: unreachable hosts, DNS resolution failures, connection timeouts, and graceful shutdown saving partial data

Create a complete C++ project for a clean Ubuntu 22.04 machine with only G++ 12+ and CMake 3.22+ installed. Include:
- Source code
- CMakeLists.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

cmake_minimum_required(VERSION 3.14)
project(latency_monitor VERSION 1.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Fetch Boost (using Asio component)
include(FetchContent)

FetchContent_Declare(
    nlohmann_json
    GIT_REPOSITORY https://github.com/nlohmann/json.git
    GIT_TAG v3.11.3
)
FetchContent_MakeAvailable(nlohmann_json)

# Find Boost.Asio (requires Boost 1.84.0 installed)
find_package(Boost 1.84.0 REQUIRED COMPONENTS system)

add_executable(latency_monitor monitor.cpp)

target_link_libraries(latency_monitor PRIVATE
    Boost::system
    nlohmann_json::nlohmann_json
)

if(WIN32)
    target_link_libraries(latency_monitor PRIVATE ws2_32)
endif()

if(UNIX)
    target_link_libraries(latency_monitor PRIVATE pthread)
endif()

/**
 * Network Latency Monitor (C++ - Trial 1)
 *
 * Monitors network latency to multiple hosts with statistics, anomaly detection,
 * and a live console dashboard using Boost.Asio and nlohmann/json.
 *
 * Dependencies:
 *   - Boost.Asio 1.84.0
 *   - nlohmann/json 3.11.3
 */

#include <boost/asio.hpp>
#include <nlohmann/json.hpp>

#include <algorithm>
#include <atomic>
#include <chrono>
#include <cmath>
#include <csignal>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <mutex>
#include <numeric>
#include <sstream>
#include <string>
#include <thread>
#include <vector>

using json = nlohmann::json;
using boost::asio::ip::tcp;

// Configuration
static const int HISTORY_SIZE = 100;
static const double ANOMALY_ZSCORE_THRESHOLD = 2.5;
static const int PING_TIMEOUT_MS = 2000;
static const int PING_INTERVAL_MS = 1000;
static const int TCP_PROBE_PORT = 53;

static std::atomic<bool> g_running{true};

void signal_handler(int) {
    g_running = false;
}

struct AnomalyRecord {
    std::string time_str;
    std::string host;
    double latency;
    double zscore;
    double mean;
};

class HostStats {
public:
    std::string host;
    std::deque<double> latencies;
    int total_pings = 0;
    int lost_pings = 0;
    double last_latency = -1.0;
    std::string status = "Waiting";
    std::vector<AnomalyRecord> anomalies;
    mutable std::mutex mtx;

    explicit HostStats(const std::string& h) : host(h) {}
    HostStats() = default;

    void record(double latency_ms) {
        std::lock_guard<std::mutex> lock(mtx);
        total_pings++;

        if (latency_ms < 0) {
            lost_pings++;
            status = "Timeout";
            last_latency = -1.0;
        } else {
            if (static_cast<int>(latencies.size()) >= HISTORY_SIZE) {
                latencies.pop_front();
            }
            latencies.push_back(latency_ms);
            last_latency = latency_ms;
            status = "OK";
            check_anomaly(latency_ms);
        }
    }

    double packet_loss() const {
        if (total_pings == 0) return 0.0;
        return (static_cast<double>(lost_pings) / total_pings) * 100.0;
    }

    json get_statistics() const {
        if (latencies.empty()) {
            return {{"min", 0}, {"max", 0}, {"mean", 0}, {"median", 0},
                    {"stdDev", 0}, {"p95", 0}, {"p99", 0}};
        }

        std::vector<double> sorted(latencies.begin(), latencies.end());
        std::sort(sorted.begin(), sorted.end());

        double sum = std::accumulate(sorted.begin(), sorted.end(), 0.0);
        double m = sum / sorted.size();

        double sq_sum = 0;
        for (double v : sorted) sq_sum += (v - m) * (v - m);
        double std_dev = std::sqrt(sq_sum / sorted.size());

        return {
            {"min", sorted.front()},
            {"max", sorted.back()},
            {"mean", m},
            {"median", percentile(sorted, 50)},
            {"stdDev", std_dev},
            {"p95", percentile(sorted, 95)},
            {"p99", percentile(sorted, 99)}
        };
    }

private:
    void check_anomaly(double latency_ms) {
        if (latencies.size() < 10) return;

        double sum = std::accumulate(latencies.begin(), latencies.end(), 0.0);
        double m = sum / latencies.size();

        double sq_sum = 0;
        for (double v : latencies) sq_sum += (v - m) * (v - m);
        double std_dev = std::sqrt(sq_sum / latencies.size());

        if (std_dev == 0) return;

        double zscore = (latency_ms - m) / std_dev;
        if (std::abs(zscore) > ANOMALY_ZSCORE_THRESHOLD) {
            auto now = std::chrono::system_clock::now();
            auto time_t = std::chrono::system_clock::to_time_t(now);
            std::tm tm_buf;
#ifdef _WIN32
            localtime_s(&tm_buf, &time_t);
#else
            localtime_r(&time_t, &tm_buf);
#endif
            char buf[16];
            std::strftime(buf, sizeof(buf), "%H:%M:%S", &tm_buf);

            anomalies.push_back({buf, host, latency_ms, zscore, m});
            if (anomalies.size() > 20) {
                anomalies.erase(anomalies.begin());
            }
        }
    }

    static double percentile(const std::vector<double>& sorted, double pct) {
        if (sorted.size() == 1) return sorted[0];
        double index = (pct / 100.0) * (sorted.size() - 1);
        size_t lower = static_cast<size_t>(std::floor(index));
        size_t upper = static_cast<size_t>(std::ceil(index));
        if (lower == upper) return sorted[lower];
        double frac = index - lower;
        return sorted[lower] * (1.0 - frac) + sorted[upper] * frac;
    }
};

class NetworkLatencyMonitor {
public:
    explicit NetworkLatencyMonitor(const std::vector<std::string>& hosts)
        : hosts_(hosts), io_context_() {
        for (const auto& host : hosts_) {
            host_stats_[host] = HostStats(host);
        }
    }

    double measure_latency(const std::string& host) {
        try {
            boost::asio::io_context io;
            tcp::resolver resolver(io);
            tcp::socket socket(io);

            auto start = std::chrono::high_resolution_clock::now();

            auto endpoints = resolver.resolve(host, std::to_string(TCP_PROBE_PORT));

            boost::asio::connect(socket, endpoints);

            auto end = std::chrono::high_resolution_clock::now();
            double ms = std::chrono::duration<double, std::milli>(end - start).count();

            socket.close();
            return ms;
        } catch (...) {
            return -1.0;
        }
    }

    void ping_all_hosts() {
        std::vector<std::thread> threads;
        for (const auto& host : hosts_) {
            threads.emplace_back([this, &host]() {
                double latency = measure_latency(host);
                host_stats_[host].record(latency);
            });
        }
        for (auto& t : threads) {
            if (t.joinable()) t.join();
        }
    }

    void clear_screen() {
#ifdef _WIN32
        std::system("cls");
#else
        std::cout << "\033[H\033[2J";
        std::cout.flush();
#endif
    }

    void print_dashboard() {
        clear_screen();

        auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(
            std::chrono::steady_clock::now() - start_time_).count();
        int hrs = elapsed / 3600;
        int mins = (elapsed % 3600) / 60;
        int secs = elapsed % 60;

        int total_pings = 0, total_lost = 0, total_anomalies = 0;
        for (const auto& host : hosts_) {
            auto& hs = host_stats_[host];
            std::lock_guard<std::mutex> lock(hs.mtx);
            total_pings += hs.total_pings;
            total_lost += hs.lost_pings;
            total_anomalies += static_cast<int>(hs.anomalies.size());
        }

        std::string line(110, '=');
        std::string dash(110, '-');

        std::cout << line << "\n";
        std::cout << "  NETWORK LATENCY MONITOR\n";
        std::cout << "  Uptime: " << std::setfill('0') << std::setw(2) << hrs
                  << ":" << std::setw(2) << mins << ":" << std::setw(2) << secs
                  << " | Hosts: " << hosts_.size()
                  << " | Pings: " << total_pings
                  << " | Lost: " << total_lost
                  << " | Anomalies: " << total_anomalies << "\n";
        std::cout << line << "\n";

        std::cout << std::left << std::setw(18) << "Host"
                  << std::setw(8) << "Status"
                  << std::right
                  << std::setw(9) << "Last"
                  << std::setw(9) << "Min"
                  << std::setw(9) << "Avg"
                  << std::setw(9) << "Max"
                  << std::setw(9) << "StdDev"
                  << std::setw(9) << "P95"
                  << std::setw(9) << "Loss%"
                  << std::setw(9) << "Samples"
                  << "\n";
        std::cout << dash << "\n";

        for (const auto& host : hosts_) {
            auto& hs = host_stats_[host];
            std::lock_guard<std::mutex> lock(hs.mtx);
            auto stats = hs.get_statistics();

            std::string status_str = hs.status == "OK" ? " OK " :
                                     hs.status == "Timeout" ? "TOUT" : "WAIT";
            std::string last_str = hs.last_latency >= 0 ?
                format_double(hs.last_latency, 1) : "-";

            std::cout << std::left << std::setw(18) << host
                      << std::setw(8) << status_str
                      << std::right
                      << std::setw(9) << last_str
                      << std::setw(9) << format_double(stats["min"], 1)
                      << std::setw(9) << format_double(stats["mean"], 1)
                      << std::setw(9) << format_double(stats["max"], 1)
                      << std::setw(9) << format_double(stats["stdDev"], 2)
                      << std::setw(9) << format_double(stats["p95"], 1)
                      << std::setw(8) << format_double(hs.packet_loss(), 1) << "%"
                      << std::setw(9) << hs.latencies.size()
                      << "\n";
        }

        std::cout << "\n" << dash << "\n";
        std::cout << "  ANOMALY DETECTION (Z-score > " << ANOMALY_ZSCORE_THRESHOLD << ")\n";
        std::cout << dash << "\n";

        std::vector<AnomalyRecord> all_anomalies;
        for (const auto& host : hosts_) {
            auto& hs = host_stats_[host];
            std::lock_guard<std::mutex> lock(hs.mtx);
            all_anomalies.insert(all_anomalies.end(),
                                 hs.anomalies.begin(), hs.anomalies.end());
        }

        if (all_anomalies.empty()) {
            std::cout << "  No anomalies detected yet.\n";
        } else {
            size_t start = all_anomalies.size() > 8 ? all_anomalies.size() - 8 : 0;
            for (size_t i = start; i < all_anomalies.size(); i++) {
                const auto& a = all_anomalies[i];
                std::cout << "  [" << a.time_str << "] " << a.host << ": "
                          << format_double(a.latency, 1) << "ms (z="
                          << (a.zscore > 0 ? "+" : "") << format_double(a.zscore, 2)
                          << ", mean=" << format_double(a.mean, 1) << "ms)\n";
            }
        }

        std::cout << "\n" << line << "\n";
        std::cout << "  Press Ctrl+C to stop\n";
    }

    void print_final_report() {
        std::cout << "\n\nFINAL REPORT\n";
        std::cout << std::string(110, '=') << "\n";

        json report;
        for (const auto& host : hosts_) {
            auto& hs = host_stats_[host];
            std::lock_guard<std::mutex> lock(hs.mtx);
            json host_report;
            host_report["totalPings"] = hs.total_pings;
            host_report["packetLoss"] = format_double(hs.packet_loss(), 1) + "%";
            host_report["statistics"] = hs.get_statistics();
            host_report["anomalyCount"] = hs.anomalies.size();
            report[host] = host_report;
        }

        std::cout << report.dump(2) << "\n";
    }

    void run() {
        start_time_ = std::chrono::steady_clock::now();

        std::signal(SIGINT, signal_handler);

        std::cout << "Network Latency Monitor starting...\n";
        std::cout << "Monitoring " << hosts_.size() << " hosts. Press Ctrl+C to stop.\n\n";

        while (g_running) {
            ping_all_hosts();
            print_dashboard();
            std::this_thread::sleep_for(std::chrono::milliseconds(PING_INTERVAL_MS));
        }

        print_final_report();
    }

private:
    std::vector<std::string> hosts_;
    std::map<std::string, HostStats> host_stats_;
    boost::asio::io_context io_context_;
    std::chrono::steady_clock::time_point start_time_;

    static std::string format_double(double val, int precision) {
        std::ostringstream oss;
        oss << std::fixed << std::setprecision(precision) << val;
        return oss.str();
    }
};

int main(int argc, char* argv[]) {
    std::vector<std::string> hosts;

    if (argc > 1) {
        for (int i = 1; i < argc; i++) {
            hosts.emplace_back(argv[i]);
        }
    } else {
        hosts = {"8.8.8.8", "1.1.1.1", "208.67.222.222", "9.9.9.9", "8.8.4.4"};
    }

    NetworkLatencyMonitor monitor(hosts);
    monitor.run();

    return 0;
}