Are scopes tied to a single request (i.e. isolated)?

[agis]

Let's assume that, in a middleware we're generating a trace ID for the current request and we want all subsequent usages for this particular request to emit that trace ID. The trace ID is of course meant to be tied to a single request and not shared across requests.

So in our middleware, we currently do this:

sentry.ConfigureScope(func(scope *sentry.Scope) {
  scope.SetTag("trace_id", traceID)
})

Is this intended usage? Will this SetTag call affect other requests or it will only be local to the current request? In other words, are scopes isolated and tied to a single request, or are they shared?

Thanks in advance.

[tonyo]

Will this SetTag call affect other requests

Yes, because you're calling the "global" ConfigureScope, which modifies the global Scope object.

To isolate your additional data (in your case - provided by SetTag), you'll need to clone and propagate an instance of sentry.Hub -- basically an entity that is supposed to be scoped to a request.

Are you using any specific framework?

sentry-go currently has support for a few, here's, for example, how attaching per-request data looks like for Gin: https://docs.sentry.io/platforms/go/guides/gin/#usage

In a general case, one should do something similar to this inside the request handler:

	if hub := sentry.GetHubFromContext(ctx); hub != nil {
		hub.scope.SetTag("trace_id", traceID)
	}

...also making sure that you have a Hub in the context in the first place (here's how the Gin integration does it, for example).
This will ensure that your custom tags or any additional data don't leak in other requests.

[agis]

We're using go-chi and we do use the sentry.New().Handle middleware (added at the top of the stack) which creates a new hub and sets it in the context, as I see here:

sentry-go/http/sentryhttp.go

Lines 86 to 87 in f39baef

	hub = sentry.CurrentHub().Clone()
	ctx = sentry.SetHubOnContext(ctx, hub)

Then in our code, we do use GetHubFromContext(ctx) when we want to report events to Sentry. So, based on the above, it's my understanding that:

1. the middleware that we use, sentry.New().Handle already creates a new hub for the incoming request, since it does sentry.CurrentHub().Clone()
2. therefore, in our middleware we have to do:

hub := sentry.GetHubFromContext(ctx)
hub.ConfigureScope(...) // to set the trace_id tag

and this would work as expected, i.e. it would be isolated between requests, since the hub is also isolated between each request. Is that correct?

[tonyo]

Looks correct, yes.

By the way, if you haven't seen it yet, here's another doc page we have on concurrency and hubs, hope it can further clarify the topic: https://docs.sentry.io/platforms/go/concurrency/