sentry-go

The sentryiris handler attaches an instance of *sentry.Hub to the iris.Context. This ensures that Sentry data (like tags and scopes) is isolated per request and does not leak between different users or requests.

Key Rules:

1. Accessing the Hub: Use sentryiris.GetHubFromContext(ctx) to retrieve the hub within middleware or route handlers.
2. Avoid Global Calls: Use the retrieved *sentry.Hub (e.g., hub.CaptureMessage) instead of global functions like sentry.CaptureMessage to maintain request-level data separation.
3. Middleware Order: The *sentry.Hub is not available in any middleware that is attached before the sentryiris handler in the middleware chain.

Example: Using the Hub in Middleware and Routes

app := iris.Default()

// Attach handler first
app.Use(sentryiris.New(sentryiris.Options{
    Repanic: true,
}))

// Middleware that uses the Hub
app.Use(func(ctx iris.Context) {
    if hub := sentryiris.GetHubFromContext(ctx); hub != nil {
        hub.Scope().SetTag("someRandomTag", "maybeYouNeedIt")
    }
    ctx.Next()
})

// Route that uses the Hub
app.Get("/", func(ctx iris.Context) {
    if hub := sentryiris.GetHubFromContext(ctx); hub != nil {
        hub.WithScope(func(scope *sentry.Scope) {
            scope.SetTag("unwantedQuery", "someQueryDataMaybe")
            hub.CaptureMessage("User provided unwanted query string, but we recovered just fine")
        })
    }
})

app.Run(iris.Addr(":3000"))

The sentrygin middleware attaches a *sentry.Hub to the *gin.Context. This allows you to maintain request-specific data (like tags or breadcrumbs) throughout the lifetime of a single HTTP request.

Important:

• Use sentrygin.GetHubFromContext(ctx) to retrieve the hub.
• You must use the hub retrieved from the context instead of global calls like sentry.CaptureMessage or sentry.CaptureException to ensure proper data separation between concurrent requests.
• The hub will not be available in any middleware that is attached before the sentrygin middleware.

app.Use(sentrygin.New(sentrygin.Options{
    Repanic: true,
}))

// Subsequent middleware can access the hub
app.Use(func(ctx *gin.Context) {
    if hub := sentrygin.GetHubFromContext(ctx); hub != nil {
        hub.Scope().SetTag("someRandomTag", "maybeYouNeedIt")
    }
    ctx.Next()
})

app.GET("/", func(ctx *gin.Context) {
    if hub := sentrygin.GetHubFromContext(ctx); hub != nil {
        hub.WithScope(func(scope *sentry.Scope) {
            scope.SetTag("unwantedQuery", "someQueryDataMaybe")
            hub.CaptureMessage("User provided unwanted query string")
        })
    }
    ctx.Status(http.StatusOK
})

The sentryfasthttp handler attaches a *sentry.Hub to the fasthttp.RequestCtx. This allows you to maintain request-specific data (like tags and scopes) throughout the request lifecycle.

To access the hub in your middleware or routes, use sentryfasthttp.GetHubFromContext(ctx).

Important:

• You should use the hub retrieved from the context (e.g., hub.CaptureMessage) instead of global Sentry functions (e.g., sentry.CaptureMessage) to ensure proper data separation between requests.
• The *sentry.Hub will not be available in any middleware that is attached before the sentryfasthttp handler in the middleware chain.

func enhanceSentryEvent(handler fasthttp.RequestHandler) fasthttp.RequestHandler {
	return func(ctx *fasthttp.RequestCtx) {
		if hub := sentryfasthttp.GetHubFromContext(ctx); hub != nil {
			hub.Scope().SetTag("someRandomTag", "maybeYouNeedIt")
		}
		handler(ctx)
	}
}

The sentryhttp handler attaches an instance of *sentry.Hub to the request's context. This allows you to maintain request-scoped data (like tags or breadcrumbs) and ensures that errors are associated with the correct request.

Key Concepts:

• Accessing the Hub: Use sentry.GetHubFromContext(r.Context()) to retrieve the hub within your handlers or subsequent middleware.
• Scoped Data: Use hub.WithScope() or hub.Scope() to set tags or extra data specific to the current request.
• Avoid Global Calls: Instead of using global functions like sentry.CaptureMessage, use the hub retrieved from the context (hub.CaptureMessage) to maintain proper data separation between concurrent requests.
• Middleware Order: The *sentry.Hub will not be available in any middleware that is attached before the sentryhttp handler in the chain.

func (h *handler) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
    // Retrieve the hub from the request context
    if hub := sentry.GetHubFromContext(r.Context()); hub != nil {
        hub.WithScope(func(scope *sentry.Scope) {
            scope.SetTag("unwantedQuery", "someQueryDataMaybe")
            hub.CaptureMessage("User provided unwanted query string")
        })
    }
    rw.WriteHeader(http.StatusOK)
}

