go version go1.9.4 linux/amd64

    GOARCH="amd64"
    GOBIN="/home/sszuecs/go/bin"
    GOEXE=""
    GOHOSTARCH="amd64"
    GOHOSTOS="linux"
    GOOS="linux"
    GOPATH="/home/sszuecs/go"
    GORACE=""
    GOROOT="/usr/share/go"
    GOTOOLDIR="/usr/share/go/pkg/tool/linux_amd64"
    GCCGO="gccgo"
    CC="gcc"
    GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build480041304=/tmp/go-build -gno-record-gcc-switches"
    CXX="g++"
    CGO_ENABLED="1"
    CGO_CFLAGS="-g -O2"
    CGO_CPPFLAGS=""
    CGO_CXXFLAGS="-g -O2"
    CGO_FFLAGS="-g -O2"
    CGO_LDFLAGS="-g -O2"
    PKG_CONFIG="pkg-config"

package main

import (
	"context"
	"fmt"
	"log"
	"net"
	"net/http"
	"time"
)

type proxyError struct {
	err           error
	code          int
	dialingFailed bool
}

func (e proxyError) Error() string {
	return fmt.Sprintf("proxyError: %v", e.err)
}

type myDialer struct {
	net.Dialer
	f func(ctx context.Context, network, addr string) (net.Conn, error)
}

func myDialerNew(d net.Dialer) *myDialer {
	return &myDialer{
		Dialer: d,
		f:      d.DialContext,
	}
}

func (dc *myDialer) DialContext(ctx context.Context, network, addr string) (net.Conn, error) {
	con, err := dc.f(ctx, network, addr)
	if err != nil {
		return nil, proxyError{
			err:           err,
			dialingFailed: true,
		}
	}
	return con, nil
}

func main() {

	tr := &http.Transport{
		DialContext: myDialerNew(net.Dialer{
			Timeout:   100 * time.Millisecond,
			KeepAlive: 30 * time.Second,
			DualStack: true,
		}).DialContext,
		TLSHandshakeTimeout:   200 * time.Millisecond,
		ResponseHeaderTimeout: 500 * time.Millisecond,
		IdleConnTimeout:       5 * time.Second,
	}

	go func(rt http.RoundTripper) {
		for {
			time.Sleep(1 * time.Second)

			req, err := http.NewRequest("GET", "http://127.0.0.1:10000/", nil)
			if err != nil {
				log.Printf("Failed to create request: %v", err)
				continue
			}

			resp, err := rt.RoundTrip(req)
			if err != nil {
				if perr, ok := err.(proxyError); ok {
					if nerr, ok := perr.err.(interface {
						Temporary() bool
						Timeout() bool
					}); ok {
						log.Printf("Failed to do roundtrip %v %v: %v", nerr.Temporary(), nerr.Timeout(), perr.err)
					}
					log.Printf("dial error: %v", perr)
				} else {
					if nerr, ok := err.(interface {
						Temporary() bool
						Timeout() bool
					}); ok {
						log.Printf("Failed to do roundtrip %v %v: %v", nerr.Temporary(), nerr.Timeout(), err)
					}
					log.Printf("not a dial error: %v", err)
				}
				continue
			}
			resp.Body.Close()
			log.Printf("resp status: %v", resp.Status)
		}
	}(tr)

	ch := make(chan struct{})
	<-ch
}

if nerr, ok := err.(net.Error); ok {
    if nerr.DialError() {
        retrySend(req)
    }
}