// ToFloat converts a value of this type to a float64
// ToFloat panics if this type doesn't support conversion to float64
func (t Type) ToFloat(x interface{}) float64 {
switch t {
case Int8:
return float64(x.(int8))
case Int16:
return float64(x.(int16))
case Int32:
return float64(x.(int32))
case Int64:
return float64(x.(int64))
case Uint8:
return float64(x.(uint8))
case Uint16:
return float64(x.(uint16))
case Uint32:
return float64(x.(uint32))
case Uint64:
return float64(x.(uint64))
case Float32:
return float64(x.(float32))
case Float64:
return x.(float64)
case GoTime:
return duration.TimeToFloat(x.(time.Time))
case GoDuration:
return duration.ToFloat(x.(time.Duration))
default:
panic("Type doesn't support conversion to float")
}
}
func query(
request *tsdbjson.QueryRequest,
endpoints *datastructs.ApplicationStatuses,
minDownSampleTime time.Duration) (
result []tsdbjson.TimeSeries, err error) {
parsedQueries, err := tsdbjson.ParseQueryRequest(request)
if err != nil {
return
}
var allSeries []tsdbjson.TimeSeries
for i := range parsedQueries {
var options tsdbimpl.QueryOptions
options.HostNameFilter, err = newTagFilter(
parsedQueries[i].Options.HostNameFilter)
if err != nil {
return
}
options.AppNameFilter, err = newTagFilter(
parsedQueries[i].Options.AppNameFilter)
if err != nil {
return
}
options.GroupByAppName = parsedQueries[i].Options.GroupByAppName
options.GroupByHostName = parsedQueries[i].Options.GroupByHostName
if parsedQueries[i].Aggregator.DownSample == nil {
return nil, tsdbjson.ErrUnsupportedAggregator
}
ensureDurationAtLeast(
duration.ToFloat(minDownSampleTime),
&parsedQueries[i].Aggregator.DownSample)
var aggregatorGen tsdb.AggregatorGenerator
aggregatorGen, err = tsdbjson.NewAggregatorGenerator(
parsedQueries[i].Aggregator.Type,
parsedQueries[i].Aggregator.DownSample,
parsedQueries[i].Aggregator.RateOptions,
)
if err != nil {
return
}
var series *tsdb.TaggedTimeSeriesSet
series, err = tsdbimpl.Query(
endpoints,
parsedQueries[i].Metric,
aggregatorGen,
parsedQueries[i].Start,
parsedQueries[i].End,
&options)
if err != nil {
return
}
allSeries = append(allSeries, tsdbjson.NewTimeSeriesSlice(series)...)
}
if allSeries == nil {
return make([]tsdbjson.TimeSeries, 0), nil
}
return allSeries, nil
}
func parseDownSample(downSampleStr string) (result *DownSampleSpec, err error) {
// down sample is optional.
if downSampleStr == "" {
return
}
components := strings.SplitN(downSampleStr, "-", 3)
if len(components) < 2 {
err = ErrBadValue
return
}
dur, err := time.ParseDuration(components[0])
if err != nil {
return
}
var spec DownSampleSpec
spec.DurationInSeconds = duration.ToFloat(dur)
spec.Type = components[1]
if len(components) == 3 {
spec.Fill = components[2]
}
return &spec, nil
}
func asFloat64(r *pstore.Record) float64 {
switch r.Kind {
case types.Bool:
if r.Value.(bool) {
return 1.0
}
return 0.0
case types.Int8:
return float64(r.Value.(int8))
case types.Int16:
return float64(r.Value.(int16))
case types.Int32:
return float64(r.Value.(int32))
case types.Int64:
return float64(r.Value.(int64))
case types.Uint8:
return float64(r.Value.(uint8))
case types.Uint16:
return float64(r.Value.(uint16))
case types.Uint32:
return float64(r.Value.(uint32))
case types.Uint64:
return float64(r.Value.(uint64))
case types.Float32:
return float64(r.Value.(float32))
case types.Float64:
return r.Value.(float64)
case types.GoTime:
return duration.TimeToFloat(r.Value.(time.Time))
case types.GoDuration:
return duration.ToFloat(
r.Value.(time.Duration)) * units.FromSeconds(
r.Unit)
default:
panic("Unsupported type")
}
}