Package types contains miscellaneous structs and interfaces used throughout tsmon. They live here to avoid circular dependencies between other packages.



    View Source
    const (
    	Unknown      = ""
    	Seconds      = "s"
    	Milliseconds = "ms"
    	Microseconds = "us"
    	Nanoseconds  = "ns"
    	Bits         = "B"
    	Bytes        = "By"
    	Kilobytes = "kBy"  // 1000 bytes (not 1024).
    	Megabytes = "MBy"  // 1e6 (1,000,000) bytes.
    	Gigabytes = "GBy"  // 1e9 (1,000,000,000) bytes.
    	Kibibytes = "kiBy" // 1024 bytes.
    	Mebibytes = "MiBy" // 1024^2 (1,048,576) bytes.
    	Gibibytes = "GiBy" // 1024^3 (1,073,741,824) bytes.
    	// * Extended Units
    	AmpUnit           = "A"
    	MilliampUnit      = "mA"
    	DegreeCelsiusUnit = "Cel"

      Units of metrics data.


      This section is empty.


      This section is empty.


      type Cell

      type Cell struct {

        Cell is the smallest unit of data recorded by tsmon. Metrics can be thought of as multi-dimensional maps (with fields defining the dimensions) - a Cell is one value in that map, with information about its fields and its type.

        type CellData

        type CellData struct {
        	FieldVals []interface{}
        	Target    Target
        	ResetTime time.Time
        	Value     interface{}

          CellData contains the value of a single cell.

          type DistributionMetric

          type DistributionMetric interface {
          	Bucketer() *distribution.Bucketer

            DistributionMetric is the low-level interface provided by all distribution metrics. It has a Bucketer which is responsible for assigning buckets to samples. Concrete types are defined in the "metrics" package.

            type Metric

            type Metric interface {
            	Info() MetricInfo
            	Metadata() MetricMetadata
            	// SetFixedResetTime overrides the reset time for this metric.  Usually cells
            	// take the current time when they're first assigned a value, but it can be
            	// useful to override the reset time when tracking an external counter.
            	SetFixedResetTime(t time.Time)

              Metric is the low-level interface provided by all metrics. Concrete types are defined in the "metrics" package.

              type MetricDataUnits

              type MetricDataUnits string

                MetricDataUnits are enums for the units of metrics data.

                func (MetricDataUnits) IsSpecified

                func (units MetricDataUnits) IsSpecified() bool

                  IsSpecified returns true if a unit annotation has been specified for a given metric.

                  type MetricInfo

                  type MetricInfo struct {
                  	Name        string
                  	Description string
                  	Fields      []field.Field
                  	ValueType   ValueType
                  	TargetType  TargetType

                    MetricInfo contains the definition of a metric.

                    type MetricMetadata

                    type MetricMetadata struct {
                    	Units MetricDataUnits // the unit of recorded data for a given metric.

                      MetricMetadata contains user-provided metadata for a metric.

                      type Target

                      type Target interface {
                      	// TODO(1026140): the hash and proto of a Target object should be created
                      	// at the time of the object creation.
                      	PopulateProto(d *pb.MetricsCollection)
                      	Hash() uint64
                      	Clone() Target
                      	Type() TargetType

                        A Target knows how to put information about itself in a MetricsData message.

                        type TargetType

                        type TargetType struct {
                        	// Name is the name of the TargeType that can be given to --target-type
                        	// command line option.
                        	Name string
                        	// Type is the reflect.Type of the Target struct.
                        	Type reflect.Type

                          TargetType represents the type of a Target, which identifies a metric with the name.

                          A metric is identified by (,

                          func (TargetType) String

                          func (tt TargetType) String() string

                          type ValueType

                          type ValueType int

                            ValueType is an enum for the type of a metric.

                            const (
                            	NonCumulativeIntType ValueType = iota

                              Types of metric values.

                              func (ValueType) IsCumulative

                              func (v ValueType) IsCumulative() bool

                                IsCumulative returns true if this is a cumulative metric value type.

                                func (ValueType) String

                                func (v ValueType) String() string