// 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") } }