tsdb

Documentation

Index

• func ConvertSqlTimeColumnToEpochMs(values RowValues, timeIndex int)
• func ConvertSqlValueColumnToFloat(columnName string, columnValue interface{}) (null.Float, error)
• func EpochPrecisionToMs(value float64) float64
• func GetIntervalFrom(dsInfo *models.DataSource, queryModel *simplejson.Json, ...) (time.Duration, error)
• func NewIntervalCalculator(opt *IntervalOptions) *intervalCalculator
• func RegisterTsdbQueryEndpoint(pluginId string, fn GetTsdbQueryEndpointFn)
• type DefaultSqlEngine
  • func (e *DefaultSqlEngine) InitEngine(driverName string, dsInfo *models.DataSource, cnnstr string) error
  • func (e *DefaultSqlEngine) Query(ctx context.Context, dsInfo *models.DataSource, tsdbQuery *TsdbQuery, ...) (*Response, error)
• type GetTsdbQueryEndpointFn
• type HandleRequestFunc
• type Interval
• type IntervalCalculator
• type IntervalOptions
• type Query
• type QueryResult
  • func NewQueryResult() *QueryResult
• type Response
  • func HandleRequest(ctx context.Context, dsInfo *models.DataSource, req *TsdbQuery) (*Response, error)
• type RowValues
• type SqlEngine
• type SqlMacroEngine
• type Table
• type TableColumn
• type TimePoint
  • func NewTimePoint(value null.Float, timestamp float64) TimePoint
• type TimeRange
  • func NewFakeTimeRange(from, to string, now time.Time) *TimeRange
  • func NewTimeRange(from, to string) *TimeRange
  • func (tr *TimeRange) GetFromAsMsEpoch() int64
  • func (tr *TimeRange) GetFromAsSecondsEpoch() int64
  • func (tr *TimeRange) GetFromAsTimeUTC() time.Time
  • func (tr *TimeRange) GetToAsMsEpoch() int64
  • func (tr *TimeRange) GetToAsSecondsEpoch() int64
  • func (tr *TimeRange) GetToAsTimeUTC() time.Time
  • func (tr *TimeRange) MustGetFrom() time.Time
  • func (tr *TimeRange) MustGetTo() time.Time
  • func (tr *TimeRange) ParseFrom() (time.Time, error)
  • func (tr *TimeRange) ParseTo() (time.Time, error)
• type TimeSeries
  • func NewTimeSeries(name string, points TimeSeriesPoints) *TimeSeries
• type TimeSeriesPoints
  • func NewTimeSeriesPointsFromArgs(values ...float64) TimeSeriesPoints
• type TimeSeriesSlice
• type TsdbQuery
• type TsdbQueryEndpoint

Functions

func ConvertSqlTimeColumnToEpochMs

func ConvertSqlTimeColumnToEpochMs(values RowValues, timeIndex int)

ConvertSqlTimeColumnToEpochMs converts column named time to unix timestamp in milliseconds to make native datetime types and epoch dates work in annotation and table queries.

func ConvertSqlValueColumnToFloat

func ConvertSqlValueColumnToFloat(columnName string, columnValue interface{}) (null.Float, error)

ConvertSqlValueColumnToFloat converts timeseries value column to float.

func EpochPrecisionToMs

func EpochPrecisionToMs(value float64) float64

EpochPrecisionToMs converts epoch precision to millisecond, if needed. Only seconds to milliseconds supported right now

func GetIntervalFrom

func GetIntervalFrom(dsInfo *models.DataSource, queryModel *simplejson.Json, defaultInterval time.Duration) (time.Duration, error)

func NewIntervalCalculator

func NewIntervalCalculator(opt *IntervalOptions) *intervalCalculator

func RegisterTsdbQueryEndpoint

func RegisterTsdbQueryEndpoint(pluginId string, fn GetTsdbQueryEndpointFn)

Types

type DefaultSqlEngine

type DefaultSqlEngine struct {
	MacroEngine SqlMacroEngine
	XormEngine  *xorm.Engine
}

func (*DefaultSqlEngine) InitEngine

func (e *DefaultSqlEngine) InitEngine(driverName string, dsInfo *models.DataSource, cnnstr string) error

InitEngine creates the db connection and inits the xorm engine or loads it from the engine cache

func (*DefaultSqlEngine) Query

func (e *DefaultSqlEngine) Query(
	ctx context.Context,
	dsInfo *models.DataSource,
	tsdbQuery *TsdbQuery,
	transformToTimeSeries func(query *Query, rows *core.Rows, result *QueryResult, tsdbQuery *TsdbQuery) error,
	transformToTable func(query *Query, rows *core.Rows, result *QueryResult, tsdbQuery *TsdbQuery) error,
) (*Response, error)

Query is a default implementation of the Query method for an SQL data source. The caller of this function must implement transformToTimeSeries and transformToTable and pass them in as parameters.

type GetTsdbQueryEndpointFn

type GetTsdbQueryEndpointFn func(dsInfo *models.DataSource) (TsdbQueryEndpoint, error)

