Method HandleRPC

server/limits.go:155–185

(ctx context.Context, rpcStats stats.RPCStats)

}

func (g *grpcInflightLimitCheck) HandleRPC(ctx context.Context, rpcStats stats.RPCStats) {
	switch rpcStats.(type) {
	case *stats.InHeader:
		if state, ok := ctx.Value(gprcInflightLimitCheckerStateKey{}).(*gprcInflightLimitCheckerState); ok {
			// We're processing this request, stop the timer.
			if !state.nonProcessedRequestTimer.Stop() {
				level.Warn(state.logger(g.logger)).Log("msg", "gRPC request processing has started, but the non-processing timer already fired, need to signal that we're processing it now")
				// The timer has already expired, so the function is either executing or has executed.
				//
				// This (stats.InHeader) should be called once and only once, but gRPC is known for changing contracts
				// and we don't want this to start panicking trying to close the channel multiple times,
				// so a sync.Once doesn't hurt here.
				state.headersProcessedOnce.Do(func() { close(state.headersProcessed) })
			}
		}

	case *stats.End:
		if state, ok := ctx.Value(gprcInflightLimitCheckerStateKey{}).(*gprcInflightLimitCheckerState); ok {
			// We're done processing the request, but there's a scenario under which we may have already called RPCCallFinished,
			// from the goroutine watching the context in TapHandle, so we need to ensure it's called only once.
			called := false
			state.rpcCallFinishedOnce.Do(func() {
				g.methodLimiter.RPCCallFinished(ctx)
				called = true
			})
			if !called {
				level.Warn(state.logger(g.logger)).Log("msg", "RPCCallFinished was already called for this gRPC request before the request actually finished processing")
			}
		}
	}
}

func (g *grpcInflightLimitCheck) TagConn(ctx context.Context, _ *stats.ConnTagInfo) context.Context {
	return ctx