prometheus

type Count ¶

type Count struct {
	sync.Mutex
	*Metrics
	Key string
	*CounterVec
	io_prometheus_client.Metric
	prometheus.Counter
}

Count is an implementation of metrics.Count.

func (metric *Count) Add(delta uint64) uint64

func (metric *Count) WithOverriddenTags(tags Fields) metrics.Count

type CounterVec ¶

type CounterVec struct {
	*prometheus.CounterVec
	Key            string
	PossibleLabels []string
}

func (v *CounterVec) AddPossibleLabels(newLabels []string)

func (v *CounterVec) GetMetricWith(labels prometheus.Labels) (prometheus.Counter, error)

type Fields ¶

type Fields = fields.Fields

type Gauge ¶

type Gauge struct {
	sync.Mutex
	*Metrics
	Key string
	*GaugeVec
	io_prometheus_client.Metric
	prometheus.Gauge
}

Gauge is an implementation of metrics.Gauge.

func (metric *Gauge) Add(delta float64) float64

func (metric *Gauge) WithOverriddenTags(tags Fields) metrics.Gauge

type GaugeVec ¶

type GaugeVec struct {
	*prometheus.GaugeVec
	Key            string
	PossibleLabels []string
}

func (v *GaugeVec) AddPossibleLabels(newLabels []string)

func (v *GaugeVec) GetMetricWith(labels prometheus.Labels) (prometheus.Gauge, error)

type IntGauge ¶

type IntGauge struct {
	sync.Mutex
	*Metrics
	Key string
	*GaugeVec
	io_prometheus_client.Metric
	prometheus.Gauge
}

IntGauge is an implementation of metrics.IntGauge.

func (metric *IntGauge) Add(delta int64) int64

func (metric *IntGauge) WithOverriddenTags(tags Fields) metrics.IntGauge

type Metrics ¶

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

Metrics implements a wrapper of prometheus metrics to implement metrics.Metrics.

Pretty slow and naive implementation. Could be improved by on-need basis. If you need a faster implementation, then try `tsmetrics`.

Warning! This implementation does not remove automatically metrics, thus if a metric was created once, it will be kept in memory forever. If you need a version of metrics which automatically removes metrics non-used for a long time, then try `tsmetrics`.

Warning! Prometheus does not support changing amount of labels for a metric, therefore we delete and create a metric from scratch if it is required to extend the set of labels. This procedure leads to a reset of the metric value. If you need a version of metrics which does not have such flaw, then try `tsmetrics` or `simplemetrics`.

func New(registerer prometheus.Registerer, gatherer prometheus.Gatherer, opts ...Option) *Metrics

func (m *Metrics) Count(key string) metrics.Count

func (m *Metrics) Gatherer() prometheus.Gatherer

func (m *Metrics) Gauge(key string) metrics.Gauge

func (m *Metrics) IntGauge(key string) metrics.IntGauge

func (m *Metrics) List() []prometheus.Collector

func (m *Metrics) Registerer() prometheus.Registerer

func (m *Metrics) WithTag(key string, value interface{}) metrics.Metrics

func (m *Metrics) WithTags(tags Fields) metrics.Metrics

type Option ¶

type Option interface {
	// contains filtered or unexported methods
}

Option is an optional argument to function New, that changes the behavior of the metrics handler.

type OptionDisableLabels ¶

type OptionDisableLabels bool

OptionDisableLabels disables the labels (tags) and makes all the metrics flat. Attempts to get a metrics with the same key but different tags will result into getting the same metric. And all the metrics will be registered without labels.