metrics

type Counter ¶

type Counter interface {
	Inc()
	Add(float64)
}

Counter is a Metric that represents a single numerical value that only ever goes up. A Counter is typically used to count requests served, tasks completed, errors occurred, etc.

func NewCounter(key string, opts ...Option) Counter

type DummyRegistry ¶

type DummyRegistry struct {
}

func NewDummyRegistry() *DummyRegistry

func (d *DummyRegistry) NewCounter(key string, opts ...Option) Counter

func (d *DummyRegistry) NewGauge(key string, opts ...Option) Gauge

func (d *DummyRegistry) NewHistogram(key string, opts ...Option) Histogram

func (d *DummyRegistry) NewServerMetrics(opts ...Option) ServerMetrics

func (d *DummyRegistry) NewTimer(key string, opts ...Option) Timer

func (d *DummyRegistry) NewWorker(key string, opts ...Option) Worker

func (d *DummyRegistry) ServeHTTP(w http.ResponseWriter, r *http.Request)

type Gauge ¶

type Gauge interface {
	Set(float64)
}

Gauge is a Metric that represents a single numerical value that can arbitrarily go up and down. A Gauge is typically used for measured values like temperatures or current memory usage.

func NewGauge(key string, opts ...Option) Gauge

type Histogram ¶

type Histogram interface {
	Observe(float64)
}

A Histogram counts individual observations from an event or sample stream in configurable buckets. Similar to a summary, it also provides a sum of observations and an observation count.

func NewHistogram(key string, opts ...Option) Histogram

type Option ¶

type Option func(opt *Options)

func Labels(lbs map[string]string) Option

func Namespace(namespace string) Option

func Subsystem(subsystem string) Option

type Options ¶

type Options struct {
	Namespace string
	Subsystem string
	Labels    map[string]string
}

func NewOptions(namespace, subsystem string, lbs map[string]string) *Options

type PrometheusRegistry ¶

type PrometheusRegistry struct {
	// contains filtered or unexported fields
}

func NewPrometheusRegistry() *PrometheusRegistry

func (p *PrometheusRegistry) AppendLabels(labels map[string]string)

func (p *PrometheusRegistry) NewCounter(key string, opts ...Option) Counter

func (p *PrometheusRegistry) NewGauge(key string, opts ...Option) Gauge

func (p *PrometheusRegistry) NewHistogram(key string, opts ...Option) Histogram

func (p *PrometheusRegistry) NewServerMetrics(opts ...Option) ServerMetrics

func (p *PrometheusRegistry) NewTimer(key string, opts ...Option) Timer

func (p *PrometheusRegistry) NewWorker(key string, opts ...Option) Worker

func (p *PrometheusRegistry) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (p *PrometheusRegistry) SetNamespace(namespace string)

type Registry ¶

type Registry interface {
	NewServerMetrics(opts ...Option) ServerMetrics
	NewCounter(key string, opts ...Option) Counter
	NewGauge(key string, opts ...Option) Gauge
	NewHistogram(key string, opts ...Option) Histogram
	NewTimer(key string, opts ...Option) Timer
	NewWorker(key string, opts ...Option) Worker

	// ServeHTTP is used to display all metric values through http request
	ServeHTTP(w http.ResponseWriter, r *http.Request)
}

Registry is a metrics gather

var DefaultRegistry Registry = NewDummyRegistry()

type ServerMetrics ¶

type ServerMetrics interface {
	InitializeMetrics(*grpc.Server)
	StreamServerInterceptor() func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error
	UnaryServerInterceptor() func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error)
}

ServerMetrics is an integrated metric collector to measure count of any kind of error and elapsed time of each grpc method.

func NewServerMetrics(opts ...Option) ServerMetrics

type Timer ¶

type Timer interface {
	Observe(time.Time)
}

Timer represents a Histogram Metrics to observe the time duration according to given begin time. Timer is usually used to time a function call in the following way:

func TimeMe() {
    begin := time.Now()
    defer Timer.Observe(begin)
}

func NewTimer(key string, opts ...Option) Timer

type Worker ¶

type Worker interface {
	Observe(time.Time, error)
}

Worker includes Timer Metrics to observe the time duration according to given begin time, and counter Metreic to gather the success count and fail count. Worker is usually used to measure a function call in the following way:

func MeasureMe()(err error) {
    begin := time.Now()
    defer Worker.Observe(begin, err)
}

func NewWorker(key string, opts ...Option) Worker