metrics

Documentation

Index

• Variables
• func AddLatencyProbe(ch channel2.Channel, interval time.Duration, handler LatencyHandler)
• func AddLatencyProbeResponder(ch channel2.Channel)
• func AsBatch(msg *metrics_pb.MetricsMessage) (*influxdb.BatchPoints, error)
• func Init(cfg *Config)
• func LoadInfluxConfig(src map[interface{}]interface{}) (*influxConfig, error)
• func LoadOutputFileConfig(src map[interface{}]interface{}) (*outputfileConfig, error)
• func ProbeLatency(ch channel2.Channel, histogram Histogram, interval time.Duration, ...)
• func ProbeLatencyConfigurable(config *LatencyProbeConfig)
• type Config
  • func LoadConfig(srcmap map[interface{}]interface{}) (*Config, error)
• type Formatter
• type Gauge
• type Handler
  • func NewChannelReporter(ch channel2.Channel) Handler
  • func NewDispatchWrapper(deletage func(event event.Event)) Handler
  • func NewInfluxDBMetricsHandler(cfg *influxConfig) (Handler, error)
  • func NewOutputFileMetricsHandler(cfg *outputfileConfig) (Handler, error)
• type HandlerF
  • func (self HandlerF) AcceptMetrics(message *metrics_pb.MetricsMessage)
• type HandlerType
• type Histogram
• type IntervalCounter
• type JsonFormatter
  • func (formatter *JsonFormatter) WriteTo(msg *metrics_pb.MetricsMessage, out io.Writer) error
• type LatencyHandler
• type LatencyProbeConfig
• type LatencyResponder
  • func (self *LatencyResponder) ContentType() int32
  • func (self *LatencyResponder) HandleReceive(msg *channel2.Message, _ channel2.Channel)
• type Meter
• type Metric
• type NilHandler
  • func (NilHandler) AcceptMetrics(message *metrics_pb.MetricsMessage)
• type PlainTextFormatter
  • func (PlainTextFormatter) WriteTo(msg *metrics_pb.MetricsMessage, out io.Writer) error
• type Registry
  • func NewRegistry(sourceId string, tags map[string]string) Registry
• type Timer
• type UsageRegistry
  • func NewUsageRegistry(sourceId string, tags map[string]string, closeNotify <-chan struct{}) UsageRegistry

Variables

var EventHandlerRegistry = cowslice.NewCowSlice(make([]Handler, 0))

Functions

func AddLatencyProbe

func AddLatencyProbe(ch channel2.Channel, interval time.Duration, handler LatencyHandler)

func AddLatencyProbeResponder

func AddLatencyProbeResponder(ch channel2.Channel)

func AsBatch

func AsBatch(msg *metrics_pb.MetricsMessage) (*influxdb.BatchPoints, error)

func Init

func Init(cfg *Config)

func LoadInfluxConfig

func LoadInfluxConfig(src map[interface{}]interface{}) (*influxConfig, error)

func LoadOutputFileConfig

func LoadOutputFileConfig(src map[interface{}]interface{}) (*outputfileConfig, error)

func ProbeLatency

func ProbeLatency(ch channel2.Channel, histogram Histogram, interval time.Duration, timeout time.Duration)

send regular latency probes

func ProbeLatencyConfigurable

func ProbeLatencyConfigurable(config *LatencyProbeConfig)

Types

type Config

type Config struct {
	Source         string
	Tags           map[string]string
	ReportInterval time.Duration
	EventSink      Handler
	// contains filtered or unexported fields
}

func LoadConfig

func LoadConfig(srcmap map[interface{}]interface{}) (*Config, error)

type Formatter

type Formatter interface {
	WriteTo(msg *metrics_pb.MetricsMessage, out io.Writer) error
}

type Gauge

type Gauge interface {
	metrics.Gauge
	Metric
}

Gauge represents a metric which is measuring a count and a rate

type Handler

type Handler interface {
	// AcceptMetrics is called when new metrics become available
	AcceptMetrics(message *metrics_pb.MetricsMessage)
}

Handler represents a sink for metric events

func NewChannelReporter

func NewChannelReporter(ch channel2.Channel) Handler

