dnsperftest.cs

using System;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Linq;
using System.Threading;

var options = Cli.ParseArgs(args);
Console.WriteLine("DNS Performance Test");
Console.WriteLine($"  Server:      {options.Server}");
Console.WriteLine($"  Requests:    {options.Requests}");
Console.WriteLine($"  Concurrency: {options.Concurrency}");
Console.WriteLine($"  Timeout:     {options.TimeoutMs}ms");
Console.WriteLine();

var serverIp = IPAddress.TryParse(options.Server, out var parsed)
    ? parsed
    : Dns.GetHostAddresses(options.Server)[0];

var semaphore = new SemaphoreSlim(options.Concurrency);
var tasks = new Task<(bool Success, double LatencyMs)>[options.Requests];
var totalSw = Stopwatch.StartNew();

for (int i = 0; i < options.Requests; i++)
{
    await semaphore.WaitAsync();
    var baseDomain = DnsRunner.Domains[i % DnsRunner.Domains.Length];
    var domain = options.RandomSubdomains ? $"{Guid.NewGuid():N}.{baseDomain}" : baseDomain;
    var id = (ushort)(i % ushort.MaxValue);
    tasks[i] = Task.Run(async () =>
    {
        try
        {
            return await DnsRunner.SendQuery(serverIp, domain, id, options.TimeoutMs);
        }
        finally
        {
            semaphore.Release();
        }
    });
}

await Task.WhenAll(tasks);
totalSw.Stop();

var results = tasks.Select(t => t.Result).ToArray();
var successful = results.Where(r => r.Success).ToArray();
var failed = results.Length - successful.Length;
var latencies = successful.Select(r => r.LatencyMs).OrderBy(x => x).ToArray();

double Percentile(double[] sorted, int p)
{
    if (sorted.Length == 0) return 0;
    int index = (int)Math.Ceiling(p / 100.0 * sorted.Length) - 1;
    return sorted[Math.Max(0, index)];
}

Console.WriteLine("Results:");
Console.WriteLine($"  Successful:  {successful.Length}");
Console.WriteLine($"  Failed:      {failed} ({(double)failed / results.Length:P1})");
Console.WriteLine($"  Total time:  {totalSw.Elapsed.TotalSeconds:F2}s");
Console.WriteLine($"  Req/sec:     {results.Length / totalSw.Elapsed.TotalSeconds:F1}");

if (latencies.Length > 0)
{
    Console.WriteLine("  Latency (ms):");
    Console.WriteLine($"    Min:       {latencies[0]:F1}");
    Console.WriteLine($"    Avg:       {latencies.Average():F1}");
    Console.WriteLine($"    P50:       {Percentile(latencies, 50):F1}");
    Console.WriteLine($"    P95:       {Percentile(latencies, 95):F1}");
    Console.WriteLine($"    P99:       {Percentile(latencies, 99):F1}");
    Console.WriteLine($"    Max:       {latencies[^1]:F1}");
}

static class Cli
{
    public record Options(string Server, int Requests, int Concurrency, int TimeoutMs, bool RandomSubdomains);

