This pull request introduces a configurable DNS concurrency feature to the HTTP client, allowing DNS queries to be performed either sequentially or in parallel, improving DNS resolution performance and flexibility. It refactors the DNS resolution logic to support early cancellation when results are found, and updates the client and dialer code to handle the new concurrency option. Additionally, minor improvements and dependency updates are included.

Note: the current behavior is kinda weird, we can add as many DNS servers as we want when configuring the client, but only 4 at most are being used. It felt like a very weird behavior (my fault) so I made this.

How round-robin and concurrency work together

The Key: Round-Robin is BETWEEN requests, not within

What Round-Robin does

Round-robin only determines which server to start with for each new DNS request. It rotates the starting position across different requests.

What happens within a single request

Let's say you have 5 DNS servers [A, B, C, D, E] and DNSConcurrency = 3:

Request 1 (startIdx = 0):

• Server queue created: [A, B, C, D, E]
• This queue goes into a channel
• 3 workers are spawned (line 107)
• Worker 1 pulls A from channel → queries server A
• Worker 2 pulls B from channel → queries server B
• Worker 3 pulls C from channel → queries server C
• All 3 queries happen at the same time ← This is the concurrency
• When Worker 1 finishes with A, it pulls D from channel
• When Worker 2 finishes with B, it pulls E from channel
• When Worker 3 finishes with C, channel is empty

So within Request 1, you're trying servers A, B, C concurrently (not round-robin).

Request 2 (different request, startIdx = 1):

• Server queue created: [B, C, D, E, A] ← Starting position rotated
• 3 workers query B, C, D concurrently

Request 3 (startIdx = 2):

• Server queue created: [C, D, E, A, B]
• 3 workers query C, D, E concurrently

The Pattern

• Within a single request: Servers are tried concurrently (worker pool pattern)
• Across multiple requests: Starting position rotates (round-robin)

The round-robin ensures that over many requests, all servers get equal load, even though within each individual request you're hitting multiple servers at once.

DNS Concurrency Configuration & Logic

• Added a new DNSConcurrency field to HTTPClientSettings and passed it through the client and dialer constructors, enabling users to control how many DNS servers are queried in parallel. [1] [2] [3]
• Implemented the concurrentDNSLookup method in customDialer, which performs DNS queries with the specified concurrency, supports unlimited concurrency, and cancels remaining queries early when results are found. [1] [2]

Code Structure & Refactoring

• Refactored the DNS resolution logic in archiveDNS to use the new concurrent lookup method, replacing the previous fallback and goroutine approach.
• Updated network address selection logic to use switch statements for clarity and maintainability in both TCP and UDP cases. [1] [2]
• Introduced the dnsExchanger interface for DNS clients, improving abstraction and testability.

Dependency Updates

• Updated Go version to 1.25.4 and added golang.org/x/sys v0.37.0 as a direct dependency. [1] [2] [3]

Testing Improvements

• Improved error handling in the testFileEarlyEOF test to ensure decompression errors are caught and reported, and added missing error checks for robustness. [1] [2]