metrics

Documentation

Index

• Variables
• func AddPolicyCountCallback(service string, f func() int64)
• func GRPCClientInterceptor(service string) grpc.UnaryClientInterceptor
• func HTTPMetricsHandler(service string) func(next http.Handler) http.Handler
• func HTTPMetricsRoundTripper(service string, destination string) func(next http.RoundTripper) http.RoundTripper
• func NewGRPCServerStatsHandler(service string) grpcstats.Handler
• func PrometheusHandler() (http.Handler, error)
• func RegisterInfoMetrics()
• func SetBuildInfo(service string)
• func SetConfigChecksum(service string, checksum uint64)
• func SetConfigInfo(service string, success bool, checksum string)
• type GRPCServerStatsHandler
  • func (h *GRPCServerStatsHandler) TagRPC(ctx context.Context, tagInfo *grpcstats.RPCTagInfo) context.Context

Variables

var (
	TagKeyHTTPMethod  = tag.MustNewKey("http_method")
	TagKeyService     = tag.MustNewKey("service")
	TagKeyGRPCService = tag.MustNewKey("grpc_service")
	TagKeyGRPCMethod  = tag.MustNewKey("grpc_method")
	TagKeyHost        = tag.MustNewKey("host")
	TagKeyDestination = tag.MustNewKey("destination")
)

The following tags are applied to stats recorded by this package.

var (
	DefaulHTTPSizeDistribution = view.Distribution(
		1, 256, 512, 1024, 2048, 8192, 16384, 32768, 65536, 131072, 262144,
		524288, 1048576, 2097152, 4194304, 8388608)
	DefaultHTTPLatencyDistrubtion = view.Distribution(
		1, 2, 5, 7, 10, 25, 500, 750, 100, 250, 500, 750, 1000, 2500, 5000,
		7500, 10000, 25000, 50000, 75000, 100000)

	DefaultMillisecondsDistribution = ocgrpc.DefaultMillisecondsDistribution
)

Default distributions used by views in this package.

