metrics

type AggregateCounterVec ¶ added in v3.1.1

type AggregateCounterVec interface {
	Inc(labels map[string]string)
}

AggregateCounterVec means a set of aggregate counter metrics with the same metricKey but different labels.

func NewAggregateCounterVec(metricRegistry MetricRegistry, metricKey *MetricKey) AggregateCounterVec

type ApplicationMetricLevel ¶ added in v3.1.1

type ApplicationMetricLevel struct {
	ApplicationName string
	Version         string
	GitCommitId     string
	Ip              string
	HostName        string
}

func GetApplicationLevel() *ApplicationMetricLevel

func (m *ApplicationMetricLevel) Tags() map[string]string

type BaseCollector ¶ added in v3.1.1

type BaseCollector struct {
	R MetricRegistry
}

func (c *BaseCollector) StateCount(total, succ, fail *MetricKey, level MetricLevel, succed bool)

type CollectorFunc ¶ added in v3.1.1

type CollectorFunc func(MetricRegistry, *common.URL)

CollectorFunc used to extend more indicators

type ConfigCenterLevel ¶ added in v3.1.1

type ConfigCenterLevel struct {
	ApplicationName string
	Ip              string
	HostName        string
	Key             string
	Group           string
	ConfigCenter    string
	ChangeType      string
}

func NewConfigCenterLevel(key string, group string, configCenter string, changeType string) *ConfigCenterLevel

func (l ConfigCenterLevel) Tags() map[string]string

type CounterMetric ¶ added in v3.1.1

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

CounterMetric counter metric

type CounterVec ¶ added in v3.1.1

type CounterVec interface {
	Inc(labels map[string]string)
	Add(labels map[string]string, v float64)
}

CounterVec means a set of counters with the same metricKey but different labels

func NewCounterVec(metricRegistry MetricRegistry, metricKey *MetricKey) CounterVec

type DefaultAggregateCounterVec ¶ added in v3.1.1

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

DefaultAggregateCounterVec is a default AggregateCounterVec implementation.

It is concurrent safe, and it uses the aggregate.TimeWindowCounter to store and calculate the aggregate counter metrics.

func (d *DefaultAggregateCounterVec) Inc(labels map[string]string)

type DefaultCounterVec ¶ added in v3.1.1

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

DefaultCounterVec is a default CounterVec implementation.

func (d *DefaultCounterVec) Add(labels map[string]string, v float64)

func (d *DefaultCounterVec) Inc(labels map[string]string)

type DefaultGaugeVec ¶ added in v3.1.1

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

DefaultGaugeVec is a default GaugeVec implementation.

func (d *DefaultGaugeVec) Add(labels map[string]string, v float64)

func (d *DefaultGaugeVec) Dec(labels map[string]string)

func (d *DefaultGaugeVec) Inc(labels map[string]string)

func (d *DefaultGaugeVec) Set(labels map[string]string, v float64)

func (d *DefaultGaugeVec) Sub(labels map[string]string, v float64)

type DefaultQpsMetricVec ¶ added in v3.1.1

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

DefaultQpsMetricVec is a default QpsMetricVec implementation.

It is concurrent safe, and it uses the aggregate.TimeWindowCounter to store and calculate the qps metrics.

func (d *DefaultQpsMetricVec) Record(labels map[string]string)

type DefaultQuantileMetricVec ¶ added in v3.1.1

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

DefaultQuantileMetricVec is a default QuantileMetricVec implementation.

It is concurrent safe, and it uses the aggregate.TimeWindowQuantile to store and calculate the quantile metrics.

func (d *DefaultQuantileMetricVec) Record(labels map[string]string, v float64)

type DefaultRtVec ¶ added in v3.1.1

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

DefaultRtVec is a default RtVec implementation.

If rtOpts.Aggregate is true, it will use the aggregate.TimeWindowAggregator with local aggregation, else it will use the aggregate.Result without aggregation.

func (d *DefaultRtVec) Record(labels map[string]string, v float64)

type GaugeMetric ¶ added in v3.1.1

type GaugeMetric interface {
	Set(float64)
	Inc()
	Dec()
	Add(float64)
	Sub(float64)
}

GaugeMetric gauge metric

type GaugeVec ¶ added in v3.1.1

type GaugeVec interface {
	Set(labels map[string]string, v float64)
	Inc(labels map[string]string)
	Dec(labels map[string]string)
	Add(labels map[string]string, v float64)
	Sub(labels map[string]string, v float64)
}

GaugeVec means a set of gauges with the same metricKey but different labels

func NewGaugeVec(metricRegistry MetricRegistry, metricKey *MetricKey) GaugeVec

