add httptrace option

module/apmhttp/client.go

@@ -70,6 +70,7 @@ type roundTripper struct {
 	r              http.RoundTripper
 	requestName    RequestNameFunc
 	requestIgnorer RequestIgnorerFunc
+	traceRequests  bool
 }
 
 // RoundTrip delegates to r.r, emitting a span if req's context
@@ -102,6 +103,10 @@ func (r *roundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
 
 	name := r.requestName(req)
 	span := tx.StartSpan(name, "external.http", apm.SpanFromContext(ctx))
+	var rt requestTracer
+	if r.traceRequests {
+		ctx = rt.start(ctx, span)
+	}
 	if !span.Dropped() {
 		traceContext = span.TraceContext()
 		ctx = apm.ContextWithSpan(ctx, span)
@@ -116,10 +121,17 @@ func (r *roundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
 	resp, err := r.r.RoundTrip(req)
 	if span != nil {
 		if err != nil {
+			if r.traceRequests {
+				rt.end()
+			}
 			span.End()
 		} else {
 			span.Context.SetHTTPStatusCode(resp.StatusCode)
-			resp.Body = &responseBody{span: span, body: resp.Body}
+			body := &responseBody{span: span, body: resp.Body}
+			if r.traceRequests {
+				body.requestTracer = &rt
+			}
+			resp.Body = body
 		}
 	}
 	return resp, err
@@ -158,6 +170,7 @@ func (r *roundTripper) CancelRequest(req *http.Request) {
 
 type responseBody struct {
 	span *apm.Span
+	*requestTracer
 	body io.ReadCloser
 }
 
@@ -178,6 +191,7 @@ func (b *responseBody) Read(p []byte) (n int, err error) {
 }
 
 func (b *responseBody) endSpan() {
+	b.requestTracer.end()
 	addr := (*unsafe.Pointer)(unsafe.Pointer(&b.span))
 	if old := atomic.SwapPointer(addr, nil); old != nil {
 		(*apm.Span)(old).End()

module/apmhttp/client_test.go

@@ -21,6 +21,7 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io/ioutil"
 	"net"
 	"net/http"
@@ -311,6 +312,23 @@ func TestWithClientRequestName(t *testing.T) {
 	assert.Equal(t, "http://test", span.Name)
 }
 
+func TestWithClientTrace(t *testing.T) {
+	server := httptest.NewServer(http.NotFoundHandler())
+	defer server.Close()
+
+	_, spans, _ := apmtest.WithTransaction(func(ctx context.Context) {
+		mustGET(ctx, server.URL, apmhttp.WithClientTrace())
+	})
+
+	require.Len(t, spans, 4)
+	assert.True(t, strings.HasPrefix(spans[0].Name, "Connect "),
+		fmt.Sprintf("want: Connect ... got: %s", spans[0].Name))
+	assert.Equal(t, "Request", spans[1].Name)
+	assert.Equal(t, "Response", spans[2].Name)
+	assert.Equal(t, model.IfaceMap{
+		model.IfaceMapItem{Key: "dns", Value: false}}, spans[0].Context.Tags)
+}
+
 func mustGET(ctx context.Context, url string, o ...apmhttp.ClientOption) (statusCode int, responseBody string) {
 	client := apmhttp.WrapClient(http.DefaultClient, o...)
 	resp, err := ctxhttp.Get(ctx, client, url)

module/apmhttp/clienttrace.go

@@ -0,0 +1,106 @@
+// Licensed to Elasticsearch B.V. under one or more contributor
+// license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright
+// ownership. Elasticsearch B.V. licenses this file to you under
+// the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package apmhttp
+
+import (
+	"context"
+	"crypto/tls"
+	"fmt"
+	"net/http/httptrace"
+
+	"go.elastic.co/apm"
+)
+
+// WithClientTrace returns a ClientOption for
+// tracing events within HTTP client requests.
+func WithClientTrace() ClientOption {
+	return func(rt *roundTripper) {
+		rt.traceRequests = true
+	}
+}
+
+type requestTracer struct {
+	tx *apm.Transaction
+
+	DNS,
+	TLS,
+	Request,
+	Response *apm.Span
+
+	Connects map[[2]string]*apm.Span
+}
+
+func connectKey(network, addr string) [2]string {
+	return [2]string{network, addr}
+}
+
+func (r *requestTracer) start(ctx context.Context, parent *apm.Span) context.Context {
+	r.tx = apm.TransactionFromContext(ctx)
+	r.Connects = make(map[[2]string]*apm.Span)
+	return httptrace.WithClientTrace(ctx, &httptrace.ClientTrace{
+		DNSStart: func(i httptrace.DNSStartInfo) {
+			r.DNS = r.tx.StartSpan(fmt.Sprintf("DNS %s", i.Host), "http.dns", parent)
+		},
+
+		DNSDone: func(i httptrace.DNSDoneInfo) {
+			r.DNS.End()
+		},
+
+		ConnectStart: func(network, addr string) {
+			span := r.tx.StartSpan(fmt.Sprintf("Connect %s", addr), "http.connect", parent)
+			if r.DNS == nil {
+				span.Context.SetLabel("dns", false)
+			}
+			r.Connects[connectKey(network, addr)] = span
+		},
+
+		ConnectDone: func(network, addr string, err error) {
+			span := r.Connects[connectKey(network, addr)]
+			if err != nil {
+				span.Context.SetLabel("error", err.Error())
+			}
+			span.End()
+		},
+
+		TLSHandshakeStart: func() {
+			r.TLS = r.tx.StartSpan("TLS", "http.tls", parent)
+		},
+
+		TLSHandshakeDone: func(_ tls.ConnectionState, _ error) {
+			r.TLS.End()
+		},
+
+		WroteRequest: func(info httptrace.WroteRequestInfo) {
+			r.Request = r.tx.StartSpan("Request", "http.request", parent)
+		},
+
+		GotFirstResponseByte: func() {
+			r.Request.End()
+			r.Response = r.tx.StartSpan("Response", "http.response", parent)
+		},
+	})
+}
+
+func (r *requestTracer) end() {
+	if r == nil {
+		return
+	}
+	if r.Response != nil {
+		r.Response.End()
+	}
+}