var (
	// GRPCClientViews contains opencensus views for GRPC Client metrics.
	GRPCClientViews = []*view.View{
		GRPCClientRequestCountView,
		GRPCClientRequestDurationView,
		GRPCClientResponseSizeView,
		GRPCClientRequestSizeView}
	// GRPCServerViews contains opencensus views for GRPC Server metrics.
	GRPCServerViews = []*view.View{
		GRPCServerRequestCountView,
		GRPCServerRequestDurationView,
		GRPCServerResponseSizeView,
		GRPCServerRequestSizeView}

	// GRPCServerRequestCountView is an OpenCensus view which counts GRPC Server
	// requests by pomerium service, grpc service, grpc method, and status
	GRPCServerRequestCountView = &view.View{
		Name:        "grpc/server/requests_total",
		Measure:     ocgrpc.ServerLatency,
		Description: "Total grpc Requests",
		TagKeys:     []tag.Key{TagKeyService, TagKeyGRPCMethod, ocgrpc.KeyServerStatus, TagKeyGRPCService},
		Aggregation: view.Count(),
	}

	// GRPCServerRequestDurationView is an OpenCensus view which tracks GRPC Server
	// request duration by pomerium service, grpc service, grpc method, and status
	GRPCServerRequestDurationView = &view.View{
		Name:        "grpc/server/request_duration_ms",
		Measure:     ocgrpc.ServerLatency,
		Description: "grpc Request duration in ms",
		TagKeys:     []tag.Key{TagKeyService, TagKeyGRPCMethod, ocgrpc.KeyServerStatus, TagKeyGRPCService},
		Aggregation: DefaultMillisecondsDistribution,
	}

	// GRPCServerResponseSizeView is an OpenCensus view which tracks GRPC Server
	// response size by pomerium service, grpc service, grpc method, and status
	GRPCServerResponseSizeView = &view.View{
		Name:        "grpc/server/response_size_bytes",
		Measure:     ocgrpc.ServerSentBytesPerRPC,
		Description: "grpc Server Response Size in bytes",
		TagKeys:     []tag.Key{TagKeyService, TagKeyGRPCMethod, ocgrpc.KeyServerStatus, TagKeyGRPCService},
		Aggregation: grpcSizeDistribution,
	}

	// GRPCServerRequestSizeView is an OpenCensus view which tracks GRPC Server
	// request size by pomerium service, grpc service, grpc method, and status
	GRPCServerRequestSizeView = &view.View{
		Name:        "grpc/server/request_size_bytes",
		Measure:     ocgrpc.ServerReceivedBytesPerRPC,
		Description: "grpc Server Request Size in bytes",
		TagKeys:     []tag.Key{TagKeyService, TagKeyGRPCMethod, ocgrpc.KeyServerStatus, TagKeyGRPCService},
		Aggregation: grpcSizeDistribution,
	}

	// GRPCClientRequestCountView is an OpenCensus view which tracks GRPC Client
	// requests by pomerium service, target host, grpc service, grpc method, and status
	GRPCClientRequestCountView = &view.View{
		Name:        "grpc/client/requests_total",
		Measure:     ocgrpc.ClientRoundtripLatency,
		Description: "Total grpc Client Requests",
		TagKeys:     []tag.Key{TagKeyService, TagKeyHost, TagKeyGRPCMethod, TagKeyGRPCService, ocgrpc.KeyClientStatus},
		Aggregation: view.Count(),
	}

	// GRPCClientRequestDurationView is an OpenCensus view which tracks GRPC Client
	// request duration by pomerium service, target host, grpc service, grpc method, and status
	GRPCClientRequestDurationView = &view.View{
		Name:        "grpc/client/request_duration_ms",
		Measure:     ocgrpc.ClientRoundtripLatency,
		Description: "grpc Client Request duration in ms",
		TagKeys:     []tag.Key{TagKeyService, TagKeyHost, TagKeyGRPCMethod, TagKeyGRPCService, ocgrpc.KeyClientStatus},
		Aggregation: DefaultMillisecondsDistribution,
	}

	// GRPCClientResponseSizeView  is an OpenCensus view which tracks GRPC Client
	// response size by pomerium service, target host, grpc service, grpc method, and status
	GRPCClientResponseSizeView = &view.View{
		Name:        "grpc/client/response_size_bytes",
		Measure:     ocgrpc.ClientReceivedBytesPerRPC,
		Description: "grpc Client Response Size in bytes",
		TagKeys:     []tag.Key{TagKeyService, TagKeyHost, TagKeyGRPCMethod, TagKeyGRPCService, ocgrpc.KeyClientStatus},
		Aggregation: grpcSizeDistribution,
	}

	// GRPCClientRequestSizeView  is an OpenCensus view which tracks GRPC Client
	// request size by pomerium service, target host, grpc service, grpc method, and status
	GRPCClientRequestSizeView = &view.View{
		Name:        "grpc/client/request_size_bytes",
		Measure:     ocgrpc.ClientSentBytesPerRPC,
		Description: "grpc Client Request Size in bytes",
		TagKeys:     []tag.Key{TagKeyService, TagKeyHost, TagKeyGRPCMethod, TagKeyGRPCService, ocgrpc.KeyClientStatus},
		Aggregation: grpcSizeDistribution,
	}
)

GRPC Views