    public static Options ParseArgs(string[] args)
    {
        string? server = null;
        int requests = 1000;
        int concurrency = 50;
        int timeoutMs = 2000;
        bool randomSubdomains = false;

        for (int i = 0; i < args.Length; i++)
        {
            switch (args[i])
            {
                case "--server":
                case "-s":
                    if (i + 1 >= args.Length)
                    {
                        Console.Error.WriteLine($"Error: {args[i]} requires a value");
                        Environment.Exit(1);
                    }
                    server = args[++i];
                    break;
                case "--requests":
                case "-n":
                    if (i + 1 >= args.Length)
                    {
                        Console.Error.WriteLine($"Error: {args[i]} requires a value");
                        Environment.Exit(1);
                    }
                    requests = int.Parse(args[++i]);
                    break;
                case "--concurrency":
                case "-c":
                    if (i + 1 >= args.Length)
                    {
                        Console.Error.WriteLine($"Error: {args[i]} requires a value");
                        Environment.Exit(1);
                    }
                    concurrency = int.Parse(args[++i]);
                    break;
                case "--timeout":
                case "-t":
                    if (i + 1 >= args.Length)
                    {
                        Console.Error.WriteLine($"Error: {args[i]} requires a value");
                        Environment.Exit(1);
                    }
                    timeoutMs = int.Parse(args[++i]);
                    break;
                case "--random":
                case "-r":
                    randomSubdomains = true;
                    break;
                default:
                    Console.Error.WriteLine($"Error: unknown argument '{args[i]}'");
                    Environment.Exit(1);
                    break;
            }
        }

        if (server is null)
        {
            Console.Error.WriteLine("Usage: dnsperftest --server|-s <ip> [--requests|-n <count>] [--concurrency|-c <count>] [--timeout|-t <ms>] [--random|-r]");
            Environment.Exit(1);
        }

        return new Options(server!, requests, concurrency, timeoutMs, randomSubdomains);
    }
}

static class DnsRunner
{
    public static readonly string[] Domains = [
        "google.com", "facebook.com", "youtube.com", "amazon.com", "wikipedia.org",
        "twitter.com", "reddit.com", "instagram.com", "linkedin.com", "netflix.com",
        "apple.com", "microsoft.com", "github.com", "stackoverflow.com", "cloudflare.com",
        "yahoo.com", "bing.com", "twitch.tv", "discord.com", "spotify.com"
    ];

    public static async Task<(bool Success, double LatencyMs)> SendQuery(
        IPAddress serverIp, string domain, ushort id, int timeoutMs)
    {
        using var udp = new UdpClient();
        var query = DnsPacket.BuildQuery(id, domain);
        var sw = Stopwatch.StartNew();
        try
        {
            await udp.SendAsync(query, new IPEndPoint(serverIp, 53));
            using var cts = new CancellationTokenSource(timeoutMs);
            var result = await udp.ReceiveAsync(cts.Token);
            sw.Stop();
            var parsed = DnsPacket.ParseResponse(result.Buffer, result.Buffer.Length);
            return (parsed.Success, sw.Elapsed.TotalMilliseconds);
        }
        catch
        {
            sw.Stop();
            return (false, sw.Elapsed.TotalMilliseconds);
        }
    }
}

static class DnsPacket
{
    public static byte[] BuildQuery(ushort id, string domain)
    {
        using var ms = new System.IO.MemoryStream();
        using var writer = new System.IO.BinaryWriter(ms);

        // Header
        writer.Write(IPAddress.HostToNetworkOrder((short)id));
        writer.Write(IPAddress.HostToNetworkOrder((short)0x0100)); // Standard query, recursion desired
        writer.Write(IPAddress.HostToNetworkOrder((short)1));      // QDCOUNT
        writer.Write(IPAddress.HostToNetworkOrder((short)0));      // ANCOUNT
        writer.Write(IPAddress.HostToNetworkOrder((short)0));      // NSCOUNT
        writer.Write(IPAddress.HostToNetworkOrder((short)0));      // ARCOUNT

        // Question: domain name as labels
        foreach (var label in domain.Split('.'))
        {
            writer.Write((byte)label.Length);
            writer.Write(Encoding.ASCII.GetBytes(label));
        }
        writer.Write((byte)0); // Root label

        writer.Write(IPAddress.HostToNetworkOrder((short)1)); // QTYPE = A
        writer.Write(IPAddress.HostToNetworkOrder((short)1)); // QCLASS = IN

        return ms.ToArray();
    }

    public static (ushort Id, int AnswerCount, bool Success) ParseResponse(byte[] data, int length)
    {
        if (length < 12)
            return (0, 0, false);

        ushort id = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 0));
        ushort flags = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 2));
        int rcode = flags & 0x0F;
        ushort ancount = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 6));

        // RCODE 0 (NOERROR) and 3 (NXDOMAIN) both mean the server responded successfully
        return (id, ancount, rcode == 0 || rcode == 3);
    }
}