feat: Add a method to start a transaction

http/sentryhttp.go

@@ -86,15 +86,19 @@ func (h *Handler) handle(handler http.Handler) http.HandlerFunc {
 			hub = sentry.CurrentHub().Clone()
 			ctx = sentry.SetHubOnContext(ctx, hub)
 		}
-		span := sentry.StartSpan(ctx, "http.server",
-			sentry.TransactionName(fmt.Sprintf("%s %s", r.Method, r.URL.Path)),
+		options := []sentry.SpanOption{
+			sentry.OpName("http.server"),
 			sentry.ContinueFromRequest(r),
+		}
+		transaction := sentry.StartTransaction(ctx,
+			fmt.Sprintf("%s %s", r.Method, r.URL.Path),
+			options...,
 		)
-		defer span.Finish()
+		defer transaction.Finish()
 		// TODO(tracing): if the next handler.ServeHTTP panics, store
 		// information on the transaction accordingly (status, tag,
 		// level?, ...).
-		r = r.WithContext(span.Context())
+		r = r.WithContext(transaction.Context())
 		hub.Scope().SetRequest(r)
 		defer h.recoverWithSentry(hub, r)
 		// TODO(tracing): use custom response writer to intercept

tracing.go

@@ -5,6 +5,7 @@ import (
 	"crypto/rand"
 	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"regexp"
@@ -567,6 +568,13 @@ func TransactionName(name string) SpanOption {
 	}
 }
 
+// OpName sets the operation name for a given span.
+func OpName(name string) SpanOption {
+	return func(s *Span) {
+		s.Op = name
+	}
+}
+
 // ContinueFromRequest returns a span option that updates the span to continue
 // an existing trace. If it cannot detect an existing trace in the request, the
 // span will be left unchanged.
@@ -626,3 +634,27 @@ func spanFromContext(ctx context.Context) *Span {
 	}
 	return nil
 }
+
+// ErrTransactionAlreadyInProgress is returne when we try to start a transaction
+// when another one is in progress.
+var ErrTransactionAlreadyInProgress = errors.New("transaction already in progress")
+
+// StartTransaction will create a transaction (root span) if there's no existing
+// transaction in the context.
+func StartTransaction(ctx context.Context, name string, options ...SpanOption) *Span {
+	currentTransaction := ctx.Value(spanContextKey{})
+	if currentTransaction != nil {
+		panic(ErrTransactionAlreadyInProgress)
+	}
+	hub := GetHubFromContext(ctx)
+	if hub == nil {
+		hub = CurrentHub().Clone()
+		ctx = SetHubOnContext(ctx, hub)
+	}
+	options = append(options, TransactionName(name))
+	return StartSpan(
+		ctx,
+		"",
+		options...,
+	)
+}

tracing_test.go

@@ -88,63 +88,58 @@ func testMarshalJSONOmitEmptyParentSpanID(t *testing.T, v interface{}) {
 	}
 }
 
-func TestStartSpan(t *testing.T) {
+func TestStartTransaction(t *testing.T) {
 	transport := &TransportMock{}
 	ctx := NewTestContext(ClientOptions{
 		Transport: transport,
 	})
-	op := "test.op"
-	transaction := "Test Transaction"
+	transactionName := "Test Transaction"
 	description := "A Description"
 	status := SpanStatusOK
-	parentSpanID := SpanIDFromHex("f00db33f")
 	sampled := SampledTrue
 	startTime := time.Now()
 	endTime := startTime.Add(3 * time.Second)
 	data := map[string]interface{}{
 		"k": "v",
 	}
-	span := StartSpan(ctx, op,
-		TransactionName(transaction),
+	transaction := StartTransaction(ctx,
+		transactionName,
 		func(s *Span) {
 			s.Description = description
 			s.Status = status
-			s.ParentSpanID = parentSpanID
 			s.Sampled = sampled
 			s.StartTime = startTime
 			s.EndTime = endTime
 			s.Data = data
 		},
 	)
-	span.Finish()
+	transaction.Finish()
 
 	SpanCheck{
 		Sampled:     sampled,
 		RecorderLen: 1,
-	}.Check(t, span)
+	}.Check(t, transaction)
 
 	events := transport.Events()
 	if got := len(events); got != 1 {
 		t.Fatalf("sent %d events, want 1", got)
 	}
 	want := &Event{
 		Type:        transactionType,
-		Transaction: transaction,
+		Transaction: transactionName,
 		Contexts: map[string]Context{
 			"trace": TraceContext{
-				TraceID:      span.TraceID,
-				SpanID:       span.SpanID,
-				ParentSpanID: parentSpanID,
-				Op:           op,
-				Description:  description,
-				Status:       status,
+				TraceID:     transaction.TraceID,
+				SpanID:      transaction.SpanID,
+				Description: description,
+				Status:      status,
 			}.Map(),
 		},
 		Tags: nil,
 		// TODO(tracing): the root span / transaction data field is
 		// mapped into Event.Extra for now, pending spec clarification.
 		// https://github.com/getsentry/develop/issues/244#issuecomment-778694182
-		Extra:     span.Data,
+		Extra:     transaction.Data,
 		Timestamp: endTime,
 		StartTime: startTime,
 	}
@@ -165,6 +160,22 @@ func TestStartSpan(t *testing.T) {
 	}
 }
 
+func TestStartTransactionAlreadyInProgress(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("StartTransaction should panic if a transaction is already in progress")
+		}
+	}()
+	transport := &TransportMock{}
+	ctx := NewTestContext(ClientOptions{
+		Transport: transport,
+	})
+	// Simulate a transaction already in progress
+	ctx = context.WithValue(ctx, spanContextKey{}, &Span{})
+	transactionName := "Test Transaction"
+	_ = StartTransaction(ctx, transactionName)
+}
+
 func TestStartChild(t *testing.T) {
 	transport := &TransportMock{}
 	ctx := NewTestContext(ClientOptions{