1d95609fb7
Adds automation for generating the map of `gRPC Method Name → Rate Limit Type` used by the middleware introduced in #15550, and will ensure we don't forget to add new endpoints. Engineers must annotate their RPCs in the proto file like so: ``` rpc Foo(FooRequest) returns (FooResponse) { option (consul.internal.ratelimit.spec) = { operation_type: READ, }; } ``` When they run `make proto` a protoc plugin `protoc-gen-consul-rate-limit` will be installed that writes rate-limit specs as a JSON array to a file called `.ratelimit.tmp` (one per protobuf package/directory). After running Buf, `make proto` will execute a post-process script that will ingest all of the `.ratelimit.tmp` files and generate a Go file containing the mappings in the `agent/grpc-middleware` package. In the enterprise repository, it will write an additional file with the enterprise-only endpoints. If an engineer forgets to add the annotation to a new RPC, the plugin will return an error like so: ``` RPC Foo is missing rate-limit specification, fix it with: import "proto-public/annotations/ratelimit/ratelimit.proto"; service Bar { rpc Foo(...) returns (...) { option (hashicorp.consul.internal.ratelimit.spec) = { operation_type: OPERATION_READ | OPERATION_WRITE | OPERATION_EXEMPT, }; } } ``` In the future, this annotation can be extended to support rate-limit category (e.g. KV vs Catalog) and to determine the retry policy.
37 lines
1 KiB
Go
37 lines
1 KiB
Go
package middleware
|
|
|
|
import (
|
|
recovery "github.com/grpc-ecosystem/go-grpc-middleware/recovery"
|
|
"github.com/hashicorp/go-hclog"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
)
|
|
|
|
// PanicHandlerMiddlewareOpts returns the []recovery.Option containing
|
|
// recovery handler function.
|
|
func PanicHandlerMiddlewareOpts(logger Logger) []recovery.Option {
|
|
return []recovery.Option{
|
|
recovery.WithRecoveryHandler(NewPanicHandler(logger)),
|
|
}
|
|
}
|
|
|
|
// NewPanicHandler returns a recovery.RecoveryHandlerFunc closure function
|
|
// to handle panic in GRPC server's handlers.
|
|
func NewPanicHandler(logger Logger) recovery.RecoveryHandlerFunc {
|
|
return func(p interface{}) (err error) {
|
|
// Log the panic and the stack trace of the Goroutine that caused the panic.
|
|
stacktrace := hclog.Stacktrace()
|
|
logger.Error("panic serving grpc request",
|
|
"panic", p,
|
|
"stack", stacktrace,
|
|
)
|
|
|
|
return status.Errorf(codes.Internal, "grpc: panic serving request")
|
|
}
|
|
}
|
|
|
|
type Logger interface {
|
|
Error(string, ...interface{})
|
|
Warn(string, ...interface{})
|
|
}
|