Documentation

Index

Constants

View Source
const (
	Counter = MetricType(iota) // A counter that sums its data points
	Gauge                      // A gauge that displays the latest value
	Trend                      // A trend, min/max/avg/med are interesting
	Rate                       // A rate, displays % of values that aren't 0
)

    Possible values for MetricType.

    View Source
    const (
    	Default = ValueType(iota) // Values are presented as-is
    	Time                      // Values are timestamps (nanoseconds)
    	Data                      // Values are data amounts (bytes)
    )

      Possible values for ValueType.

      Variables

        DefaultSystemTagSet includes all of the system tags emitted with metrics by default. Other tags that are not enabled by default include: iter, vu, ocsp_status, ip nolint:gochecknoglobals

        View Source
        var ErrInvalidMetricType = errors.New("invalid metric type")

          The serialized metric type is invalid.

          View Source
          var ErrInvalidValueType = errors.New("invalid value type")

            The serialized value type is invalid.

            Functions

            func D

            func D(d time.Duration) float64

              D formats a duration for emission. The reverse of D() is ToD().

              func GetResolversForTrendColumns

              func GetResolversForTrendColumns(trendColumns []string) (map[string]func(s *TrendSink) float64, error)

                GetResolversForTrendColumns checks if passed trend columns are valid for use in the summary output and then returns a map of the corresponding resolvers.

                func PushIfNotDone

                func PushIfNotDone(ctx context.Context, output chan<- SampleContainer, sample SampleContainer) bool

                  PushIfNotDone first checks if the supplied context is done and doesn't push the sample container if it is.

                  func ToD

                  func ToD(d float64) time.Duration

                    ToD converts an emitted duration to a time.Duration. The reverse of ToD() is D().

                    Types

                    type ConnectedSampleContainer

                    type ConnectedSampleContainer interface {
                    	SampleContainer
                    	GetTags() *SampleTags
                    	GetTime() time.Time
                    }

                      ConnectedSampleContainer is an extension of the SampleContainer interface that should be implemented when emitted samples are connected and share the same time and tags.

                      type ConnectedSamples

                      type ConnectedSamples struct {
                      	Samples []Sample
                      	Tags    *SampleTags
                      	Time    time.Time
                      }

                        ConnectedSamples is the simplest ConnectedSampleContainer implementation that will be used when there's no need for extra information

                        func (ConnectedSamples) GetSamples

                        func (cs ConnectedSamples) GetSamples() []Sample

                          GetSamples implements the SampleContainer and ConnectedSampleContainer interfaces and returns the stored slice with samples.

                          func (ConnectedSamples) GetTags

                          func (cs ConnectedSamples) GetTags() *SampleTags

                            GetTags implements ConnectedSampleContainer interface and returns stored tags.

                            func (ConnectedSamples) GetTime

                            func (cs ConnectedSamples) GetTime() time.Time

                              GetTime implements ConnectedSampleContainer interface and returns stored time.

                              type CounterSink

                              type CounterSink struct {
                              	Value float64
                              	First time.Time
                              }

                              func (*CounterSink) Add

                              func (c *CounterSink) Add(s Sample)

                              func (*CounterSink) Calc

                              func (c *CounterSink) Calc()

                              func (*CounterSink) Format

                              func (c *CounterSink) Format(t time.Duration) map[string]float64

                              type DummySink

                              type DummySink map[string]float64

                              func (DummySink) Add

                              func (d DummySink) Add(s Sample)

                              func (DummySink) Calc

                              func (d DummySink) Calc()

                              func (DummySink) Format

                              func (d DummySink) Format(t time.Duration) map[string]float64

                              type GaugeSink

                              type GaugeSink struct {
                              	Value    float64
                              	Max, Min float64
                              	// contains filtered or unexported fields
                              }

                              func (*GaugeSink) Add

                              func (g *GaugeSink) Add(s Sample)

                              func (*GaugeSink) Calc

                              func (g *GaugeSink) Calc()

                              func (*GaugeSink) Format

                              func (g *GaugeSink) Format(t time.Duration) map[string]float64

                              type Metric

                              type Metric struct {
                              	Name       string       `json:"name"`
                              	Type       MetricType   `json:"type"`
                              	Contains   ValueType    `json:"contains"`
                              	Tainted    null.Bool    `json:"tainted"`
                              	Thresholds Thresholds   `json:"thresholds"`
                              	Submetrics []*Submetric `json:"submetrics"`
                              	Sub        Submetric    `json:"sub,omitempty"`
                              	Sink       Sink         `json:"-"`
                              }

                                A Metric defines the shape of a set of data.

                                func New

                                func New(name string, typ MetricType, t ...ValueType) *Metric

                                func (*Metric) HumanizeValue

                                func (m *Metric) HumanizeValue(v float64, timeUnit string) string

                                  HumanizeValue makes the value human-readable TODO: get rid of this after we remove the Go-based summary

                                  type MetricType

                                  type MetricType int

                                    A MetricType specifies the type of a metric.

                                    func (MetricType) MarshalJSON

                                    func (t MetricType) MarshalJSON() ([]byte, error)

                                      MarshalJSON serializes a MetricType as a human readable string.

                                      func (MetricType) MarshalText

                                      func (t MetricType) MarshalText() ([]byte, error)

                                        MarshalText serializes a MetricType as a human readable string.

                                        func (MetricType) String

                                        func (t MetricType) String() string

                                        func (*MetricType) UnmarshalText

                                        func (t *MetricType) UnmarshalText(data []byte) error

                                          UnmarshalText deserializes a MetricType from a string representation.

                                          type RateSink

                                          type RateSink struct {
                                          	Trues int64
                                          	Total int64
                                          }

                                          func (*RateSink) Add

                                          func (r *RateSink) Add(s Sample)

                                          func (RateSink) Calc

                                          func (r RateSink) Calc()

                                          func (RateSink) Format

                                          func (r RateSink) Format(t time.Duration) map[string]float64

                                          type Sample

                                          type Sample struct {
                                          	Metric *Metric
                                          	Time   time.Time
                                          	Tags   *SampleTags
                                          	Value  float64
                                          }

                                            A Sample is a single measurement.

                                            func (Sample) GetSamples

                                            func (s Sample) GetSamples() []Sample

                                              GetSamples implement the ConnectedSampleContainer interface for a single Sample, since it's obviously connected with itself :)

                                              func (Sample) GetTags

                                              func (s Sample) GetTags() *SampleTags

                                                GetTags implements ConnectedSampleContainer interface and returns the sample's tags.

                                                func (Sample) GetTime

                                                func (s Sample) GetTime() time.Time

                                                  GetTime just implements ConnectedSampleContainer interface and returns the sample's time.

                                                  type SampleContainer

                                                  type SampleContainer interface {
                                                  	GetSamples() []Sample
                                                  }

                                                    SampleContainer is a simple abstraction that allows sample producers to attach extra information to samples they return

                                                    func GetBufferedSamples

                                                    func GetBufferedSamples(input <-chan SampleContainer) (result []SampleContainer)

                                                      GetBufferedSamples will read all present (i.e. buffered or currently being pushed) values in the input channel and return them as a slice.

                                                      type SampleTags

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

                                                        SampleTags is an immutable string[string] map for tags. Once a tag set is created, direct modification is prohibited. It has copy-on-write semantics and uses pointers for faster comparison between maps, since the same tag set is often used for multiple samples. All methods should not panic, even if they are called on a nil pointer. easyjson:skip

                                                        func IntoSampleTags

                                                        func IntoSampleTags(data *map[string]string) *SampleTags

                                                          IntoSampleTags "consumes" the passed map and creates a new SampleTags struct with the data. The map is set to nil as a hint that it shouldn't be changed after it has been transformed into an "immutable" tag set. Oh, how I miss Rust and move semantics... :)

                                                          func NewSampleTags

                                                          func NewSampleTags(data map[string]string) *SampleTags

                                                            NewSampleTags *copies* the supplied tag set and returns a new SampleTags instance with the key-value pairs from it.

                                                            func (*SampleTags) CloneTags

                                                            func (st *SampleTags) CloneTags() map[string]string

                                                              CloneTags copies the underlying set of a sample tags and returns it. If the receiver is nil, it returns an empty non-nil map.

                                                              func (*SampleTags) Contains

                                                              func (st *SampleTags) Contains(other *SampleTags) bool

                                                              func (*SampleTags) Get

                                                              func (st *SampleTags) Get(key string) (string, bool)

                                                                Get returns an empty string and false if the the requested key is not present or its value and true if it is.

                                                                func (*SampleTags) IsEmpty

                                                                func (st *SampleTags) IsEmpty() bool

                                                                  IsEmpty checks for a nil pointer or zero tags. It's necessary because of this envconfig issue: https://github.com/kelseyhightower/envconfig/issues/113

                                                                  func (*SampleTags) IsEqual

                                                                  func (st *SampleTags) IsEqual(other *SampleTags) bool

                                                                    IsEqual tries to compare two tag sets with maximum efficiency.

                                                                    func (*SampleTags) MarshalEasyJSON

                                                                    func (st *SampleTags) MarshalEasyJSON(w *jwriter.Writer)

                                                                      MarshalEasyJSON supports easyjson.Marshaler interface

                                                                      func (*SampleTags) MarshalJSON

                                                                      func (st *SampleTags) MarshalJSON() ([]byte, error)

                                                                        MarshalJSON serializes SampleTags to a JSON string and caches the result. It is not thread safe in the sense that the Go race detector will complain if it's used concurrently, but no data should be corrupted.

                                                                        func (*SampleTags) UnmarshalJSON

                                                                        func (st *SampleTags) UnmarshalJSON(data []byte) error

                                                                          UnmarshalJSON deserializes SampleTags from a JSON string.

                                                                          type Samples

                                                                          type Samples []Sample

                                                                            Samples is just the simplest SampleContainer implementation that will be used when there's no need for extra information

                                                                            func (Samples) GetSamples

                                                                            func (s Samples) GetSamples() []Sample

                                                                              GetSamples just implements the SampleContainer interface

                                                                              type Sink

                                                                              type Sink interface {
                                                                              	Add(s Sample)                              // Add a sample to the sink.
                                                                              	Calc()                                     // Make final calculations.
                                                                              	Format(t time.Duration) map[string]float64 // Data for thresholds.
                                                                              }

                                                                              type Submetric

                                                                              type Submetric struct {
                                                                              	Name   string      `json:"name"`
                                                                              	Parent string      `json:"parent"`
                                                                              	Suffix string      `json:"suffix"`
                                                                              	Tags   *SampleTags `json:"tags"`
                                                                              	Metric *Metric     `json:"-"`
                                                                              }

                                                                                A Submetric represents a filtered dataset based on a parent metric.

                                                                                func NewSubmetric

                                                                                func NewSubmetric(name string) (parentName string, sm *Submetric)

                                                                                  Creates a submetric from a name.

                                                                                  type SystemTagSet

                                                                                  type SystemTagSet uint32

                                                                                    SystemTagSet is a bitmask that is used to keep track which system tags should be included with which metrics. go:generate enumer -type=SystemTagSet -transform=snake -trimprefix=Tag -output system_tag_set_gen.go

                                                                                    const (
                                                                                    	TagProto SystemTagSet = 1 << iota
                                                                                    	TagSubproto
                                                                                    	TagStatus
                                                                                    	TagMethod
                                                                                    	TagURL
                                                                                    	TagName
                                                                                    	TagGroup
                                                                                    	TagCheck
                                                                                    	TagError
                                                                                    	TagErrorCode
                                                                                    	TagTLSVersion
                                                                                    	TagScenario
                                                                                    	TagService
                                                                                    
                                                                                    	// System tags not enabled by default.
                                                                                    	TagIter
                                                                                    	TagVU
                                                                                    	TagOCSPStatus
                                                                                    	TagIP
                                                                                    )

                                                                                      Default system tags includes all of the system tags emitted with metrics by default.

                                                                                      func NewSystemTagSet

                                                                                      func NewSystemTagSet(tags ...SystemTagSet) *SystemTagSet

                                                                                        NewSystemTagSet returns a SystemTagSet from input.

                                                                                        func SystemTagSetString

                                                                                        func SystemTagSetString(s string) (SystemTagSet, error)

                                                                                          SystemTagSetString retrieves an enum value from the enum constants string name. Throws an error if the param is not part of the enum.

                                                                                          func SystemTagSetValues

                                                                                          func SystemTagSetValues() []SystemTagSet

                                                                                            SystemTagSetValues returns all values of the enum

                                                                                            func ToSystemTagSet

                                                                                            func ToSystemTagSet(tags []string) *SystemTagSet

                                                                                              ToSystemTagSet converts list of tags to SystemTagSet TODO: emit error instead of discarding invalid values.

                                                                                              func (*SystemTagSet) Add

                                                                                              func (i *SystemTagSet) Add(tag SystemTagSet)

                                                                                                Add adds a tag to tag set.

                                                                                                func (*SystemTagSet) Has

                                                                                                func (i *SystemTagSet) Has(tag SystemTagSet) bool

                                                                                                  Has checks a tag included in tag set.

                                                                                                  func (SystemTagSet) IsASystemTagSet

                                                                                                  func (i SystemTagSet) IsASystemTagSet() bool

                                                                                                    IsASystemTagSet returns "true" if the value is listed in the enum definition. "false" otherwise

                                                                                                    func (SystemTagSet) Map

                                                                                                    func (i SystemTagSet) Map() TagSet

                                                                                                      Map returns the TagSet with current value from SystemTagSet

                                                                                                      func (*SystemTagSet) MarshalJSON

                                                                                                      func (i *SystemTagSet) MarshalJSON() ([]byte, error)

                                                                                                        MarshalJSON converts the SystemTagSet to a list (JS array).

                                                                                                        func (SystemTagSet) SetString

                                                                                                        func (i SystemTagSet) SetString() string

                                                                                                          SetString returns comma separated list of the string representation of all values in the set

                                                                                                          func (SystemTagSet) String

                                                                                                          func (i SystemTagSet) String() string

                                                                                                          func (*SystemTagSet) UnmarshalJSON

                                                                                                          func (i *SystemTagSet) UnmarshalJSON(data []byte) error

                                                                                                            UnmarshalJSON converts the tag list back to expected tag set.

                                                                                                            func (*SystemTagSet) UnmarshalText

                                                                                                            func (i *SystemTagSet) UnmarshalText(data []byte) error

                                                                                                              UnmarshalText converts the tag list to SystemTagSet.

                                                                                                              type TagSet

                                                                                                              type TagSet map[string]bool

                                                                                                                TagSet is a string to bool map (for lookup efficiency) that is used to keep track of which system tags and non-system tags to include.

                                                                                                                func (*TagSet) MarshalJSON

                                                                                                                func (i *TagSet) MarshalJSON() ([]byte, error)

                                                                                                                  MarshalJSON converts the TagSet to a list (JS array).

                                                                                                                  func (*TagSet) UnmarshalJSON

                                                                                                                  func (i *TagSet) UnmarshalJSON(data []byte) error

                                                                                                                    UnmarshalJSON converts the tag list back to expected tag set.

                                                                                                                    func (*TagSet) UnmarshalText

                                                                                                                    func (i *TagSet) UnmarshalText(data []byte) error

                                                                                                                      UnmarshalText converts the tag list to TagSet.

                                                                                                                      type Threshold

                                                                                                                      type Threshold struct {
                                                                                                                      	// Source is the text based source of the threshold
                                                                                                                      	Source string
                                                                                                                      	// LastFailed is a makrer if the last testing of this threshold failed
                                                                                                                      	LastFailed bool
                                                                                                                      	// AbortOnFail marks if a given threshold fails that the whole test should be aborted
                                                                                                                      	AbortOnFail bool
                                                                                                                      	// AbortGracePeriod is a the minimum amount of time a test should be running before a failing
                                                                                                                      	// this threshold will abort the test
                                                                                                                      	AbortGracePeriod types.NullDuration
                                                                                                                      	// contains filtered or unexported fields
                                                                                                                      }

                                                                                                                        Threshold is a representation of a single threshold for a single metric

                                                                                                                        type Thresholds

                                                                                                                        type Thresholds struct {
                                                                                                                        	Runtime    *goja.Runtime
                                                                                                                        	Thresholds []*Threshold
                                                                                                                        	Abort      bool
                                                                                                                        }

                                                                                                                          Thresholds is the combination of all Thresholds for a given metric

                                                                                                                          func NewThresholds

                                                                                                                          func NewThresholds(sources []string) (Thresholds, error)

                                                                                                                            NewThresholds returns Thresholds objects representing the provided source strings

                                                                                                                            func (Thresholds) MarshalJSON

                                                                                                                            func (ts Thresholds) MarshalJSON() ([]byte, error)

                                                                                                                              MarshalJSON is implementation of json.Marshaler

                                                                                                                              func (*Thresholds) Run

                                                                                                                              func (ts *Thresholds) Run(sink Sink, t time.Duration) (bool, error)

                                                                                                                                Run processes all the thresholds with the provided Sink at the provided time and returns if any of them fails

                                                                                                                                func (*Thresholds) UnmarshalJSON

                                                                                                                                func (ts *Thresholds) UnmarshalJSON(data []byte) error

                                                                                                                                  UnmarshalJSON is implementation of json.Unmarshaler

                                                                                                                                  type TrendSink

                                                                                                                                  type TrendSink struct {
                                                                                                                                  	Values []float64
                                                                                                                                  
                                                                                                                                  	Count    uint64
                                                                                                                                  	Min, Max float64
                                                                                                                                  	Sum, Avg float64
                                                                                                                                  	Med      float64
                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                  }

                                                                                                                                  func (*TrendSink) Add

                                                                                                                                  func (t *TrendSink) Add(s Sample)

                                                                                                                                  func (*TrendSink) Calc

                                                                                                                                  func (t *TrendSink) Calc()

                                                                                                                                  func (*TrendSink) Format

                                                                                                                                  func (t *TrendSink) Format(tt time.Duration) map[string]float64

                                                                                                                                  func (*TrendSink) P

                                                                                                                                  func (t *TrendSink) P(pct float64) float64

                                                                                                                                    P calculates the given percentile from sink values.

                                                                                                                                    type ValueType

                                                                                                                                    type ValueType int

                                                                                                                                      The type of values a metric contains.

                                                                                                                                      func (ValueType) MarshalJSON

                                                                                                                                      func (t ValueType) MarshalJSON() ([]byte, error)

                                                                                                                                        MarshalJSON serializes a ValueType to a JSON string.

                                                                                                                                        func (ValueType) MarshalText

                                                                                                                                        func (t ValueType) MarshalText() ([]byte, error)

                                                                                                                                          MarshalText serializes a ValueType as a human readable string.

                                                                                                                                          func (ValueType) String

                                                                                                                                          func (t ValueType) String() string

                                                                                                                                          func (*ValueType) UnmarshalText

                                                                                                                                          func (t *ValueType) UnmarshalText(data []byte) error

                                                                                                                                            UnmarshalText deserializes a ValueType from a string representation.

                                                                                                                                            Directories

                                                                                                                                            Path Synopsis