Add more visibility to IP address resolution when using DNS

dflag/configmap/updater_test.go

@@ -124,7 +124,8 @@ type (
 
 // eventually tries a given Assert function 5 times over the period of time.
 func eventually(t *testing.T, duration time.Duration,
-	af assertFunc, expected interface{}, actual getter, msgFmt string, msgArgs ...interface{}) {
+	af assertFunc, expected interface{}, actual getter, msgFmt string, msgArgs ...interface{},
+) {
 	increment := duration / 5
 	for i := 0; i < 5; i++ {
 		time.Sleep(increment)

dflag/dynstringset.go

@@ -78,7 +78,8 @@ func (d *DynStringSetValue) WithValidator(validator func(map[string]struct{}) er
 // WithNotifier adds a function that is called every time a new value is successfully set.
 // Each notifier is executed asynchronously in a new go-routine.
 func (d *DynStringSetValue) WithNotifier(notifier func(oldValue map[string]struct{},
-	newValue map[string]struct{})) *DynStringSetValue {
+	newValue map[string]struct{}),
+) *DynStringSetValue {
 	d.notifier = notifier
 	return d
 }

fhttp/http_client.go

@@ -46,6 +46,8 @@ type Fetcher interface {
 	// Close() cleans up connections and state - must be paired with NewClient calls.
 	// returns how many sockets have been used (Fastclient only)
 	Close() int
+	// GetIPAddress() get the ip address that DNS resolves to
+	GetIPAddress() string
 }
 
 const (
@@ -62,6 +64,7 @@ var (
 	connectionCloseHeader = []byte("\r\nconnection: close")
 	chunkedHeader         = []byte("\r\nTransfer-Encoding: chunked")
 	rander                = NewSyncReader(rand.New(rand.NewSource(time.Now().UnixNano())))
+	stdClientIP           = make(chan string)
 )
 
 // NewHTTPOptions creates and initialize a HTTPOptions object.
@@ -396,6 +399,11 @@ func (c *Client) Fetch() (int, []byte, int) {
 	return code, data, 0
 }
 
+// GetIPAddress get the ip address that DNS resolves to when using stdClient.
+func (c *Client) GetIPAddress() string {
+	return <-stdClientIP
+}
+
 // NewClient creates either a standard or fast client (depending on
 // the DisableFastClient flag).
 func NewClient(o *HTTPOptions) (Fetcher, error) {
@@ -426,6 +434,16 @@ func NewStdClient(o *HTTPOptions) (*Client, error) {
 			if o.Resolve != "" {
 				addr = o.Resolve + addr[strings.LastIndex(addr, ":"):]
 			}
+			// TODO: Find out how many time this get called. Should be num of conn + error
+			conn, err := net.Dial(network, addr)
+			if err != nil {
+				log.Errf("Fail to dial addr %s, err msg: %s\n", addr, err)
+			}
+
+			go func() {
+				stdClientIP <- conn.RemoteAddr().String()
+			}()
+
 			return (&net.Dialer{
 				Timeout: o.HTTPReqTimeOut,
 			}).DialContext(ctx, network, addr)
@@ -511,6 +529,11 @@ type FastClient struct {
 	tlsConfig    *tls.Config
 }
 
+// GetIPAddress get the ip address that DNS resolves to when using fast client.
+func (c *FastClient) GetIPAddress() string {
+	return c.dest.String()
+}
+
 // Close cleans up any resources used by FastClient.
 func (c *FastClient) Close() int {
 	log.Debugf("Closing %p %s socket count %d", c, c.url, c.socketCount)

fhttp/httprunner.go

@@ -37,6 +37,7 @@ type HTTPRunnerResults struct {
 	periodic.RunnerResults
 	client   Fetcher
 	RetCodes map[int]int64
+	IPCount  map[string]int64
 	// internal type/data
 	sizes       *stats.Histogram
 	headerSizes *stats.Histogram
@@ -98,6 +99,7 @@ func RunHTTPTest(o *HTTPRunnerOptions) (*HTTPRunnerResults, error) {
 	total := HTTPRunnerResults{
 		HTTPOptions: o.HTTPOptions,
 		RetCodes:    make(map[int]int64),
+		IPCount:     make(map[string]int64),
 		sizes:       stats.NewHistogram(0, 100),
 		headerSizes: stats.NewHistogram(0, 5),
 		AbortOn:     o.AbortOn,
@@ -182,6 +184,11 @@ func RunHTTPTest(o *HTTPRunnerOptions) (*HTTPRunnerResults, error) {
 	// unused ones. We also must cleanup all the created clients.
 	keys := []int{}
 	for i := 0; i < numThreads; i++ {
+		// Get the report on the IP address each thread use to send traffic
+		ip := httpstate[i].client.GetIPAddress()
+		log.Infof("[%d] Host %s resolve to IP address: %s \n", i, o.URL, ip)
+		total.IPCount[ip]++
+
 		total.SocketCount += httpstate[i].client.Close()
 		// Q: is there some copying each time stats[i] is used?
 		for k := range httpstate[i].RetCodes {
@@ -201,6 +208,9 @@ func RunHTTPTest(o *HTTPRunnerOptions) (*HTTPRunnerResults, error) {
 		_, _ = fmt.Fprintf(out, "Sockets used: %d (for perfect keepalive, would be %d)\n", total.SocketCount, r.Options().NumThreads)
 	}
 	_, _ = fmt.Fprintf(out, "Uniform: %t, Jitter: %t\n", total.Uniform, total.Jitter)
+	for k, v := range total.IPCount {
+		_, _ = fmt.Fprintf(out, "IP address %s usage count: %d\n", k, v)
+	}
 	for _, k := range keys {
 		_, _ = fmt.Fprintf(out, "Code %3d : %d (%.1f %%)\n", k, total.RetCodes[k], 100.*float64(total.RetCodes[k])/totalCount)
 	}
@@ -216,7 +226,7 @@ func RunHTTPTest(o *HTTPRunnerOptions) (*HTTPRunnerResults, error) {
 	return &total, nil
 }
 
-// A errgroup is a collection of goroutines working on subtasks that are part of
+// An errgroup is a collection of goroutines working on subtasks that are part of
 // the same overall task.
 type errgroup struct {
 	wg sync.WaitGroup

stats/stats_test.go

@@ -726,7 +726,6 @@ func TestBucketLookUp(t *testing.T) {
 		input float64 // input
 		start float64 // start
 		end   float64 // end
-
 	}{
 		{input: 11, start: 10, end: 11},
 		{input: 171, start: 160, end: 180},

ui/restHandler.go

@@ -236,7 +236,8 @@ func RESTRunHandler(w http.ResponseWriter, r *http.Request) { // nolint: funlen
 
 // Run executes the run (can be called async or not, writer is nil for async mode).
 func Run(w http.ResponseWriter, r *http.Request, jd map[string]interface{},
-	runner, url string, ro periodic.RunnerOptions, httpopts *fhttp.HTTPOptions) {
+	runner, url string, ro periodic.RunnerOptions, httpopts *fhttp.HTTPOptions,
+) {
 	//	go func() {
 	var res periodic.HasRunnerResult
 	var err error