Update dependencies

vendor/github.com/aws/smithy-go/transport/http/client.go

@@ -6,7 +6,9 @@ import (
 	"net/http"
 
 	smithy "github.com/aws/smithy-go"
+	"github.com/aws/smithy-go/metrics"
 	"github.com/aws/smithy-go/middleware"
+	"github.com/aws/smithy-go/tracing"
 )
 
 // ClientDo provides the interface for custom HTTP client implementations.
@@ -27,13 +29,30 @@ func (fn ClientDoFunc) Do(r *http.Request) (*http.Response, error) {
 // implementation is http.Client.
 type ClientHandler struct {
 	client ClientDo
+
+	Meter metrics.Meter // For HTTP client metrics.
 }
 
 // NewClientHandler returns an initialized middleware handler for the client.
+//
+// Deprecated: Use [NewClientHandlerWithOptions].
 func NewClientHandler(client ClientDo) ClientHandler {
-	return ClientHandler{
+	return NewClientHandlerWithOptions(client)
+}
+
+// NewClientHandlerWithOptions returns an initialized middleware handler for the client
+// with applied options.
+func NewClientHandlerWithOptions(client ClientDo, opts ...func(*ClientHandler)) ClientHandler {
+	h := ClientHandler{
 		client: client,
 	}
+	for _, opt := range opts {
+		opt(&h)
+	}
+	if h.Meter == nil {
+		h.Meter = metrics.NopMeterProvider{}.Meter("")
+	}
+	return h
 }
 
 // Handle implements the middleware Handler interface, that will invoke the
@@ -42,6 +61,14 @@ func NewClientHandler(client ClientDo) ClientHandler {
 func (c ClientHandler) Handle(ctx context.Context, input interface{}) (
 	out interface{}, metadata middleware.Metadata, err error,
 ) {
+	ctx, span := tracing.StartSpan(ctx, "DoHTTPRequest")
+	defer span.End()
+
+	ctx, client, err := withMetrics(ctx, c.client, c.Meter)
+	if err != nil {
+		return nil, metadata, fmt.Errorf("instrument with HTTP metrics: %w", err)
+	}
+
 	req, ok := input.(*Request)
 	if !ok {
 		return nil, metadata, fmt.Errorf("expect Smithy http.Request value as input, got unsupported type %T", input)
@@ -52,7 +79,17 @@ func (c ClientHandler) Handle(ctx context.Context, input interface{}) (
 		return nil, metadata, err
 	}
 
-	resp, err := c.client.Do(builtRequest)
+	span.SetProperty("http.method", req.Method)
+	span.SetProperty("http.request_content_length", -1) // at least indicate unknown
+	length, ok, err := req.StreamLength()
+	if err != nil {
+		return nil, metadata, err
+	}
+	if ok {
+		span.SetProperty("http.request_content_length", length)
+	}
+
+	resp, err := client.Do(builtRequest)
 	if resp == nil {
 		// Ensure a http response value is always present to prevent unexpected
 		// panics.
@@ -79,6 +116,10 @@ func (c ClientHandler) Handle(ctx context.Context, input interface{}) (
 		_ = builtRequest.Body.Close()
 	}
 
+	span.SetProperty("net.protocol.version", fmt.Sprintf("%d.%d", resp.ProtoMajor, resp.ProtoMinor))
+	span.SetProperty("http.status_code", resp.StatusCode)
+	span.SetProperty("http.response_content_length", resp.ContentLength)
+
 	return &Response{Response: resp}, metadata, err
 }
 

vendor/github.com/aws/smithy-go/transport/http/host.go

@@ -69,7 +69,7 @@ func ValidPortNumber(port string) bool {
 	return true
 }
 
-// ValidHostLabel returns whether the label is a valid RFC 3986 host abel.
+// ValidHostLabel returns whether the label is a valid RFC 3986 host label.
 func ValidHostLabel(label string) bool {
 	if l := len(label); l == 0 || l > 63 {
 		return false

vendor/github.com/aws/smithy-go/transport/http/metrics.go

@@ -0,0 +1,198 @@
+package http
+
+import (
+	"context"
+	"crypto/tls"
+	"net/http"
+	"net/http/httptrace"
+	"sync/atomic"
+	"time"
+
+	"github.com/aws/smithy-go/metrics"
+)
+
+var now = time.Now
+
+// withMetrics instruments an HTTP client and context to collect HTTP metrics.
+func withMetrics(parent context.Context, client ClientDo, meter metrics.Meter) (
+	context.Context, ClientDo, error,
+) {
+	hm, err := newHTTPMetrics(meter)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	ctx := httptrace.WithClientTrace(parent, &httptrace.ClientTrace{
+		DNSStart:          hm.DNSStart,
+		ConnectStart:      hm.ConnectStart,
+		TLSHandshakeStart: hm.TLSHandshakeStart,
+
+		GotConn:              hm.GotConn(parent),
+		PutIdleConn:          hm.PutIdleConn(parent),
+		ConnectDone:          hm.ConnectDone(parent),
+		DNSDone:              hm.DNSDone(parent),
+		TLSHandshakeDone:     hm.TLSHandshakeDone(parent),
+		GotFirstResponseByte: hm.GotFirstResponseByte(parent),
+	})
+	return ctx, &timedClientDo{client, hm}, nil
+}
+
+type timedClientDo struct {
+	ClientDo
+	hm *httpMetrics
+}
+
+func (c *timedClientDo) Do(r *http.Request) (*http.Response, error) {
+	c.hm.doStart.Store(now())
+	resp, err := c.ClientDo.Do(r)
+
+	c.hm.DoRequestDuration.Record(r.Context(), c.hm.doStart.Elapsed())
+	return resp, err
+}
+
+type httpMetrics struct {
+	DNSLookupDuration    metrics.Float64Histogram   // client.http.connections.dns_lookup_duration
+	ConnectDuration      metrics.Float64Histogram   // client.http.connections.acquire_duration
+	TLSHandshakeDuration metrics.Float64Histogram   // client.http.connections.tls_handshake_duration
+	ConnectionUsage      metrics.Int64UpDownCounter // client.http.connections.usage
+
+	DoRequestDuration metrics.Float64Histogram // client.http.do_request_duration
+	TimeToFirstByte   metrics.Float64Histogram // client.http.time_to_first_byte
+
+	doStart      safeTime
+	dnsStart     safeTime
+	connectStart safeTime
+	tlsStart     safeTime
+}
+
+func newHTTPMetrics(meter metrics.Meter) (*httpMetrics, error) {
+	hm := &httpMetrics{}
+
+	var err error
+	hm.DNSLookupDuration, err = meter.Float64Histogram("client.http.connections.dns_lookup_duration", func(o *metrics.InstrumentOptions) {
+		o.UnitLabel = "s"
+		o.Description = "The time it takes a request to perform DNS lookup."
+	})
+	if err != nil {
+		return nil, err
+	}
+	hm.ConnectDuration, err = meter.Float64Histogram("client.http.connections.acquire_duration", func(o *metrics.InstrumentOptions) {
+		o.UnitLabel = "s"
+		o.Description = "The time it takes a request to acquire a connection."
+	})
+	if err != nil {
+		return nil, err
+	}
+	hm.TLSHandshakeDuration, err = meter.Float64Histogram("client.http.connections.tls_handshake_duration", func(o *metrics.InstrumentOptions) {
+		o.UnitLabel = "s"
+		o.Description = "The time it takes an HTTP request to perform the TLS handshake."
+	})
+	if err != nil {
+		return nil, err
+	}
+	hm.ConnectionUsage, err = meter.Int64UpDownCounter("client.http.connections.usage", func(o *metrics.InstrumentOptions) {
+		o.UnitLabel = "{connection}"
+		o.Description = "Current state of connections pool."
+	})
+	if err != nil {
+		return nil, err
+	}
+	hm.DoRequestDuration, err = meter.Float64Histogram("client.http.do_request_duration", func(o *metrics.InstrumentOptions) {
+		o.UnitLabel = "s"
+		o.Description = "Time spent performing an entire HTTP transaction."
+	})
+	if err != nil {
+		return nil, err
+	}
+	hm.TimeToFirstByte, err = meter.Float64Histogram("client.http.time_to_first_byte", func(o *metrics.InstrumentOptions) {
+		o.UnitLabel = "s"
+		o.Description = "Time from start of transaction to when the first response byte is available."
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return hm, nil
+}
+
+func (m *httpMetrics) DNSStart(httptrace.DNSStartInfo) {
+	m.dnsStart.Store(now())
+}
+
+func (m *httpMetrics) ConnectStart(string, string) {
+	m.connectStart.Store(now())
+}
+
+func (m *httpMetrics) TLSHandshakeStart() {
+	m.tlsStart.Store(now())
+}
+
+func (m *httpMetrics) GotConn(ctx context.Context) func(httptrace.GotConnInfo) {
+	return func(httptrace.GotConnInfo) {
+		m.addConnAcquired(ctx, 1)
+	}
+}
+
+func (m *httpMetrics) PutIdleConn(ctx context.Context) func(error) {
+	return func(error) {
+		m.addConnAcquired(ctx, -1)
+	}
+}
+
+func (m *httpMetrics) DNSDone(ctx context.Context) func(httptrace.DNSDoneInfo) {
+	return func(httptrace.DNSDoneInfo) {
+		m.DNSLookupDuration.Record(ctx, m.dnsStart.Elapsed())
+	}
+}
+
+func (m *httpMetrics) ConnectDone(ctx context.Context) func(string, string, error) {
+	return func(string, string, error) {
+		m.ConnectDuration.Record(ctx, m.connectStart.Elapsed())
+	}
+}
+
+func (m *httpMetrics) TLSHandshakeDone(ctx context.Context) func(tls.ConnectionState, error) {
+	return func(tls.ConnectionState, error) {
+		m.TLSHandshakeDuration.Record(ctx, m.tlsStart.Elapsed())
+	}
+}
+
+func (m *httpMetrics) GotFirstResponseByte(ctx context.Context) func() {
+	return func() {
+		m.TimeToFirstByte.Record(ctx, m.doStart.Elapsed())
+	}
+}
+
+func (m *httpMetrics) addConnAcquired(ctx context.Context, incr int64) {
+	m.ConnectionUsage.Add(ctx, incr, func(o *metrics.RecordMetricOptions) {
+		o.Properties.Set("state", "acquired")
+	})
+}
+
+// Not used: it is recommended to track acquired vs idle conn, but we can't
+// determine when something is truly idle with the current HTTP client hooks
+// available to us.
+func (m *httpMetrics) addConnIdle(ctx context.Context, incr int64) {
+	m.ConnectionUsage.Add(ctx, incr, func(o *metrics.RecordMetricOptions) {
+		o.Properties.Set("state", "idle")
+	})
+}
+
+type safeTime struct {
+	atomic.Value // time.Time
+}
+
+func (st *safeTime) Store(v time.Time) {
+	st.Value.Store(v)
+}
+
+func (st *safeTime) Load() time.Time {
+	t, _ := st.Value.Load().(time.Time)
+	return t
+}
+
+func (st *safeTime) Elapsed() float64 {
+	end := now()
+	elapsed := end.Sub(st.Load())
+	return float64(elapsed) / 1e9
+}

vendor/github.com/aws/smithy-go/transport/http/middleware_close_response_body.go

@@ -2,10 +2,10 @@ package http
 
 import (
 	"context"
+	"io"
+
 	"github.com/aws/smithy-go/logging"
 	"github.com/aws/smithy-go/middleware"
-	"io"
-	"io/ioutil"
 )
 
 // AddErrorCloseResponseBodyMiddleware adds the middleware to automatically
@@ -30,7 +30,7 @@ func (m *errorCloseResponseBodyMiddleware) HandleDeserialize(
 	if err != nil {
 		if resp, ok := out.RawResponse.(*Response); ok && resp != nil && resp.Body != nil {
 			// Consume the full body to prevent TCP connection resets on some platforms
-			_, _ = io.Copy(ioutil.Discard, resp.Body)
+			_, _ = io.Copy(io.Discard, resp.Body)
 			// Do not validate that the response closes successfully.
 			resp.Body.Close()
 		}
@@ -64,7 +64,7 @@ func (m *closeResponseBody) HandleDeserialize(
 
 	if resp, ok := out.RawResponse.(*Response); ok {
 		// Consume the full body to prevent TCP connection resets on some platforms
-		_, copyErr := io.Copy(ioutil.Discard, resp.Body)
+		_, copyErr := io.Copy(io.Discard, resp.Body)
 		if copyErr != nil {
 			middleware.GetLogger(ctx).Logf(logging.Warn, "failed to discard remaining HTTP response body, this may affect connection reuse")
 		}

vendor/github.com/aws/smithy-go/transport/http/request.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"net/url"
 	"strings"
@@ -167,7 +166,7 @@ func (r *Request) Build(ctx context.Context) *http.Request {
 
 	switch stream := r.stream.(type) {
 	case *io.PipeReader:
-		req.Body = ioutil.NopCloser(stream)
+		req.Body = io.NopCloser(stream)
 		req.ContentLength = -1
 	default:
 		// HTTP Client Request must only have a non-nil body if the
@@ -175,7 +174,7 @@ func (r *Request) Build(ctx context.Context) *http.Request {
 		// Client will interpret a non-nil body and ContentLength 0 as
 		// "unknown". This is unwanted behavior.
 		if req.ContentLength != 0 && r.stream != nil {
-			req.Body = iointernal.NewSafeReadCloser(ioutil.NopCloser(stream))
+			req.Body = iointernal.NewSafeReadCloser(io.NopCloser(stream))
 		}
 	}