Add sortBy, sortByMaxima, and sortByTotal functions

docs/graphite.md

@@ -32,7 +32,7 @@ Here are the currently included functions:
 | alias(seriesList, alias) seriesList                            |             | Stable     |
 | aliasByNode(seriesList, nodeList) seriesList                   | aliasByTags | Stable     |
 | aliasSub(seriesList, pattern, replacement) seriesList          |             | Stable     |
-| asPercent(seriesList, seriesList, nodeList) seriesList |             | Stable     |
+| asPercent(seriesList, seriesList, nodeList) seriesList         |             | Stable     |
 | averageSeries(seriesLists) series                              | avg         | Stable     |
 | consolidateBy(seriesList, func) seriesList                     |             | Stable     |
 | countSeries(seriesLists) series                                |             | Stable     |
@@ -62,7 +62,11 @@ Here are the currently included functions:
 | removeAboveValue(seriesList, n) seriesList                     |             | Stable     |
 | removeBelowValue(seriesList, n) seriesList                     |             | Stable     |
 | scale(seriesList, num) series                                  |             | Stable     |
-| scaleToSeconds(seriesList, seconds) series                     |             | Stable     |
+| scaleToSeconds(seriesList, seconds) seriesList                 |             | Stable     |
+| sortBy(seriesList, func, reverse) seriesList                   |             | Stable     |
+| sortByMaxima(seriesList) seriesList                            |             | Stable     |
+| sortByName(seriesList, natural, reverse) seriesList            |             | Stable     |
+| sortByTotal(seriesList) seriesList                             |             | Stable     |
 | stddevSeries(seriesList) series                                |             | Stable     |
 | sumSeries(seriesLists) series                                  | sum         | Stable     |
 | summarize(seriesList) seriesList                               |             | Stable     |

expr/func_highestlowest.go

@@ -1,9 +1,6 @@
 package expr
 
 import (
-	"math"
-	"sort"
-
 	"github.com/grafana/metrictank/consolidation"
 
 	"github.com/grafana/metrictank/api/models"
@@ -40,11 +37,6 @@ func (s *FuncHighestLowest) Context(context Context) Context {
 	return context
 }
 
-type ScoredSeries struct {
-	score float64
-	serie models.Series
-}
-
 func (s *FuncHighestLowest) Exec(cache map[Req][]models.Series) ([]models.Series, error) {
 	series, err := s.in.Exec(cache)
 	if err != nil {
@@ -55,33 +47,11 @@ func (s *FuncHighestLowest) Exec(cache map[Req][]models.Series) ([]models.Series
 		return series, nil
 	}
 
-	consolidationFunc := consolidation.GetAggFunc(consolidation.FromConsolidateBy(s.fn))
-
-	// score series by their consolidated value
-	scored := make([]ScoredSeries, len(series))
-	for i, serie := range series {
-		scored[i] = ScoredSeries{
-			score: consolidationFunc(serie.Datapoints),
-			serie: serie,
-		}
-	}
-
-	sort.SliceStable(scored, func(i, j int) bool {
-		iVal := scored[i].score
-		jVal := scored[j].score
-		if s.highest {
-			return math.IsNaN(jVal) && !math.IsNaN(iVal) || iVal > jVal
-		}
-		return math.IsNaN(jVal) && !math.IsNaN(iVal) || iVal < jVal
-	})
+	SortSeriesWithConsolidator(series, consolidation.FromConsolidateBy(s.fn), s.highest)
 
 	if s.n > int64(len(series)) {
 		s.n = int64(len(series))
 	}
 
-	for i := 0; i < int(s.n); i++ {
-		series[i] = scored[i].serie
-	}
-
 	return series[:s.n], nil
 }

expr/func_sortby.go

@@ -0,0 +1,80 @@
+package expr
+
+import (
+	"math"
+	"sort"
+
+	"github.com/grafana/metrictank/consolidation"
+
+	"github.com/grafana/metrictank/api/models"
+)
+
+type FuncSortBy struct {
+	in      GraphiteFunc
+	fn      string
+	reverse bool
+}
+
+func NewSortByConstructor(fn string, reverse bool) func() GraphiteFunc {
+	return func() GraphiteFunc {
+		return &FuncSortBy{fn: fn, reverse: reverse}
+	}
+}
+
+func (s *FuncSortBy) Signature() ([]Arg, []Arg) {
+	if s.fn != "" {
+		return []Arg{
+			ArgSeriesList{val: &s.in},
+		}, []Arg{ArgSeriesList{}}
+	}
+	return []Arg{
+		ArgSeriesList{val: &s.in},
+		ArgString{key: "func", val: &s.fn, validator: []Validator{IsConsolFunc}},
+		ArgBool{key: "reverse", val: &s.reverse, opt: true},
+	}, []Arg{ArgSeriesList{}}
+}
+
+func (s *FuncSortBy) Context(context Context) Context {
+	return context
+}
+
+func (s *FuncSortBy) Exec(cache map[Req][]models.Series) ([]models.Series, error) {
+	series, err := s.in.Exec(cache)
+	if err != nil {
+		return nil, err
+	}
+
+	SortSeriesWithConsolidator(series, consolidation.FromConsolidateBy(s.fn), s.reverse)
+
+	return series, nil
+}
+
+type ScoredSeries struct {
+	score float64
+	serie models.Series
+}
+
+func SortSeriesWithConsolidator(series []models.Series, c consolidation.Consolidator, reverse bool) {
+	consolidationFunc := consolidation.GetAggFunc(c)
+	// score series by their consolidated value
+	scored := make([]ScoredSeries, len(series))
+	for i, serie := range series {
+		scored[i] = ScoredSeries{
+			score: consolidationFunc(serie.Datapoints),
+			serie: serie,
+		}
+	}
+
+	sort.SliceStable(scored, func(i, j int) bool {
+		iVal := scored[i].score
+		jVal := scored[j].score
+		if reverse {
+			return math.IsNaN(jVal) && !math.IsNaN(iVal) || iVal > jVal
+		}
+		return math.IsNaN(iVal) && !math.IsNaN(jVal) || iVal < jVal
+	})
+
+	for i := range scored {
+		series[i] = scored[i].serie
+	}
+}