ts

Documentation

Index

• func Memset(data []float64, value float64)
• func MemsetInt(data []int, value int)
• type Datapoint
• type Datapoints
  • func (d Datapoints) DatapointAt(n int) Datapoint
  • func (d Datapoints) Len() int
  • func (d Datapoints) ValueAt(n int) float64
• type FixedResolutionMutableValues
  • func NewFixedStepValues(resolution time.Duration, numSteps int, initialValue float64, ...) FixedResolutionMutableValues
  • func RawPointsToFixedStep(datapoints Datapoints, start time.Time, end time.Time, interval time.Duration) (FixedResolutionMutableValues, error)
• type MutableValues
• type Series
  • func NewSeries(name string, vals Values, tags models.Tags) *Series
  • func (s *Series) Align(start, end time.Time, interval time.Duration) (*Series, error)
  • func (s *Series) Len() int
  • func (s *Series) Name() string
  • func (s *Series) Values() Values
• type SeriesList
  • func (seriesList SeriesList) Align(start, end time.Time, interval time.Duration) (SeriesList, error)
  • func (seriesList SeriesList) Resolution() (time.Duration, error)
• type Values

Functions

func Memset

func Memset(data []float64, value float64)

Memset is a faster way to initialize a float64 array.

• Inspired from https://github.com/tmthrgd/go-memset. Can't use that library here directly since the library works on byte interface. 0 case is optimized due to https://github.com/golang/go/issues/5373 but for non zero case, we use the copy() optimization.

BenchmarkMemsetZeroValues-4 1000000 1344 ns/op 0 B/op 0 allocs/op BenchmarkLoopZeroValues-4 500000 3217 ns/op 0 B/op 0 allocs/op BenchmarkMemsetNonZeroValues-4 1000000 1537 ns/op 0 B/op 0 allocs/op BenchmarkLoopNonZeroValues-4 500000 3236 ns/op 0 B/op 0 allocs/op *

func MemsetInt

func MemsetInt(data []int, value int)

MemsetInt is a faster way to initialize an int array.

Types

type Datapoint

type Datapoint struct {
	Timestamp time.Time
	Value     float64
}

A Datapoint is a single data value reported at a given time

type Datapoints

type Datapoints []Datapoint

Datapoints is a list of datapoints.

func (Datapoints) DatapointAt

func (d Datapoints) DatapointAt(n int) Datapoint

DatapointAt returns the value at the nth element.

func (Datapoints) Len

func (d Datapoints) Len() int

Len is the length of the array.

func (Datapoints) ValueAt

func (d Datapoints) ValueAt(n int) float64

ValueAt returns the value at the nth element.

type FixedResolutionMutableValues

type FixedResolutionMutableValues interface {
	MutableValues
	Resolution() time.Duration
	StepAtTime(t time.Time) int
	StartTimeForStep(n int) time.Time
	// Time when the series starts
	StartTime() time.Time
}

FixedResolutionMutableValues are mutable values with fixed resolution between steps

func NewFixedStepValues

func NewFixedStepValues(resolution time.Duration, numSteps int, initialValue float64, startTime time.Time) FixedResolutionMutableValues

NewFixedStepValues returns mutable values with fixed resolution

func RawPointsToFixedStep

func RawPointsToFixedStep(datapoints Datapoints, start time.Time, end time.Time, interval time.Duration) (FixedResolutionMutableValues, error)

RawPointsToFixedStep converts raw datapoints into the interval required within the bounds specified. For every time step, it finds the closest point.

type MutableValues

type MutableValues interface {
	Values

	// Sets the value at the given entry
	SetValueAt(n int, v float64)
}

MutableValues is the interface for values that can be updated

type Series

type Series struct {
	Tags models.Tags
	// contains filtered or unexported fields
}

Series is the public interface to a block of timeseries values. Each block has a start time, a logical number of steps, and a step size indicating the number of milliseconds represented by each point.

func NewSeries

func NewSeries(name string, vals Values, tags models.Tags) *Series

NewSeries creates a new Series at a given start time, backed by the provided values

func (*Series) Align

func (s *Series) Align(start, end time.Time, interval time.Duration) (*Series, error)

Align adjusts the datapoints to start, end and a fixed interval

func (*Series) Len

func (s *Series) Len() int

Len returns the number of values in the time series. Used for aggregation

func (*Series) Name

func (s *Series) Name() string

Name returns the name of the timeseries block

func (*Series) Values

func (s *Series) Values() Values

Values returns the underlying values interface

type SeriesList

type SeriesList []*Series

SeriesList represents a slice of series pointers

func (SeriesList) Align

func (seriesList SeriesList) Align(start, end time.Time, interval time.Duration) (SeriesList, error)

Align aligns each series to the given start, end and step.

func (SeriesList) Resolution

func (seriesList SeriesList) Resolution() (time.Duration, error)

Resolution returns the resolution for a fixed step series list. It assumes all underlying series will have the same resolution

type Values

type Values interface {
	// Len returns the number of values present
	Len() int

	// ValueAt returns the value at the nth element
	ValueAt(n int) float64

	// DatapointAt returns the datapoint at the nth element
	DatapointAt(n int) Datapoint
}

Values holds the values for a timeseries. It provides a minimal interface for storing and retrieving values in the series, with Series providing a more convenient interface for applications to build on top of. Values objects are not specific to a given time, allowing them to be pre-allocated, pooled, and re-used across multiple series. There are multiple implementations of Values so that we can optimize storage based on the density of the series.