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)
set(CMAKE_CXX_EXTENSIONS OFF)

# ---------------------------------------------------------------------------
# Dependencies
# ---------------------------------------------------------------------------
# libcurl (system) — HTTP client for measuring TCP connect latency
# cxxopts 3.1.1 — Lightweight command-line option parser for C++
# nlohmann/json 3.11.3 — Modern JSON for C++
# ---------------------------------------------------------------------------

include(FetchContent)

# libcurl (system install)
find_package(CURL REQUIRED)

# cxxopts via FetchContent
FetchContent_Declare(
    cxxopts
    GIT_REPOSITORY https://github.com/jarro2783/cxxopts.git
    GIT_TAG        v3.1.1
    GIT_SHALLOW    TRUE
)

# nlohmann/json via FetchContent
FetchContent_Declare(
    nlohmann_json
    GIT_REPOSITORY https://github.com/nlohmann/json.git
    GIT_TAG        v3.11.3
    GIT_SHALLOW    TRUE
)

set(CXXOPTS_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
set(CXXOPTS_BUILD_TESTS OFF CACHE BOOL "" FORCE)
set(JSON_BuildTests OFF CACHE BOOL "" FORCE)

FetchContent_MakeAvailable(cxxopts nlohmann_json)

# ---------------------------------------------------------------------------
# Executable
# ---------------------------------------------------------------------------

add_executable(latency_monitor main.cpp)

target_link_libraries(latency_monitor PRIVATE
    CURL::libcurl
    cxxopts::cxxopts
    nlohmann_json::nlohmann_json
)

# Pthreads on Linux
find_package(Threads REQUIRED)
target_link_libraries(latency_monitor PRIVATE Threads::Threads)

if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    target_compile_options(latency_monitor PRIVATE -Wall -Wextra -Wpedantic)
endif()

/**
 * Network Latency Monitor - Trial 3 (C++)
 *
 * Monitors network latency to multiple hosts using HTTP-based timing via libcurl,
 * with statistics, anomaly detection, and a live console dashboard.
 *
 * Dependencies:
 *   - libcurl (system)
 *   - cxxopts 3.1.1
 *   - nlohmann/json 3.11.3
 */

#include <algorithm>
#include <atomic>
#include <chrono>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <mutex>
#include <numeric>
#include <signal.h>
#include <sstream>
#include <string>
#include <thread>
#include <vector>

#include <curl/curl.h>
#include <cxxopts.hpp>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

// ---------------------------------------------------------------------------
// Configuration
// ---------------------------------------------------------------------------

static const std::vector<std::string> DEFAULT_HOSTS = {
    "8.8.8.8", "1.1.1.1", "208.67.222.222", "9.9.9.9", "8.8.4.4"
};

static int PING_INTERVAL_MS = 1000;
static int HISTORY_SIZE = 100;
static double ZSCORE_THRESHOLD = 2.5;
static int TIMEOUT_SEC = 2;
static int MAX_ROUNDS = 0;

// ---------------------------------------------------------------------------
// Statistics helpers
// ---------------------------------------------------------------------------

static double vec_mean(const std::deque<double>& values) {
    if (values.empty()) return 0;
    return std::accumulate(values.begin(), values.end(), 0.0) / values.size();
}

static double vec_stddev(const std::deque<double>& values) {
    if (values.size() <= 1) return 0;
    double m = vec_mean(values);
    double sq_sum = 0;
    for (double v : values) { double d = v - m; sq_sum += d * d; }
    return std::sqrt(sq_sum / values.size());
}

static double vec_percentile(const std::deque<double>& values, double p) {
    if (values.empty()) return 0;
    std::vector<double> sorted(values.begin(), values.end());
    std::sort(sorted.begin(), sorted.end());
    double idx = (p / 100.0) * static_cast<double>(sorted.size() - 1);
    size_t lo = static_cast<size_t>(std::floor(idx));
    size_t hi = lo + 1;
    if (hi >= sorted.size()) return sorted.back();
    double frac = idx - static_cast<double>(lo);
    return sorted[lo] * (1.0 - frac) + sorted[hi] * frac;
}

// ---------------------------------------------------------------------------
// Anomaly record
// ---------------------------------------------------------------------------

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

// ---------------------------------------------------------------------------
// HostStats class
// ---------------------------------------------------------------------------

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

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

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

    bool check_anomaly() {
        if (latencies.size() < 10 || last_latency < 0) return false;
        double m = vec_mean(latencies);
        double s = vec_stddev(latencies);
        if (s == 0) return false;
        double z = (last_latency - m) / s;
        if (std::abs(z) > ZSCORE_THRESHOLD) {
            // Get current time as string
            auto now = std::chrono::system_clock::now();
            auto now_t = std::chrono::system_clock::to_time_t(now);
            char timebuf[32];
            std::strftime(timebuf, sizeof(timebuf), "%H:%M:%S", std::localtime(&now_t));

            AnomalyRecord a;
            a.time = timebuf;
            a.host = host;
            a.latency = last_latency;
            a.zscore = std::round(z * 100.0) / 100.0;
            a.mean = std::round(m * 100.0) / 100.0;
            anomalies.push_back(a);
            if (anomalies.size() > 20) anomalies.pop_front();
            return true;
        }
        return false;
    }

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

    struct Stats {
        double min_ms, max_ms, mean_ms, median_ms, std_ms, p95_ms, p99_ms;
    };

    Stats stats() const {
        Stats s = {0, 0, 0, 0, 0, 0, 0};
        if (latencies.empty()) return s;
        std::vector<double> sorted(latencies.begin(), latencies.end());
        std::sort(sorted.begin(), sorted.end());
        s.min_ms = sorted.front();
        s.max_ms = sorted.back();
        s.mean_ms = vec_mean(latencies);
        s.median_ms = vec_percentile(latencies, 50);
        s.std_ms = vec_stddev(latencies);
        s.p95_ms = vec_percentile(latencies, 95);
        s.p99_ms = vec_percentile(latencies, 99);
        return s;
    }
};

