The highest tagged major version is
Documentation
¶
Overview ¶
Package monitor package handle the logging, collection and computation of statistical data. Every application can send some Measure (for the moment, we mostly measure the CPU time but it can be applied later for any kind of measures). The Monitor receives them and updates a Stats struct. This Stats struct can hold many different kinds of Measurements (the measure of a specific action such as "round time" or "verify time" etc). These measurements contain Values which compute the actual min/max/dev/avg values.
The Proxy allows to relay Measure from clients to the listening Monitor. A starter feature is also the DataFilter which can apply some filtering rules to the data before making any statistics about them.
Index ¶
- Constants
- func ConnectSink(addr string) error
- func EndAndCleanup()
- func RecordSingleMeasure(name string, value float64)
- func RecordSingleMeasureWithHost(name string, value float64, host int)
- type BucketStats
- type CounterIO
- type CounterIOMeasure
- type DataFilter
- type Measure
- type Monitor
- type Stats
- type TCPProxy
- type TimeMeasure
- type Value
- func (t *Value) Avg() float64
- func (t *Value) Collect()
- func (t *Value) Dev() float64
- func (t *Value) Filter(filt DataFilter)
- func (t *Value) HeaderFields() []string
- func (t *Value) Max() float64
- func (t *Value) Min() float64
- func (t *Value) NumValue() int
- func (t *Value) SingleValues(i int) []string
- func (t *Value) Store(newTime float64)
- func (t *Value) Sum() float64
- func (t *Value) Values() []string
Constants ¶
const DefaultSinkPort = 10000
DefaultSinkPort is the default port where a monitor will listen and a proxy will contact the monitor.
const InvalidHostIndex = -1
InvalidHostIndex is the default value when the measure is not assigned to a specific host
const Sink = "0.0.0.0"
Sink is the address where to listen for the monitor. The endpoint can be a monitor.Proxy or a direct connection with measure.go
Variables ¶
This section is empty.
Functions ¶
func ConnectSink ¶
ConnectSink connects to the given endpoint and initialises a json encoder. It can be the address of a proxy or a monitoring process. Returns an error if it could not connect to the endpoint.
func EndAndCleanup ¶
func EndAndCleanup()
EndAndCleanup sends a message to end the logging and closes the connection
func RecordSingleMeasure ¶
RecordSingleMeasure sends the pair name - value to the monitor directly.
func RecordSingleMeasureWithHost ¶
RecordSingleMeasureWithHost sends the pair name - value with the host index to the monitor directly.
Types ¶
type BucketStats ¶
type BucketStats struct {
// contains filtered or unexported fields
}
BucketStats splits the statistics into buckets according to network addresses and associated rules
func (*BucketStats) Get ¶
func (bs *BucketStats) Get(index int) *Stats
Get returns the bucket at the given index if it exists, nil otherwise
func (*BucketStats) Set ¶
func (bs *BucketStats) Set(index int, rules []string, stats *Stats) error
Set creates a new bucket at the given index that uses the rules to filter incoming measures
func (*BucketStats) Update ¶
func (bs *BucketStats) Update(m *singleMeasure)
Update takes a single measure and fill the buckets that will match the host index if defined in the measure
type CounterIO ¶
type CounterIO interface {
// Rx returns the number of bytes read by this interface.
Rx() uint64
// Tx returns the number of bytes transmitted / written by this interface.
Tx() uint64
// MsgRx returns the number of messages read by this interface.
MsgRx() uint64
// MsgTx returns the number of messages transmitted / written by this interface.
MsgTx() uint64
}
CounterIO is an interface that can be used to count how many bytes does an object have written and how many bytes does it have read. For example it is implemented by cothority/network/ Conn + Host to know how many bytes a connection / Host has written /read.
type CounterIOMeasure ¶
type CounterIOMeasure struct {
// contains filtered or unexported fields
}
CounterIOMeasure is a struct that takes a CounterIO and can send the measurements to the monitor. Each time Record() is called, the measurements are put back to 0 (while the CounterIO still sends increased bytes number).
func NewCounterIOMeasure ¶
func NewCounterIOMeasure(name string, counter CounterIO) *CounterIOMeasure
NewCounterIOMeasure returns a CounterIOMeasure fresh. The base value are set to the current value of counter.Rx() and counter.Tx().
func NewCounterIOMeasureWithHost ¶
func NewCounterIOMeasureWithHost(name string, counter CounterIO, host int) *CounterIOMeasure
NewCounterIOMeasureWithHost returns a CounterIOMeasure bounded to a host index. The base value are set to the current value of counter.Rx() and counter.Tx().
func (*CounterIOMeasure) Record ¶
func (cm *CounterIOMeasure) Record()
Record send the actual number of bytes read and written (**name**_written & **name**_read) and reset the counters.
func (*CounterIOMeasure) Reset ¶
func (cm *CounterIOMeasure) Reset()
Reset sets the base to the current value of the counter.
type DataFilter ¶
type DataFilter struct {
// contains filtered or unexported fields
}
DataFilter is used to process data before making any statistics about them
func NewDataFilter ¶
func NewDataFilter(config map[string]string) DataFilter
NewDataFilter returns a new data filter initialized with the rights values taken out from the run config. If absent, will take defaults values. Keys expected are: discard_measurementname = perc => will take the lower and upper percentile = perc discard_measurementname = lower,upper => will take different percentiles
type Measure ¶
type Measure interface {
// Record must be called when you want to send the value
// over the monitor listening.
// Implementation of this interface must RESET the value to `0` at the end
// of Record(). `0` means the initial value / meaning this measure had when
// created.
// Example: TimeMeasure.Record() will reset the time to `time.Now()`
// CounterIOMeasure.Record() will reset the counter of the bytes
// read / written to 0.
// etc
Record()
}
Measure is an interface for measurements Usage:
measure := monitor.SingleMeasure("bandwidth")
or
measure := monitor.NewTimeMeasure("round")
measure.Record()
type Monitor ¶
type Monitor struct {
SinkPort uint16
// contains filtered or unexported fields
}
Monitor struct is used to collect measures and make the statistics about them. It takes a stats object so it update that in a concurrent-safe manner for each new measure it receives.
func NewMonitor ¶
NewMonitor returns a new monitor given the stats
func (*Monitor) InsertBucket ¶
InsertBucket creates a bucket at the given index that will use the rules to filter the incoming measures
type Stats ¶
Stats holds the different measurements done
func AverageStats ¶
AverageStats will make an average of the given stats
func NewStats ¶
NewStats return a NewStats with some fields extracted from the platform run config It enforces the default set of measure to have if you pass that as defaults.
func (*Stats) Collect ¶
func (s *Stats) Collect()
Collect make the final computations before stringing or writing. Automatically done in other methods anyway.
func (*Stats) Update ¶
func (s *Stats) Update(m *singleMeasure)
Update will update the Stats with this given measure
func (*Stats) WriteHeader ¶
WriteHeader will write the header to the writer
func (*Stats) WriteIndividualStats ¶
WriteIndividualStats will write the values to the specified writer but without making averages. Each value should either be:
- represented once - then it'll be copied to all runs
- have the same frequency as the other non-once values
func (*Stats) WriteValues ¶
WriteValues will write the values to the specified writer
type TCPProxy ¶
type TCPProxy struct {
Listener net.Listener
Endpoints []*net.SRV
MonitorInterval time.Duration
// contains filtered or unexported fields
}
A TCPProxy proxies connections arriving at the Listener to one of the Endpoints.
func NewProxy ¶
NewProxy returns a new TCP proxy listening on addr:listenPort, which forwards connections to localhost:toPort.
type TimeMeasure ¶
type TimeMeasure struct {
Wall *singleMeasure
CPU *singleMeasure
User *singleMeasure
// contains filtered or unexported fields
}
TimeMeasure represents a measure regarding time: It includes the wallclock time, the cpu time + the user time.
func NewTimeMeasure ¶
func NewTimeMeasure(name string) *TimeMeasure
NewTimeMeasure return *TimeMeasure
func NewTimeMeasureWithHost ¶
func NewTimeMeasureWithHost(name string, host int) *TimeMeasure
NewTimeMeasureWithHost makes a time measure bounded to a host index.
func (*TimeMeasure) Record ¶
func (tm *TimeMeasure) Record()
Record sends the measurements to the monitor:
- wall time: *name*_wall
- system time: *name*_system
- user time: *name*_user
type Value ¶
Value is used to compute the statistics it reprensent the time to an action (setup, shamir round, coll round etc) use it to compute streaming mean + dev
func AverageValue ¶
AverageValue will create a Value averaging all Values given
func (*Value) Collect ¶
func (t *Value) Collect()
Collect will collect all float64 stored in the store's Value and will compute the basic statistics about them such as min, max, dev and avg.
func (*Value) HeaderFields ¶
HeaderFields returns the first line of the CSV-file
func (*Value) SingleValues ¶
SingleValues returns the string representation of an entry in the value
func (*Value) Store ¶
Store takes this new time and stores it for later analysis Since we might want to do percentile sorting, we need to have all the Values For the moment, we do a simple store of the Value, but note that some streaming percentile algorithm exists in case the number of messages is growing to big.
Source Files