Documentation ¶
Index ¶
- Variables
- func ClientUserHeaderInterceptor(ctx context.Context, method string, req, reply interface{}, ...) error
- func CountingListener(l net.Listener, g prometheus.Gauge) net.Listener
- func HTTPGRPCTracingInterceptor(router *mux.Router) grpc.UnaryServerInterceptor
- func IsWSHandshakeRequest(req *http.Request) bool
- func MakeLabelValue(path string) string
- func NewStatsHandler(receivedPayloadSize, sentPayloadSize *prometheus.HistogramVec, ...) stats.Handler
- func NewZeroResponseListener(list net.Listener, log log.Logger) net.Listener
- func ServerUserHeaderInterceptor(ctx context.Context, req interface{}, _ *grpc.UnaryServerInfo, ...) (interface{}, error)
- func StreamClientInstrumentInterceptor(metric *prometheus.HistogramVec, ...) grpc.StreamClientInterceptor
- func StreamClientUserHeaderInterceptor(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, ...) (grpc.ClientStream, error)
- func StreamServerInstrumentInterceptor(hist *prometheus.HistogramVec, instrumentationOptions ...InstrumentationOption) grpc.StreamServerInterceptor
- func StreamServerUserHeaderInterceptor(srv interface{}, ss grpc.ServerStream, _ *grpc.StreamServerInfo, ...) error
- func UnaryClientInstrumentInterceptor(metric *prometheus.HistogramVec, ...) grpc.UnaryClientInterceptor
- func UnaryServerInstrumentInterceptor(hist *prometheus.HistogramVec, instrumentationOptions ...InstrumentationOption) grpc.UnaryServerInterceptor
- type DoNotLogError
- type ErrorHandler
- type Func
- type GRPCServerLog
- type HeaderAdder
- type Instrument
- type InstrumentationOption
- type Interface
- type Log
- type OptionalLogging
- type PerTenantCallback
- type RouteMatcher
- type SourceIPExtractor
- type Tracer
Constants ¶
This section is empty.
Variables ¶
var AuthenticateUser = Func(func(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _, ctx, err := user.ExtractOrgIDFromHTTPRequest(r) if err != nil { http.Error(w, err.Error(), http.StatusUnauthorized) return } next.ServeHTTP(w, r.WithContext(ctx)) }) })
AuthenticateUser propagates the user ID from HTTP headers back to the request's context.
var BodySizeBuckets = []float64{1 * mb, 2.5 * mb, 5 * mb, 10 * mb, 25 * mb, 50 * mb, 100 * mb, 250 * mb}
BodySizeBuckets defines buckets for request/response body sizes.
Functions ¶
func ClientUserHeaderInterceptor ¶
func ClientUserHeaderInterceptor(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error
ClientUserHeaderInterceptor propagates the user ID from the context to gRPC metadata, which eventually ends up as a HTTP2 header.
func CountingListener ¶
CountingListener returns a Listener that increments a Prometheus gauge when a connection is accepted, and decrements the gauge when the connection is closed.
func HTTPGRPCTracingInterceptor ¶
func HTTPGRPCTracingInterceptor(router *mux.Router) grpc.UnaryServerInterceptor
HTTPGRPCTracingInterceptor adds additional information about the encapsulated HTTP request to httpgrpc trace spans.
The httpgrpc client wraps HTTP requests up into a generic httpgrpc.HTTP/Handle gRPC method. The httpgrpc server unwraps httpgrpc.HTTP/Handle gRPC requests into HTTP requests and forwards them to its own internal HTTP router.
By default, the server-side tracing spans for the httpgrpc.HTTP/Handle gRPC method have no data about the wrapped HTTP request being handled.
HTTPGRPCTracer.Wrap starts a child span with span name and tags following the approach in Tracer.Wrap's usage of opentracing-contrib/go-stdlib/nethttp.Middleware and attaches the HTTP server span tags to the parent httpgrpc.HTTP/Handle gRPC span, allowing tracing tooling to differentiate the HTTP requests represented by the httpgrpc.HTTP/Handle spans.
Note that we cannot do this in the httpgrpc Server implementation, as some applications (eg. Mimir's queriers) call Server.Handle() directly, which means we'd attach HTTP-request related span tags to whatever parent span is active in the caller, rather than the /httpgrpc.HTTP/Handle span created by the tracing middleware for requests that arrive over the network.
func IsWSHandshakeRequest ¶
IsWSHandshakeRequest returns true if the given request is a websocket handshake request.
func MakeLabelValue ¶
MakeLabelValue converts a Gorilla mux path to a string suitable for use in a Prometheus label value.
func NewStatsHandler ¶
func NewStatsHandler(receivedPayloadSize, sentPayloadSize *prometheus.HistogramVec, inflightRequests *prometheus.GaugeVec) stats.Handler
NewStatsHandler creates handler that can be added to gRPC server options to track received and sent message sizes.
func NewZeroResponseListener ¶
NewZeroResponseListener returns a Listener that logs all connections that encountered io timeout on reads, and were closed before sending any response.
func ServerUserHeaderInterceptor ¶
func ServerUserHeaderInterceptor(ctx context.Context, req interface{}, _ *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error)
ServerUserHeaderInterceptor propagates the user ID from the gRPC metadata back to our context.
func StreamClientInstrumentInterceptor ¶
func StreamClientInstrumentInterceptor(metric *prometheus.HistogramVec, instrumentationOptions ...InstrumentationOption) grpc.StreamClientInterceptor
StreamClientInstrumentInterceptor records duration of streaming gRPC requests client side.
func StreamClientUserHeaderInterceptor ¶
func StreamClientUserHeaderInterceptor(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error)
StreamClientUserHeaderInterceptor propagates the user ID from the context to gRPC metadata, which eventually ends up as a HTTP2 header. For streaming gRPC requests.
func StreamServerInstrumentInterceptor ¶
func StreamServerInstrumentInterceptor(hist *prometheus.HistogramVec, instrumentationOptions ...InstrumentationOption) grpc.StreamServerInterceptor
StreamServerInstrumentInterceptor instruments gRPC requests for errors and latency.
func StreamServerUserHeaderInterceptor ¶
func StreamServerUserHeaderInterceptor(srv interface{}, ss grpc.ServerStream, _ *grpc.StreamServerInfo, handler grpc.StreamHandler) error
StreamServerUserHeaderInterceptor propagates the user ID from the gRPC metadata back to our context.
func UnaryClientInstrumentInterceptor ¶
func UnaryClientInstrumentInterceptor(metric *prometheus.HistogramVec, instrumentationOptions ...InstrumentationOption) grpc.UnaryClientInterceptor
UnaryClientInstrumentInterceptor records duration of gRPC requests client side.
func UnaryServerInstrumentInterceptor ¶
func UnaryServerInstrumentInterceptor(hist *prometheus.HistogramVec, instrumentationOptions ...InstrumentationOption) grpc.UnaryServerInterceptor
UnaryServerInstrumentInterceptor instruments gRPC requests for errors and latency.
Types ¶
type DoNotLogError ¶
type DoNotLogError struct{ Err error }
func (DoNotLogError) Error ¶
func (i DoNotLogError) Error() string
func (DoNotLogError) Unwrap ¶
func (i DoNotLogError) Unwrap() error
type ErrorHandler ¶
ErrorHandler lets you call an alternate http handler upon a certain response code. Note it will assume a 200 if the wrapped handler does not write anything
type Func ¶
Func is to Interface as http.HandlerFunc is to http.Handler
func NewTimeoutMiddleware ¶
NewTimeoutMiddleware returns a new timeout middleware that returns a 503 Service Unavailable using the http.TimeoutHandler. Note also that the middleware disables the http server write timeout to ensure the two timeouts don't conflict. We disable the server write timeout b/c it's behavior may be unintuitive. See below.
Server.WriteTimeout:
- does not cancel context and instead allows the request to go until the next write. in practice this means that an http server with a write timeout of 10s may go for significantly longer
- closes the tcp connection on the next write after the timeout has elapsed instead of sending a meaningful http response
- allows streaming of http response back to caller
http.TimeoutHandler
- cancels context allowing downstream code to abandon the request
- returns a 503 Service Unavailable with the provided message
- buffers response in memory which may be undesirable for large responses
type GRPCServerLog ¶
type GRPCServerLog struct { Log log.Logger // WithRequest will log the entire request rather than just the error WithRequest bool DisableRequestSuccessLog bool }
GRPCServerLog logs grpc requests, errors, and latency.
func (GRPCServerLog) StreamServerInterceptor ¶
func (s GRPCServerLog) StreamServerInterceptor(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error
StreamServerInterceptor returns an interceptor that logs gRPC requests
func (GRPCServerLog) UnaryServerInterceptor ¶
func (s GRPCServerLog) UnaryServerInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error)
UnaryServerInterceptor returns an interceptor that logs gRPC requests
type HeaderAdder ¶
HeaderAdder adds headers to responses
type Instrument ¶
type Instrument struct { RouteMatcher RouteMatcher Duration *prometheus.HistogramVec PerTenantDuration *prometheus.HistogramVec PerTenantCallback PerTenantCallback RequestBodySize *prometheus.HistogramVec ResponseBodySize *prometheus.HistogramVec InflightRequests *prometheus.GaugeVec }
Instrument is a Middleware which records timings for every HTTP request
type InstrumentationOption ¶
type InstrumentationOption func(*instrumentationLabel)
var ( // ReportGRPCStatusOption is an InstrumentationOption that is used for enabling gRPC status codes to be used // in instrumentation labels. ReportGRPCStatusOption InstrumentationOption = func(instrumentationLabel *instrumentationLabel) { instrumentationLabel.reportGRPCStatus = true } )
func WithPerTenantInstrumentation ¶
func WithPerTenantInstrumentation(m *prometheus.HistogramVec, f PerTenantCallback) InstrumentationOption
type Interface ¶
Interface is the shared contract for all middlesware, and allows middlesware to wrap handlers.
Identity is an Interface which doesn't do anything.
func Merge ¶
Merge produces a middleware that applies multiple middlesware in turn; ie Merge(f,g,h).Wrap(handler) == f.Wrap(g.Wrap(h.Wrap(handler)))
func PathReplace ¶
PathReplace replcase Request.RequestURI with the specified string.
type Log ¶
type Log struct { Log log.Logger DisableRequestSuccessLog bool LogRequestHeaders bool // LogRequestHeaders true -> dump http headers at debug log level LogRequestAtInfoLevel bool // LogRequestAtInfoLevel true -> log requests at info log level SourceIPs *SourceIPExtractor HTTPHeadersToExclude map[string]bool }
Log middleware logs http requests
func NewLogMiddleware ¶
type OptionalLogging ¶
type OptionalLogging interface { // ShouldLog returns whether the error should be logged and the reason. For example, if the error should be sampled // return returned reason could be something like "sampled 1/10". The reason, if any, is used to decorate the error // both in case the error should be logged or skipped. ShouldLog(ctx context.Context) (bool, string) }
OptionalLogging is the interface that needs be implemented by an error that wants to control whether the log should be logged by GRPCServerLog.
type PerTenantCallback ¶
PerTenantCallback is a function that returns a tenant ID for a given request. When the returned tenant ID is not empty, it is used to label the duration histogram.
type RouteMatcher ¶
type RouteMatcher interface {
Match(*http.Request, *mux.RouteMatch) bool
}
RouteMatcher matches routes
type SourceIPExtractor ¶
type SourceIPExtractor struct {
// contains filtered or unexported fields
}
SourceIPExtractor extracts the source IPs from a HTTP request
func NewSourceIPs ¶
func NewSourceIPs(header, regex string, extractAllHosts bool) (*SourceIPExtractor, error)
NewSourceIPs creates a new SourceIPs