Network Latency Monitor (java, written by Claude Code)

--- /dev/null
+++ b/src/main/java/LatencyMonitor.java
@@ -0,0 +1,330 @@
+import org.apache.commons.net.echo.EchoTCPClient;
+import org.apache.commons.net.echo.EchoUDPClient;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.stream.Collectors;
+
+/**
+ * Network Latency Monitor (Java - Trial 1)
+ * Monitors network latency to multiple hosts with statistics, anomaly detection,
+ * and a live console dashboard using Apache Commons Net and Gson.
+ */
+public class LatencyMonitor {
+
+    private static final String[] DEFAULT_HOSTS = {
+        "8.8.8.8", "1.1.1.1", "208.67.222.222", "9.9.9.9", "8.8.4.4"
+    };
+    private static final int HISTORY_SIZE = 100;
+    private static final double ANOMALY_ZSCORE_THRESHOLD = 2.5;
+    private static final int PING_TIMEOUT_MS = 2000;
+    private static final int PING_INTERVAL_MS = 1000;
+    private static final int TCP_PROBE_PORT = 53;
+
+    private final List<String> hosts;
+    private final Map<String, HostStats> hostStats;
+    private final ExecutorService executor;
+    private final Gson gson;
+    private volatile boolean running = true;
+    private long startTime;
+
+    static class HostStats {
+        String host;
+        final Deque<Double> latencies = new ArrayDeque<>();
+        int totalPings = 0;
+        int lostPings = 0;
+        Double lastLatency = null;
+        String status = "Waiting";
+        final List<AnomalyRecord> anomalies = new ArrayList<>();
+
+        HostStats(String host) {
+            this.host = host;
+        }
+
+        synchronized void record(Double latencyMs) {
+            totalPings++;
+            if (latencyMs == null) {
+                lostPings++;
+                status = "Timeout";
+                lastLatency = null;
+            } else {
+                if (latencies.size() >= HISTORY_SIZE) {
+                    latencies.pollFirst();
+                }
+                latencies.add(latencyMs);
+                lastLatency = latencyMs;
+                status = "OK";
+                checkAnomaly(latencyMs);
+            }
+        }
+
+        private void checkAnomaly(double latencyMs) {
+            if (latencies.size() < 10) return;
+            double[] arr = latencies.stream().mapToDouble(Double::doubleValue).toArray();
+            double mean = mean(arr);
+            double std = stdDev(arr, mean);
+            if (std == 0) return;
+            double zscore = (latencyMs - mean) / std;
+            if (Math.abs(zscore) > ANOMALY_ZSCORE_THRESHOLD) {
+                anomalies.add(new AnomalyRecord(
+                    new Date(), host, latencyMs, zscore, mean
+                ));
+                if (anomalies.size() > 20) {
+                    anomalies.remove(0);
+                }
+            }
+        }
+
+        synchronized double getPacketLoss() {
+            return totalPings == 0 ? 0.0 : (lostPings / (double) totalPings) * 100;
+        }
+
+        synchronized Map<String, Double> getStatistics() {
+            Map<String, Double> stats = new LinkedHashMap<>();
+            if (latencies.isEmpty()) {
+                stats.put("min", 0.0);
+                stats.put("max", 0.0);
+                stats.put("mean", 0.0);
+                stats.put("median", 0.0);
+                stats.put("stdDev", 0.0);
+                stats.put("p95", 0.0);
+                stats.put("p99", 0.0);
+                return stats;
+            }
+            double[] arr = latencies.stream().mapToDouble(Double::doubleValue).toArray();
+            Arrays.sort(arr);
+            stats.put("min", arr[0]);
+            stats.put("max", arr[arr.length - 1]);
+            stats.put("mean", mean(arr));
+            stats.put("median", percentile(arr, 50));
+            stats.put("stdDev", stdDev(arr, mean(arr)));
+            stats.put("p95", percentile(arr, 95));
+            stats.put("p99", percentile(arr, 99));
+            return stats;
+        }
+    }
+
+    static class AnomalyRecord {
+        Date timestamp;
+        String host;
+        double latency;
+        double zscore;
+        double mean;
+
+        AnomalyRecord(Date timestamp, String host, double latency, double zscore, double mean) {
+            this.timestamp = timestamp;
+            this.host = host;
+            this.latency = latency;
+            this.zscore = zscore;
+            this.mean = mean;
+        }
+    }
+
+    public LatencyMonitor(List<String> hosts) {
+        this.hosts = hosts;
+        this.hostStats = new LinkedHashMap<>();
+        this.executor = Executors.newFixedThreadPool(hosts.size());
+        this.gson = new GsonBuilder().setPrettyPrinting().create();
+
+        for (String host : hosts) {
+            hostStats.put(host, new HostStats(host));
+        }
+    }
+
+    /**
+     * Measures latency using TCP connection to port 53 (DNS).
+     * Falls back to InetAddress.isReachable if TCP probe fails.
+     */
+    private Double measureLatency(String host) {
+        // Try TCP connect to port 53 (DNS) for accurate timing
+        long start = System.nanoTime();
+        try (Socket socket = new Socket()) {
+            socket.connect(new InetSocketAddress(host, TCP_PROBE_PORT), PING_TIMEOUT_MS);
+            long elapsed = System.nanoTime() - start;
+            return elapsed / 1_000_000.0;
+        } catch (IOException e) {
+            // Fallback: try ICMP via InetAddress.isReachable
+            try {
+                start = System.nanoTime();
+                InetAddress addr = InetAddress.getByName(host);
+                if (addr.isReachable(PING_TIMEOUT_MS)) {
+                    long elapsed = System.nanoTime() - start;
+                    return elapsed / 1_000_000.0;
+                }
+            } catch (IOException ex) {
+                // Host unreachable
+            }
+        }
+        return null;
+    }
+
+    private void pingAllHosts() {
+        List<Future<?>> futures = new ArrayList<>();
+        for (String host : hosts) {
+            futures.add(executor.submit(() -> {
+                Double latency = measureLatency(host);
+                hostStats.get(host).record(latency);
+            }));
+        }
+        for (Future<?> f : futures) {
+            try {
+                f.get(PING_TIMEOUT_MS + 1000, TimeUnit.MILLISECONDS);
+            } catch (Exception e) {
+                // Timeout or error
+            }
+        }
+    }
+
+    private void clearScreen() {
+        System.out.print("\033[H\033[2J");
+        System.out.flush();
+    }
+
+    private void printDashboard() {
+        clearScreen();
+        long elapsed = (System.currentTimeMillis() - startTime) / 1000;
+        long hrs = elapsed / 3600;
+        long mins = (elapsed % 3600) / 60;
+        long secs = elapsed % 60;
+
+        int totalPings = hostStats.values().stream().mapToInt(s -> s.totalPings).sum();
+        int totalLost = hostStats.values().stream().mapToInt(s -> s.lostPings).sum();
+        long totalAnomalies = hostStats.values().stream().mapToInt(s -> s.anomalies.size()).sum();
+
+        System.out.println("=".repeat(110));
+        System.out.println("  NETWORK LATENCY MONITOR");
+        System.out.printf("  Uptime: %02d:%02d:%02d | Hosts: %d | Pings: %d | Lost: %d | Anomalies: %d%n",
+            hrs, mins, secs, hosts.size(), totalPings, totalLost, totalAnomalies);
+        System.out.println("=".repeat(110));
+
+        // Main table header
+        System.out.printf("%-18s %-8s %8s %8s %8s %8s %8s %8s %8s %8s%n",
+            "Host", "Status", "Last", "Min", "Avg", "Max", "StdDev", "P95", "Loss%", "Samples");
+        System.out.println("-".repeat(110));
+
+        for (String host : hosts) {
+            HostStats hs = hostStats.get(host);
+            Map<String, Double> s = hs.getStatistics();
+
+            String statusStr = hs.status.equals("OK") ? " OK " :
+                              hs.status.equals("Timeout") ? "TOUT" : "WAIT";
+            String lastStr = hs.lastLatency != null ? String.format("%.1f", hs.lastLatency) : "-";
+
+            synchronized (hs) {
+                System.out.printf("%-18s %-8s %8s %8.1f %8.1f %8.1f %8.2f %8.1f %7.1f%% %8d%n",
+                    host, statusStr, lastStr,
+                    s.get("min"), s.get("mean"), s.get("max"),
+                    s.get("stdDev"), s.get("p95"),
+                    hs.getPacketLoss(), hs.latencies.size());
+            }
+        }
+
+        // Anomaly section
+        System.out.println("\n" + "-".repeat(110));
+        System.out.println("  ANOMALY DETECTION (Z-score > " + ANOMALY_ZSCORE_THRESHOLD + ")");
+        System.out.println("-".repeat(110));
+
+        List<AnomalyRecord> allAnomalies = new ArrayList<>();
+        for (HostStats hs : hostStats.values()) {
+            synchronized (hs) {
+                allAnomalies.addAll(hs.anomalies);
+            }
+        }
+        allAnomalies.sort(Comparator.comparing(a -> a.timestamp));
+
+        if (allAnomalies.isEmpty()) {
+            System.out.println("  No anomalies detected yet.");
+        } else {
+            int start = Math.max(0, allAnomalies.size() - 8);
+            for (int i = start; i < allAnomalies.size(); i++) {
+                AnomalyRecord a = allAnomalies.get(i);
+                System.out.printf("  [%tT] %s: %.1fms (z=%+.2f, mean=%.1fms)%n",
+                    a.timestamp, a.host, a.latency, a.zscore, a.mean);
+            }
+        }
+
+        System.out.println("\n" + "=".repeat(110));
+        System.out.println("  Press Ctrl+C to stop");
+    }
+
+    private void printFinalReport() {
+        System.out.println("\n\nFINAL REPORT");
+        System.out.println("=".repeat(110));
+
+        Map<String, Object> report = new LinkedHashMap<>();
+        for (String host : hosts) {
+            HostStats hs = hostStats.get(host);
+            Map<String, Object> hostReport = new LinkedHashMap<>();
+            hostReport.put("totalPings", hs.totalPings);
+            hostReport.put("packetLoss", String.format("%.1f%%", hs.getPacketLoss()));
+            hostReport.put("statistics", hs.getStatistics());
+            hostReport.put("anomalyCount", hs.anomalies.size());
+            report.put(host, hostReport);
+        }
+
+        System.out.println(gson.toJson(report));
+    }
+
+    public void run() {
+        startTime = System.currentTimeMillis();
+        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+            running = false;
+            printFinalReport();
+            executor.shutdownNow();
+        }));
+
+        System.out.println("Network Latency Monitor starting...");
+        System.out.println("Monitoring " + hosts.size() + " hosts. Press Ctrl+C to stop.\n");
+
+        while (running) {
+            pingAllHosts();
+            printDashboard();
+            try {
+                Thread.sleep(PING_INTERVAL_MS);
+            } catch (InterruptedException e) {
+                running = false;
+            }
+        }
+    }
+
+    // -- Utility math functions --
+
+    static double mean(double[] arr) {
+        double sum = 0;
+        for (double v : arr) sum += v;
+        return sum / arr.length;
+    }
+
+    static double stdDev(double[] arr, double mean) {
+        double sumSq = 0;
+        for (double v : arr) sumSq += (v - mean) * (v - mean);
+        return Math.sqrt(sumSq / arr.length);
+    }
+
+    static double percentile(double[] sorted, double pct) {
+        if (sorted.length == 1) return sorted[0];
+        double index = (pct / 100.0) * (sorted.length - 1);
+        int lower = (int) Math.floor(index);
+        int upper = (int) Math.ceil(index);
+        if (lower == upper) return sorted[lower];
+        double frac = index - lower;
+        return sorted[lower] * (1 - frac) + sorted[upper] * frac;
+    }
+
+    public static void main(String[] args) {
+        List<String> hosts;
+        if (args.length > 0) {
+            hosts = Arrays.asList(args);
+        } else {
+            hosts = Arrays.asList(DEFAULT_HOSTS);
+        }
+        LatencyMonitor monitor = new LatencyMonitor(hosts);
+        monitor.run();
+    }
+}

