Customizing the HTTP Client (DynamoDB). How to override default IdleConnTimeout?

[gcfabri]

Hello,

I 'd like some help to understand why this code is not overriding the default idle connection timeout. In the code below, the connection is not reused correctly when the parameter is set higher than the DefaultHTTPTransportIdleConnTimeout (90s).

Note: I tried to build the client using the NewBuildableClient helper too, same result.

I appreciate any suggestions on the topic. Thanks in advance.

package main

import (
	"context"
	"crypto/tls"
	"encoding/json"
	"github.com/aws/aws-sdk-go-v2/aws"
	awsconfig "github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
	"github.com/aws/smithy-go/middleware"
	"log"
	"net/http"
	"net/http/httptrace"
	"time"
)

const (
	region = "us-east-2"
)

func main() {
	ctx := context.Background()

	transport := http.DefaultTransport.(*http.Transport).Clone()

	transport.MaxIdleConns = 5
	transport.MaxIdleConnsPerHost = 5
	transport.MaxConnsPerHost = 10
	transport.IdleConnTimeout = time.Second * 120
	transport.DisableKeepAlives = false

	httpClient := &http.Client{
		Transport: transport,
	}

	//httpClient := awshttp.NewBuildableClient().
	//	WithTimeout(time.Second * 5).
	//	WithDialerOptions(func(d *net.Dialer) {
	//		d.KeepAlive = 0 // Set to 0 to enable keep-alives if supported by the protocol and operating system.
	//		d.Timeout = time.Millisecond * 500
	//	}).
	//	WithTransportOptions(func(tr *http.Transport) {
	//		tr.MaxIdleConns = 5
	//		tr.IdleConnTimeout = time.Second * 120
	//		tr.MaxConnsPerHost = 5
	//		tr.MaxIdleConnsPerHost = 5
	//		tr.ForceAttemptHTTP2 = false
	//		tr.DisableCompression = true
	//		tr.DisableKeepAlives = false
	//	}).Freeze()

	cfg, err := awsconfig.LoadDefaultConfig(
		ctx,
		awsconfig.WithRegion(region),
		awsconfig.WithHTTPClient(httpClient),
		awsconfig.WithAPIOptions([]func(*middleware.Stack) error{
			func(stack *middleware.Stack) error {
				err := addHttpTraceMiddleware(stack)
				if err != nil {
					return err
				}
				return nil
			},
		}),
		awsconfig.WithClientLogMode(aws.LogResponseWithBody),
	)
	if err != nil {
		log.Fatalln(err)
	}

	dynamodbClient := dynamodb.NewFromConfig(cfg)

	GetItemByID(ctx, dynamodbClient)

	time.Sleep(time.Second * 119)

	GetItemByID(ctx, dynamodbClient)

	time.Sleep(time.Second * 121)

	GetItemByID(ctx, dynamodbClient)
}

func addHttpTraceMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(
		middleware.InitializeMiddlewareFunc("HttpTraceMiddleware", func(
			ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
			out middleware.InitializeOutput, metadata middleware.Metadata, err error) {

			var dnsStart time.Time
			var dnsDone time.Time
			var getConn time.Time
			var gotConn time.Time
			var tlsHandshakeStart time.Time
			var tlsHandshakeDone time.Time
			var connectDone time.Time

			var trace = &httptrace.ClientTrace{
				GetConn: func(hostPort string) {
					getConn = time.Now()
				},
				GotConn: func(connInfo httptrace.GotConnInfo) {
					gotConn = time.Now()
					log.Printf("Got Conn: %+v Latency: %s", connInfo, gotConn.Sub(getConn).String())
				},
				PutIdleConn: func(err error) {
					if err != nil {
						log.Println("Put IdleConn:", err.Error())
					}
				},
				DNSStart: func(dnsInfo httptrace.DNSStartInfo) {
					dnsStart = time.Now()
					log.Printf("DNS Start: %+v", dnsInfo)
				},
				DNSDone: func(dnsInfo httptrace.DNSDoneInfo) {
					dnsDone = time.Now()
					log.Printf("DNS Done: %+v Lantecy: %s", dnsInfo, dnsDone.Sub(dnsStart).String())
				},
				ConnectStart: func(_, _ string) {
					if dnsDone.IsZero() {
						dnsDone = time.Now()
					}
					if dnsStart.IsZero() {
						dnsStart = dnsDone
					}
				},
				ConnectDone: func(net, addr string, err error) {
					connectDone = time.Now()
					log.Printf("Connect Done: %+v %+v Latency: %s", net, addr, connectDone.Sub(dnsDone).String())
				},
				TLSHandshakeStart: func() {
					tlsHandshakeStart = time.Now()
				},
				TLSHandshakeDone: func(cs tls.ConnectionState, err error) {
					tlsHandshakeDone = time.Now()
					log.Printf("TLS Handshake Done: Latency: %s", tlsHandshakeDone.Sub(tlsHandshakeStart).String())
				},
			} // Adding the trace context to the middleware context
			ctx = httptrace.WithClientTrace(ctx, trace)

			return next.HandleInitialize(ctx, in)
		}),
		middleware.After,
	)
}

func GetItemByID(ctx context.Context, dynamodbClient *dynamodb.Client) {
	resp, err := dynamodbClient.GetItem(ctx, &dynamodb.GetItemInput{
		Key: map[string]types.AttributeValue{
			"key": &types.AttributeValueMemberS{
				Value: "<REPLACE_ME>",
			},
		},
		TableName: aws.String("<REPLACE_ME>"),
	})
	if err != nil {
		log.Println("Err", err.Error())
	} else {
		var result map[string]any

		_ = attributevalue.UnmarshalMap(resp.Item, &result)

		b, _ := json.Marshal(resp.Item)

		log.Println(string(b))
	}
}