Method TapHandle

server/limits.go:63–88

TapHandle is called after receiving grpc request and headers, but before reading any request data yet. If we reject request here (by returning non-nil error), it won't be counted towards any metrics (eg. in middleware.grpcStatsHandler). If we accept request (no error), the request should be processe

(ctx context.Context, info *tap.Info)

// If we accept request (no error), the request should be processed and eventually HandleRPC with stats.End notification will be called,
// unless the context is cancelled before we start processing the request.
func (g *grpcInflightLimitCheck) TapHandle(ctx context.Context, info *tap.Info) (context.Context, error) {
	if !isMethodNameValid(info.FullMethodName) {
		// If method name is not valid, we let the request continue, but not call method limiter.
		// Otherwise, we would not be able to call method limiter again when the call finishes, because in this case grpc server will not call stat handler.
		return ctx, nil
	}

	ctx, err := g.methodLimiter.RPCCallStarting(ctx, info.FullMethodName, info.Header)
	if err != nil {
		return ctx, err
	}

	// We called RPCCallStarting, so we need to ensure RPCCallFinished is called once the request is done.
	// Because of a shortcut introduced in https://github.com/grpc/grpc-go/pull/8439 this may not happen.
	// We could create a goroutine that would watch ctx.Done() and call RPCCallFinished if the context is done and we have not started processing the headers yet.
	// However, that would mean paying the cost of an extra goroutine for every single gRPC request, just in case the request's context is cancelled before we start processing it.
	// Instead of that we schedule a cheaper timer that we will cancel in the happy case, which will run after 10s and perform the cleanup only when needed.
	state := &gprcInflightLimitCheckerState{
		fullMethod:       info.FullMethodName,
		timestamp:        time.Now(),
		headersProcessed: make(chan struct{}),
	}
	state.nonProcessedRequestTimer = g.timeAfterFunc(unprocessedRequestCheckTimeout, g.checkProbablyEarlyAbortedRequest(ctx, state))

	return context.WithValue(ctx, gprcInflightLimitCheckerStateKey{}, state), nil
}

func (g *grpcInflightLimitCheck) checkProbablyEarlyAbortedRequest(ctx context.Context, state *gprcInflightLimitCheckerState) func() {
	return func() {