feat: expose concurrency limits and inflight resolves (#1501)

<!--
Important: Before developing new features, please open an issue to
discuss your ideas with the maintainers. This ensures project alignment
and helps avoid unnecessary work for you.

Thank you for your contribution! Please provide a detailed description
below and ensure you've met all the requirements.

Squashed commit messages must follow the [Conventional
Commits](https://www.conventionalcommits.org/en/v1.0.0/) standard to
facilitate changelog generation.

Please ensure your PR title follows the Conventional Commits
specification, using the appropriate type (e.g., feat, fix, docs) and
scope.

Examples of good PR titles:

- 💥feat!: change implementation in an non-backward compatible way
- ✨feat(auth): add support for OAuth2 login
- 🐞fix(router): add support for custom metrics
- 📚docs(README): update installation instructions
- 🧹chore(deps): bump dependencies to latest versions
-->

@coderabbitai summary

## Checklist

- [ ] I have discussed my proposed changes in an issue and have received
approval to proceed.
- [ ] I have followed the coding standards of the project.
- [ ] Tests or benchmarks have been added or updated.

## Open Source AI Manifesto

This project follows the principles of the [Open Source AI
Manifesto](https://human-oss.dev). Please ensure your contribution
aligns with its principles.

<!--
Please add any additional information or context regarding your changes
here.
-->

Author: alepane21

v2/pkg/engine/resolve/resolve.go

@@ -106,6 +106,19 @@ func (r *Resolver) SetAsyncErrorWriter(w AsyncErrorWriter) {
 	r.errorFormatter = w
 }
 
+// MaxConcurrentResolves returns the configured maximum number of concurrent
+// resolves (the size of the resolver semaphore). Use only for stats.
+func (r *Resolver) MaxConcurrentResolves() int {
+	return cap(r.maxConcurrency)
+}
+
+// InflightResolves returns the number of resolves currently holding a
+// semaphore slot. The value is a snapshot and may change immediately after
+// being read. Use only for stats.
+func (r *Resolver) InflightResolves() int {
+	return cap(r.maxConcurrency) - len(r.maxConcurrency)
+}
+
 type tools struct {
 	resolvable *Resolvable
 	loader     *Loader
@@ -338,6 +351,16 @@ type GraphQLResolveInfo struct {
 
 	// ResolveDeduplicated indicates whether the resolution of the entire operation was deduplicated via single flight
 	ResolveDeduplicated bool
+
+	// ResponseResolveStartTime is the time when GraphQL response completion and rendering started.
+	ResponseResolveStartTime time.Time
+	// ResponseResolveDuration is the time spent completing and rendering the GraphQL response.
+	ResponseResolveDuration time.Duration
+
+	// ResponseWriteStartTime is the time when the resolved response started writing to the client.
+	ResponseWriteStartTime time.Time
+	// ResponseWriteDuration is the time spent writing the resolved response to the client.
+	ResponseWriteDuration time.Duration
 }
 
 func (r *Resolver) ResolveGraphQLResponse(ctx *Context, response *GraphQLResponse, data []byte, writer io.Writer) (*GraphQLResolveInfo, error) {
@@ -364,7 +387,10 @@ func (r *Resolver) ResolveGraphQLResponse(ctx *Context, response *GraphQLRespons
 		}
 	}
 
+	responseResolveStart := time.Now()
 	err = t.resolvable.Resolve(ctx.ctx, response.Data, response.Fetches, writer)
+	resp.ResponseResolveStartTime = responseResolveStart
+	resp.ResponseResolveDuration = time.Since(responseResolveStart)
 	if err != nil {
 		return nil, err
 	}
@@ -389,7 +415,10 @@ func (r *Resolver) ArenaResolveGraphQLResponse(ctx *Context, response *GraphQLRe
 		if ctx.SetDeduplicationData != nil && inflight.SharedData != nil {
 			ctx.SetDeduplicationData(ctx.ctx, inflight.SharedData)
 		}
+		responseWriteStart := time.Now()
 		_, err = writer.Write(inflight.Data)
+		resp.ResponseWriteStartTime = responseWriteStart
+		resp.ResponseWriteDuration = time.Since(responseWriteStart)
 		return resp, err
 	}
 
@@ -423,7 +452,10 @@ func (r *Resolver) ArenaResolveGraphQLResponse(ctx *Context, response *GraphQLRe
 	// only when loading is done, acquire an arena for the response buffer
 	responseArena := r.responseBufferPool.Acquire(ctx.Request.ID)
 	buf := arena.NewArenaBuffer(responseArena.Arena)
+	responseResolveStart := time.Now()
 	err = t.resolvable.Resolve(ctx.ctx, response.Data, response.Fetches, buf)
+	resp.ResponseResolveStartTime = responseResolveStart
+	resp.ResponseResolveDuration = time.Since(responseResolveStart)
 	if err != nil {
 		r.inboundRequestSingleFlight.FinishErr(inflight, err)
 		r.resolveArenaPool.Release(resolveArena)
@@ -439,7 +471,10 @@ func (r *Resolver) ArenaResolveGraphQLResponse(ctx *Context, response *GraphQLRe
 	// this includes flushing and syscalls
 	// as such, it can take some time
 	// which is why we split the arenas and released the first one
+	responseWriteStart := time.Now()
 	_, err = writer.Write(buf.Bytes())
+	resp.ResponseWriteStartTime = responseWriteStart
+	resp.ResponseWriteDuration = time.Since(responseWriteStart)
 	// Extract data from the leader's context to share with singleflight followers.
 	// This runs after the leader has fully resolved and written its response, so all
 	// subgraph response headers have been accumulated on the leader's context.

v2/pkg/engine/resolve/resolve_test.go

@@ -232,6 +232,30 @@ func (customErrResolve) Resolve(_ *Context, value []byte) ([]byte, error) {
 	return nil, errors.New("custom error")
 }
 
+func TestResolver_ConcurrencyGetters(t *testing.T) {
+	ctx, cancel := context.WithCancel(t.Context())
+	defer cancel()
+
+	r := New(ctx, ResolverOptions{
+		MaxConcurrency:   4,
+		AsyncErrorWriter: &TestErrorWriter{},
+	})
+
+	require.Equal(t, 4, r.MaxConcurrentResolves())
+	require.Equal(t, 0, r.InflightResolves())
+
+	<-r.maxConcurrency
+	<-r.maxConcurrency
+	require.Equal(t, 2, r.InflightResolves())
+	require.Equal(t, 4, r.MaxConcurrentResolves())
+
+	r.maxConcurrency <- struct{}{}
+	require.Equal(t, 1, r.InflightResolves())
+
+	r.maxConcurrency <- struct{}{}
+	require.Equal(t, 0, r.InflightResolves())
+}
+
 func TestResolver_ResolveNode(t *testing.T) {
 	testFn := func(enableSingleFlight bool, fn func(t *testing.T, ctrl *gomock.Controller) (response *GraphQLResponse, ctx Context, expectedOutput string)) func(t *testing.T) {
 		ctrl := gomock.NewController(t)