Claude Code wrote this java 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 Java project for a clean Ubuntu 22.04 machine with only JDK 17+ installed. Include:
- Source code
- pom.xml with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[
  {
    "category": "misspecification",
    "rule": "signature.build_layout_mismatch",
    "source": "failure_signature",
    "excerpt": "error: no classes were compiled"
  }
]

import org.apache.commons.net.echo.EchoTCPClient;
import org.apache.commons.net.echo.EchoUDPClient;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;

/**
 * Network Latency Monitor (Java - Trial 1)
 * Monitors network latency to multiple hosts with statistics, anomaly detection,
 * and a live console dashboard using Apache Commons Net and Gson.
 */
public class LatencyMonitor {

    private static final String[] DEFAULT_HOSTS = {
        "8.8.8.8", "1.1.1.1", "208.67.222.222", "9.9.9.9", "8.8.4.4"
    };
    private static final int HISTORY_SIZE = 100;
    private static final double ANOMALY_ZSCORE_THRESHOLD = 2.5;
    private static final int PING_TIMEOUT_MS = 2000;
    private static final int PING_INTERVAL_MS = 1000;
    private static final int TCP_PROBE_PORT = 53;

    private final List<String> hosts;
    private final Map<String, HostStats> hostStats;
    private final ExecutorService executor;
    private final Gson gson;
    private volatile boolean running = true;
    private long startTime;

