using the same hooks for HTTP/3 with small specific logic

app/http3.go

@@ -115,14 +115,14 @@ func newHttp3RoundTripper(config *Config, runtimeConfig *RuntimeConfig, w *webCl
 		DisableCompression: config.DisableCompression,
 		Dial: func(ctx context.Context, addr string, tlsCfg *tls.Config, cfg *quic.Config) (quic.EarlyConnection, error) {
 
-			tr, _ := ctx.Value(http3EventKey{}).(*Http3ClientTrace)
+			trh := httptrace.ContextClientTrace(ctx)
 
-			if tr != nil && tr.GetConn != nil {
-				tr.GetConn(addr)
+			if trh != nil && trh.GetConn != nil {
+				trh.GetConn(addr)
 			}
 
-			if tr != nil && tr.DNSStart != nil {
-				tr.DNSStart(httptrace.DNSStartInfo{
+			if trh != nil && trh.DNSStart != nil {
+				trh.DNSStart(httptrace.DNSStartInfo{
 					Host: addr,
 				})
 			}
@@ -134,28 +134,28 @@ func newHttp3RoundTripper(config *Config, runtimeConfig *RuntimeConfig, w *webCl
 			}
 			runtimeConfig.ResolvedConnAddress = connAddr
 
-			if tr != nil && tr.DNSDone != nil {
+			if trh != nil && trh.DNSDone != nil {
 
-				tr.DNSDone(httptrace.DNSDoneInfo{
+				trh.DNSDone(httptrace.DNSDoneInfo{
 					Addrs: []net.IPAddr{},
 				})
 			}
 
-			if tr != nil && tr.QUICStart != nil {
-				tr.QUICStart()
+			if trh != nil && trh.TLSHandshakeStart != nil {
+				trh.TLSHandshakeStart()
 			}
 
 			dae, err := quic.DialAddrEarly(ctx, connAddr, tlsCfg, cfg)
 			if err != nil {
 				return nil, err
 			}
 
-			if tr != nil && tr.QUICDone != nil {
-				tr.QUICDone()
+			if trh != nil && trh.TLSHandshakeDone != nil {
+				trh.TLSHandshakeDone(tls.ConnectionState{}, nil)
 			}
 
-			if tr != nil && tr.GotConn != nil {
-				tr.GotConn()
+			if trh != nil && trh.GotConn != nil {
+				trh.GotConn(httptrace.GotConnInfo{Conn: connAdapter{remoteAddr: dae.RemoteAddr()}})
 			}
 
 			return wrapEarlyConnection(dae, w), err
@@ -168,6 +168,15 @@ func newHttp3RoundTripper(config *Config, runtimeConfig *RuntimeConfig, w *webCl
 	}, nil
 }
 
+type connAdapter struct {
+	*net.UDPConn
+	remoteAddr net.Addr
+}
+
+func (c connAdapter) RemoteAddr() net.Addr {
+	return c.remoteAddr
+}
+
 func CheckAltSvcH3Header(h http.Header) *string {
 	for k, entries := range h {
 		if strings.ToUpper(k) == "ALT-SVC" {

app/pinglogger.go

@@ -20,6 +20,7 @@ import (
 	"fever.ch/http-ping/stats"
 	"fmt"
 	"io"
+	"strings"
 	"time"
 )
 
@@ -144,7 +145,6 @@ func (logger *standardLogger) onClose() {
 
 type verboseLogger struct {
 	standardLogger
-	//stats.MeasuresCollection
 	measureSum *HTTPMeasure
 }
 
@@ -153,14 +153,18 @@ func newVerboseLogger(config *Config, stdout io.Writer, pinger Pinger) logger {
 		standardLogger: *newStandardLogger(config, stdout, pinger),
 		measureSum: &HTTPMeasure{
 			MeasuresCollection: stats.NewMeasureRegistry(),
-			//DNSResolution: stats.MeasureNotValid,
-			//TCPHandshake:  stats.MeasureNotValid,
-			//TLSDuration:   stats.MeasureNotValid,
 		},
 	}
 }
 
 func (logger *verboseLogger) onMeasure(measure *HTTPMeasure) {
+
+	if strings.HasPrefix(measure.Proto, "HTTP/3") {
+		measure.MeasuresCollection.Set(stats.QUIC, measure.MeasuresCollection.Get(stats.TLS))
+		measure.MeasuresCollection.Set(stats.TLS, stats.MeasureNotValid)
+	} else {
+		measure.MeasuresCollection.Set(stats.ReqAndWait, stats.MeasureNotValid)
+	}
 	logger.standardLogger.onMeasure(measure)
 	if logger.config.Throughput {
 		return
@@ -172,19 +176,8 @@ func (logger *verboseLogger) onMeasure(measure *HTTPMeasure) {
 	_, _ = fmt.Fprintf(logger.stdout, "          proto=%s, socket reused=%t, compressed=%t\n", measure.Proto, measure.SocketReused, measure.Compressed)
 	_, _ = fmt.Fprintf(logger.stdout, "          network i/o: bytes read=%d, bytes written=%d\n", measure.InBytes, measure.OutBytes)
 
-	//if measure.TLSEnabled {
 	_, _ = fmt.Fprintf(logger.stdout, "          tls version=%s\n", measure.TLSVersion)
-	//}
-	//logger.
 	logger.measureSum.MeasuresCollection.Append(measure.MeasuresCollection)
-	//logger.measureSum.TotalTime += measure.TotalTime
-	//logger.measureSum.ConnEstablishment = logger.measureSum.ConnEstablishment.SumIfValid(measure.ConnEstablishment)
-	//logger.measureSum.DNSResolution = logger.measureSum.DNSResolution.SumIfValid(measure.DNSResolution)
-	//logger.measureSum.TCPHandshake = logger.measureSum.TCPHandshake.SumIfValid(measure.TCPHandshake)
-	//logger.measureSum.TLSDuration = logger.measureSum.TLSDuration.SumIfValid(measure.TLSDuration)
-	//logger.measureSum.RequestSending += measure.RequestSending
-	//logger.measureSum.Wait += measure.Wait
-	//logger.measureSum.ResponseIngesting += measure.ResponseIngesting
 
 	_, _ = fmt.Fprintf(logger.stdout, "\n")
 
@@ -202,16 +195,6 @@ func (logger *verboseLogger) onClose() {
 
 	if successes > 0 && !logger.config.Throughput {
 		logger.measureSum.MeasuresCollection.Divide(successes)
-		//logger.measureSum.TotalTime = logger.measureSum.TotalTime.Divide(successes)
-		//logger.measureSum.ConnEstablishment = logger.measureSum.ConnEstablishment.Divide(successes)
-		//logger.measureSum.DNSResolution = logger.measureSum.DNSResolution.Divide(successes)
-		//logger.measureSum.TCPHandshake = logger.measureSum.TCPHandshake.Divide(successes)
-		//logger.measureSum.TLSDuration = logger.measureSum.TLSDuration.Divide(successes)
-		//logger.measureSum.RequestSending = logger.measureSum.RequestSending.Divide(successes)
-		//logger.measureSum.Wait = logger.measureSum.Wait.Divide(successes)
-		//logger.measureSum.ResponseIngesting = logger.measureSum.ResponseIngesting.Divide(successes)
-		//logger.measureSum.TLSEnabled = logger.measureSum.MeasuresCollection.Get(stats.TLS) > 0
-		//logger.measureSum.TLSEnabled = logger.measureSum.TLSDuration > 0
 
 		_, _ = fmt.Fprintf(logger.stdout, "\naverage latency contributions:\n")
 
@@ -237,9 +220,6 @@ func (logger *verboseLogger) drawMeasure(measure *HTTPMeasure, stdout io.Writer)
 			{label: "response ingestion", duration: measure.MeasuresCollection.Get(stats.Resp)},
 		},
 	}
-	//if !measure.TLSEnabled {
-	//	entries.children[0].children = entries.children[0].children[0:2]
-	//}
 
 	l := logger.makeTreeList(&entries)
 

app/webclientimpl.go

@@ -286,6 +286,7 @@ func (webClient *webClientImpl) DoMeasure(followRedirect bool) *HTTPMeasure {
 			remoteAddr = info.Conn.RemoteAddr().String()
 			timerRegistry.Get(stats.Conn).Stop()
 			timerRegistry.Get(stats.Req).Start()
+			timerRegistry.Get(stats.ReqAndWait).Start()
 			reused = info.Reused
 		},
 
@@ -296,6 +297,8 @@ func (webClient *webClientImpl) DoMeasure(followRedirect bool) *HTTPMeasure {
 
 		GotFirstResponseByte: func() {
 			timerRegistry.Get(stats.Wait).Stop()
+			timerRegistry.Get(stats.ReqAndWait).Stop()
+
 			timerRegistry.Get(stats.Resp).Start()
 		},
 	}
@@ -316,7 +319,9 @@ func (webClient *webClientImpl) DoMeasure(followRedirect bool) *HTTPMeasure {
 			timerRegistry.Get(stats.DNS).Stop()
 		},
 
-		QUICStart: func() { timerRegistry.Get(stats.QUIC).Start() },
+		QUICStart: func() {
+			timerRegistry.Get(stats.QUIC).Start()
+		},
 		QUICDone: func() {
 			timerRegistry.Get(stats.QUIC).Stop()
 			timerRegistry.Get(stats.ReqAndWait).Start()