func()

in transport/httpcommon/diag.go [39:133]

• 93 lines of code
• 11 McCabe index (conditional complexity)

func (settings *HTTPTransportSettings) DiagRequests(reqs []*http.Request, opts ...TransportOption) func() []byte {
	if settings == nil {
		return func() []byte {
			return []byte(`error: nil httpcommon.HTTPTransportSettings`)
		}
	}
	if len(reqs) == 0 {
		return func() []byte {
			return []byte(`error: 0 requests`)
		}
	}
	return func() []byte {
		var b bytes.Buffer
		rt, err := settings.RoundTripper(opts...)
		if err != nil {
			b.WriteString("unable to get roundtripper: " + err.Error())
			return b.Bytes()
		}
		logger := log.New(&b, "", log.LstdFlags|log.Lmicroseconds|log.LUTC)
		if settings.TLS == nil {
			logger.Print("No TLS settings")
		} else {
			logger.Print("TLS settings detected")
		}
		logger.Printf("Proxy disable=%v url=%s", settings.Proxy.Disable, settings.Proxy.URL)

		ct := &httptrace.ClientTrace{
			GetConn: func(hostPort string) {
				logger.Printf("GetConn called for %q", hostPort)
			},
			GotConn: func(connInfo httptrace.GotConnInfo) {
				logger.Printf("GotConn for %q", connInfo.Conn.RemoteAddr())
			},
			GotFirstResponseByte: func() {
				logger.Print("Response started")
			},
			Got1xxResponse: func(code int, header textproto.MIMEHeader) error {
				logger.Printf("Got info response status=%d, headers=%v", code, header)
				return nil
			},
			DNSStart: func(info httptrace.DNSStartInfo) {
				logger.Printf("Starting DNS lookup for %q", info.Host)
			},
			DNSDone: func(info httptrace.DNSDoneInfo) {
				logger.Printf("Done DNS lookup: %+v", info)
			},
			ConnectStart: func(network, addr string) {
				logger.Printf("Connection started to %s:%s", network, addr)
			},
			ConnectDone: func(network, addr string, err error) {
				logger.Printf("Connection to %s:%s done, err: %v", network, addr, err)
			},
			TLSHandshakeStart: func() {
				logger.Print("TLS handshake starting")
			},
			TLSHandshakeDone: func(state tls.ConnectionState, err error) {
				logger.Printf("TLS handshake done. state=%+v err=%v", state, err)
				logger.Printf("Peer certificate count %d", len(state.PeerCertificates))
				for i, crt := range state.PeerCertificates {
					logger.Printf("- Peer Certificate %d\n\t%s", i, tlscommon.CertDiagString(crt))
				}

				logger.Printf("Verified chains count: %d", len(state.VerifiedChains))
				for i, chain := range state.VerifiedChains {
					for j, crt := range chain {
						logger.Printf("- Chain %d certificate %d\n\t%s", i, j, tlscommon.CertDiagString(crt))
					}
				}
			},
			WroteHeaders: func() {
				logger.Printf("Wrote request headers")
			},
			Wait100Continue: func() {
				logger.Printf("Waiting for continue")
			},
			WroteRequest: func(info httptrace.WroteRequestInfo) {
				logger.Printf("Wrote request err=%v", info.Err)
			},
		}
		for i, req := range reqs {
			logger.Printf("Request %d to %s starting", i, req.URL.String())
			req = req.WithContext(httptrace.WithClientTrace(req.Context(), ct))
			if resp, err := rt.RoundTrip(req); err != nil {
				logger.Printf("request %d error: %s", i, diagError(err))
			} else if isGoHTTPResp(resp) {
				resp.Body.Close()
				logger.Printf("request %d error: HTTP request sent to HTTPS server.", i)
			} else {
				resp.Body.Close()
				logger.Printf("request %d successful. status=%d", i, resp.StatusCode)
			}
		}
		return b.Bytes()
	}
}