var (
	// HTTPClientViews contains opencensus views for HTTP Client metrics.
	HTTPClientViews = []*view.View{
		HTTPClientRequestCountView,
		HTTPClientRequestDurationView,
		HTTPClientResponseSizeView}
	// HTTPServerViews contains opencensus views for HTTP Server metrics.
	HTTPServerViews = []*view.View{
		HTTPServerRequestCountView,
		HTTPServerRequestDurationView,
		HTTPServerRequestSizeView,
		HTTPServerResponseSizeView}

	// HTTPServerRequestCountView is an OpenCensus View that tracks HTTP server
	// requests by pomerium service, host, method and status
	HTTPServerRequestCountView = &view.View{
		Name:        "http/server/requests_total",
		Measure:     ochttp.ServerLatency,
		Description: "Total HTTP Requests",
		TagKeys:     []tag.Key{TagKeyService, TagKeyHost, TagKeyHTTPMethod, ochttp.StatusCode},
		Aggregation: view.Count(),
	}

	// HTTPServerRequestDurationView is an OpenCensus view that tracks HTTP
	// server request duration by pomerium service, host, method and status
	HTTPServerRequestDurationView = &view.View{
		Name:        "http/server/request_duration_ms",
		Measure:     ochttp.ServerLatency,
		Description: "HTTP Request duration in ms",
		TagKeys:     []tag.Key{TagKeyService, TagKeyHost, TagKeyHTTPMethod, ochttp.StatusCode},
		Aggregation: DefaultHTTPLatencyDistrubtion,
	}

	// HTTPServerRequestSizeView is an OpenCensus view that tracks HTTP server
	// request size by pomerium service, host and method
	HTTPServerRequestSizeView = &view.View{
		Name:        "http/server/request_size_bytes",
		Measure:     ochttp.ServerRequestBytes,
		Description: "HTTP Server Request Size in bytes",
		TagKeys:     []tag.Key{TagKeyService, TagKeyHost, TagKeyHTTPMethod},
		Aggregation: DefaulHTTPSizeDistribution,
	}

	// HTTPServerResponseSizeView is an OpenCensus view that tracks HTTP server
	// response size by pomerium service, host, method and status
	HTTPServerResponseSizeView = &view.View{
		Name:        "http/server/response_size_bytes",
		Measure:     ochttp.ServerResponseBytes,
		Description: "HTTP Server Response Size in bytes",
		TagKeys:     []tag.Key{TagKeyService, TagKeyHost, TagKeyHTTPMethod, ochttp.StatusCode},
		Aggregation: DefaulHTTPSizeDistribution,
	}

	// HTTPClientRequestCountView is an OpenCensus View that tracks HTTP client
	// requests by pomerium service, destination, host, method and status
	HTTPClientRequestCountView = &view.View{
		Name:        "http/client/requests_total",
		Measure:     ochttp.ClientRoundtripLatency,
		Description: "Total HTTP Client Requests",
		TagKeys:     []tag.Key{TagKeyService, TagKeyHost, TagKeyHTTPMethod, ochttp.StatusCode, TagKeyDestination},
		Aggregation: view.Count(),
	}

	// HTTPClientRequestDurationView is an OpenCensus view that tracks HTTP
	// client request duration by pomerium service, destination, host, method and status
	HTTPClientRequestDurationView = &view.View{
		Name:        "http/client/request_duration_ms",
		Measure:     ochttp.ClientRoundtripLatency,
		Description: "HTTP Client Request duration in ms",
		TagKeys:     []tag.Key{TagKeyService, TagKeyHost, TagKeyHTTPMethod, ochttp.StatusCode, TagKeyDestination},
		Aggregation: DefaultHTTPLatencyDistrubtion,
	}

	// HTTPClientResponseSizeView is an OpenCensus view that tracks HTTP client
	// esponse size by pomerium service, destination, host, method and status
	HTTPClientResponseSizeView = &view.View{
		Name:        "http/client/response_size_bytes",
		Measure:     ochttp.ClientReceivedBytes,
		Description: "HTTP Client Response Size in bytes",
		TagKeys:     []tag.Key{TagKeyService, TagKeyHost, TagKeyHTTPMethod, ochttp.StatusCode, TagKeyDestination},
		Aggregation: DefaulHTTPSizeDistribution,
	}

	// HTTPClientRequestSizeView is an OpenCensus view that tracks HTTP client
	//request size by pomerium service, destination, host and method
	HTTPClientRequestSizeView = &view.View{
		Name:        "http/client/response_size_bytes",
		Measure:     ochttp.ClientSentBytes,
		Description: "HTTP Client Response Size in bytes",
		TagKeys:     []tag.Key{TagKeyService, TagKeyHost, TagKeyHTTPMethod, TagKeyDestination},
		Aggregation: DefaulHTTPSizeDistribution,
	}
)

