Use native dialer for scout

mtglib/internal/doppel/init.go

 
 import (
 	"context"
+	"net"
 	"net/http"
 	"time"
 
 	// Dial establishes context-free TCP connections.
 	Dial(network, address string) (essentials.Conn, error)
 
-	// DialContext dials using a context. This is a preferrable way of
+	// DialContext dials using a context. This is a preferable way of
 	// establishing TCP connections.
 	DialContext(ctx context.Context, network, address string) (essentials.Conn, error)
 
 	// MakeHTTPClient build an HTTP client with given dial function. If nothing is
 	// provided, then DialContext of this interface is going to be used.
 	MakeHTTPClient(func(ctx context.Context, network, address string) (essentials.Conn, error)) *http.Client
+
+	// NativeDialer returns a configured instance of native dialer that
+	// skips proxy connections or any other irrelevant settings.
+	NativeDialer() *net.Dialer
 }

mtglib/internal/doppel/init_test.go

 	return conn.(*net.TCPConn), nil
 }
 
+func (s SimpleNetwork) NativeDialer() *net.Dialer {
+	return &net.Dialer{}
+}
+
 func (s SimpleNetwork) MakeHTTPClient(dialFunc func(ctx context.Context, network, address string) (essentials.Conn, error)) *http.Client {
 	if dialFunc == nil {
 		dialFunc = s.DialContext

mtglib/internal/doppel/scout.go

 }
 
 func (s Scout) makeClient() (*http.Client, *ScoutConnCollected) {
+	dialer := s.network.NativeDialer()
 	collected := NewScoutConnCollected()
 	client := s.network.MakeHTTPClient(func(
 		ctx context.Context,
 		network string,
 		address string,
 	) (essentials.Conn, error) {
-		conn, err := s.network.DialContext(ctx, network, address)
+		conn, err := dialer.DialContext(ctx, network, address)
 		if err != nil {
 			return nil, err
 		}
 
-		return NewScoutConn(conn, collected), nil
+		return NewScoutConn(essentials.WrapNetConn(conn), collected), nil
 	})
 
 	return client, collected