    static class HostStats {
        String host;
        final Deque<Double> latencies = new ArrayDeque<>();
        int totalPings = 0;
        int lostPings = 0;
        Double lastLatency = null;
        String status = "Waiting";
        final List<AnomalyRecord> anomalies = new ArrayList<>();

        HostStats(String host) {
            this.host = host;
        }

        synchronized void record(Double latencyMs) {
            totalPings++;
            if (latencyMs == null) {
                lostPings++;
                status = "Timeout";
                lastLatency = null;
            } else {
                if (latencies.size() >= HISTORY_SIZE) {
                    latencies.pollFirst();
                }
                latencies.add(latencyMs);
                lastLatency = latencyMs;
                status = "OK";
                checkAnomaly(latencyMs);
            }
        }

        private void checkAnomaly(double latencyMs) {
            if (latencies.size() < 10) return;
            double[] arr = latencies.stream().mapToDouble(Double::doubleValue).toArray();
            double mean = mean(arr);
            double std = stdDev(arr, mean);
            if (std == 0) return;
            double zscore = (latencyMs - mean) / std;
            if (Math.abs(zscore) > ANOMALY_ZSCORE_THRESHOLD) {
                anomalies.add(new AnomalyRecord(
                    new Date(), host, latencyMs, zscore, mean
                ));
                if (anomalies.size() > 20) {
                    anomalies.remove(0);
                }
            }
        }