HTTP Views

var (
	// InfoViews contains opencensus views for informational metrics about
	// pomerium itself.
	InfoViews = []*view.View{ConfigLastReloadView, ConfigLastReloadSuccessView}

	// ConfigLastReloadView contains the timestamp the configuration was last
	// reloaded, labeled by service.
	ConfigLastReloadView = &view.View{
		Name:        configLastReload.Name(),
		Description: configLastReload.Description(),
		Measure:     configLastReload,
		TagKeys:     []tag.Key{TagKeyService},
		Aggregation: view.LastValue(),
	}

	// ConfigLastReloadSuccessView contains the result of the last configuration
	// reload, labeled by service.
	ConfigLastReloadSuccessView = &view.View{
		Name:        configLastReloadSuccess.Name(),
		Description: configLastReloadSuccess.Description(),
		Measure:     configLastReloadSuccess,
		TagKeys:     []tag.Key{TagKeyService},
		Aggregation: view.LastValue(),
	}
)

var (
	DefaultViews = [][]*view.View{
		GRPCServerViews,
		HTTPServerViews,
		GRPCClientViews,
		GRPCServerViews,
		InfoViews,
	}
)

DefaultViews are a set of default views to view HTTP and GRPC metrics.

Functions

func AddPolicyCountCallback

func AddPolicyCountCallback(service string, f func() int64)

AddPolicyCountCallback sets the function to call when exporting the policy count metric. You must call RegisterInfoMetrics to have this exported

func GRPCClientInterceptor

func GRPCClientInterceptor(service string) grpc.UnaryClientInterceptor

GRPCClientInterceptor creates a UnaryClientInterceptor which updates the RPC context with metric tag metadata

func HTTPMetricsHandler

func HTTPMetricsHandler(service string) func(next http.Handler) http.Handler

HTTPMetricsHandler creates a metrics middleware for incoming HTTP requests

func HTTPMetricsRoundTripper

func HTTPMetricsRoundTripper(service string, destination string) func(next http.RoundTripper) http.RoundTripper

HTTPMetricsRoundTripper creates a metrics tracking tripper for outbound HTTP Requests

func NewGRPCServerStatsHandler

func NewGRPCServerStatsHandler(service string) grpcstats.Handler

NewGRPCServerStatsHandler creates a new GRPCServerStatsHandler for a pomerium service

func PrometheusHandler

func PrometheusHandler() (http.Handler, error)

PrometheusHandler creates an exporter that exports stats to Prometheus and returns a handler suitable for exporting metrics.

func RegisterInfoMetrics

func RegisterInfoMetrics()

Register non-view based metrics registry globally for export

func SetBuildInfo

func SetBuildInfo(service string)

SetBuildInfo records the pomerium build info. You must call RegisterInfoMetrics to have this exported

func SetConfigChecksum

func SetConfigChecksum(service string, checksum uint64)

SetConfigChecksum creates the configuration checksum metric. You must call RegisterInfoMetrics to have this exported

func SetConfigInfo

func SetConfigInfo(service string, success bool, checksum string)

SetConfigInfo records the status, checksum and timestamp of a configuration reload. You must register InfoViews or the related config views before calling

Types

type GRPCServerStatsHandler

type GRPCServerStatsHandler struct {
	grpcstats.Handler
	// contains filtered or unexported fields
}

GRPCServerStatsHandler provides a grpc stats.Handler for a pomerium service to add tags and track metrics to server side calls

func (*GRPCServerStatsHandler) TagRPC

func (h *GRPCServerStatsHandler) TagRPC(ctx context.Context, tagInfo *grpcstats.RPCTagInfo) context.Context

TagRPC implements grpc.stats.Handler and adds tags to the context of a given RPC