To capture errors occurring during gRPC client calls, add sentrygrpc.UnaryClientInterceptor and sentrygrpc.StreamClientInterceptor to your grpc.NewClient (or grpc.Dial) configuration.

import (
	"context"
	"fmt"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"

	"github.com/getsentry/sentry-go"
	sentrygrpc "github.com/getsentry/sentry-go/grpc"
)

func main() {
	// Initialize Sentry
	if err := sentry.Init(sentry.ClientOptions{
		Dsn: "your-public-dsn",
	}); err != nil {
		fmt.Printf("Sentry initialization failed: %v\n", err)
	}

	// Create gRPC client with Sentry interceptors
	conn, err := grpc.NewClient(
		"localhost:50051",
		grpc.WithTransportCredentials(insecure.NewCredentials()),
		grpc.WithUnaryInterceptor(sentrygrpc.UnaryClientInterceptor()),
		grpc.WithStreamInterceptor(sentrygrpc.StreamClientInterceptor()),
	)
	if err != nil {
		sentry.CaptureException(err)
		fmt.Printf("Failed to connect: %v\n", err)
		return
	}
	defer conn.Close()

	client := NewYourServiceClient(conn)

	// Make a request
	_, err = client.YourMethod(context.Background(), &YourRequest{})
	if err != nil {
		sentry.CaptureException(err)
		fmt.Printf("Error calling method: %v\n", err)
	}
}

To capture errors and manage Sentry context for incoming gRPC requests, add sentrygrpc.UnaryServerInterceptor and sentrygrpc.StreamServerInterceptor to your grpc.NewServer configuration. You can pass sentrygrpc.ServerOptions to customize behavior, such as enabling Repanic.

import (
	"fmt"
	"net"

	"google.golang.org/grpc"
	"google.golang.org/grpc/reflection"

	"github.com/getsentry/sentry-go"
	sentrygrpc "github.com/getsentry/sentry-go/grpc"
)

func main() {
	// Initialize Sentry
	if err := sentry.Init(sentry.ClientOptions{
		Dsn: "your-public-dsn",
	}); err != nil {
		fmt.Printf("Sentry initialization failed: %v\n", err)
	}

	// Create gRPC server with Sentry interceptors
	server := grpc.NewServer(
		grpc.UnaryInterceptor(sentrygrpc.UnaryServerInterceptor(sentrygrpc.ServerOptions{
			Repanic: true,
		})),
		grpc.StreamInterceptor(sentrygrpc.StreamServerInterceptor(sentrygrpc.ServerOptions{
			Repanic: true,
		})),
	)

	// Register reflection for debugging
	reflection.Register(server)

	// Start the server
	listener, err := net.Listen("tcp", ":50051")
	if err != nil {
		sentry.CaptureException(err)
		fmt.Printf("Failed to listen: %v\n", err)
		return
	}

	fmt.Println("Server running...")
	if err := server.Serve(listener); err != nil {
		sentry.CaptureException(err)
	}
}