NewChannelReporter creates a metrics handler which sends metrics messages out on the given channel

func NewDispatchWrapper

func NewDispatchWrapper(deletage func(event event.Event)) Handler

func NewInfluxDBMetricsHandler

func NewInfluxDBMetricsHandler(cfg *influxConfig) (Handler, error)

NewInfluxDBMetricsHandler creates a new HandlerTypeInfluxDB metrics ChannelReporter

func NewOutputFileMetricsHandler

func NewOutputFileMetricsHandler(cfg *outputfileConfig) (Handler, error)

Message handler that write node and link metrics to a file in json format

type HandlerF

type HandlerF func(message *metrics_pb.MetricsMessage)

func (HandlerF) AcceptMetrics

func (self HandlerF) AcceptMetrics(message *metrics_pb.MetricsMessage)

type HandlerType

type HandlerType string

HandlerType is used to define known handler types

const (
	HandlerTypeInfluxDB HandlerType = "influxdb"
	HandlerTypeJSONFile HandlerType = "jsonfile"
	HandlerTypeFile     HandlerType = "file"
)

type Histogram

type Histogram interface {
	Metric
	Clear()
	Update(int64)
}

Histogram represents a metric which is measuring the distribution of values for some measurement

type IntervalCounter

type IntervalCounter interface {
	Metric
	Update(intervalId string, time time.Time, value uint64)
}

IntervalCounter allows tracking counters which are bucketized by some interval

type JsonFormatter

type JsonFormatter struct{}

func (*JsonFormatter) WriteTo

func (formatter *JsonFormatter) WriteTo(msg *metrics_pb.MetricsMessage, out io.Writer) error

type LatencyHandler

type LatencyHandler interface {
	LatencyReported(latency time.Duration)
	ChannelClosed()
}

type LatencyProbeConfig

type LatencyProbeConfig struct {
	Channel        channel2.Channel
	Interval       time.Duration
	Timeout        time.Duration
	ResultHandler  func(resultNanos int64)
	TimeoutHandler func()
	ExitHandler    func()
}

type LatencyResponder

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

LatencyResponder responds to latency messages with LatencyResponse messages.

func (*LatencyResponder) ContentType

func (self *LatencyResponder) ContentType() int32

func (*LatencyResponder) HandleReceive

func (self *LatencyResponder) HandleReceive(msg *channel2.Message, _ channel2.Channel)

type Meter

type Meter interface {
	Metric
	Mark(int64)
}

Meter represents a metric which is measuring a count and a rate

type Metric

type Metric interface {
	Dispose()
}

Metric is the base functionality for all metrics types

type NilHandler

type NilHandler struct{}

func (NilHandler) AcceptMetrics

func (NilHandler) AcceptMetrics(message *metrics_pb.MetricsMessage)

type PlainTextFormatter

type PlainTextFormatter struct {
}

func (PlainTextFormatter) WriteTo

func (PlainTextFormatter) WriteTo(msg *metrics_pb.MetricsMessage, out io.Writer) error

type Registry

type Registry interface {
	SourceId() string
	Gauge(name string) Gauge
	FuncGauge(name string, f func() int64) Gauge
	Meter(name string) Meter
	Histogram(name string) Histogram
	Timer(name string) Timer
	EachMetric(visitor func(name string, metric Metric))
	Poll() *metrics_pb.MetricsMessage
	DisposeAll()
}

Registry allows for configuring and accessing metrics for a fabric application

func NewRegistry

func NewRegistry(sourceId string, tags map[string]string) Registry

type Timer

type Timer interface {
	Metric
	Time(func())
	Update(time.Duration)
	UpdateSince(time.Time)
}

type UsageRegistry

type UsageRegistry interface {
	Registry
	IntervalCounter(name string, intervalSize time.Duration) IntervalCounter
	FlushToHandler(handler Handler)
	Flush()
	StartReporting(eventSink Handler, reportInterval time.Duration, msgQueueSize int)
}

UsageRegistry extends registry to allow collecting usage metrics

func NewUsageRegistry

func NewUsageRegistry(sourceId string, tags map[string]string, closeNotify <-chan struct{}) UsageRegistry