type HandleRequestFunc

type HandleRequestFunc func(ctx context.Context, dsInfo *models.DataSource, req *TsdbQuery) (*Response, error)

type Interval

type Interval struct {
	Text  string
	Value time.Duration
}

type IntervalCalculator

type IntervalCalculator interface {
	Calculate(timeRange *TimeRange, minInterval time.Duration) Interval
}

type IntervalOptions

type IntervalOptions struct {
	MinInterval time.Duration
}

type Query

type Query struct {
	RefId         string
	Model         *simplejson.Json
	DataSource    *models.DataSource
	MaxDataPoints int64
	IntervalMs    int64
}

type QueryResult

type QueryResult struct {
	Error       error            `json:"-"`
	ErrorString string           `json:"error,omitempty"`
	RefId       string           `json:"refId"`
	Meta        *simplejson.Json `json:"meta,omitempty"`
	Series      TimeSeriesSlice  `json:"series"`
	Tables      []*Table         `json:"tables"`
}

func NewQueryResult

func NewQueryResult() *QueryResult

type Response

type Response struct {
	Results map[string]*QueryResult `json:"results"`
	Message string                  `json:"message,omitempty"`
}

func HandleRequest

func HandleRequest(ctx context.Context, dsInfo *models.DataSource, req *TsdbQuery) (*Response, error)

type RowValues

type RowValues []interface{}

type SqlEngine

type SqlEngine interface {
	InitEngine(driverName string, dsInfo *models.DataSource, cnnstr string) error
	Query(
		ctx context.Context,
		ds *models.DataSource,
		query *TsdbQuery,
		transformToTimeSeries func(query *Query, rows *core.Rows, result *QueryResult, tsdbQuery *TsdbQuery) error,
		transformToTable func(query *Query, rows *core.Rows, result *QueryResult, tsdbQuery *TsdbQuery) error,
	) (*Response, error)
}

SqlEngine is a wrapper class around xorm for relational database data sources.

type SqlMacroEngine

type SqlMacroEngine interface {
	Interpolate(query *Query, timeRange *TimeRange, sql string) (string, error)
}

SqlMacroEngine interpolates macros into sql. It takes in the Query to have access to query context and timeRange to be able to generate queries that use from and to.

type Table

type Table struct {
	Columns []TableColumn `json:"columns"`
	Rows    []RowValues   `json:"rows"`
}

type TableColumn

type TableColumn struct {
	Text string `json:"text"`
}

type TimePoint

type TimePoint [2]null.Float

func NewTimePoint

func NewTimePoint(value null.Float, timestamp float64) TimePoint

type TimeRange

type TimeRange struct {
	From string
	To   string
	// contains filtered or unexported fields
}

func NewFakeTimeRange

func NewFakeTimeRange(from, to string, now time.Time) *TimeRange

func NewTimeRange

func NewTimeRange(from, to string) *TimeRange

func (*TimeRange) GetFromAsMsEpoch

func (tr *TimeRange) GetFromAsMsEpoch() int64

func (*TimeRange) GetFromAsSecondsEpoch

func (tr *TimeRange) GetFromAsSecondsEpoch() int64

func (*TimeRange) GetFromAsTimeUTC

func (tr *TimeRange) GetFromAsTimeUTC() time.Time

func (*TimeRange) GetToAsMsEpoch

func (tr *TimeRange) GetToAsMsEpoch() int64

func (*TimeRange) GetToAsSecondsEpoch

func (tr *TimeRange) GetToAsSecondsEpoch() int64

func (*TimeRange) GetToAsTimeUTC

func (tr *TimeRange) GetToAsTimeUTC() time.Time

func (*TimeRange) MustGetFrom

func (tr *TimeRange) MustGetFrom() time.Time

func (*TimeRange) MustGetTo

func (tr *TimeRange) MustGetTo() time.Time

func (*TimeRange) ParseFrom

func (tr *TimeRange) ParseFrom() (time.Time, error)

func (*TimeRange) ParseTo

func (tr *TimeRange) ParseTo() (time.Time, error)

type TimeSeries

type TimeSeries struct {
	Name   string            `json:"name"`
	Points TimeSeriesPoints  `json:"points"`
	Tags   map[string]string `json:"tags,omitempty"`
}

func NewTimeSeries

func NewTimeSeries(name string, points TimeSeriesPoints) *TimeSeries

type TimeSeriesPoints

type TimeSeriesPoints []TimePoint

func NewTimeSeriesPointsFromArgs

func NewTimeSeriesPointsFromArgs(values ...float64) TimeSeriesPoints

type TimeSeriesSlice

type TimeSeriesSlice []*TimeSeries

type TsdbQuery

type TsdbQuery struct {
	TimeRange *TimeRange
	Queries   []*Query
}

type TsdbQueryEndpoint

type TsdbQueryEndpoint interface {
	Query(ctx context.Context, ds *models.DataSource, query *TsdbQuery) (*Response, error)
}