From e6f1a1b52efd616660f9392fec5650269d9eb4cd Mon Sep 17 00:00:00 2001 From: Michi Hoffmann Date: Sat, 14 Sep 2024 10:41:14 +0200 Subject: [PATCH] Update Go docs (#9992) Co-authored-by: Stephanie Anderson Co-authored-by: vivianyentran <20403606+vivianyentran@users.noreply.github.com> --- docs/platforms/go/guides/fiber/index.mdx | 163 +++++++++++++++++++ docs/product/performance/getting-started.mdx | 15 +- platform-includes/crons/setup/go.mdx | 13 +- src/components/platformIcon.tsx | 7 + src/middleware.ts | 4 + 5 files changed, 189 insertions(+), 13 deletions(-) create mode 100644 docs/platforms/go/guides/fiber/index.mdx diff --git a/docs/platforms/go/guides/fiber/index.mdx b/docs/platforms/go/guides/fiber/index.mdx new file mode 100644 index 0000000000000..9f8507d6759c4 --- /dev/null +++ b/docs/platforms/go/guides/fiber/index.mdx @@ -0,0 +1,163 @@ +--- +title: Fiber +description: "Learn how to add Sentry instrumentation to programs using the Fiber package." +--- + +package. + +The Sentry Go SDK repository has a [complete +example](https://github.com/getsentry/sentry-go/tree/master/_examples/fiber) +of how to set up Sentry for a Fiber app. + +For additional reference, see the [`sentryfiber` API +documentation](https://godoc.org/github.com/getsentry/sentry-go/fiber). + +## Install + +```shell +go get github.com/getsentry/sentry-go/fiber +``` + + + + + +```go +import ( + "fmt" + "net/http" + + "github.com/getsentry/sentry-go" + sentryfiber "github.com/getsentry/sentry-go/fiber" +) + +// To initialize Sentry's handler, you need to initialize Sentry itself beforehand +if err := sentry.Init(sentry.ClientOptions{ + Dsn: "___PUBLIC_DSN___", + EnableTracing: true, + // Set TracesSampleRate to 1.0 to capture 100% + // of transactions for performance monitoring. + // We recommend adjusting this value in production, + TracesSampleRate: 1.0, +}); err != nil { + fmt.Printf("Sentry initialization failed: %v\n", err) +} + + // Later in the code + sentryHandler := sentryfiber.New(sentryfiber.Options{ + Repanic: true, + WaitForDelivery: true, + }) + + enhanceSentryEvent := func(ctx *fiber.Ctx) error { + if hub := sentryfiber.GetHubFromContext(ctx); hub != nil { + hub.Scope().SetTag("someRandomTag", "maybeYouNeedIt") + } + return ctx.Next() + } + + app := fiber.New() + + app.Use(sentryHandler) + + app.All("/foo", enhanceSentryEvent, func(c *fiber.Ctx) error { + panic("y tho") + }) + + app.All("/", func(ctx *fiber.Ctx) error { + if hub := sentryfiber.GetHubFromContext(ctx); hub != nil { + hub.WithScope(func(scope *sentry.Scope) { + scope.SetExtra("unwantedQuery", "someQueryDataMaybe") + hub.CaptureMessage("User provided unwanted query string, but we recovered just fine") + }) + } + return ctx.SendStatus(fiber.StatusOK) + }) + + if err := app.Listen(":3000"); err != nil { + panic(err) + } +``` + +## Configure + +`sentryfiber` accepts a struct of `Options` that allows you to configure how the handler will behave. + +Currently, it respects three options: + +```go +// Repanic configures whether Sentry should repanic after recovery, in most cases it should be set to true, +// as fiber includes its own Recover middleware that handles http responses. +Repanic bool +// WaitForDelivery configures whether you want to block the request before moving forward with the response. +// Because Fiber's `Recover` handler doesn't restart the application, +// it's safe to either skip this option or set it to `false`. +WaitForDelivery bool +// Timeout for the event delivery requests. +Timeout time.Duration +``` + +## Usage + +`sentryfiber` attaches an instance of `*sentry.Hub` (https://godoc.org/github.com/getsentry/sentry-go#Hub) to the request's context, which makes it available throughout the rest of the request's lifetime. +You can access it by using the `sentryfiber.GetHubFromContext()` method on the context itself in any of your proceeding middleware and routes. +This method should be used instead of the global `sentry.CaptureMessage`, `sentry.CaptureException`, or any other calls, as it maintains the separation of data between the requests. + +**Keep in mind that `*sentry.Hub` won't be available in middleware attached before `sentryfiber`!** + +```go +func enhanceSentryEvent := func(ctx *fiber.Ctx) error { + if hub := sentryfiber.GetHubFromContext(ctx); hub != nil { + hub.Scope().SetTag("someRandomTag", "maybeYouNeedIt") + } + return ctx.Next() +} + +// Later in the code +sentryHandler := sentryfiber.New(sentryfiber.Options{ + Repanic: true, + WaitForDelivery: true, +}) + +defaultHandler := func(ctx *fiber.Ctx) error { + if hub := sentryfiber.GetHubFromContext(ctx); hub != nil { + hub.WithScope(func(scope *sentry.Scope) { + scope.SetExtra("unwantedQuery", "someQueryDataMaybe") + hub.CaptureMessage("User provided unwanted query string, but we recovered just fine") + }) + } + return ctx.SendStatus(fiber.StatusOK) +} + +fooHandler := enhanceSentryEvent(func(ctx *fiber.Ctx) { + panic("y tho") +}) + +app.All("/foo", fooHandler) +app.All("/", defaultHandler) + +if err := app.Listen(":3000"); err != nil { + panic(err) +} + +fmt.Println("Listening and serving HTTP on :3000") +``` + +### Accessing Context in `BeforeSend` callback + + + +```go +sentry.Init(sentry.ClientOptions{ + Dsn: "___PUBLIC_DSN___", + BeforeSend: func(event *sentry.Event, hint *sentry.EventHint) *sentry.Event { + if hint.Context != nil { + if ctx, ok := hint.Context.Value(sentry.RequestContextKey).(*fiber.Ctx); ok { + // You have access to the original Context if it panicked + fmt.Println(utils.CopyString(ctx.Hostname())) + } + } + return event + }, +}) +``` diff --git a/docs/product/performance/getting-started.mdx b/docs/product/performance/getting-started.mdx index 3434e382de758..9e7367d60d4b5 100644 --- a/docs/product/performance/getting-started.mdx +++ b/docs/product/performance/getting-started.mdx @@ -15,13 +15,14 @@ If you don't already have performance monitoring enabled, use the links for supp - - - [Echo](/platforms/go/guides/echo/tracing/) - - [FastHTTP](/platforms/go/guides/fasthttp/tracing/) - - [Gin](/platforms/go/guides/gin/tracing/) - - [Iris](/platforms/go/guides/iris/tracing/) - - [Negroni](/platforms/go/guides/negroni/tracing/) - - [net/http](/platforms/go/guides/http/tracing/) - - [OpenTelemetry](/platforms/go/tracing/instrumentation/opentelemetry/) + - [Echo](/platforms/go/guides/echo/performance/) + - [FastHTTP](/platforms/go/guides/fasthttp/performance/) + - [Fiber](/platforms/go/guides/fiber/performance/) + - [Gin](/platforms/go/guides/gin/performance/) + - [Iris](/platforms/go/guides/iris/performance/) + - [Negroni](/platforms/go/guides/negroni/performance/) + - [net/http](/platforms/go/guides/http/performance/) + - [OpenTelemetry](/platforms/go/performance/instrumentation/opentelemetry/) -