Tracing without performance improvements

dynamic_sampling_context.go

@@ -39,8 +39,6 @@ func DynamicSamplingContextFromHeader(header []byte) (DynamicSamplingContext, er
 }
 
 func DynamicSamplingContextFromTransaction(span *Span) DynamicSamplingContext {
-	entries := map[string]string{}
-
 	hub := hubFromContext(span.Context())
 	scope := hub.Scope()
 	client := hub.Client()
@@ -52,6 +50,8 @@ func DynamicSamplingContextFromTransaction(span *Span) DynamicSamplingContext {
 		}
 	}
 
+	entries := make(map[string]string)
+
 	if traceID := span.TraceID.String(); traceID != "" {
 		entries["trace_id"] = traceID
 	}
@@ -80,10 +80,7 @@ func DynamicSamplingContextFromTransaction(span *Span) DynamicSamplingContext {
 
 	entries["sampled"] = strconv.FormatBool(span.Sampled.Bool())
 
-	return DynamicSamplingContext{
-		Entries: entries,
-		Frozen:  true,
-	}
+	return DynamicSamplingContext{Entries: entries, Frozen: true}
 }
 
 func (d DynamicSamplingContext) HasEntries() bool {

echo/sentryecho.go

@@ -50,7 +50,7 @@ func New(options Options) echo.MiddlewareFunc {
 
 func (h *handler) handle(next echo.HandlerFunc) echo.HandlerFunc {
 	return func(ctx echo.Context) error {
-		hub := sentry.GetHubFromContext(ctx.Request().Context())
+		hub := GetHubFromContext(ctx)
 		if hub == nil {
 			hub = sentry.CurrentHub().Clone()
 		}
@@ -70,8 +70,8 @@ func (h *handler) handle(next echo.HandlerFunc) echo.HandlerFunc {
 		}
 
 		options := []sentry.SpanOption{
+			sentry.ContinueTrace(hub, r.Header.Get(sentry.SentryTraceHeader), r.Header.Get(sentry.SentryBaggageHeader)),
 			sentry.WithOpName("http.server"),
-			sentry.ContinueFromRequest(r),
 			sentry.WithTransactionSource(transactionSource),
 			sentry.WithSpanOrigin(sentry.SpanOriginEcho),
 		}
@@ -82,7 +82,7 @@ func (h *handler) handle(next echo.HandlerFunc) echo.HandlerFunc {
 			options...,
 		)
 
-		transaction.SetData("http.request.method", ctx.Request().Method)
+		transaction.SetData("http.request.method", r.Method)
 
 		defer func() {
 			status := ctx.Response().Status

fasthttp/sentryfasthttp.go

@@ -58,17 +58,20 @@ func New(options Options) *Handler {
 // Handle wraps fasthttp.RequestHandler and recovers from caught panics.
 func (h *Handler) Handle(handler fasthttp.RequestHandler) fasthttp.RequestHandler {
 	return func(ctx *fasthttp.RequestCtx) {
-		hub := sentry.CurrentHub().Clone()
+		hub := GetHubFromContext(ctx)
+		if hub == nil {
+			hub = sentry.CurrentHub().Clone()
+		}
 
 		if client := hub.Client(); client != nil {
 			client.SetSDKIdentifier(sdkIdentifier)
 		}
 
-		convertedHTTPRequest := convert(ctx)
+		r := convert(ctx)
 
 		options := []sentry.SpanOption{
+			sentry.ContinueTrace(hub, r.Header.Get(sentry.SentryTraceHeader), r.Header.Get(sentry.SentryBaggageHeader)),
 			sentry.WithOpName("http.server"),
-			sentry.ContinueFromRequest(convertedHTTPRequest),
 			sentry.WithTransactionSource(sentry.SourceRoute),
 			sentry.WithSpanOrigin(sentry.SpanOriginFastHTTP),
 		}
@@ -90,11 +93,12 @@ func (h *Handler) Handle(handler fasthttp.RequestHandler) fasthttp.RequestHandle
 		transaction.SetData("http.request.method", method)
 
 		scope := hub.Scope()
-		scope.SetRequest(convertedHTTPRequest)
+		scope.SetRequest(r)
 		scope.SetRequestBody(ctx.Request.Body())
 		ctx.SetUserValue(valuesKey, hub)
 		ctx.SetUserValue(transactionKey, transaction)
 		defer h.recoverWithSentry(hub, ctx)
+
 		handler(ctx)
 	}
 }

fiber/sentryfiber.go

@@ -54,22 +54,25 @@ func New(options Options) fiber.Handler {
 }
 
 func (h *handler) handle(ctx *fiber.Ctx) error {
-	hub := sentry.CurrentHub().Clone()
+	hub := GetHubFromContext(ctx)
+	if hub == nil {
+		hub = sentry.CurrentHub().Clone()
+	}
 
 	if client := hub.Client(); client != nil {
 		client.SetSDKIdentifier(sdkIdentifier)
 	}
 
-	convertedHTTPRequest := convert(ctx)
+	r := convert(ctx)
 
 	method := ctx.Method()
 
 	transactionName := ctx.Path()
 	transactionSource := sentry.SourceURL
 
 	options := []sentry.SpanOption{
+		sentry.ContinueTrace(hub, r.Header.Get(sentry.SentryTraceHeader), r.Header.Get(sentry.SentryBaggageHeader)),
 		sentry.WithOpName("http.server"),
-		sentry.ContinueFromRequest(convertedHTTPRequest),
 		sentry.WithTransactionSource(transactionSource),
 		sentry.WithSpanOrigin(sentry.SpanOriginFiber),
 	}
@@ -90,11 +93,12 @@ func (h *handler) handle(ctx *fiber.Ctx) error {
 	transaction.SetData("http.request.method", method)
 
 	scope := hub.Scope()
-	scope.SetRequest(convertedHTTPRequest)
+	scope.SetRequest(r)
 	scope.SetRequestBody(ctx.Request().Body())
 	ctx.Locals(valuesKey, hub)
 	ctx.Locals(transactionKey, transaction)
 	defer h.recoverWithSentry(hub, ctx)
+
 	return ctx.Next()
 }
 

gin/sentrygin.go

@@ -17,6 +17,7 @@ import (
 const sdkIdentifier = "sentry.go.gin"
 
 const valuesKey = "sentry"
+const transactionKey = "sentry_transaction"
 
 type handler struct {
 	repanic         bool
@@ -50,50 +51,54 @@ func New(options Options) gin.HandlerFunc {
 	}).handle
 }
 
-func (h *handler) handle(c *gin.Context) {
-	ctx := c.Request.Context()
-	hub := sentry.GetHubFromContext(ctx)
+func (h *handler) handle(ctx *gin.Context) {
+	hub := sentry.GetHubFromContext(ctx.Request.Context())
 	if hub == nil {
 		hub = sentry.CurrentHub().Clone()
-		ctx = sentry.SetHubOnContext(ctx, hub)
 	}
 
 	if client := hub.Client(); client != nil {
 		client.SetSDKIdentifier(sdkIdentifier)
 	}
 
-	transactionName := c.Request.URL.Path
+	r := ctx.Request
+
+	transactionName := r.URL.Path
 	transactionSource := sentry.SourceURL
 
-	if fp := c.FullPath(); fp != "" {
+	if fp := ctx.FullPath(); fp != "" {
 		transactionName = fp
 		transactionSource = sentry.SourceRoute
 	}
 
 	options := []sentry.SpanOption{
+		sentry.ContinueTrace(hub, ctx.GetHeader(sentry.SentryTraceHeader), ctx.GetHeader(sentry.SentryBaggageHeader)),
 		sentry.WithOpName("http.server"),
-		sentry.ContinueFromRequest(c.Request),
 		sentry.WithTransactionSource(transactionSource),
 		sentry.WithSpanOrigin(sentry.SpanOriginGin),
 	}
 
-	transaction := sentry.StartTransaction(ctx,
-		fmt.Sprintf("%s %s", c.Request.Method, transactionName),
+	transaction := sentry.StartTransaction(
+		sentry.SetHubOnContext(r.Context(), hub),
+		fmt.Sprintf("%s %s", r.Method, transactionName),
 		options...,
 	)
-	transaction.SetData("http.request.method", c.Request.Method)
+
+	transaction.SetData("http.request.method", r.Method)
+
 	defer func() {
-		status := c.Writer.Status()
+		status := ctx.Writer.Status()
 		transaction.Status = sentry.HTTPtoSpanStatus(status)
 		transaction.SetData("http.response.status_code", status)
 		transaction.Finish()
 	}()
 
-	c.Request = c.Request.WithContext(transaction.Context())
-	hub.Scope().SetRequest(c.Request)
-	c.Set(valuesKey, hub)
-	defer h.recoverWithSentry(hub, c.Request)
-	c.Next()
+	hub.Scope().SetRequest(r)
+	ctx.Set(valuesKey, hub)
+	ctx.Set(transactionKey, transaction)
+	defer h.recoverWithSentry(hub, r)
+
+	ctx.Next()
 }
 
 func (h *handler) recoverWithSentry(hub *sentry.Hub, r *http.Request) {
@@ -135,3 +140,14 @@ func GetHubFromContext(ctx *gin.Context) *sentry.Hub {
 	}
 	return nil
 }
+
+// GetSpanFromContext retrieves attached *sentry.Span instance from gin.Context.
+// If there is no transaction on echo.Context, it will return nil.
+func GetSpanFromContext(ctx *gin.Context) *sentry.Span {
+	if span, ok := ctx.Get(transactionKey); ok {
+		if span, ok := span.(*sentry.Span); ok {
+			return span
+		}
+	}
+	return nil
+}

http/sentryhttp.go

@@ -84,7 +84,7 @@ func (h *Handler) HandleFunc(handler http.HandlerFunc) http.HandlerFunc {
 func (h *Handler) handle(handler http.Handler) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		ctx := r.Context()
-		hub := sentry.GetHubFromContext(ctx)
+		hub := sentry.GetHubFromContext(r.Context())
 		if hub == nil {
 			hub = sentry.CurrentHub().Clone()
 			ctx = sentry.SetHubOnContext(ctx, hub)
@@ -95,8 +95,8 @@ func (h *Handler) handle(handler http.Handler) http.HandlerFunc {
 		}
 
 		options := []sentry.SpanOption{
+			sentry.ContinueTrace(hub, r.Header.Get(sentry.SentryTraceHeader), r.Header.Get(sentry.SentryBaggageHeader)),
 			sentry.WithOpName("http.server"),
-			sentry.ContinueFromRequest(r),
 			sentry.WithTransactionSource(sentry.SourceURL),
 			sentry.WithSpanOrigin(sentry.SpanOriginStdLib),
 		}
@@ -116,13 +116,10 @@ func (h *Handler) handle(handler http.Handler) http.HandlerFunc {
 			transaction.Finish()
 		}()
 
-		// TODO(tracing): if the next handler.ServeHTTP panics, store
-		// information on the transaction accordingly (status, tag,
-		// level?, ...).
-		r = r.WithContext(transaction.Context())
 		hub.Scope().SetRequest(r)
-
+		r = r.WithContext(transaction.Context())
 		defer h.recoverWithSentry(hub, r)
+
 		handler.ServeHTTP(rw, r)
 	}
 }

hub.go

@@ -2,6 +2,7 @@
 
 import (
 	"context"
+	"fmt"
 	"sync"
 	"time"
 )
@@ -367,6 +368,7 @@
 
 // Continue a trace based on HTTP header values. If performance is enabled this
 // returns a SpanOption that can be used to start a transaction, otherwise nil.
+// TODO: remove - moved to tracing.go
 func (hub *Hub) ContinueTrace(trace, baggage string) (SpanOption, error) {
 	scope := hub.Scope()
 	propagationContext, err := PropagationContextFromHeaders(trace, baggage)
@@ -386,6 +388,34 @@
 	return nil, nil
 }
 
+// GetTraceparent returns the current Sentry traceparent string, to be used as a HTTP header value
+// or HTML meta tag value.
+// This function is context aware, as in it either returns the traceparent based
+// on the current span, or the scope's propagation context.
+func (hub *Hub) GetTraceparent() string {
+	scope := hub.Scope()
+
+	if scope.span != nil {
+		return scope.span.ToSentryTrace()
+	}
+
+	return fmt.Sprintf("%s-%s", scope.propagationContext.TraceID, scope.propagationContext.SpanID)
+}
+
+// GetBaggage returns the current Sentry baggage string, to be used as a HTTP header value
+// or HTML meta tag value.
+// This function is context aware, as in it either returns the baggage based
+// on the current span or the scope's propagation context.
+func (hub *Hub) GetBaggage() string {
+	scope := hub.Scope()
+
+	if scope.span != nil {
+		return scope.span.ToBaggage()
+	}
+
+	return scope.propagationContext.DynamicSamplingContext.String()
+}
+
 // HasHubOnContext checks whether Hub instance is bound to a given Context struct.
 func HasHubOnContext(ctx context.Context) bool {
 	_, ok := ctx.Value(HubContextKey).(*Hub)