// ---------------------------------------------------------------------------
// libcurl-based latency measurement
// ---------------------------------------------------------------------------

static size_t write_callback(void*, size_t size, size_t nmemb, void*) {
    return size * nmemb;  // Discard response body
}

static double measure_latency(const std::string& host, int timeout_sec) {
    CURL* curl = curl_easy_init();
    if (!curl) return -1;

    // Try to connect to the host. We use a simple TCP connect approach.
    // For IP addresses, we connect on port 80 (HTTP) and measure the connect time.
    std::string url = "http://" + host + "/";

    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_NOBODY, 1L);  // HEAD request
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, static_cast<long>(timeout_sec));
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, static_cast<long>(timeout_sec));
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
    curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);

    // Disable SSL verification for simplicity
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);

    CURLcode res = curl_easy_perform(curl);

    double connect_time = -1;
    if (res == CURLE_OK || res == CURLE_HTTP_RETURNED_ERROR) {
        double total_time;
        curl_easy_getinfo(curl, CURLINFO_CONNECT_TIME, &total_time);
        connect_time = total_time * 1000.0;  // Convert to ms
    }

    curl_easy_cleanup(curl);
    return connect_time;
}

// ---------------------------------------------------------------------------
// Global state
// ---------------------------------------------------------------------------

static std::atomic<bool> g_running(true);

static void signal_handler(int) {
    g_running = false;
}

// ---------------------------------------------------------------------------
// Console display
// ---------------------------------------------------------------------------

static void print_status(const std::vector<HostStats>& hosts, double elapsed_sec) {
    int mins = static_cast<int>(elapsed_sec) / 60;
    int secs = static_cast<int>(elapsed_sec) % 60;

    std::string sep(90, '=');
    std::cout << "\n" << sep << "\n";
    std::cout << "  NETWORK LATENCY MONITOR (libcurl + cxxopts + nlohmann/json)\n";
    std::cout << sep << "\n";
    std::cout << "  Uptime: " << std::setfill('0') << std::setw(2) << mins
              << ":" << std::setw(2) << secs << "  |  ";
    std::cout << "Hosts: " << hosts.size() << "  |  ";

    int total_pings = 0, total_anomalies = 0;
    for (const auto& h : hosts) {
        total_pings += h.total_pings;
        total_anomalies += static_cast<int>(h.anomalies.size());
    }
    std::cout << "Total Pings: " << total_pings << "  |  "
              << "Anomalies: " << total_anomalies << "\n";
    std::cout << std::string(90, '-') << "\n";

    printf("  %-18s %-8s %8s %8s %8s %8s %8s %8s %7s %7s\n",
           "HOST", "STATUS", "LAST", "MIN", "AVG", "MAX", "STD", "P95", "LOSS%", "SAMPLES");
    std::cout << "  " << std::string(88, '-') << "\n";

    for (const auto& h : hosts) {
        auto s = h.stats();
        const char* status_str = "WAIT";
        if (h.status == "OK") status_str = "OK";
        else if (h.status == "Timeout") status_str = "TIMEOUT";

        std::string last_str = h.last_latency >= 0
            ? (std::to_string(static_cast<int>(h.last_latency * 10) / 10) + "." +
               std::to_string(static_cast<int>(h.last_latency * 10) % 10))
            : "-";

        printf("  %-18s %-8s %8.1f %8.1f %8.1f %8.1f %8.2f %8.1f %6.1f%% %7d\n",
               h.host.c_str(),
               status_str,
               h.last_latency >= 0 ? h.last_latency : 0.0,
               s.min_ms, s.mean_ms, s.max_ms, s.std_ms, s.p95_ms,
               h.packet_loss(),
               static_cast<int>(h.latencies.size()));
    }

    // Recent anomalies
    std::vector<AnomalyRecord> all_anomalies;
    for (const auto& h : hosts) {
        for (const auto& a : h.anomalies) {
            all_anomalies.push_back(a);
        }
    }

    if (!all_anomalies.empty()) {
        std::cout << "\n  -- Recent Anomalies --\n";
        size_t start = all_anomalies.size() > 5 ? all_anomalies.size() - 5 : 0;
        for (size_t i = start; i < all_anomalies.size(); i++) {
            const auto& a = all_anomalies[i];
            printf("    [%s] %s: %.1fms (z=%+.2f, mean=%.1fms)\n",
                   a.time.c_str(), a.host.c_str(), a.latency, a.zscore, a.mean);
        }
    }

    std::cout << sep << "\n";
}