        synchronized double getPacketLoss() {
            return totalPings == 0 ? 0.0 : (lostPings / (double) totalPings) * 100;
        }

        synchronized Map<String, Double> getStatistics() {
            Map<String, Double> stats = new LinkedHashMap<>();
            if (latencies.isEmpty()) {
                stats.put("min", 0.0);
                stats.put("max", 0.0);
                stats.put("mean", 0.0);
                stats.put("median", 0.0);
                stats.put("stdDev", 0.0);
                stats.put("p95", 0.0);
                stats.put("p99", 0.0);
                return stats;
            }
            double[] arr = latencies.stream().mapToDouble(Double::doubleValue).toArray();
            Arrays.sort(arr);
            stats.put("min", arr[0]);
            stats.put("max", arr[arr.length - 1]);
            stats.put("mean", mean(arr));
            stats.put("median", percentile(arr, 50));
            stats.put("stdDev", stdDev(arr, mean(arr)));
            stats.put("p95", percentile(arr, 95));
            stats.put("p99", percentile(arr, 99));
            return stats;
        }
    }

    static class AnomalyRecord {
        Date timestamp;
        String host;
        double latency;
        double zscore;
        double mean;

        AnomalyRecord(Date timestamp, String host, double latency, double zscore, double mean) {
            this.timestamp = timestamp;
            this.host = host;
            this.latency = latency;
            this.zscore = zscore;
            this.mean = mean;
        }
    }

