IntenseWebs/grafana
3
0
Fork 0
mirror of https://github.com/grafana/grafana.git synced 2025-02-25 18:55:37 -06:00
Code Issues Packages Projects Releases Wiki Activity

chore(tsdb): tidy up code

Browse Source
This commit is contained in:
bergquist 2016-10-10 11:58:06 +02:00
parent b841e649ab
commit 8d96262106
5 changed files with 45 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pkg/tsdb/influxdb/influxdb.go
View File

@ -127,6 +127,6 @@ func (e *InfluxDBExecutor) createRequest(query string) (*http.Request, error) {
req.SetBasicAuth(e.BasicAuthUser, e.BasicAuthPassword)
}
glog.Debug("influxdb request", "url", req.URL.String())
glog.Debug("Influxdb request", "url", req.URL.String())
return req, nil
}

1
pkg/tsdb/influxdb/model_parser.go
View File

@ -134,7 +134,6 @@ func (*InfluxdbQueryParser) parseQueryPart(model *simplejson.Json) (*QueryPart,
}
return qp, nil
//return &QueryPart{Type: typ, Params: params}, nil
}
func (qp *InfluxdbQueryParser) parseGroupBy(model *simplejson.Json) ([]*QueryPart, error) {

34
pkg/tsdb/influxdb/query_builder.go
View File

@ -9,7 +9,17 @@ import (
type QueryBuilder struct{}
func renderTags(query *Query) []string {
func (qb *QueryBuilder) Build(query *Query, queryContext *tsdb.QueryContext) (string, error) {
res := qb.renderSelectors(query, queryContext)
res += qb.renderMeasurement(query)
res += qb.renderWhereClause(query)
res += qb.renderTimeFilter(query, queryContext)
res += qb.renderGroupBy(query, queryContext)
return res, nil
}
func (qb *QueryBuilder) renderTags(query *Query) []string {
var res []string
for i, tag := range query.Tags {
str := ""
@ -29,17 +39,7 @@ func renderTags(query *Query) []string {
return res
}
func (*QueryBuilder) Build(query *Query, queryContext *tsdb.QueryContext) (string, error) {
res := renderSelectors(query, queryContext)
res += renderMeasurement(query)
res += renderWhereClause(query)
res += renderTimeFilter(query, queryContext)
res += renderGroupBy(query, queryContext)
return res, nil
}
func renderTimeFilter(query *Query, queryContext *tsdb.QueryContext) string {
func (qb *QueryBuilder) renderTimeFilter(query *Query, queryContext *tsdb.QueryContext) string {
from := "now() - " + queryContext.TimeRange.From
to := ""
@ -50,7 +50,7 @@ func renderTimeFilter(query *Query, queryContext *tsdb.QueryContext) string {
return fmt.Sprintf("time > %s%s", from, to)
}
func renderSelectors(query *Query, queryContext *tsdb.QueryContext) string {
func (qb *QueryBuilder) renderSelectors(query *Query, queryContext *tsdb.QueryContext) string {
res := "SELECT "
var selectors []string
@ -66,7 +66,7 @@ func renderSelectors(query *Query, queryContext *tsdb.QueryContext) string {
return res + strings.Join(selectors, ", ")
}
func renderMeasurement(query *Query) string {
func (qb *QueryBuilder) renderMeasurement(query *Query) string {
policy := ""
if query.Policy == "" || query.Policy == "default" {
policy = ""
@ -76,9 +76,9 @@ func renderMeasurement(query *Query) string {
return fmt.Sprintf(` FROM %s"%s"`, policy, query.Measurement)
}
func renderWhereClause(query *Query) string {
func (qb *QueryBuilder) renderWhereClause(query *Query) string {
res := " WHERE "
conditions := renderTags(query)
conditions := qb.renderTags(query)
res += strings.Join(conditions, " ")
if len(conditions) > 0 {
res += " AND "
@ -87,7 +87,7 @@ func renderWhereClause(query *Query) string {
return res
}
func renderGroupBy(query *Query, queryContext *tsdb.QueryContext) string {
func (qb *QueryBuilder) renderGroupBy(query *Query, queryContext *tsdb.QueryContext) string {
groupBy := ""
for i, group := range query.GroupBy {
if i == 0 {

5
pkg/tsdb/influxdb/query_builder_test.go
View File

@ -56,15 +56,16 @@ func TestInfluxdbQueryBuilder(t *testing.T) {
Convey("can render time range", func() {
query := Query{}
builder := &QueryBuilder{}
Convey("render from: 2h to now-1h", func() {
query := Query{}
queryContext := &tsdb.QueryContext{TimeRange: tsdb.NewTimeRange("2h", "now-1h")}
So(renderTimeFilter(&query, queryContext), ShouldEqual, "time > now() - 2h and time < now() - 1h")
So(builder.renderTimeFilter(&query, queryContext), ShouldEqual, "time > now() - 2h and time < now() - 1h")
})
Convey("render from: 10m", func() {
queryContext := &tsdb.QueryContext{TimeRange: tsdb.NewTimeRange("10m", "now")}
So(renderTimeFilter(&query, queryContext), ShouldEqual, "time > now() - 10m")
So(builder.renderTimeFilter(&query, queryContext), ShouldEqual, "time > now() - 10m")
})
})
})

42
pkg/tsdb/influxdb/response_parser.go
View File

@ -15,33 +15,39 @@ func (rp *ResponseParser) Parse(response *Response) *tsdb.QueryResult {
queryRes := tsdb.NewQueryResult()
for _, result := range response.Results {
rp.parseResult(result.Series, queryRes)
queryRes.Series = append(queryRes.Series, rp.transformRows(result.Series, queryRes)...)
}
return queryRes
}
func (rp *ResponseParser) parseResult(result []Row, queryResult *tsdb.QueryResult) {
for _, r := range result {
for columnIndex, column := range r.Columns {
func (rp *ResponseParser) transformRows(rows []Row, queryResult *tsdb.QueryResult) tsdb.TimeSeriesSlice {
var result tsdb.TimeSeriesSlice
for _, row := range rows {
for columnIndex, column := range row.Columns {
if column == "time" {
continue
}
var points tsdb.TimeSeriesPoints
for _, k := range r.Values {
points = append(points, rp.parseTimepoint(k, columnIndex))
for _, valuePair := range row.Values {
point, err := rp.parseTimepoint(valuePair, columnIndex)
if err == nil {
points = append(points, point)
}
}
queryResult.Series = append(queryResult.Series, &tsdb.TimeSeries{
Name: rp.formatName(r, column),
result = append(result, &tsdb.TimeSeries{
Name: rp.formatSerieName(row, column),
Points: points,
})
}
}
return result
}
func (rp *ResponseParser) formatName(row Row, column string) string {
func (rp *ResponseParser) formatSerieName(row Row, column string) string {
var tags []string
for k, v := range row.Tags {
@ -56,30 +62,30 @@ func (rp *ResponseParser) formatName(row Row, column string) string {
return fmt.Sprintf("%s.%s%s", row.Name, column, tagText)
}
func (rp *ResponseParser) parseTimepoint(k []interface{}, valuePosition int) tsdb.TimePoint {
var value null.Float = rp.parseValue(k[valuePosition])
func (rp *ResponseParser) parseTimepoint(valuePair []interface{}, valuePosition int) (tsdb.TimePoint, error) {
var value null.Float = rp.parseValue(valuePair[valuePosition])
timestampNumber, _ := k[0].(json.Number)
timestampNumber, _ := valuePair[0].(json.Number)
timestamp, err := timestampNumber.Float64()
if err != nil {
glog.Error("Invalid timestamp format. This should never happen!")
return tsdb.TimePoint{}, err
}
return tsdb.NewTimePoint(value, timestamp)
return tsdb.NewTimePoint(value, timestamp), nil
}
func (rp *ResponseParser) parseValue(value interface{}) null.Float {
num, ok := value.(json.Number)
number, ok := value.(json.Number)
if !ok {
return null.FloatFromPtr(nil)
}
fvalue, err := num.Float64()
fvalue, err := number.Float64()
if err == nil {
return null.FloatFrom(fvalue)
}
ivalue, err := num.Int64()
ivalue, err := number.Int64()
if err == nil {
return null.FloatFrom(float64(ivalue))
}