static void print_final_report(const std::vector<HostStats>& hosts) {
    std::string sep(80, '=');
    std::cout << "\n" << sep << "\n";
    std::cout << "  FINAL REPORT\n";
    std::cout << sep << "\n";

    printf("  %-18s %6s %7s %8s %8s %8s %8s %8s %8s\n",
           "HOST", "PINGS", "LOSS%", "MIN", "MEAN", "MEDIAN", "P95", "P99", "MAX");
    std::cout << "  " << std::string(78, '-') << "\n";

    for (const auto& h : hosts) {
        auto s = h.stats();
        printf("  %-18s %6d %6.1f%% %8.1f %8.1f %8.1f %8.1f %8.1f %8.1f\n",
               h.host.c_str(), h.total_pings, h.packet_loss(),
               s.min_ms, s.mean_ms, s.median_ms, s.p95_ms, s.p99_ms, s.max_ms);
    }

    std::cout << sep << "\n";
}

static void export_json_report(const std::vector<HostStats>& hosts, const std::string& filepath) {
    json report;
    report["hosts"] = json::array();

    for (const auto& h : hosts) {
        auto s = h.stats();
        json host_obj;
        host_obj["host"] = h.host;
        host_obj["total_pings"] = h.total_pings;
        host_obj["lost_pings"] = h.lost_pings;
        host_obj["packet_loss_pct"] = std::round(h.packet_loss() * 100.0) / 100.0;
        host_obj["statistics"] = {
            {"min_ms", std::round(s.min_ms * 100.0) / 100.0},
            {"max_ms", std::round(s.max_ms * 100.0) / 100.0},
            {"mean_ms", std::round(s.mean_ms * 100.0) / 100.0},
            {"median_ms", std::round(s.median_ms * 100.0) / 100.0},
            {"stddev_ms", std::round(s.std_ms * 100.0) / 100.0},
            {"p95_ms", std::round(s.p95_ms * 100.0) / 100.0},
            {"p99_ms", std::round(s.p99_ms * 100.0) / 100.0}
        };

        json anomalies_arr = json::array();
        for (const auto& a : h.anomalies) {
            anomalies_arr.push_back({
                {"time", a.time},
                {"latency_ms", a.latency},
                {"zscore", a.zscore},
                {"mean_ms", a.mean}
            });
        }
        host_obj["anomalies"] = anomalies_arr;
        report["hosts"].push_back(host_obj);
    }

    std::ofstream out(filepath);
    if (out) {
        out << report.dump(2) << std::endl;
        std::cout << "JSON report written to " << filepath << std::endl;
    } else {
        std::cerr << "Error: Could not write to " << filepath << std::endl;
    }
}

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------