type MethodMetricLevel ¶ added in v3.1.1

type MethodMetricLevel struct {
	*ServiceMetricLevel
	Method  string
	Group   string
	Version string
}

func (m MethodMetricLevel) Tags() map[string]string

type MetricId ¶ added in v3.1.1

type MetricId struct {
	Name string
	Desc string
	Tags map[string]string // also named label
	Type Type              // TODO check if this field is useful
}

MetricId # HELP dubbo_metadata_store_provider_succeed_total Succeed Store Provider Metadata # TYPE dubbo_metadata_store_provider_succeed_total gauge dubbo_metadata_store_provider_succeed_total{application_name="provider",hostname="localhost",interface="org.example.DemoService",ip="10.252.156.213",} 1.0 other properties except value

func NewMetricId(key *MetricKey, level MetricLevel) *MetricId

func NewMetricIdByLabels(key *MetricKey, labels map[string]string) *MetricId

func (m *MetricId) TagKeys() []string

type MetricKey ¶ added in v3.1.1

type MetricKey struct {
	Name string
	Desc string
}

func NewMetricKey(name string, desc string) *MetricKey

type MetricLevel ¶ added in v3.1.1

type MetricLevel interface {
	Tags() map[string]string
}

type MetricRegistry ¶ added in v3.1.1

type MetricRegistry interface {
	Counter(*MetricId) CounterMetric        // add or update a counter
	Gauge(*MetricId) GaugeMetric            // add or update a gauge
	Histogram(*MetricId) ObservableMetric   // add a metric num to a histogram
	Summary(*MetricId) ObservableMetric     // add a metric num to a summary
	Rt(*MetricId, *RtOpts) ObservableMetric // add a metric num to a rt
	Export()                                // expose metric data， such as Prometheus http exporter

}

MetricRegistry data container，data compute、expose、agg

type MetricSample ¶ added in v3.1.1

type MetricSample struct {
	*MetricId
	// contains filtered or unexported fields
}

MetricSample a metric sample，This is the final data presentation, not an intermediate result(like summary，histogram they will export to a set of MetricSample)

type MetricsEvent ¶ added in v3.1.1

type MetricsEvent interface {
	Type() string
}

MetricsEvent represents an event that can be published and subscribed to.

type ObservableMetric ¶ added in v3.1.1

type ObservableMetric interface {
	Observe(float64)
}

histogram summary rt metric

type QpsMetricVec ¶ added in v3.1.1

type QpsMetricVec interface {
	Record(labels map[string]string)
}

QpsMetricVec means a set of qps metrics with the same metricKey but different labels.

func NewQpsMetricVec(metricRegistry MetricRegistry, metricKey *MetricKey) QpsMetricVec

type QuantileMetricVec ¶ added in v3.1.1

type QuantileMetricVec interface {
	Record(labels map[string]string, v float64)
}

QuantileMetricVec means a set of quantile metrics with the same metricKey but different labels.

func NewQuantileMetricVec(metricRegistry MetricRegistry, metricKeys []*MetricKey, quantiles []float64) QuantileMetricVec

type ReportMode ¶

type ReportMode string

type Reporter ¶

type Reporter interface {
	StartServer(config *ReporterConfig)
	ShutdownServer()
}

Reporter is an interface used to represent the backend of metrics to be exported

type ReporterConfig ¶

type ReporterConfig struct {
	Enable             bool
	Namespace          string
	Mode               ReportMode
	Port               string
	Path               string
	PushGatewayAddress string
	SummaryMaxAge      int64
	Protocol           string // exporters, like prometheus
}

func NewReporterConfig() *ReporterConfig

type RtOpts ¶ added in v3.1.1

type RtOpts struct {
	Aggregate         bool
	BucketNum         int   // only for aggRt
	TimeWindowSeconds int64 // only for aggRt
}

type RtVec ¶ added in v3.1.1

type RtVec interface {
	Record(labels map[string]string, v float64)
}

RtVec means a set of rt metrics with the same metricKey but different labels

func NewRtVec(metricRegistry MetricRegistry, metricKey *MetricKey, rtOpts *RtOpts) RtVec

type ServiceMetricLevel ¶ added in v3.1.1

type ServiceMetricLevel struct {
	*ApplicationMetricLevel
	Interface string
}

func NewServiceMetric(interfaceName string) *ServiceMetricLevel

func (m ServiceMetricLevel) Tags() map[string]string

type Type ¶ added in v3.1.1

type Type uint8 // TODO check if Type is is useful

Type metric type, same with micrometer

const (
	Counter Type = iota
	Gauge
	LongTaskTimer
	Timer
	DistributionSummary
	Other
)