feat(performance): start transaction for echo middleware/integration

_examples/echo/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"net/http"
 
@@ -52,6 +53,24 @@ func main() {
 				hub.CaptureMessage("User provided unwanted query string, but we recovered just fine")
 			})
 		}
+
+		expensiveThing := func(ctx context.Context) error {
+			span := sentry.StartTransaction(ctx, "expensive_thing")
+			defer span.Finish()
+			// do resource intensive thing
+			return nil
+		}
+
+		// Acquire transaction on current hub that's created by the SDK.
+		// Be careful, it might be a nil value if you didn't set up sentryecho middleware.
+		sentrySpan := sentryecho.GetSpanFromContext(ctx)
+		// Pass in the `.Context()` method from `*sentry.Span` struct.
+		// The `context.Context` instance inherits the context from `echo.Context`.
+		err := expensiveThing(sentrySpan.Context())
+		if err != nil {
+			return err
+		}
+
 		return ctx.String(http.StatusOK, "Hello, World!")
 	})
 

echo/example_test.go

@@ -0,0 +1,35 @@
+package sentryecho_test
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/getsentry/sentry-go"
+	sentryecho "github.com/getsentry/sentry-go/echo"
+	"github.com/labstack/echo/v4"
+)
+
+func ExampleGetSpanFromContext() {
+	router := echo.New()
+	router.Use(sentryecho.New(sentryecho.Options{}))
+	router.GET("/", func(c echo.Context) error {
+		expensiveThing := func(ctx context.Context) error {
+			span := sentry.StartTransaction(ctx, "expensive_thing")
+			defer span.Finish()
+			// do resource intensive thing
+			return nil
+		}
+
+		// Acquire transaction on current hub that's created by the SDK.
+		// Be careful, it might be a nil value if you didn't set up sentryecho middleware.
+		sentrySpan := sentryecho.GetSpanFromContext(c)
+		// Pass in the `.Context()` method from `*sentry.Span` struct.
+		// The `context.Context` instance inherits the context from `echo.Context`.
+		err := expensiveThing(sentrySpan.Context())
+		if err != nil {
+			return err
+		}
+
+		return c.NoContent(http.StatusOK)
+	})
+}

echo/sentryecho.go

@@ -2,6 +2,7 @@ package sentryecho
 
 import (
 	"context"
+	"fmt"
 	"net/http"
 	"time"
 
@@ -13,6 +14,7 @@ import (
 const sdkIdentifier = "sentry.go.echo"
 
 const valuesKey = "sentry"
+const transactionKey = "sentry_transaction"
 
 type handler struct {
 	repanic         bool
@@ -22,7 +24,7 @@ type handler struct {
 
 type Options struct {
 	// Repanic configures whether Sentry should repanic after recovery, in most cases it should be set to true,
-	// as echo includes it's own Recover middleware what handles http responses.
+	// as echo includes its own Recover middleware what handles http responses.
 	Repanic bool
 	// WaitForDelivery configures whether you want to block the request before moving forward with the response.
 	// Because Echo's Recover handler doesn't restart the application,
@@ -57,10 +59,51 @@ func (h *handler) handle(next echo.HandlerFunc) echo.HandlerFunc {
 			client.SetSDKIdentifier(sdkIdentifier)
 		}
 
-		hub.Scope().SetRequest(ctx.Request())
+		r := ctx.Request()
+
+		transactionName := r.URL.Path
+		transactionSource := sentry.SourceURL
+
+		if path := ctx.Path(); path != "" {
+			transactionName = path
+			transactionSource = sentry.SourceRoute
+		}
+
+		options := []sentry.SpanOption{
+			sentry.WithOpName("http.server"),
+			sentry.ContinueFromRequest(r),
+			sentry.WithTransactionSource(transactionSource),
+		}
+
+		transaction := sentry.StartTransaction(
+			sentry.SetHubOnContext(r.Context(), hub),
+			fmt.Sprintf("%s %s", r.Method, transactionName),
+			options...,
+		)
+
+		defer func() {
+			if err := ctx.Get("error"); err != nil {
+				if httpError, ok := err.(*echo.HTTPError); ok {
+					transaction.Status = sentry.HTTPtoSpanStatus(httpError.Code)
+				}
+			} else {
+				transaction.Status = sentry.HTTPtoSpanStatus(ctx.Response().Status)
+			}
+			transaction.Finish()
+		}()
+
+		hub.Scope().SetRequest(r)
 		ctx.Set(valuesKey, hub)
-		defer h.recoverWithSentry(hub, ctx.Request())
-		return next(ctx)
+		ctx.Set(transactionKey, transaction)
+		defer h.recoverWithSentry(hub, r)
+
+		err := next(ctx)
+		if err != nil {
+			// Store the error so it can be used in the deferred function
+			ctx.Set("error", err)
+		}
+
+		return err
 	}
 }
 
@@ -86,3 +129,12 @@ func GetHubFromContext(ctx echo.Context) *sentry.Hub {
 	}
 	return nil
 }
+
+// GetSpanFromContext retrieves attached *sentry.Span instance from echo.Context.
+// If there is no transaction on echo.Context, it will return nil.
+func GetSpanFromContext(ctx echo.Context) *sentry.Span {
+	if span, ok := ctx.Get(transactionKey).(*sentry.Span); ok {
+		return span
+	}
+	return nil
+}