feat(spans): only start 'http.client' op as a child span

httpclient/sentryhttpclient.go

@@ -67,10 +67,15 @@ type SentryRoundTripper struct {
 }
 
 func (s *SentryRoundTripper) RoundTrip(request *http.Request) (*http.Response, error) {
-	ctx := request.Context()
+	// Only create the `http.client` span only if there is a parent span.
+	parentSpan := sentry.GetSpanFromContext(request.Context())
+	if parentSpan == nil {
+		return s.originalRoundTripper.RoundTrip(request)
+	}
+
 	cleanRequestURL := request.URL.Redacted()
 
-	span := sentry.StartSpan(ctx, "http.client", sentry.WithTransactionName(fmt.Sprintf("%s %s", request.Method, cleanRequestURL)))
+	span := parentSpan.StartChild("http.client", sentry.WithTransactionName(fmt.Sprintf("%s %s", request.Method, cleanRequestURL)))
 	span.Tags = s.tags
 	defer span.Finish()
 

httpclient/sentryhttpclient_test.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"net/http"
 	"strconv"
+	"strings"
 	"testing"
 
 	"github.com/getsentry/sentry-go"
@@ -52,15 +53,15 @@ func TestIntegration(t *testing.T) {
 		TracerOptions      []sentryhttpclient.SentryRoundTripTracerOption
 		WantStatus         int
 		WantResponseLength int
-		WantTransaction    *sentry.Event
+		WantSpan           *sentry.Span
 	}{
 		{
 			RequestMethod:      "GET",
 			RequestURL:         "https://example.com/foo",
 			WantStatus:         200,
 			WantResponseLength: 0,
-			WantTransaction: &sentry.Event{
-				Extra: map[string]interface{}{
+			WantSpan: &sentry.Span{
+				Data: map[string]interface{}{
 					"http.fragment":                string(""),
 					"http.query":                   string(""),
 					"http.request.method":          string("GET"),
@@ -69,11 +70,12 @@ func TestIntegration(t *testing.T) {
 					"server.address":               string("example.com"),
 					"server.port":                  string(""),
 				},
-				Level:           sentry.LevelInfo,
-				Transaction:     "GET https://example.com/foo",
-				Type:            "transaction",
-				TransactionInfo: &sentry.TransactionInfo{Source: "custom"},
-				Tags:            map[string]string{},
+				Name:    "GET https://example.com/foo",
+				Op:      "http.client",
+				Tags:    map[string]string{},
+				Origin:  "manual",
+				Sampled: sentry.SampledTrue,
+				Status:  sentry.SpanStatusOK,
 			},
 		},
 		{
@@ -82,8 +84,8 @@ func TestIntegration(t *testing.T) {
 			TracerOptions:      []sentryhttpclient.SentryRoundTripTracerOption{nil, nil, nil},
 			WantStatus:         200,
 			WantResponseLength: 0,
-			WantTransaction: &sentry.Event{
-				Extra: map[string]interface{}{
+			WantSpan: &sentry.Span{
+				Data: map[string]interface{}{
 					"http.fragment":                string("readme"),
 					"http.query":                   string("baz=123"),
 					"http.request.method":          string("GET"),
@@ -92,11 +94,12 @@ func TestIntegration(t *testing.T) {
 					"server.address":               string("example.com"),
 					"server.port":                  string("443"),
 				},
-				Level:           sentry.LevelInfo,
-				Transaction:     "GET https://example.com:443/foo/bar?baz=123#readme",
-				Type:            "transaction",
-				TransactionInfo: &sentry.TransactionInfo{Source: "custom"},
-				Tags:            map[string]string{},
+				Name:    "GET https://example.com:443/foo/bar?baz=123#readme",
+				Op:      "http.client",
+				Tags:    map[string]string{},
+				Origin:  "manual",
+				Sampled: sentry.SampledTrue,
+				Status:  sentry.SpanStatusOK,
 			},
 		},
 		{
@@ -105,8 +108,8 @@ func TestIntegration(t *testing.T) {
 			TracerOptions:      []sentryhttpclient.SentryRoundTripTracerOption{sentryhttpclient.WithTag("user", "def"), sentryhttpclient.WithTags(map[string]string{"domain": "example.com"})},
 			WantStatus:         400,
 			WantResponseLength: 0,
-			WantTransaction: &sentry.Event{
-				Extra: map[string]interface{}{
+			WantSpan: &sentry.Span{
+				Data: map[string]interface{}{
 					"http.fragment":                string(""),
 					"http.query":                   string("abc=def&bar=123"),
 					"http.request.method":          string("HEAD"),
@@ -119,19 +122,20 @@ func TestIntegration(t *testing.T) {
 					"user":   "def",
 					"domain": "example.com",
 				},
-				Level:           sentry.LevelInfo,
-				Transaction:     "HEAD https://example.com:8443/foo?bar=123&abc=def",
-				Type:            "transaction",
-				TransactionInfo: &sentry.TransactionInfo{Source: "custom"},
+				Name:    "HEAD https://example.com:8443/foo?bar=123&abc=def",
+				Op:      "http.client",
+				Origin:  "manual",
+				Sampled: sentry.SampledTrue,
+				Status:  sentry.SpanStatusInvalidArgument,
 			},
 		},
 		{
 			RequestMethod:      "POST",
 			RequestURL:         "https://john:[email protected]:4321/secret",
 			WantStatus:         200,
 			WantResponseLength: 1024,
-			WantTransaction: &sentry.Event{
-				Extra: map[string]interface{}{
+			WantSpan: &sentry.Span{
+				Data: map[string]interface{}{
 					"http.fragment":                string(""),
 					"http.query":                   string(""),
 					"http.request.method":          string("POST"),
@@ -140,33 +144,35 @@ func TestIntegration(t *testing.T) {
 					"server.address":               string("example.com"),
 					"server.port":                  string("4321"),
 				},
-				Level:           sentry.LevelInfo,
-				Transaction:     "POST https://john:[email protected]:4321/secret",
-				Type:            "transaction",
-				TransactionInfo: &sentry.TransactionInfo{Source: "custom"},
-				Tags:            map[string]string{},
+				Name:    "POST https://john:[email protected]:4321/secret",
+				Op:      "http.client",
+				Tags:    map[string]string{},
+				Origin:  "manual",
+				Sampled: sentry.SampledTrue,
+				Status:  sentry.SpanStatusOK,
 			},
 		},
 	}
 
-	transactionsCh := make(chan *sentry.Event, len(tests))
+	spansCh := make(chan []*sentry.Span, len(tests))
 
 	sentryClient, err := sentry.NewClient(sentry.ClientOptions{
 		EnableTracing:    true,
 		TracesSampleRate: 1.0,
 		BeforeSendTransaction: func(event *sentry.Event, hint *sentry.EventHint) *sentry.Event {
-			transactionsCh <- event
+			spansCh <- event.Spans
 			return event
 		},
 	})
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	var want []*sentry.Event
 	for _, tt := range tests {
 		hub := sentry.NewHub(sentryClient, sentry.NewScope())
 		ctx := sentry.SetHubOnContext(context.Background(), hub)
+		span := sentry.StartSpan(ctx, "fake_parent", sentry.WithTransactionName("Fake Parent"))
+		ctx = span.Context()
 
 		request, err := http.NewRequestWithContext(ctx, tt.RequestMethod, tt.RequestURL, nil)
 		if err != nil {
@@ -188,32 +194,45 @@ func TestIntegration(t *testing.T) {
 		}
 
 		response.Body.Close()
-		want = append(want, tt.WantTransaction)
+		span.Finish()
 	}
 
 	if ok := sentryClient.Flush(testutils.FlushTimeout()); !ok {
 		t.Fatal("sentry.Flush timed out")
 	}
-	close(transactionsCh)
-	var got []*sentry.Event
-	for e := range transactionsCh {
+	close(spansCh)
+
+	var got [][]*sentry.Span
+	for e := range spansCh {
 		got = append(got, e)
 	}
 
 	optstrans := cmp.Options{
 		cmpopts.IgnoreFields(
-			sentry.Event{},
-			"Contexts", "EventID", "Platform", "Modules",
-			"Release", "Sdk", "ServerName", "Timestamp",
-			"sdkMetaData", "StartTime", "Spans",
-		),
-		cmpopts.IgnoreFields(
-			sentry.Request{},
-			"Env",
+			sentry.Span{},
+			"TraceID", "SpanID", "ParentSpanID", "StartTime", "EndTime",
+			"mu", "parent", "sampleRate", "ctx", "dynamicSamplingContext", "recorder", "finishOnce", "collectProfile", "contexts",
 		),
 	}
-	if diff := cmp.Diff(want, got, optstrans); diff != "" {
-		t.Fatalf("Transaction mismatch (-want +got):\n%s", diff)
+	for i, tt := range tests {
+		var foundMatch = false
+		gotSpans := got[i]
+
+		var diffs []string
+		for _, gotSpan := range gotSpans {
+			if diff := cmp.Diff(tt.WantSpan, gotSpan, optstrans); diff != "" {
+				diffs = append(diffs, diff)
+			} else {
+				foundMatch = true
+				break
+			}
+		}
+
+		if foundMatch {
+			continue
+		} else {
+			t.Errorf("Span mismatch (-want +got):\n%s", strings.Join(diffs, "\n"))
+		}
 	}
 }
 

tracing.go

@@ -206,6 +206,17 @@ func StartSpan(ctx context.Context, operation string, options ...SpanOption) *Sp
 	return &span
 }
 
+// GetSpanFromContext retrieves attached *sentry.Span instance from context.Context.
+// If there are no spans, it will return nil.
+func GetSpanFromContext(ctx context.Context) *Span {
+	span, ok := ctx.Value(spanContextKey{}).(*Span)
+	if ok {
+		return span
+	}
+
+	return nil
+}
+
 // Finish sets the span's end time, unless already set. If the span is the root
 // of a span tree, Finish sends the span tree to Sentry as a transaction.
 //

tracing_test.go

@@ -1091,3 +1091,25 @@ func TestSpanFinishConcurrentlyWithoutRaces(_ *testing.T) {
 
 	time.Sleep(50 * time.Millisecond)
 }
+
+func TestGetSpanFromContext(t *testing.T) {
+	t.Run("Exists", func(t *testing.T) {
+		span := StartSpan(context.Background(), "something")
+
+		value := GetSpanFromContext(span.Context())
+		if value == nil {
+			t.Error("expecting `value` to be not nil")
+		} else {
+			if span.Op != "something" {
+				t.Errorf("expecting `span.Op` to be 'something', instead got %q", span.Op)
+			}
+		}
+	})
+
+	t.Run("Nil", func(t *testing.T) {
+		value := GetSpanFromContext(context.Background())
+		if value != nil {
+			t.Error("expecting `value` to be nil")
+		}
+	})
+}