int main(int argc, char* argv[]) {
    cxxopts::Options options("latency_monitor", "Network Latency Monitor");

    options.add_options()
        ("hosts", "Comma-separated list of hosts to monitor",
            cxxopts::value<std::string>()->default_value(""))
        ("i,interval", "Ping interval in milliseconds",
            cxxopts::value<int>()->default_value(std::to_string(PING_INTERVAL_MS)))
        ("n,history", "Number of latency samples to keep",
            cxxopts::value<int>()->default_value(std::to_string(HISTORY_SIZE)))
        ("t,timeout", "Connection timeout in seconds",
            cxxopts::value<int>()->default_value(std::to_string(TIMEOUT_SEC)))
        ("z,zscore", "Z-score threshold for anomaly detection",
            cxxopts::value<double>()->default_value(std::to_string(ZSCORE_THRESHOLD)))
        ("c,count", "Number of ping rounds (0 = infinite)",
            cxxopts::value<int>()->default_value("0"))
        ("o,output", "Output JSON report file path",
            cxxopts::value<std::string>()->default_value(""))
        ("h,help", "Show help");

    options.parse_positional({"hosts"});
    options.positional_help("[hosts]");

    try {
        auto result = options.parse(argc, argv);

        if (result.count("help")) {
            std::cout << options.help() << std::endl;
            return 0;
        }

        PING_INTERVAL_MS = result["interval"].as<int>();
        HISTORY_SIZE = result["history"].as<int>();
        TIMEOUT_SEC = result["timeout"].as<int>();
        ZSCORE_THRESHOLD = result["zscore"].as<double>();
        MAX_ROUNDS = result["count"].as<int>();
        std::string output_path = result["output"].as<std::string>();

        // Parse hosts
        std::vector<std::string> hosts;
        std::string hosts_str = result["hosts"].as<std::string>();
        if (!hosts_str.empty()) {
            std::stringstream ss(hosts_str);
            std::string token;
            while (std::getline(ss, token, ',')) {
                token.erase(0, token.find_first_not_of(" \t"));
                token.erase(token.find_last_not_of(" \t") + 1);
                if (!token.empty()) hosts.push_back(token);
            }
        } else {
            hosts = DEFAULT_HOSTS;
        }

        // Initialize libcurl
        curl_global_init(CURL_GLOBAL_DEFAULT);

        // Create host stats
        std::vector<HostStats> host_stats;
        for (const auto& h : hosts) {
            host_stats.emplace_back(h);
        }

        // Set up signal handler
        signal(SIGINT, signal_handler);

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

        auto start_time = std::chrono::steady_clock::now();
        int round = 0;
        std::mutex stats_mutex;

        while (g_running) {
            round++;

            // Ping all hosts concurrently
            std::vector<std::thread> threads;
            for (auto& hs : host_stats) {
                threads.emplace_back([&hs, &stats_mutex]() {
                    double latency = measure_latency(hs.host, TIMEOUT_SEC);
                    std::lock_guard<std::mutex> lock(stats_mutex);
                    hs.record(latency);
                    hs.check_anomaly();
                });
            }

            for (auto& t : threads) {
                t.join();
            }

            // Display status
            auto now = std::chrono::steady_clock::now();
            double elapsed = std::chrono::duration<double>(now - start_time).count();
            print_status(host_stats, elapsed);

            if (MAX_ROUNDS > 0 && round >= MAX_ROUNDS) break;

            // Wait for interval
            std::this_thread::sleep_for(std::chrono::milliseconds(PING_INTERVAL_MS));
        }

        std::cout << "\nMonitor stopped." << std::endl;
        print_final_report(host_stats);

        if (!output_path.empty()) {
            export_json_report(host_stats, output_path);
        }

        curl_global_cleanup();

    } catch (const cxxopts::exceptions::exception& e) {
        std::cerr << "Error parsing options: " << e.what() << std::endl;
        std::cout << options.help() << std::endl;
        return 1;
    }

    return 0;
}

# Network Latency Monitor (C++ - Trial 3)

A network latency monitoring tool that tracks TCP connect latency to multiple hosts using libcurl, with real-time statistics, Z-score anomaly detection, and JSON report export.

## Dependencies

- **libcurl** (system) - HTTP client library used to measure TCP connect latency via HEAD requests
- **cxxopts** (3.1.1) - Lightweight, header-only command-line option parser for C++
- **nlohmann/json** (3.11.3) - Modern JSON library for structured report output

## Build

```bash
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build --parallel
```

### Prerequisites

On Ubuntu/Debian:

```bash
sudo apt-get install -y cmake g++ git libcurl4-openssl-dev
```

## Usage

```bash
# Monitor default DNS servers
./build/latency_monitor

# Monitor specific hosts
./build/latency_monitor "8.8.8.8,1.1.1.1,google.com"

# Custom interval and timeout
./build/latency_monitor -i 2000 -t 5

# Run a fixed number of rounds
./build/latency_monitor -c 10

# Adjust anomaly detection sensitivity
./build/latency_monitor -z 3.0

# Export JSON report
./build/latency_monitor -o report.json
```

## Features

- Concurrent latency measurement of multiple hosts using libcurl
- TCP connect time measurement via HTTP HEAD requests
- Statistical analysis: min, max, mean, median, P95, P99, standard deviation
- Z-score based anomaly detection with configurable threshold
- Packet loss tracking
- Live console dashboard with formatted table output
- JSON report export via nlohmann/json
- CLI argument parsing via cxxopts
- Final summary report on exit