    public LatencyMonitor(List<String> hosts) {
        this.hosts = hosts;
        this.hostStats = new LinkedHashMap<>();
        this.executor = Executors.newFixedThreadPool(hosts.size());
        this.gson = new GsonBuilder().setPrettyPrinting().create();

        for (String host : hosts) {
            hostStats.put(host, new HostStats(host));
        }
    }

    /**
     * Measures latency using TCP connection to port 53 (DNS).
     * Falls back to InetAddress.isReachable if TCP probe fails.
     */
    private Double measureLatency(String host) {
        // Try TCP connect to port 53 (DNS) for accurate timing
        long start = System.nanoTime();
        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress(host, TCP_PROBE_PORT), PING_TIMEOUT_MS);
            long elapsed = System.nanoTime() - start;
            return elapsed / 1_000_000.0;
        } catch (IOException e) {
            // Fallback: try ICMP via InetAddress.isReachable
            try {
                start = System.nanoTime();
                InetAddress addr = InetAddress.getByName(host);
                if (addr.isReachable(PING_TIMEOUT_MS)) {
                    long elapsed = System.nanoTime() - start;
                    return elapsed / 1_000_000.0;
                }
            } catch (IOException ex) {
                // Host unreachable
            }
        }
        return null;
    }

    private void pingAllHosts() {
        List<Future<?>> futures = new ArrayList<>();
        for (String host : hosts) {
            futures.add(executor.submit(() -> {
                Double latency = measureLatency(host);
                hostStats.get(host).record(latency);
            }));
        }
        for (Future<?> f : futures) {
            try {
                f.get(PING_TIMEOUT_MS + 1000, TimeUnit.MILLISECONDS);
            } catch (Exception e) {
                // Timeout or error
            }
        }
    }

    private void clearScreen() {
        System.out.print("\033[H\033[2J");
        System.out.flush();
    }

    private void printDashboard() {
        clearScreen();
        long elapsed = (System.currentTimeMillis() - startTime) / 1000;
        long hrs = elapsed / 3600;
        long mins = (elapsed % 3600) / 60;
        long secs = elapsed % 60;

        int totalPings = hostStats.values().stream().mapToInt(s -> s.totalPings).sum();
        int totalLost = hostStats.values().stream().mapToInt(s -> s.lostPings).sum();
        long totalAnomalies = hostStats.values().stream().mapToInt(s -> s.anomalies.size()).sum();

        System.out.println("=".repeat(110));
        System.out.println("  NETWORK LATENCY MONITOR");
        System.out.printf("  Uptime: %02d:%02d:%02d | Hosts: %d | Pings: %d | Lost: %d | Anomalies: %d%n",
            hrs, mins, secs, hosts.size(), totalPings, totalLost, totalAnomalies);
        System.out.println("=".repeat(110));

        // Main table header
        System.out.printf("%-18s %-8s %8s %8s %8s %8s %8s %8s %8s %8s%n",
            "Host", "Status", "Last", "Min", "Avg", "Max", "StdDev", "P95", "Loss%", "Samples");
        System.out.println("-".repeat(110));

        for (String host : hosts) {
            HostStats hs = hostStats.get(host);
            Map<String, Double> s = hs.getStatistics();

            String statusStr = hs.status.equals("OK") ? " OK " :
                              hs.status.equals("Timeout") ? "TOUT" : "WAIT";
            String lastStr = hs.lastLatency != null ? String.format("%.1f", hs.lastLatency) : "-";

            synchronized (hs) {
                System.out.printf("%-18s %-8s %8s %8.1f %8.1f %8.1f %8.2f %8.1f %7.1f%% %8d%n",
                    host, statusStr, lastStr,
                    s.get("min"), s.get("mean"), s.get("max"),
                    s.get("stdDev"), s.get("p95"),
                    hs.getPacketLoss(), hs.latencies.size());
            }
        }

        // Anomaly section
        System.out.println("\n" + "-".repeat(110));
        System.out.println("  ANOMALY DETECTION (Z-score > " + ANOMALY_ZSCORE_THRESHOLD + ")");
        System.out.println("-".repeat(110));

        List<AnomalyRecord> allAnomalies = new ArrayList<>();
        for (HostStats hs : hostStats.values()) {
            synchronized (hs) {
                allAnomalies.addAll(hs.anomalies);
            }
        }
        allAnomalies.sort(Comparator.comparing(a -> a.timestamp));

        if (allAnomalies.isEmpty()) {
            System.out.println("  No anomalies detected yet.");
        } else {
            int start = Math.max(0, allAnomalies.size() - 8);
            for (int i = start; i < allAnomalies.size(); i++) {
                AnomalyRecord a = allAnomalies.get(i);
                System.out.printf("  [%tT] %s: %.1fms (z=%+.2f, mean=%.1fms)%n",
                    a.timestamp, a.host, a.latency, a.zscore, a.mean);
            }
        }

        System.out.println("\n" + "=".repeat(110));
        System.out.println("  Press Ctrl+C to stop");
    }

    private void printFinalReport() {
        System.out.println("\n\nFINAL REPORT");
        System.out.println("=".repeat(110));

        Map<String, Object> report = new LinkedHashMap<>();
        for (String host : hosts) {
            HostStats hs = hostStats.get(host);
            Map<String, Object> hostReport = new LinkedHashMap<>();
            hostReport.put("totalPings", hs.totalPings);
            hostReport.put("packetLoss", String.format("%.1f%%", hs.getPacketLoss()));
            hostReport.put("statistics", hs.getStatistics());
            hostReport.put("anomalyCount", hs.anomalies.size());
            report.put(host, hostReport);
        }

        System.out.println(gson.toJson(report));
    }

    public void run() {
        startTime = System.currentTimeMillis();
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            running = false;
            printFinalReport();
            executor.shutdownNow();
        }));

        System.out.println("Network Latency Monitor starting...");
        System.out.println("Monitoring " + hosts.size() + " hosts. Press Ctrl+C to stop.\n");

        while (running) {
            pingAllHosts();
            printDashboard();
            try {
                Thread.sleep(PING_INTERVAL_MS);
            } catch (InterruptedException e) {
                running = false;
            }
        }
    }

    // -- Utility math functions --

    static double mean(double[] arr) {
        double sum = 0;
        for (double v : arr) sum += v;
        return sum / arr.length;
    }

    static double stdDev(double[] arr, double mean) {
        double sumSq = 0;
        for (double v : arr) sumSq += (v - mean) * (v - mean);
        return Math.sqrt(sumSq / arr.length);
    }

    static double percentile(double[] sorted, double pct) {
        if (sorted.length == 1) return sorted[0];
        double index = (pct / 100.0) * (sorted.length - 1);
        int lower = (int) Math.floor(index);
        int upper = (int) Math.ceil(index);
        if (lower == upper) return sorted[lower];
        double frac = index - lower;
        return sorted[lower] * (1 - frac) + sorted[upper] * frac;
    }

    public static void main(String[] args) {
        List<String> hosts;
        if (args.length > 0) {
            hosts = Arrays.asList(args);
        } else {
            hosts = Arrays.asList(DEFAULT_HOSTS);
        }
        LatencyMonitor monitor = new LatencyMonitor(hosts);
        monitor.run();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.networkmonitor</groupId>
    <artifactId>latency-monitor</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <name>Network Latency Monitor</name>
    <description>Monitors network latency to multiple hosts with statistics, anomaly detection, and live dashboard</description>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>3.10.0</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.10.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>LatencyMonitor</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.5.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

# Network Latency Monitor (Java - Trial 1)

A network latency monitoring tool that tracks latency to multiple hosts with real-time statistics, anomaly detection, and a live console dashboard.

## Dependencies

- **Apache Commons Net** (3.10.0) - Network protocol implementations for TCP probing
- **Gson** (2.10.1) - JSON serialization for report output

## Build

```bash
mvn clean package
```

## Usage

```bash
# Monitor default hosts
java -jar target/latency-monitor-1.0.0.jar

# Monitor specific hosts
java -jar target/latency-monitor-1.0.0.jar 8.8.8.8 1.1.1.1 google.com
```

## Features

- TCP connect latency measurement with ICMP fallback
- Live console dashboard with auto-refresh
- Statistical analysis: min, max, mean, median, P95, P99, standard deviation
- Z-score based anomaly detection
- Packet loss tracking
- JSON-formatted final report on exit