RepoMirrors
/
prometheus
mirror of https://github.com/prometheus/prometheus
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
prometheus/rules/rules_test.go

1740 lines
55 KiB
Go
Raw Normal View History

Clean up license issues. - Move CONTRIBUTORS.md to the more common AUTHORS. - Added the required NOTICE file. - Changed "Prometheus Team" to "The Prometheus Authors". - Reverted the erroneous changes to the Apache License.
2015-01-21 19:07:45 +00:00
// Copyright 2013 The Prometheus Authors
Add copyright notices to all remaining files.
2013-02-07 10:49:04 +00:00
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
package rules
import (
"fmt"
Add the histogram_quantile function. Since we are now getting really deep into floating point calculation, the tests had to take into account the precision loss. Since the rule tests are based on direct line matching in the output, implementing the "almost equal" semantics was pretty cumbersome, but here we are.
2015-02-19 18:56:45 +00:00
"math"
Implement initial no-op alert parsing and rule parsing tests.
2013-04-22 22:26:59 +00:00
"path"
Add the histogram_quantile function. Since we are now getting really deep into floating point calculation, the tests had to take into account the precision loss. Since the rule tests are based on direct line matching in the output, implementing the "almost equal" semantics was pretty cumbersome, but here we are.
2015-02-19 18:56:45 +00:00
"regexp"
"strconv"
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
"strings"
"testing"
Use AST query analyzer and views with tiered storage.
2013-03-21 17:06:15 +00:00
"time"
WIP - Snapshot of Moving to Client Model.
2013-06-25 12:02:27 +00:00
clientmodel "github.com/prometheus/client_golang/model"
"github.com/prometheus/prometheus/rules/ast"
"github.com/prometheus/prometheus/stats"
Initial experimental snapshot of next-gen storage. Change-Id: Ifb8709960dbedd1d9f5efd88cdd359ee9fa9d26d
2014-06-06 09:55:53 +00:00
"github.com/prometheus/prometheus/storage/local"
Add regression tests for metrics mutations in AST. It turned out in the end, that only drop_common_metrics() produced any erroneous output in the old system. The second expression in the test ("sum(testmetric) keeping_extra") already worked in the old code, but why not keep it in... The way to test ranged evaluations is a bit clumsy so far, so I want to build a nicer test framework in the end, where all the test cases can be specified as text files which specify desired inputs, outputs, query step widths, etc. Change-Id: I821859789e69b8232bededf670a1b76e9e8c8ca4
2014-12-12 19:01:32 +00:00
"github.com/prometheus/prometheus/storage/metric"
WIP - Snapshot of Moving to Client Model.
2013-06-25 12:02:27 +00:00
"github.com/prometheus/prometheus/utility/test"
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
)
Implement initial no-op alert parsing and rule parsing tests.
2013-04-22 22:26:59 +00:00
var (
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
testEvalTime = testStartTime.Add(testSampleInterval * 10)
Implement initial no-op alert parsing and rule parsing tests.
2013-04-22 22:26:59 +00:00
fixturesPath = "fixtures"
Add the histogram_quantile function. Since we are now getting really deep into floating point calculation, the tests had to take into account the precision loss. Since the rule tests are based on direct line matching in the output, implementing the "almost equal" semantics was pretty cumbersome, but here we are.
2015-02-19 18:56:45 +00:00
Add ln, log2, log10 and exp functions to the query language.
2015-03-16 14:57:47 +00:00
reSample = regexp.MustCompile(`^(.*)(?: \=\>|:) (\-?\d+\.?\d*(?:e-?\d*)?|[+-]Inf|NaN) \@\[(\d+)\]$`)
Add the histogram_quantile function. Since we are now getting really deep into floating point calculation, the tests had to take into account the precision loss. Since the rule tests are based on direct line matching in the output, implementing the "almost equal" semantics was pretty cumbersome, but here we are.
2015-02-19 18:56:45 +00:00
minNormal = math.Float64frombits(0x0010000000000000) // The smallest positive normal value of type float64.
)
const (
epsilon = 0.000001 // Relative error allowed for sample values.
Implement initial no-op alert parsing and rule parsing tests.
2013-04-22 22:26:59 +00:00
)
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
Use custom timestamp type for sample timestamps and related code. So far we've been using Go's native time.Time for anything related to sample timestamps. Since the range of time.Time is much bigger than what we need, this has created two problems: - there could be time.Time values which were out of the range/precision of the time type that we persist to disk, therefore causing incorrectly ordered keys. One bug caused by this was: https://github.com/prometheus/prometheus/issues/367 It would be good to use a timestamp type that's more closely aligned with what the underlying storage supports. - sizeof(time.Time) is 192, while Prometheus should be ok with a single 64-bit Unix timestamp (possibly even a 32-bit one). Since we store samples in large numbers, this seriously affects memory usage. Furthermore, copying/working with the data will be faster if it's smaller. *MEMORY USAGE RESULTS* Initial memory usage comparisons for a running Prometheus with 1 timeseries and 100,000 samples show roughly a 13% decrease in total (VIRT) memory usage. In my tests, this advantage for some reason decreased a bit the more samples the timeseries had (to 5-7% for millions of samples). This I can't fully explain, but perhaps garbage collection issues were involved. *WHEN TO USE THE NEW TIMESTAMP TYPE* The new clientmodel.Timestamp type should be used whenever time calculations are either directly or indirectly related to sample timestamps. For example: - the timestamp of a sample itself - all kinds of watermarks - anything that may become or is compared to a sample timestamp (like the timestamp passed into Target.Scrape()). When to still use time.Time: - for measuring durations/times not related to sample timestamps, like duration telemetry exporting, timers that indicate how frequently to execute some action, etc. *NOTE ON OPERATOR OPTIMIZATION TESTS* We don't use operator optimization code anymore, but it still lives in the code as dead code. It still has tests, but I couldn't get all of them to pass with the new timestamp format. I commented out the failing cases for now, but we should probably remove the dead code soon. I just didn't want to do that in the same change as this. Change-Id: I821787414b0debe85c9fffaeb57abd453727af0f
2013-10-28 13:35:02 +00:00
func annotateWithTime(lines []string, timestamp clientmodel.Timestamp) []string {
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
annotatedLines := []string{}
for _, line := range lines {
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
annotatedLines = append(annotatedLines, fmt.Sprintf(line, timestamp))
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
}
return annotatedLines
}
func vectorComparisonString(expected []string, actual []string) string {
separator := "\n--------------\n"
return fmt.Sprintf("Expected:%v%v%v\nActual:%v%v%v ",
separator,
strings.Join(expected, "\n"),
separator,
separator,
strings.Join(actual, "\n"),
separator)
}
Add the histogram_quantile function. Since we are now getting really deep into floating point calculation, the tests had to take into account the precision loss. Since the rule tests are based on direct line matching in the output, implementing the "almost equal" semantics was pretty cumbersome, but here we are.
2015-02-19 18:56:45 +00:00
// samplesAlmostEqual returns true if the two sample lines only differ by a
// small relative error in their sample value.
func samplesAlmostEqual(a, b string) bool {
if a == b {
// Fast path if strings are equal.
return true
}
aMatches := reSample.FindStringSubmatch(a)
if aMatches == nil {
panic(fmt.Errorf("sample %q did not match regular expression", a))
}
bMatches := reSample.FindStringSubmatch(b)
if bMatches == nil {
panic(fmt.Errorf("sample %q did not match regular expression", b))
}
if aMatches[1] != bMatches[1] {
return false // Labels don't match.
}
Also support parsing float formats like "2.".
2015-03-01 21:49:06 +00:00
if aMatches[3] != bMatches[3] {
Add the histogram_quantile function. Since we are now getting really deep into floating point calculation, the tests had to take into account the precision loss. Since the rule tests are based on direct line matching in the output, implementing the "almost equal" semantics was pretty cumbersome, but here we are.
2015-02-19 18:56:45 +00:00
return false // Timestamps don't match.
}
// If we are here, we have the diff in the floats.
// We have to check if they are almost equal.
Also support parsing float formats like "2.".
2015-03-01 21:49:06 +00:00
aVal, err := strconv.ParseFloat(aMatches[2], 64)
Add the histogram_quantile function. Since we are now getting really deep into floating point calculation, the tests had to take into account the precision loss. Since the rule tests are based on direct line matching in the output, implementing the "almost equal" semantics was pretty cumbersome, but here we are.
2015-02-19 18:56:45 +00:00
if err != nil {
panic(err)
}
Also support parsing float formats like "2.".
2015-03-01 21:49:06 +00:00
bVal, err := strconv.ParseFloat(bMatches[2], 64)
Add the histogram_quantile function. Since we are now getting really deep into floating point calculation, the tests had to take into account the precision loss. Since the rule tests are based on direct line matching in the output, implementing the "almost equal" semantics was pretty cumbersome, but here we are.
2015-02-19 18:56:45 +00:00
if err != nil {
panic(err)
}
// Cf. http://floating-point-gui.de/errors/comparison/
if aVal == bVal {
return true
}
diff := math.Abs(aVal - bVal)
if aVal == 0 || bVal == 0 || diff < minNormal {
return diff < epsilon*minNormal
}
return diff/(math.Abs(aVal)+math.Abs(bVal)) < epsilon
}
Fix and improve the fp locker. Benchmark: $ go test -bench 'Fingerprint' -test.run 'Fingerprint' -test.cpu=1,2,4 OLD BenchmarkFingerprintLockerParallel 500000 3618 ns/op BenchmarkFingerprintLockerParallel-2 100000 12257 ns/op BenchmarkFingerprintLockerParallel-4 500000 10164 ns/op BenchmarkFingerprintLockerSerial 10000000 283 ns/op BenchmarkFingerprintLockerSerial-2 10000000 284 ns/op BenchmarkFingerprintLockerSerial-4 10000000 288 ns/op NEW BenchmarkFingerprintLockerParallel 1000000 1018 ns/op BenchmarkFingerprintLockerParallel-2 1000000 1164 ns/op BenchmarkFingerprintLockerParallel-4 2000000 910 ns/op BenchmarkFingerprintLockerSerial 50000000 56.0 ns/op BenchmarkFingerprintLockerSerial-2 50000000 47.9 ns/op BenchmarkFingerprintLockerSerial-4 50000000 54.5 ns/op Change-Id: I3c65a43822840e7e64c3c3cfe759e1de51272581
2014-10-08 11:49:42 +00:00
func newTestStorage(t testing.TB) (storage local.Storage, closer test.Closer) {
Implement double-delta encoded chunks.
2015-03-04 12:40:18 +00:00
storage, closer = local.NewTestStorage(t, 1)
Separate storage implementation from interfaces. This was initially motivated by wanting to distribute the rule checker tool under `tools/rule_checker`. However, this was not possible without also distributing the LevelDB dynamic libraries because the tool transitively depended on Levigo: rule checker -> query layer -> tiered storage layer -> leveldb This change separates external storage interfaces from the implementation (tiered storage, leveldb storage, memory storage) by putting them into separate packages: - storage/metric: public, implementation-agnostic interfaces - storage/metric/tiered: tiered storage implementation, including memory and LevelDB storage. I initially also considered splitting up the implementation into separate packages for tiered storage, memory storage, and LevelDB storage, but these are currently so intertwined that it would be another major project in itself. The query layers and most other parts of Prometheus now have notion of the storage implementation anymore and just use whatever implementation they get passed in via interfaces. The rule_checker is now a static binary :) Change-Id: I793bbf631a8648ca31790e7e772ecf9c2b92f7a0
2014-04-11 07:27:05 +00:00
storeMatrix(storage, testMatrix)
Initial experimental snapshot of next-gen storage. Change-Id: Ifb8709960dbedd1d9f5efd88cdd359ee9fa9d26d
2014-06-06 09:55:53 +00:00
return storage, closer
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
}
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
Implement a COUNT ... BY aggregation operator. This also removes the now obsolete scalar count() function and corrects the expressions test naming (broken in https://github.com/prometheus/prometheus/commit/2202cd71c9eb0477e218a7b854db1f35fa5427b9#L6R59) so that the expression tests will actually run.
2013-05-08 14:35:16 +00:00
func TestExpressions(t *testing.T) {
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
// Labels in expected output need to be alphabetically sorted.
Add regression tests for metrics mutations in AST. It turned out in the end, that only drop_common_metrics() produced any erroneous output in the old system. The second expression in the test ("sum(testmetric) keeping_extra") already worked in the old code, but why not keep it in... The way to test ranged evaluations is a bit clumsy so far, so I want to build a nicer test framework in the end, where all the test cases can be specified as text files which specify desired inputs, outputs, query step widths, etc. Change-Id: I821859789e69b8232bededf670a1b76e9e8c8ca4
2014-12-12 19:01:32 +00:00
expressionTests := []struct {
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
expr string
output []string
shouldFail bool
checkOrder bool
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
}{
{
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
expr: `SUM(http_requests)`,
output: []string{`{} => 3600 @[%v]`},
Don't keep extra labels in aggregations by default. MIN/MAX/SUM/AVG/COUNT aggregations will now by default drop all labels that are not specifically part of a BY-clause, even if a label value is the same within all timeseries of an aggregation group. The old behavior of keeping extra labels may still be switched on by adding KEEPING_EXTRA to the end of an aggregation statement: sum(http_requests) by (job, method) keeping_extra I'm open to better syntax/naming suggestions. Change-Id: I21d3fe7af9e98552ce3dffa3ce7c0a4ba4c0b4a4
2013-12-13 18:20:42 +00:00
}, {
expr: `SUM(http_requests{instance="0"}) BY(job)`,
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 400 @[%v]`,
`{job="app-server"} => 1200 @[%v]`,
Don't keep extra labels in aggregations by default. MIN/MAX/SUM/AVG/COUNT aggregations will now by default drop all labels that are not specifically part of a BY-clause, even if a label value is the same within all timeseries of an aggregation group. The old behavior of keeping extra labels may still be switched on by adding KEEPING_EXTRA to the end of an aggregation statement: sum(http_requests) by (job, method) keeping_extra I'm open to better syntax/naming suggestions. Change-Id: I21d3fe7af9e98552ce3dffa3ce7c0a4ba4c0b4a4
2013-12-13 18:20:42 +00:00
},
}, {
expr: `SUM(http_requests{instance="0"}) BY(job) KEEPING_EXTRA`,
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{instance="0", job="api-server"} => 400 @[%v]`,
`{instance="0", job="app-server"} => 1200 @[%v]`,
Don't keep extra labels in aggregations by default. MIN/MAX/SUM/AVG/COUNT aggregations will now by default drop all labels that are not specifically part of a BY-clause, even if a label value is the same within all timeseries of an aggregation group. The old behavior of keeping extra labels may still be switched on by adding KEEPING_EXTRA to the end of an aggregation statement: sum(http_requests) by (job, method) keeping_extra I'm open to better syntax/naming suggestions. Change-Id: I21d3fe7af9e98552ce3dffa3ce7c0a4ba4c0b4a4
2013-12-13 18:20:42 +00:00
},
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `SUM(http_requests) BY (job)`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 1000 @[%v]`,
`{job="app-server"} => 2600 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
Nonexistent labels in BY-clauses shouldn't propagate to result. This fixes bug 2. of https://github.com/prometheus/prometheus/issues/374 Change-Id: Ia4a13153616bafce5bf10597966b071434422d09
2014-01-24 15:05:30 +00:00
}, {
// Non-existent labels mentioned in BY-clauses shouldn't propagate to output.
expr: `SUM(http_requests) BY (job, nonexistent)`,
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 1000 @[%v]`,
`{job="app-server"} => 2600 @[%v]`,
Nonexistent labels in BY-clauses shouldn't propagate to result. This fixes bug 2. of https://github.com/prometheus/prometheus/issues/374 Change-Id: Ia4a13153616bafce5bf10597966b071434422d09
2014-01-24 15:05:30 +00:00
},
Swap rules lexer for much faster one. This swaps github.com/kivikakk/golex for github.com/cznic/golex. The old lexer would have taken 3.5 years to load a set of 5000 test rules (quadratic time complexity for input length), whereas this one takes only 32ms. Furthermore, since the new lexer is embedded differently, this gets rid of the global parser variables and makes the rule loader fully reentrant without a lock.
2013-07-11 16:38:44 +00:00
}, {
expr: `
// Test comment.
SUM(http_requests) BY /* comments shouldn't
have any effect */ (job) // another comment`,
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 1000 @[%v]`,
`{job="app-server"} => 2600 @[%v]`,
Swap rules lexer for much faster one. This swaps github.com/kivikakk/golex for github.com/cznic/golex. The old lexer would have taken 3.5 years to load a set of 5000 test rules (quadratic time complexity for input length), whereas this one takes only 32ms. Furthermore, since the new lexer is embedded differently, this gets rid of the global parser variables and makes the rule loader fully reentrant without a lock.
2013-07-11 16:38:44 +00:00
},
Implement a COUNT ... BY aggregation operator. This also removes the now obsolete scalar count() function and corrects the expressions test naming (broken in https://github.com/prometheus/prometheus/commit/2202cd71c9eb0477e218a7b854db1f35fa5427b9#L6R59) so that the expression tests will actually run.
2013-05-08 14:35:16 +00:00
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `COUNT(http_requests) BY (job)`,
Implement a COUNT ... BY aggregation operator. This also removes the now obsolete scalar count() function and corrects the expressions test naming (broken in https://github.com/prometheus/prometheus/commit/2202cd71c9eb0477e218a7b854db1f35fa5427b9#L6R59) so that the expression tests will actually run.
2013-05-08 14:35:16 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 4 @[%v]`,
`{job="app-server"} => 4 @[%v]`,
Implement a COUNT ... BY aggregation operator. This also removes the now obsolete scalar count() function and corrects the expressions test naming (broken in https://github.com/prometheus/prometheus/commit/2202cd71c9eb0477e218a7b854db1f35fa5427b9#L6R59) so that the expression tests will actually run.
2013-05-08 14:35:16 +00:00
},
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `SUM(http_requests) BY (job, group)`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{group="canary", job="api-server"} => 700 @[%v]`,
`{group="canary", job="app-server"} => 1500 @[%v]`,
`{group="production", job="api-server"} => 300 @[%v]`,
`{group="production", job="app-server"} => 1100 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `AVG(http_requests) BY (job)`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 250 @[%v]`,
`{job="app-server"} => 650 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `MIN(http_requests) BY (job)`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 100 @[%v]`,
`{job="app-server"} => 500 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `MAX(http_requests) BY (job)`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 400 @[%v]`,
`{job="app-server"} => 800 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `SUM(http_requests) BY (job) - COUNT(http_requests) BY (job)`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 996 @[%v]`,
`{job="app-server"} => 2596 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
Allow reversing vector and scalar arguments in binops. This allows putting a scalar as the first argument of a binary operator in which the second argument is a vector: <scalar> <binop> <vector> For example, 1 / http_requests_total ...will output a vector in which every sample value is 1 divided by the respective input vector element. This even works for filter binary operators now: 1 == http_requests_total Returns a vector with all values set to 1 for every element in http_requests_total whose initial value was 1. Note: For filter binary operators, the resulting values are always taken from the left-hand-side of the operation, no matter whether the scalar or the vector argument is the left-hand-side. That is, 1 != http_requests_total ...will set all result vector sample values to 1, although these are exactly the sample elements that were != 1 in the input vector. If you want to just filter elements without changing their sample values, you still need to do: http_requests_total != 1 The new filter form is a bit exotic, and so probably won't be used often. But it was easier to implement it than disallow it completely or change its behavior. Change-Id: Idd083f2bd3a1219ba1560cf4ace42f5b82e797a5
2014-04-08 14:14:35 +00:00
}, {
expr: `2 - SUM(http_requests) BY (job)`,
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => -998 @[%v]`,
`{job="app-server"} => -2598 @[%v]`,
Allow reversing vector and scalar arguments in binops. This allows putting a scalar as the first argument of a binary operator in which the second argument is a vector: <scalar> <binop> <vector> For example, 1 / http_requests_total ...will output a vector in which every sample value is 1 divided by the respective input vector element. This even works for filter binary operators now: 1 == http_requests_total Returns a vector with all values set to 1 for every element in http_requests_total whose initial value was 1. Note: For filter binary operators, the resulting values are always taken from the left-hand-side of the operation, no matter whether the scalar or the vector argument is the left-hand-side. That is, 1 != http_requests_total ...will set all result vector sample values to 1, although these are exactly the sample elements that were != 1 in the input vector. If you want to just filter elements without changing their sample values, you still need to do: http_requests_total != 1 The new filter form is a bit exotic, and so probably won't be used often. But it was easier to implement it than disallow it completely or change its behavior. Change-Id: Idd083f2bd3a1219ba1560cf4ace42f5b82e797a5
2014-04-08 14:14:35 +00:00
},
}, {
expr: `1000 / SUM(http_requests) BY (job)`,
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 1 @[%v]`,
`{job="app-server"} => 0.38461538461538464 @[%v]`,
Allow reversing vector and scalar arguments in binops. This allows putting a scalar as the first argument of a binary operator in which the second argument is a vector: <scalar> <binop> <vector> For example, 1 / http_requests_total ...will output a vector in which every sample value is 1 divided by the respective input vector element. This even works for filter binary operators now: 1 == http_requests_total Returns a vector with all values set to 1 for every element in http_requests_total whose initial value was 1. Note: For filter binary operators, the resulting values are always taken from the left-hand-side of the operation, no matter whether the scalar or the vector argument is the left-hand-side. That is, 1 != http_requests_total ...will set all result vector sample values to 1, although these are exactly the sample elements that were != 1 in the input vector. If you want to just filter elements without changing their sample values, you still need to do: http_requests_total != 1 The new filter form is a bit exotic, and so probably won't be used often. But it was easier to implement it than disallow it completely or change its behavior. Change-Id: Idd083f2bd3a1219ba1560cf4ace42f5b82e797a5
2014-04-08 14:14:35 +00:00
},
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `SUM(http_requests) BY (job) - 2`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 998 @[%v]`,
`{job="app-server"} => 2598 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `SUM(http_requests) BY (job) % 3`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 1 @[%v]`,
`{job="app-server"} => 2 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `SUM(http_requests) BY (job) / 0`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => +Inf @[%v]`,
`{job="app-server"} => +Inf @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `SUM(http_requests) BY (job) > 1000`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="app-server"} => 2600 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
Allow reversing vector and scalar arguments in binops. This allows putting a scalar as the first argument of a binary operator in which the second argument is a vector: <scalar> <binop> <vector> For example, 1 / http_requests_total ...will output a vector in which every sample value is 1 divided by the respective input vector element. This even works for filter binary operators now: 1 == http_requests_total Returns a vector with all values set to 1 for every element in http_requests_total whose initial value was 1. Note: For filter binary operators, the resulting values are always taken from the left-hand-side of the operation, no matter whether the scalar or the vector argument is the left-hand-side. That is, 1 != http_requests_total ...will set all result vector sample values to 1, although these are exactly the sample elements that were != 1 in the input vector. If you want to just filter elements without changing their sample values, you still need to do: http_requests_total != 1 The new filter form is a bit exotic, and so probably won't be used often. But it was easier to implement it than disallow it completely or change its behavior. Change-Id: Idd083f2bd3a1219ba1560cf4ace42f5b82e797a5
2014-04-08 14:14:35 +00:00
}, {
expr: `1000 < SUM(http_requests) BY (job)`,
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="app-server"} => 1000 @[%v]`,
Allow reversing vector and scalar arguments in binops. This allows putting a scalar as the first argument of a binary operator in which the second argument is a vector: <scalar> <binop> <vector> For example, 1 / http_requests_total ...will output a vector in which every sample value is 1 divided by the respective input vector element. This even works for filter binary operators now: 1 == http_requests_total Returns a vector with all values set to 1 for every element in http_requests_total whose initial value was 1. Note: For filter binary operators, the resulting values are always taken from the left-hand-side of the operation, no matter whether the scalar or the vector argument is the left-hand-side. That is, 1 != http_requests_total ...will set all result vector sample values to 1, although these are exactly the sample elements that were != 1 in the input vector. If you want to just filter elements without changing their sample values, you still need to do: http_requests_total != 1 The new filter form is a bit exotic, and so probably won't be used often. But it was easier to implement it than disallow it completely or change its behavior. Change-Id: Idd083f2bd3a1219ba1560cf4ace42f5b82e797a5
2014-04-08 14:14:35 +00:00
},
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `SUM(http_requests) BY (job) <= 1000`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 1000 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `SUM(http_requests) BY (job) != 1000`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="app-server"} => 2600 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `SUM(http_requests) BY (job) == 1000`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 1000 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `SUM(http_requests) BY (job) + SUM(http_requests) BY (job)`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="api-server"} => 2000 @[%v]`,
`{job="app-server"} => 5200 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `http_requests{job="api-server", group="canary"}`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
`http_requests{group="canary", instance="0", job="api-server"} => 300 @[%v]`,
`http_requests{group="canary", instance="1", job="api-server"} => 400 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
Make 2nd arg to delta optional. Add a deriv() function. The 2nd isCounter argument to delta is ugly, make it optional as the first step of deprecating it. This will makes delta only ever applied to gauges. Add a deriv function to calculate the least squares slope of a gauge. This is more useful for prediction than delta, as it isn't as heavily influenced by outliers at the boundaries.
2015-01-22 11:52:30 +00:00
expr: `http_requests{job="api-server", group="canary"} + rate(http_requests{job="api-server"}[5m]) * 5 * 60`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{group="canary", instance="0", job="api-server"} => 330 @[%v]`,
`{group="canary", instance="1", job="api-server"} => 440 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
Make 2nd arg to delta optional. Add a deriv() function. The 2nd isCounter argument to delta is ugly, make it optional as the first step of deprecating it. This will makes delta only ever applied to gauges. Add a deriv function to calculate the least squares slope of a gauge. This is more useful for prediction than delta, as it isn't as heavily influenced by outliers at the boundaries.
2015-01-22 11:52:30 +00:00
}, {
expr: `rate(http_requests[25m]) * 25 * 60`,
output: []string{
`{group="canary", instance="0", job="api-server"} => 150 @[%v]`,
`{group="canary", instance="0", job="app-server"} => 350 @[%v]`,
`{group="canary", instance="1", job="api-server"} => 200 @[%v]`,
`{group="canary", instance="1", job="app-server"} => 400 @[%v]`,
`{group="production", instance="0", job="api-server"} => 50 @[%v]`,
`{group="production", instance="0", job="app-server"} => 249.99999999999997 @[%v]`,
`{group="production", instance="1", job="api-server"} => 100 @[%v]`,
`{group="production", instance="1", job="app-server"} => 300 @[%v]`,
},
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `delta(http_requests[25m], 1)`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{group="canary", instance="0", job="api-server"} => 150 @[%v]`,
`{group="canary", instance="0", job="app-server"} => 350 @[%v]`,
`{group="canary", instance="1", job="api-server"} => 200 @[%v]`,
`{group="canary", instance="1", job="app-server"} => 400 @[%v]`,
`{group="production", instance="0", job="api-server"} => 50 @[%v]`,
`{group="production", instance="0", job="app-server"} => 250 @[%v]`,
`{group="production", instance="1", job="api-server"} => 100 @[%v]`,
`{group="production", instance="1", job="app-server"} => 300 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `sort(http_requests)`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
`http_requests{group="production", instance="0", job="api-server"} => 100 @[%v]`,
`http_requests{group="production", instance="1", job="api-server"} => 200 @[%v]`,
`http_requests{group="canary", instance="0", job="api-server"} => 300 @[%v]`,
`http_requests{group="canary", instance="1", job="api-server"} => 400 @[%v]`,
`http_requests{group="production", instance="0", job="app-server"} => 500 @[%v]`,
`http_requests{group="production", instance="1", job="app-server"} => 600 @[%v]`,
`http_requests{group="canary", instance="0", job="app-server"} => 700 @[%v]`,
`http_requests{group="canary", instance="1", job="app-server"} => 800 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
checkOrder: true,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
}, {
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `sort_desc(http_requests)`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
`http_requests{group="canary", instance="1", job="app-server"} => 800 @[%v]`,
`http_requests{group="canary", instance="0", job="app-server"} => 700 @[%v]`,
`http_requests{group="production", instance="1", job="app-server"} => 600 @[%v]`,
`http_requests{group="production", instance="0", job="app-server"} => 500 @[%v]`,
`http_requests{group="canary", instance="1", job="api-server"} => 400 @[%v]`,
`http_requests{group="canary", instance="0", job="api-server"} => 300 @[%v]`,
`http_requests{group="production", instance="1", job="api-server"} => 200 @[%v]`,
`http_requests{group="production", instance="0", job="api-server"} => 100 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
checkOrder: true,
Implement topk() and bottomk() functions. To achieve O(log n * k) runtime, this uses a heap to track the current bottom-k or top-k elements while iterating over the full set of available elements. It would be possible to reuse more code between topk and bottomk, but I decided for some more duplication for the sake of clarity. This fixes https://github.com/prometheus/prometheus/issues/399 Change-Id: I7487ddaadbe7acb22ca2cf2283ba6e7915f2b336
2014-08-05 16:57:47 +00:00
}, {
expr: `topk(3, http_requests)`,
output: []string{
`http_requests{group="canary", instance="1", job="app-server"} => 800 @[%v]`,
`http_requests{group="canary", instance="0", job="app-server"} => 700 @[%v]`,
`http_requests{group="production", instance="1", job="app-server"} => 600 @[%v]`,
},
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
checkOrder: true,
Add more topk() / bottomk() tests. Test what happens if k > number of input elements. Change-Id: Ie724b850939e297ebf085f0a5a3522e9cfcc6534
2014-08-05 18:14:04 +00:00
}, {
expr: `topk(5, http_requests{group="canary",job="app-server"})`,
output: []string{
`http_requests{group="canary", instance="1", job="app-server"} => 800 @[%v]`,
`http_requests{group="canary", instance="0", job="app-server"} => 700 @[%v]`,
},
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
checkOrder: true,
Implement topk() and bottomk() functions. To achieve O(log n * k) runtime, this uses a heap to track the current bottom-k or top-k elements while iterating over the full set of available elements. It would be possible to reuse more code between topk and bottomk, but I decided for some more duplication for the sake of clarity. This fixes https://github.com/prometheus/prometheus/issues/399 Change-Id: I7487ddaadbe7acb22ca2cf2283ba6e7915f2b336
2014-08-05 16:57:47 +00:00
}, {
expr: `bottomk(3, http_requests)`,
output: []string{
`http_requests{group="production", instance="0", job="api-server"} => 100 @[%v]`,
`http_requests{group="production", instance="1", job="api-server"} => 200 @[%v]`,
`http_requests{group="canary", instance="0", job="api-server"} => 300 @[%v]`,
},
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
checkOrder: true,
Add more topk() / bottomk() tests. Test what happens if k > number of input elements. Change-Id: Ie724b850939e297ebf085f0a5a3522e9cfcc6534
2014-08-05 18:14:04 +00:00
}, {
expr: `bottomk(5, http_requests{group="canary",job="app-server"})`,
output: []string{
`http_requests{group="canary", instance="0", job="app-server"} => 700 @[%v]`,
`http_requests{group="canary", instance="1", job="app-server"} => 800 @[%v]`,
},
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
checkOrder: true,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
}, {
// Single-letter label names and values.
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `x{y="testvalue"}`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
`x{y="testvalue"} => 100 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
// Lower-cased aggregation operators should work too.
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `sum(http_requests) by (job) + min(http_requests) by (job) + max(http_requests) by (job) + avg(http_requests) by (job)`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{job="app-server"} => 4550 @[%v]`,
`{job="api-server"} => 1750 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
}, {
// Deltas should be adjusted for target interval vs. samples under target interval.
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
expr: `delta(http_requests{group="canary", instance="1", job="app-server"}[18m])`,
output: []string{`{group="canary", instance="1", job="app-server"} => 288 @[%v]`},
Make 2nd arg to delta optional. Add a deriv() function. The 2nd isCounter argument to delta is ugly, make it optional as the first step of deprecating it. This will makes delta only ever applied to gauges. Add a deriv function to calculate the least squares slope of a gauge. This is more useful for prediction than delta, as it isn't as heavily influenced by outliers at the boundaries.
2015-01-22 11:52:30 +00:00
}, {
// Deltas should perform the same operation when 2nd argument is 0.
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
expr: `delta(http_requests{group="canary", instance="1", job="app-server"}[18m], 0)`,
output: []string{`{group="canary", instance="1", job="app-server"} => 288 @[%v]`},
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
}, {
Make 2nd arg to delta optional. Add a deriv() function. The 2nd isCounter argument to delta is ugly, make it optional as the first step of deprecating it. This will makes delta only ever applied to gauges. Add a deriv function to calculate the least squares slope of a gauge. This is more useful for prediction than delta, as it isn't as heavily influenced by outliers at the boundaries.
2015-01-22 11:52:30 +00:00
// Rates should calculate per-second rates.
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
expr: `rate(http_requests{group="canary", instance="1", job="app-server"}[60m])`,
output: []string{`{group="canary", instance="1", job="app-server"} => 0.26666666666666666 @[%v]`},
Use GetBoundaryValues() for non-counter deltas.
2013-05-12 00:03:16 +00:00
}, {
Make 2nd arg to delta optional. Add a deriv() function. The 2nd isCounter argument to delta is ugly, make it optional as the first step of deprecating it. This will makes delta only ever applied to gauges. Add a deriv function to calculate the least squares slope of a gauge. This is more useful for prediction than delta, as it isn't as heavily influenced by outliers at the boundaries.
2015-01-22 11:52:30 +00:00
// Deriv should return the same as rate in simple cases.
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
expr: `deriv(http_requests{group="canary", instance="1", job="app-server"}[60m])`,
output: []string{`{group="canary", instance="1", job="app-server"} => 0.26666666666666666 @[%v]`},
Use GetBoundaryValues() for non-counter deltas.
2013-05-12 00:03:16 +00:00
}, {
Make 2nd arg to delta optional. Add a deriv() function. The 2nd isCounter argument to delta is ugly, make it optional as the first step of deprecating it. This will makes delta only ever applied to gauges. Add a deriv function to calculate the least squares slope of a gauge. This is more useful for prediction than delta, as it isn't as heavily influenced by outliers at the boundaries.
2015-01-22 11:52:30 +00:00
// Counter resets at in the middle of range are handled correctly by rate().
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
expr: `rate(testcounter_reset_middle[60m])`,
output: []string{`{} => 0.03 @[%v]`},
Fix handling of negative deltas for non-counter values.
2013-05-28 15:36:53 +00:00
}, {
Make 2nd arg to delta optional. Add a deriv() function. The 2nd isCounter argument to delta is ugly, make it optional as the first step of deprecating it. This will makes delta only ever applied to gauges. Add a deriv function to calculate the least squares slope of a gauge. This is more useful for prediction than delta, as it isn't as heavily influenced by outliers at the boundaries.
2015-01-22 11:52:30 +00:00
// Counter resets at end of range are ignored by rate().
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
expr: `rate(testcounter_reset_end[5m])`,
output: []string{`{} => 0 @[%v]`},
Fix handling of negative deltas for non-counter values.
2013-05-28 15:36:53 +00:00
}, {
Make 2nd arg to delta optional. Add a deriv() function. The 2nd isCounter argument to delta is ugly, make it optional as the first step of deprecating it. This will makes delta only ever applied to gauges. Add a deriv function to calculate the least squares slope of a gauge. This is more useful for prediction than delta, as it isn't as heavily influenced by outliers at the boundaries.
2015-01-22 11:52:30 +00:00
// Deriv should return correct result.
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
expr: `deriv(testcounter_reset_middle[100m])`,
output: []string{`{} => 0.010606060606060607 @[%v]`},
Add count_scalar() function. Change-Id: I63f09dd0479d0a6b016f5f857dd39dcbda56c7f9
2014-01-30 12:07:26 +00:00
}, {
// count_scalar for a non-empty vector should return scalar element count.
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
expr: `count_scalar(http_requests)`,
output: []string{`scalar: 8 @[%v]`},
Add count_scalar() function. Change-Id: I63f09dd0479d0a6b016f5f857dd39dcbda56c7f9
2014-01-30 12:07:26 +00:00
}, {
// count_scalar for an empty vector should return scalar 0.
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
expr: `count_scalar(nonexistent)`,
output: []string{`scalar: 0 @[%v]`},
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
}, {
Add more topk() / bottomk() tests. Test what happens if k > number of input elements. Change-Id: Ie724b850939e297ebf085f0a5a3522e9cfcc6534
2014-08-05 18:14:04 +00:00
// Empty expressions shouldn't parse.
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: ``,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
shouldFail: true,
}, {
Add more topk() / bottomk() tests. Test what happens if k > number of input elements. Change-Id: Ie724b850939e297ebf085f0a5a3522e9cfcc6534
2014-08-05 18:14:04 +00:00
// Interval durations can't be in quotes.
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
expr: `http_requests["1m"]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
shouldFail: true,
Allow reversing vector and scalar arguments in binops. This allows putting a scalar as the first argument of a binary operator in which the second argument is a vector: <scalar> <binop> <vector> For example, 1 / http_requests_total ...will output a vector in which every sample value is 1 divided by the respective input vector element. This even works for filter binary operators now: 1 == http_requests_total Returns a vector with all values set to 1 for every element in http_requests_total whose initial value was 1. Note: For filter binary operators, the resulting values are always taken from the left-hand-side of the operation, no matter whether the scalar or the vector argument is the left-hand-side. That is, 1 != http_requests_total ...will set all result vector sample values to 1, although these are exactly the sample elements that were != 1 in the input vector. If you want to just filter elements without changing their sample values, you still need to do: http_requests_total != 1 The new filter form is a bit exotic, and so probably won't be used often. But it was easier to implement it than disallow it completely or change its behavior. Change-Id: Idd083f2bd3a1219ba1560cf4ace42f5b82e797a5
2014-04-08 14:14:35 +00:00
}, {
// Binop arguments need to be scalar or vector.
expr: `http_requests - http_requests[1m]`,
shouldFail: true,
Add regex-matching support for labels. There are four label-matching ops for selecting timeseries now: - Equal: = - NotEqual: != - RegexMatch: =~ - RegexNoMatch: !~ Instead of looking up labels by a simple clientmodel.LabelSet (basically an equals op for every key/value pair in the set), timeseries fingerprint selection is now done via a list of metric.LabelMatchers. Change-Id: I510a83f761198e80946146770ebb64e4abc3bb96
2014-03-28 10:58:47 +00:00
}, {
expr: `http_requests{group!="canary"}`,
output: []string{
`http_requests{group="production", instance="1", job="app-server"} => 600 @[%v]`,
`http_requests{group="production", instance="0", job="app-server"} => 500 @[%v]`,
`http_requests{group="production", instance="1", job="api-server"} => 200 @[%v]`,
`http_requests{group="production", instance="0", job="api-server"} => 100 @[%v]`,
},
}, {
expr: `http_requests{job=~"server",group!="canary"}`,
output: []string{
`http_requests{group="production", instance="1", job="app-server"} => 600 @[%v]`,
`http_requests{group="production", instance="0", job="app-server"} => 500 @[%v]`,
`http_requests{group="production", instance="1", job="api-server"} => 200 @[%v]`,
`http_requests{group="production", instance="0", job="api-server"} => 100 @[%v]`,
},
}, {
expr: `http_requests{job!~"api",group!="canary"}`,
output: []string{
`http_requests{group="production", instance="1", job="app-server"} => 600 @[%v]`,
`http_requests{group="production", instance="0", job="app-server"} => 500 @[%v]`,
},
}, {
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
expr: `count_scalar(http_requests{job=~"^server$"})`,
output: []string{`scalar: 0 @[%v]`},
Add regex-matching support for labels. There are four label-matching ops for selecting timeseries now: - Equal: = - NotEqual: != - RegexMatch: =~ - RegexNoMatch: !~ Instead of looking up labels by a simple clientmodel.LabelSet (basically an equals op for every key/value pair in the set), timeseries fingerprint selection is now done via a list of metric.LabelMatchers. Change-Id: I510a83f761198e80946146770ebb64e4abc3bb96
2014-03-28 10:58:47 +00:00
}, {
expr: `http_requests{group="production",job=~"^api"}`,
output: []string{
Add abs() and over-time aggregation functions. This implements aggregation functions over time as request in https://github.com/prometheus/prometheus/issues/383. Change-Id: Ifd69b850de8cfdf6e7a6c0e042056fa4c672410e
2014-07-28 14:12:58 +00:00
`http_requests{group="production", instance="0", job="api-server"} => 100 @[%v]`,
Add regex-matching support for labels. There are four label-matching ops for selecting timeseries now: - Equal: = - NotEqual: != - RegexMatch: =~ - RegexNoMatch: !~ Instead of looking up labels by a simple clientmodel.LabelSet (basically an equals op for every key/value pair in the set), timeseries fingerprint selection is now done via a list of metric.LabelMatchers. Change-Id: I510a83f761198e80946146770ebb64e4abc3bb96
2014-03-28 10:58:47 +00:00
`http_requests{group="production", instance="1", job="api-server"} => 200 @[%v]`,
Add abs() and over-time aggregation functions. This implements aggregation functions over time as request in https://github.com/prometheus/prometheus/issues/383. Change-Id: Ifd69b850de8cfdf6e7a6c0e042056fa4c672410e
2014-07-28 14:12:58 +00:00
},
},
{
expr: `abs(-1 * http_requests{group="production",job="api-server"})`,
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{group="production", instance="0", job="api-server"} => 100 @[%v]`,
`{group="production", instance="1", job="api-server"} => 200 @[%v]`,
Add regex-matching support for labels. There are four label-matching ops for selecting timeseries now: - Equal: = - NotEqual: != - RegexMatch: =~ - RegexNoMatch: !~ Instead of looking up labels by a simple clientmodel.LabelSet (basically an equals op for every key/value pair in the set), timeseries fingerprint selection is now done via a list of metric.LabelMatchers. Change-Id: I510a83f761198e80946146770ebb64e4abc3bb96
2014-03-28 10:58:47 +00:00
},
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
Add floor, ceil and round functions. Closes #402
2015-02-04 11:24:00 +00:00
{
expr: `floor(0.004 * http_requests{group="production",job="api-server"})`,
output: []string{
`{group="production", instance="0", job="api-server"} => 0 @[%v]`,
`{group="production", instance="1", job="api-server"} => 0 @[%v]`,
},
},
{
expr: `ceil(0.004 * http_requests{group="production",job="api-server"})`,
output: []string{
`{group="production", instance="0", job="api-server"} => 1 @[%v]`,
`{group="production", instance="1", job="api-server"} => 1 @[%v]`,
},
},
{
expr: `round(0.004 * http_requests{group="production",job="api-server"})`,
output: []string{
`{group="production", instance="0", job="api-server"} => 0 @[%v]`,
`{group="production", instance="1", job="api-server"} => 1 @[%v]`,
},
},
{ // Round should correctly handle negative numbers.
expr: `round(-1 * (0.004 * http_requests{group="production",job="api-server"}))`,
output: []string{
Change the 2nd argument of round to toNearest. This is more useful if you want get a multiple of 2 or 5, while still working for .001.
2015-02-05 16:06:35 +00:00
`{group="production", instance="0", job="api-server"} => 0 @[%v]`,
Add floor, ceil and round functions. Closes #402
2015-02-04 11:24:00 +00:00
`{group="production", instance="1", job="api-server"} => -1 @[%v]`,
},
},
Change the 2nd argument of round to toNearest. This is more useful if you want get a multiple of 2 or 5, while still working for .001.
2015-02-05 16:06:35 +00:00
{ // Round should round half up.
Add floor, ceil and round functions. Closes #402
2015-02-04 11:24:00 +00:00
expr: `round(0.005 * http_requests{group="production",job="api-server"})`,
output: []string{
Change the 2nd argument of round to toNearest. This is more useful if you want get a multiple of 2 or 5, while still working for .001.
2015-02-05 16:06:35 +00:00
`{group="production", instance="0", job="api-server"} => 1 @[%v]`,
Add floor, ceil and round functions. Closes #402
2015-02-04 11:24:00 +00:00
`{group="production", instance="1", job="api-server"} => 1 @[%v]`,
},
},
{
expr: `round(-1 * (0.005 * http_requests{group="production",job="api-server"}))`,
output: []string{
`{group="production", instance="0", job="api-server"} => 0 @[%v]`,
`{group="production", instance="1", job="api-server"} => -1 @[%v]`,
},
},
Change the 2nd argument of round to toNearest. This is more useful if you want get a multiple of 2 or 5, while still working for .001.
2015-02-05 16:06:35 +00:00
{
Add floor, ceil and round functions. Closes #402
2015-02-04 11:24:00 +00:00
expr: `round(1 + 0.005 * http_requests{group="production",job="api-server"})`,
output: []string{
`{group="production", instance="0", job="api-server"} => 2 @[%v]`,
`{group="production", instance="1", job="api-server"} => 2 @[%v]`,
},
},
{
expr: `round(-1 * (1 + 0.005 * http_requests{group="production",job="api-server"}))`,
output: []string{
Change the 2nd argument of round to toNearest. This is more useful if you want get a multiple of 2 or 5, while still working for .001.
2015-02-05 16:06:35 +00:00
`{group="production", instance="0", job="api-server"} => -1 @[%v]`,
Add floor, ceil and round functions. Closes #402
2015-02-04 11:24:00 +00:00
`{group="production", instance="1", job="api-server"} => -2 @[%v]`,
},
},
Change the 2nd argument of round to toNearest. This is more useful if you want get a multiple of 2 or 5, while still working for .001.
2015-02-05 16:06:35 +00:00
{ // Round should accept the number to round nearest to.
expr: `round(0.0005 * http_requests{group="production",job="api-server"}, 0.1)`,
Add floor, ceil and round functions. Closes #402
2015-02-04 11:24:00 +00:00
output: []string{
Change the 2nd argument of round to toNearest. This is more useful if you want get a multiple of 2 or 5, while still working for .001.
2015-02-05 16:06:35 +00:00
`{group="production", instance="0", job="api-server"} => 0.1 @[%v]`,
Add floor, ceil and round functions. Closes #402
2015-02-04 11:24:00 +00:00
`{group="production", instance="1", job="api-server"} => 0.1 @[%v]`,
},
},
Change the 2nd argument of round to toNearest. This is more useful if you want get a multiple of 2 or 5, while still working for .001.
2015-02-05 16:06:35 +00:00
{
expr: `round(2.1 + 0.0005 * http_requests{group="production",job="api-server"}, 0.1)`,
Add floor, ceil and round functions. Closes #402
2015-02-04 11:24:00 +00:00
output: []string{
`{group="production", instance="0", job="api-server"} => 2.2 @[%v]`,
`{group="production", instance="1", job="api-server"} => 2.2 @[%v]`,
},
},
{
Change the 2nd argument of round to toNearest. This is more useful if you want get a multiple of 2 or 5, while still working for .001.
2015-02-05 16:06:35 +00:00
expr: `round(5.2 + 0.0005 * http_requests{group="production",job="api-server"}, 0.1)`,
Add floor, ceil and round functions. Closes #402
2015-02-04 11:24:00 +00:00
output: []string{
Change the 2nd argument of round to toNearest. This is more useful if you want get a multiple of 2 or 5, while still working for .001.
2015-02-05 16:06:35 +00:00
`{group="production", instance="0", job="api-server"} => 5.3 @[%v]`,
Add floor, ceil and round functions. Closes #402
2015-02-04 11:24:00 +00:00
`{group="production", instance="1", job="api-server"} => 5.3 @[%v]`,
},
},
{ // Round should work correctly with negative numbers and multiple decimal places.
Change the 2nd argument of round to toNearest. This is more useful if you want get a multiple of 2 or 5, while still working for .001.
2015-02-05 16:06:35 +00:00
expr: `round(-1 * (5.2 + 0.0005 * http_requests{group="production",job="api-server"}), 0.1)`,
Add floor, ceil and round functions. Closes #402
2015-02-04 11:24:00 +00:00
output: []string{
`{group="production", instance="0", job="api-server"} => -5.2 @[%v]`,
`{group="production", instance="1", job="api-server"} => -5.3 @[%v]`,
},
},
Change the 2nd argument of round to toNearest. This is more useful if you want get a multiple of 2 or 5, while still working for .001.
2015-02-05 16:06:35 +00:00
{ // Round should work correctly with big toNearests.
expr: `round(0.025 * http_requests{group="production",job="api-server"}, 5)`,
output: []string{
`{group="production", instance="0", job="api-server"} => 5 @[%v]`,
`{group="production", instance="1", job="api-server"} => 5 @[%v]`,
},
},
{
expr: `round(0.045 * http_requests{group="production",job="api-server"}, 5)`,
output: []string{
`{group="production", instance="0", job="api-server"} => 5 @[%v]`,
`{group="production", instance="1", job="api-server"} => 10 @[%v]`,
},
},
Add abs() and over-time aggregation functions. This implements aggregation functions over time as request in https://github.com/prometheus/prometheus/issues/383. Change-Id: Ifd69b850de8cfdf6e7a6c0e042056fa4c672410e
2014-07-28 14:12:58 +00:00
{
expr: `avg_over_time(http_requests{group="production",job="api-server"}[1h])`,
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{group="production", instance="0", job="api-server"} => 50 @[%v]`,
`{group="production", instance="1", job="api-server"} => 100 @[%v]`,
Add abs() and over-time aggregation functions. This implements aggregation functions over time as request in https://github.com/prometheus/prometheus/issues/383. Change-Id: Ifd69b850de8cfdf6e7a6c0e042056fa4c672410e
2014-07-28 14:12:58 +00:00
},
},
{
expr: `count_over_time(http_requests{group="production",job="api-server"}[1h])`,
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{group="production", instance="0", job="api-server"} => 11 @[%v]`,
`{group="production", instance="1", job="api-server"} => 11 @[%v]`,
Add abs() and over-time aggregation functions. This implements aggregation functions over time as request in https://github.com/prometheus/prometheus/issues/383. Change-Id: Ifd69b850de8cfdf6e7a6c0e042056fa4c672410e
2014-07-28 14:12:58 +00:00
},
},
{
expr: `max_over_time(http_requests{group="production",job="api-server"}[1h])`,
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{group="production", instance="0", job="api-server"} => 100 @[%v]`,
`{group="production", instance="1", job="api-server"} => 200 @[%v]`,
Add abs() and over-time aggregation functions. This implements aggregation functions over time as request in https://github.com/prometheus/prometheus/issues/383. Change-Id: Ifd69b850de8cfdf6e7a6c0e042056fa4c672410e
2014-07-28 14:12:58 +00:00
},
},
{
expr: `min_over_time(http_requests{group="production",job="api-server"}[1h])`,
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{group="production", instance="0", job="api-server"} => 0 @[%v]`,
`{group="production", instance="1", job="api-server"} => 0 @[%v]`,
Add abs() and over-time aggregation functions. This implements aggregation functions over time as request in https://github.com/prometheus/prometheus/issues/383. Change-Id: Ifd69b850de8cfdf6e7a6c0e042056fa4c672410e
2014-07-28 14:12:58 +00:00
},
},
{
expr: `sum_over_time(http_requests{group="production",job="api-server"}[1h])`,
output: []string{
Drop metric names after transformations. After many transformations, it doesn't make sense to keep the metric names, since the result of the transformation is no longer that metric. This drops the metric name after such transformations and makes the web UI deal well with missing metric names. This depends on the current branch on the following things: - prometheus/client_golang needs to be at https://github.com/prometheus/client_golang/commit/e237cf15c6967a6184e423a08154d9c6eecb330c in branch "julius/int-fingerprints" (to be merged with new storage) - prometheus/promdash needs to be at https://github.com/prometheus/promdash/commit/dd7691c9c28c36767ae9559db8eab6d6715dffa8 Change-Id: Ib3c8cad8d647d9854e8c653c424b8c235ccc231d
2014-10-15 15:03:08 +00:00
`{group="production", instance="0", job="api-server"} => 550 @[%v]`,
`{group="production", instance="1", job="api-server"} => 1100 @[%v]`,
Add abs() and over-time aggregation functions. This implements aggregation functions over time as request in https://github.com/prometheus/prometheus/issues/383. Change-Id: Ifd69b850de8cfdf6e7a6c0e042056fa4c672410e
2014-07-28 14:12:58 +00:00
},
},
Fix time() behavior. time() should return the timestamp for which the query is executed, not the actual current time. Change-Id: I430a45cabad7785cd58f95b1028a71dff4c87710
2014-07-28 16:10:11 +00:00
{
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
expr: `time()`,
output: []string{`scalar: 3000 @[%v]`},
Fix time() behavior. time() should return the timestamp for which the query is executed, not the actual current time. Change-Id: I430a45cabad7785cd58f95b1028a71dff4c87710
2014-07-28 16:10:11 +00:00
},
Add function to drop common labels in a vector. This fixes https://github.com/prometheus/prometheus/issues/384. Change-Id: I2973c4baeb8a4618ec3875fb11c6fcf5d111784b
2014-08-05 17:56:35 +00:00
{
expr: `drop_common_labels(http_requests{group="production",job="api-server"})`,
output: []string{
`http_requests{instance="0"} => 100 @[%v]`,
`http_requests{instance="1"} => 200 @[%v]`,
},
},
Allow omitting the metric name in queries. This allows the following expression syntaxes for selecting timeseries: foo (already valid before) foo{} (already valid before) {job="prometheus"} (new, select all timeseries for job "prometheus") Omitting both the metric name *and* any label matchers ("" or "{}") will still yield a syntax error. To get all timeseries, you could do: {__name__=~".*"} or, without relying on knowledge about __metric__: {job=~".*"} Change-Id: Ifee000b9ac0184ef6ced18411069c7f2699a2dda
2014-10-14 15:21:39 +00:00
{
expr: `{` + string(clientmodel.MetricNameLabel) + `=~".*"}`,
output: []string{
`http_requests{group="canary", instance="0", job="api-server"} => 300 @[%v]`,
`http_requests{group="canary", instance="0", job="app-server"} => 700 @[%v]`,
`http_requests{group="canary", instance="1", job="api-server"} => 400 @[%v]`,
`http_requests{group="canary", instance="1", job="app-server"} => 800 @[%v]`,
`http_requests{group="production", instance="0", job="api-server"} => 100 @[%v]`,
`http_requests{group="production", instance="0", job="app-server"} => 500 @[%v]`,
`http_requests{group="production", instance="1", job="api-server"} => 200 @[%v]`,
`http_requests{group="production", instance="1", job="app-server"} => 600 @[%v]`,
`testcounter_reset_end => 0 @[%v]`,
`testcounter_reset_middle => 50 @[%v]`,
`x{y="testvalue"} => 100 @[%v]`,
Fix aggregation grouping key calculation.
2015-02-21 13:05:50 +00:00
`label_grouping_test{a="a", b="abb"} => 200 @[%v]`,
`label_grouping_test{a="aa", b="bb"} => 100 @[%v]`,
Add the histogram_quantile function. Since we are now getting really deep into floating point calculation, the tests had to take into account the precision loss. Since the rule tests are based on direct line matching in the output, implementing the "almost equal" semantics was pretty cumbersome, but here we are.
2015-02-19 18:56:45 +00:00
`testhistogram_bucket{le="0.1", start="positive"} => 50 @[%v]`,
`testhistogram_bucket{le=".2", start="positive"} => 70 @[%v]`,
`testhistogram_bucket{le="1e0", start="positive"} => 110 @[%v]`,
`testhistogram_bucket{le="+Inf", start="positive"} => 120 @[%v]`,
`testhistogram_bucket{le="-.2", start="negative"} => 10 @[%v]`,
`testhistogram_bucket{le="-0.1", start="negative"} => 20 @[%v]`,
`testhistogram_bucket{le="0.3", start="negative"} => 20 @[%v]`,
`testhistogram_bucket{le="+Inf", start="negative"} => 30 @[%v]`,
`request_duration_seconds_bucket{instance="ins1", job="job1", le="0.1"} => 10 @[%v]`,
`request_duration_seconds_bucket{instance="ins1", job="job1", le="0.2"} => 30 @[%v]`,
`request_duration_seconds_bucket{instance="ins1", job="job1", le="+Inf"} => 40 @[%v]`,
`request_duration_seconds_bucket{instance="ins2", job="job1", le="0.1"} => 20 @[%v]`,
`request_duration_seconds_bucket{instance="ins2", job="job1", le="0.2"} => 50 @[%v]`,
`request_duration_seconds_bucket{instance="ins2", job="job1", le="+Inf"} => 60 @[%v]`,
`request_duration_seconds_bucket{instance="ins1", job="job2", le="0.1"} => 30 @[%v]`,
`request_duration_seconds_bucket{instance="ins1", job="job2", le="0.2"} => 40 @[%v]`,
`request_duration_seconds_bucket{instance="ins1", job="job2", le="+Inf"} => 60 @[%v]`,
`request_duration_seconds_bucket{instance="ins2", job="job2", le="0.1"} => 40 @[%v]`,
`request_duration_seconds_bucket{instance="ins2", job="job2", le="0.2"} => 70 @[%v]`,
`request_duration_seconds_bucket{instance="ins2", job="job2", le="+Inf"} => 90 @[%v]`,
Add OR operation and vector matching options. This commits implements the OR operation between two vectors. Vector matching using the ON clause is added to limit the set of labels that define a match between two elements. Group modifiers (GROUP_LEFT/GROUP_RIGHT) to request many-to-one matching are added.
2015-03-03 09:58:28 +00:00
`vector_matching_a{l="x"} => 10 @[%v]`,
`vector_matching_a{l="y"} => 20 @[%v]`,
`vector_matching_b{l="x"} => 40 @[%v]`,
`cpu_count{instance="1", type="smp"} => 200 @[%v]`,
`cpu_count{instance="0", type="smp"} => 100 @[%v]`,
`cpu_count{instance="0", type="numa"} => 300 @[%v]`,
Allow omitting the metric name in queries. This allows the following expression syntaxes for selecting timeseries: foo (already valid before) foo{} (already valid before) {job="prometheus"} (new, select all timeseries for job "prometheus") Omitting both the metric name *and* any label matchers ("" or "{}") will still yield a syntax error. To get all timeseries, you could do: {__name__=~".*"} or, without relying on knowledge about __metric__: {job=~".*"} Change-Id: Ifee000b9ac0184ef6ced18411069c7f2699a2dda
2014-10-14 15:21:39 +00:00
},
},
{
expr: `{job=~"server", job!~"api"}`,
output: []string{
`http_requests{group="canary", instance="0", job="app-server"} => 700 @[%v]`,
`http_requests{group="canary", instance="1", job="app-server"} => 800 @[%v]`,
`http_requests{group="production", instance="0", job="app-server"} => 500 @[%v]`,
`http_requests{group="production", instance="1", job="app-server"} => 600 @[%v]`,
},
},
Allow alternative "by"-clause position in grammar. In addition to the existing by-clause syntax: sum(<expression>) by (<labels>) [keeping_extra] ...this allows the following new syntax: sum by (<labels>) [keeping_extra] (<expression>) Both orderings may be used in a single expression. It is up to the users to establish guidelines around their usage. Change-Id: Iba10c9cc5fb6ac62edfcf246d281473e82467992
2014-10-22 09:03:11 +00:00
{
// Test alternative "by"-clause order.
expr: `sum by (group) (http_requests{job="api-server"})`,
output: []string{
Fix tests after merge. Change-Id: Ia90da9a3e48ed780ec38c4a6a1fd9ea34e7f6a58
2014-11-24 19:12:58 +00:00
`{group="canary"} => 700 @[%v]`,
`{group="production"} => 300 @[%v]`,
Allow alternative "by"-clause position in grammar. In addition to the existing by-clause syntax: sum(<expression>) by (<labels>) [keeping_extra] ...this allows the following new syntax: sum by (<labels>) [keeping_extra] (<expression>) Both orderings may be used in a single expression. It is up to the users to establish guidelines around their usage. Change-Id: Iba10c9cc5fb6ac62edfcf246d281473e82467992
2014-10-22 09:03:11 +00:00
},
},
{
// Test alternative "by"-clause order with "keeping_extra".
expr: `sum by (group) keeping_extra (http_requests{job="api-server"})`,
output: []string{
Fix tests after merge. Change-Id: Ia90da9a3e48ed780ec38c4a6a1fd9ea34e7f6a58
2014-11-24 19:12:58 +00:00
`{group="canary", job="api-server"} => 700 @[%v]`,
`{group="production", job="api-server"} => 300 @[%v]`,
Allow alternative "by"-clause position in grammar. In addition to the existing by-clause syntax: sum(<expression>) by (<labels>) [keeping_extra] ...this allows the following new syntax: sum by (<labels>) [keeping_extra] (<expression>) Both orderings may be used in a single expression. It is up to the users to establish guidelines around their usage. Change-Id: Iba10c9cc5fb6ac62edfcf246d281473e82467992
2014-10-22 09:03:11 +00:00
},
},
{
// Test both alternative "by"-clause orders in one expression.
// Public health warning: stick to one form within an expression (or even
// in an organization), or risk serious user confusion.
expr: `sum(sum by (group) keeping_extra (http_requests{job="api-server"})) by (job)`,
output: []string{
Fix tests after merge. Change-Id: Ia90da9a3e48ed780ec38c4a6a1fd9ea34e7f6a58
2014-11-24 19:12:58 +00:00
`{job="api-server"} => 1000 @[%v]`,
Allow alternative "by"-clause position in grammar. In addition to the existing by-clause syntax: sum(<expression>) by (<labels>) [keeping_extra] ...this allows the following new syntax: sum by (<labels>) [keeping_extra] (<expression>) Both orderings may be used in a single expression. It is up to the users to establish guidelines around their usage. Change-Id: Iba10c9cc5fb6ac62edfcf246d281473e82467992
2014-10-22 09:03:11 +00:00
},
},
Add OR operation and vector matching options. This commits implements the OR operation between two vectors. Vector matching using the ON clause is added to limit the set of labels that define a match between two elements. Group modifiers (GROUP_LEFT/GROUP_RIGHT) to request many-to-one matching are added.
2015-03-03 09:58:28 +00:00
{
expr: `http_requests{group="canary"} and http_requests{instance="0"}`,
output: []string{
`http_requests{group="canary", instance="0", job="api-server"} => 300 @[%v]`,
`http_requests{group="canary", instance="0", job="app-server"} => 700 @[%v]`,
},
},
{
expr: `(http_requests{group="canary"} + 1) and http_requests{instance="0"}`,
output: []string{
`{group="canary", instance="0", job="api-server"} => 301 @[%v]`,
`{group="canary", instance="0", job="app-server"} => 701 @[%v]`,
},
},
{
expr: `(http_requests{group="canary"} + 1) and on(instance, job) http_requests{instance="0", group="production"}`,
output: []string{
`{group="canary", instance="0", job="api-server"} => 301 @[%v]`,
`{group="canary", instance="0", job="app-server"} => 701 @[%v]`,
},
},
{
expr: `(http_requests{group="canary"} + 1) and on(instance) http_requests{instance="0", group="production"}`,
output: []string{
`{group="canary", instance="0", job="api-server"} => 301 @[%v]`,
`{group="canary", instance="0", job="app-server"} => 701 @[%v]`,
},
},
{
expr: `http_requests{group="canary"} or http_requests{group="production"}`,
output: []string{
`http_requests{group="canary", instance="0", job="api-server"} => 300 @[%v]`,
`http_requests{group="canary", instance="0", job="app-server"} => 700 @[%v]`,
`http_requests{group="canary", instance="1", job="api-server"} => 400 @[%v]`,
`http_requests{group="canary", instance="1", job="app-server"} => 800 @[%v]`,
`http_requests{group="production", instance="0", job="api-server"} => 100 @[%v]`,
`http_requests{group="production", instance="0", job="app-server"} => 500 @[%v]`,
`http_requests{group="production", instance="1", job="api-server"} => 200 @[%v]`,
`http_requests{group="production", instance="1", job="app-server"} => 600 @[%v]`,
},
},
{
// On overlap the rhs samples must be dropped.
expr: `(http_requests{group="canary"} + 1) or http_requests{instance="1"}`,
output: []string{
`{group="canary", instance="0", job="api-server"} => 301 @[%v]`,
`{group="canary", instance="0", job="app-server"} => 701 @[%v]`,
`{group="canary", instance="1", job="api-server"} => 401 @[%v]`,
`{group="canary", instance="1", job="app-server"} => 801 @[%v]`,
`http_requests{group="production", instance="1", job="api-server"} => 200 @[%v]`,
`http_requests{group="production", instance="1", job="app-server"} => 600 @[%v]`,
},
},
{
// Matching only on instance excludes everything that has instance=0/1 but includes
// entries without the instance label.
expr: `(http_requests{group="canary"} + 1) or on(instance) (http_requests or cpu_count or vector_matching_a)`,
output: []string{
`{group="canary", instance="0", job="api-server"} => 301 @[%v]`,
`{group="canary", instance="0", job="app-server"} => 701 @[%v]`,
`{group="canary", instance="1", job="api-server"} => 401 @[%v]`,
`{group="canary", instance="1", job="app-server"} => 801 @[%v]`,
`vector_matching_a{l="x"} => 10 @[%v]`,
`vector_matching_a{l="y"} => 20 @[%v]`,
},
},
{
expr: `http_requests{group="canary"} / on(instance,job) http_requests{group="production"}`,
output: []string{
`{instance="0", job="api-server"} => 3 @[%v]`,
`{instance="0", job="app-server"} => 1.4 @[%v]`,
`{instance="1", job="api-server"} => 2 @[%v]`,
`{instance="1", job="app-server"} => 1.3333333333333333 @[%v]`,
},
},
{
// Include labels must guarantee uniquely identifiable time series.
expr: `http_requests{group="production"} / on(instance) group_left(group) cpu_count{type="smp"}`,
output: []string{}, // Empty result returned on error (see TODOs).
},
{
// Many-to-many matching is not allowed.
expr: `http_requests{group="production"} / on(instance) group_left(job,type) cpu_count`,
output: []string{}, // Empty result returned on error (see TODOs).
},
{
// Many-to-one matching must be explicit.
expr: `http_requests{group="production"} / on(instance) cpu_count{type="smp"}`,
output: []string{}, // Empty result returned on error (see TODOs).
},
{
expr: `http_requests{group="production"} / on(instance) group_left(job) cpu_count{type="smp"}`,
output: []string{
`{instance="1", job="api-server"} => 1 @[%v]`,
`{instance="0", job="app-server"} => 5 @[%v]`,
`{instance="1", job="app-server"} => 3 @[%v]`,
`{instance="0", job="api-server"} => 1 @[%v]`,
},
},
{
// Ensure sidedness of grouping preserves operand sides.
expr: `cpu_count{type="smp"} / on(instance) group_right(job) http_requests{group="production"}`,
output: []string{
`{instance="1", job="app-server"} => 0.3333333333333333 @[%v]`,
`{instance="0", job="app-server"} => 0.2 @[%v]`,
`{instance="1", job="api-server"} => 1 @[%v]`,
`{instance="0", job="api-server"} => 1 @[%v]`,
},
},
{
// Include labels from both sides.
expr: `http_requests{group="production"} / on(instance) group_left(job) cpu_count{type="smp"}`,
output: []string{
`{instance="1", job="api-server"} => 1 @[%v]`,
`{instance="0", job="app-server"} => 5 @[%v]`,
`{instance="1", job="app-server"} => 3 @[%v]`,
`{instance="0", job="api-server"} => 1 @[%v]`,
},
},
{
expr: `http_requests{group="production"} < on(instance,job) http_requests{group="canary"}`,
output: []string{
`{instance="1", job="app-server"} => 600 @[%v]`,
`{instance="0", job="app-server"} => 500 @[%v]`,
`{instance="1", job="api-server"} => 200 @[%v]`,
`{instance="0", job="api-server"} => 100 @[%v]`,
},
},
{
expr: `http_requests{group="production"} > on(instance,job) http_requests{group="canary"}`,
output: []string{},
},
{
expr: `http_requests{group="production"} == on(instance,job) http_requests{group="canary"}`,
output: []string{},
},
{
expr: `http_requests > on(instance) group_left(group,job) cpu_count{type="smp"}`,
output: []string{
`{group="canary", instance="0", job="app-server"} => 700 @[%v]`,
`{group="canary", instance="1", job="app-server"} => 800 @[%v]`,
`{group="canary", instance="0", job="api-server"} => 300 @[%v]`,
`{group="canary", instance="1", job="api-server"} => 400 @[%v]`,
`{group="production", instance="0", job="app-server"} => 500 @[%v]`,
`{group="production", instance="1", job="app-server"} => 600 @[%v]`,
},
},
{
expr: `http_requests / on(instance) 3`,
shouldFail: true,
},
{
expr: `3 / on(instance) http_requests_total`,
shouldFail: true,
},
{
expr: `3 / on(instance) 3`,
shouldFail: true,
},
{
// Missing label list for grouping mod.
expr: `http_requests{group="production"} / on(instance) group_left cpu_count{type="smp"}`,
shouldFail: true,
},
{
// No group mod allowed for logical operations.
expr: `http_requests{group="production"} or on(instance) group_left(type) cpu_count{type="smp"}`,
shouldFail: true,
},
{
// No group mod allowed for logical operations.
expr: `http_requests{group="production"} and on(instance) group_left(type) cpu_count{type="smp"}`,
shouldFail: true,
},
{
// No duplicate use of label.
expr: `http_requests{group="production"} + on(instance) group_left(job,instance) cpu_count{type="smp"}`,
shouldFail: true,
},
{
expr: `{l="x"} + on(__name__) {l="y"}`,
output: []string{
`vector_matching_a => 30 @[%v]`,
},
},
Add absent() function. A common problem in Prometheus alerting is to detect when no timeseries exist for a given metric name and label combination. Unfortunately, Prometheus alert expressions need to be of vector type, and "count(nonexistent_metric)" results in an empty vector, yielding no output vector elements to base an alert on. The newly introduced absent() function solves this issue: ALERT FooAbsent IF absent(foo{job="myjob"}) [...] absent() has the following behavior: - if the vector passed to it has any elements, it returns an empty vector. - if the vector passed to it has no elements, it returns a 1-element vector with the value 1. In the second case, absent() tries to be smart about deriving labels of the 1-element output vector from the input vector: absent(nonexistent{job="myjob"}) => {job="myjob"} absent(nonexistent{job="myjob",instance=~".*"}) => {job="myjob"} absent(sum(nonexistent{job="myjob"})) => {} That is, if the passed vector is a literal vector selector, it takes all "=" label matchers as the basis for the output labels, but ignores all non-equals or regex matchers. Also, if the passed vector results from a non-selector expression, no labels can be derived. Change-Id: I948505a1488d50265ab5692a3286bd7c8c70cd78
2014-10-15 17:13:52 +00:00
{
expr: `absent(nonexistent)`,
output: []string{
`{} => 1 @[%v]`,
},
},
{
expr: `absent(nonexistent{job="testjob", instance="testinstance", method=~".*"})`,
output: []string{
`{instance="testinstance", job="testjob"} => 1 @[%v]`,
},
},
{
expr: `count_scalar(absent(http_requests))`,
output: []string{
`scalar: 0 @[%v]`,
},
},
{
expr: `count_scalar(absent(sum(http_requests)))`,
output: []string{
`scalar: 0 @[%v]`,
},
},
{
expr: `absent(sum(nonexistent{job="testjob", instance="testinstance"}))`,
output: []string{
`{} => 1 @[%v]`,
},
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-18 01:30:41 +00:00
},
{
expr: `http_requests{group="production",job="api-server"} offset 5m`,
output: []string{
`http_requests{group="production", instance="0", job="api-server"} => 90 @[%v]`,
`http_requests{group="production", instance="1", job="api-server"} => 180 @[%v]`,
},
},
{
expr: `rate(http_requests{group="production",job="api-server"}[10m] offset 5m)`,
output: []string{
`{group="production", instance="0", job="api-server"} => 0.03333333333333333 @[%v]`,
`{group="production", instance="1", job="api-server"} => 0.06666666666666667 @[%v]`,
},
Add absent() function. A common problem in Prometheus alerting is to detect when no timeseries exist for a given metric name and label combination. Unfortunately, Prometheus alert expressions need to be of vector type, and "count(nonexistent_metric)" results in an empty vector, yielding no output vector elements to base an alert on. The newly introduced absent() function solves this issue: ALERT FooAbsent IF absent(foo{job="myjob"}) [...] absent() has the following behavior: - if the vector passed to it has any elements, it returns an empty vector. - if the vector passed to it has no elements, it returns a 1-element vector with the value 1. In the second case, absent() tries to be smart about deriving labels of the 1-element output vector from the input vector: absent(nonexistent{job="myjob"}) => {job="myjob"} absent(nonexistent{job="myjob",instance=~".*"}) => {job="myjob"} absent(sum(nonexistent{job="myjob"})) => {} That is, if the passed vector is a literal vector selector, it takes all "=" label matchers as the basis for the output labels, but ignores all non-equals or regex matchers. Also, if the passed vector results from a non-selector expression, no labels can be derived. Change-Id: I948505a1488d50265ab5692a3286bd7c8c70cd78
2014-10-15 17:13:52 +00:00
},
Add tests for invalid uses of "offset".
2015-02-18 01:56:40 +00:00
{
expr: `rate(http_requests[10m]) offset 5m`,
shouldFail: true,
},
{
expr: `sum(http_requests) offset 5m`,
shouldFail: true,
},
Fix aggregation grouping key calculation.
2015-02-21 13:05:50 +00:00
// Regression test for missing separator byte in labelsToGroupingKey.
{
expr: `sum(label_grouping_test) by (a, b)`,
output: []string{
`{a="a", b="abb"} => 200 @[%v]`,
`{a="aa", b="bb"} => 100 @[%v]`,
},
},
Add the histogram_quantile function. Since we are now getting really deep into floating point calculation, the tests had to take into account the precision loss. Since the rule tests are based on direct line matching in the output, implementing the "almost equal" semantics was pretty cumbersome, but here we are.
2015-02-19 18:56:45 +00:00
// Quantile too low.
{
expr: `histogram_quantile(-0.1, testhistogram_bucket)`,
output: []string{
`{start="positive"} => -Inf @[%v]`,
`{start="negative"} => -Inf @[%v]`,
},
},
// Quantile too high.
{
expr: `histogram_quantile(1.01, testhistogram_bucket)`,
output: []string{
`{start="positive"} => +Inf @[%v]`,
`{start="negative"} => +Inf @[%v]`,
},
},
// Quantile value in lowest bucket, which is positive.
{
expr: `histogram_quantile(0, testhistogram_bucket{start="positive"})`,
output: []string{
`{start="positive"} => 0 @[%v]`,
},
},
// Quantile value in lowest bucket, which is negative.
{
expr: `histogram_quantile(0, testhistogram_bucket{start="negative"})`,
output: []string{
`{start="negative"} => -0.2 @[%v]`,
},
},
// Quantile value in highest bucket.
{
expr: `histogram_quantile(1, testhistogram_bucket)`,
output: []string{
`{start="positive"} => 1 @[%v]`,
`{start="negative"} => 0.3 @[%v]`,
},
},
// Finally some useful quantiles.
{
expr: `histogram_quantile(0.2, testhistogram_bucket)`,
output: []string{
`{start="positive"} => 0.048 @[%v]`,
`{start="negative"} => -0.2 @[%v]`,
},
},
{
expr: `histogram_quantile(0.5, testhistogram_bucket)`,
output: []string{
`{start="positive"} => 0.15 @[%v]`,
`{start="negative"} => -0.15 @[%v]`,
},
},
{
expr: `histogram_quantile(0.8, testhistogram_bucket)`,
output: []string{
`{start="positive"} => 0.72 @[%v]`,
`{start="negative"} => 0.3 @[%v]`,
},
},
// More realistic with rates.
{
expr: `histogram_quantile(0.2, rate(testhistogram_bucket[5m]))`,
output: []string{
`{start="positive"} => 0.048 @[%v]`,
`{start="negative"} => -0.2 @[%v]`,
},
},
{
expr: `histogram_quantile(0.5, rate(testhistogram_bucket[5m]))`,
output: []string{
`{start="positive"} => 0.15 @[%v]`,
`{start="negative"} => -0.15 @[%v]`,
},
},
{
expr: `histogram_quantile(0.8, rate(testhistogram_bucket[5m]))`,
output: []string{
`{start="positive"} => 0.72 @[%v]`,
`{start="negative"} => 0.3 @[%v]`,
},
},
// Aggregated histogram: Everything in one.
{
expr: `histogram_quantile(0.3, sum(rate(request_duration_seconds_bucket[5m])) by (le))`,
output: []string{
`{} => 0.075 @[%v]`,
},
},
{
expr: `histogram_quantile(0.5, sum(rate(request_duration_seconds_bucket[5m])) by (le))`,
output: []string{
`{} => 0.1277777777777778 @[%v]`,
},
},
// Aggregated histogram: Everything in one. Now with avg, which does not change anything.
{
expr: `histogram_quantile(0.3, avg(rate(request_duration_seconds_bucket[5m])) by (le))`,
output: []string{
`{} => 0.075 @[%v]`,
},
},
{
expr: `histogram_quantile(0.5, avg(rate(request_duration_seconds_bucket[5m])) by (le))`,
output: []string{
`{} => 0.12777777777777778 @[%v]`,
},
},
// Aggregated histogram: By job.
{
expr: `histogram_quantile(0.3, sum(rate(request_duration_seconds_bucket[5m])) by (le, instance))`,
output: []string{
`{instance="ins1"} => 0.075 @[%v]`,
`{instance="ins2"} => 0.075 @[%v]`,
},
},
{
expr: `histogram_quantile(0.5, sum(rate(request_duration_seconds_bucket[5m])) by (le, instance))`,
output: []string{
`{instance="ins1"} => 0.1333333333 @[%v]`,
`{instance="ins2"} => 0.125 @[%v]`,
},
},
// Aggregated histogram: By instance.
{
expr: `histogram_quantile(0.3, sum(rate(request_duration_seconds_bucket[5m])) by (le, job))`,
output: []string{
`{job="job1"} => 0.1 @[%v]`,
`{job="job2"} => 0.0642857142857143 @[%v]`,
},
},
{
expr: `histogram_quantile(0.5, sum(rate(request_duration_seconds_bucket[5m])) by (le, job))`,
output: []string{
`{job="job1"} => 0.14 @[%v]`,
`{job="job2"} => 0.1125 @[%v]`,
},
},
// Aggregated histogram: By job and instance.
{
expr: `histogram_quantile(0.3, sum(rate(request_duration_seconds_bucket[5m])) by (le, job, instance))`,
output: []string{
`{instance="ins1", job="job1"} => 0.11 @[%v]`,
`{instance="ins2", job="job1"} => 0.09 @[%v]`,
`{instance="ins1", job="job2"} => 0.06 @[%v]`,
`{instance="ins2", job="job2"} => 0.0675 @[%v]`,
},
},
{
expr: `histogram_quantile(0.5, sum(rate(request_duration_seconds_bucket[5m])) by (le, job, instance))`,
output: []string{
`{instance="ins1", job="job1"} => 0.15 @[%v]`,
`{instance="ins2", job="job1"} => 0.1333333333333333 @[%v]`,
`{instance="ins1", job="job2"} => 0.1 @[%v]`,
`{instance="ins2", job="job2"} => 0.1166666666666667 @[%v]`,
},
},
// The unaggregated histogram for comparison. Same result as the previous one.
{
expr: `histogram_quantile(0.3, rate(request_duration_seconds_bucket[5m]))`,
output: []string{
`{instance="ins1", job="job1"} => 0.11 @[%v]`,
`{instance="ins2", job="job1"} => 0.09 @[%v]`,
`{instance="ins1", job="job2"} => 0.06 @[%v]`,
`{instance="ins2", job="job2"} => 0.0675 @[%v]`,
},
},
{
expr: `histogram_quantile(0.5, rate(request_duration_seconds_bucket[5m]))`,
output: []string{
`{instance="ins1", job="job1"} => 0.15 @[%v]`,
`{instance="ins2", job="job1"} => 0.13333333333333333 @[%v]`,
`{instance="ins1", job="job2"} => 0.1 @[%v]`,
`{instance="ins2", job="job2"} => 0.11666666666666667 @[%v]`,
},
},
Support scientific notation and special float values. This adds support for scientific notation in the expression language, as well as for all possible literal forms of +Inf/-Inf/NaN. TODO: Keep enough state in the parser/lexer to distinguish contexts in which "Inf", "NaN", etc. should be parsed as a number vs. parsed as a label name. Currently, foo{nan="bar"} would be a syntax error. However, that is an existing bug for all our reserved words. E.g. foo{sum="bar"} is a syntax error as well. This should be fixed separately.
2015-03-01 18:18:33 +00:00
{
expr: `12.34e6`,
output: []string{`scalar: 12340000 @[%v]`},
},
{
expr: `12.34e+6`,
output: []string{`scalar: 12340000 @[%v]`},
},
{
expr: `12.34e-6`,
output: []string{`scalar: 0.00001234 @[%v]`},
},
Fix unary +/- expressions. Unary expressions cause parsing errors if they are done in the lexer by tokenizing them into the number. This fix moves unary expressions to the parser.
2015-03-03 11:16:46 +00:00
{
expr: `1+1`,
output: []string{`scalar: 2 @[%v]`},
},
{
expr: `1-1`,
output: []string{`scalar: 0 @[%v]`},
},
{
expr: `1 - -1`,
output: []string{`scalar: 2 @[%v]`},
},
Support scientific notation and special float values. This adds support for scientific notation in the expression language, as well as for all possible literal forms of +Inf/-Inf/NaN. TODO: Keep enough state in the parser/lexer to distinguish contexts in which "Inf", "NaN", etc. should be parsed as a number vs. parsed as a label name. Currently, foo{nan="bar"} would be a syntax error. However, that is an existing bug for all our reserved words. E.g. foo{sum="bar"} is a syntax error as well. This should be fixed separately.
2015-03-01 18:18:33 +00:00
{
expr: `.2`,
output: []string{`scalar: 0.2 @[%v]`},
},
{
expr: `+0.2`,
output: []string{`scalar: 0.2 @[%v]`},
},
{
expr: `-0.2e-6`,
output: []string{`scalar: -0.0000002 @[%v]`},
},
{
expr: `+Inf`,
output: []string{`scalar: +Inf @[%v]`},
},
{
expr: `inF`,
output: []string{`scalar: +Inf @[%v]`},
},
{
expr: `-inf`,
output: []string{`scalar: -Inf @[%v]`},
},
{
expr: `NaN`,
output: []string{`scalar: NaN @[%v]`},
},
{
expr: `nan`,
output: []string{`scalar: NaN @[%v]`},
},
{
Also support parsing float formats like "2.".
2015-03-01 21:49:06 +00:00
expr: `2.`,
output: []string{`scalar: 2 @[%v]`},
Support scientific notation and special float values. This adds support for scientific notation in the expression language, as well as for all possible literal forms of +Inf/-Inf/NaN. TODO: Keep enough state in the parser/lexer to distinguish contexts in which "Inf", "NaN", etc. should be parsed as a number vs. parsed as a label name. Currently, foo{nan="bar"} would be a syntax error. However, that is an existing bug for all our reserved words. E.g. foo{sum="bar"} is a syntax error as well. This should be fixed separately.
2015-03-01 18:18:33 +00:00
},
{
expr: `999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999`,
output: []string{`scalar: +Inf @[%v]`},
},
Fix special value handling in division and modulo. This fixes https://github.com/prometheus/prometheus/issues/597
2015-03-16 13:23:03 +00:00
{
expr: `1 / 0`,
output: []string{`scalar: +Inf @[%v]`},
},
{
expr: `-1 / 0`,
output: []string{`scalar: -Inf @[%v]`},
},
{
expr: `0 / 0`,
output: []string{`scalar: NaN @[%v]`},
},
{
expr: `1 % 0`,
output: []string{`scalar: NaN @[%v]`},
},
{
expr: `http_requests{group="canary", instance="0", job="api-server"} / 0`,
output: []string{
`{group="canary", instance="0", job="api-server"} => +Inf @[%v]`,
},
},
{
expr: `-1 * http_requests{group="canary", instance="0", job="api-server"} / 0`,
output: []string{
`{group="canary", instance="0", job="api-server"} => -Inf @[%v]`,
},
},
{
expr: `0 * http_requests{group="canary", instance="0", job="api-server"} / 0`,
output: []string{
`{group="canary", instance="0", job="api-server"} => NaN @[%v]`,
},
},
{
expr: `0 * http_requests{group="canary", instance="0", job="api-server"} % 0`,
output: []string{
`{group="canary", instance="0", job="api-server"} => NaN @[%v]`,
},
},
Add ln, log2, log10 and exp functions to the query language.
2015-03-16 14:57:47 +00:00
{
expr: `exp(vector_matching_a)`,
output: []string{
`{l="x"} => 22026.465794806718 @[%v]`,
`{l="y"} => 485165195.4097903 @[%v]`,
},
},
{
expr: `exp(vector_matching_a - 10)`,
output: []string{
`{l="y"} => 22026.465794806718 @[%v]`,
`{l="x"} => 1 @[%v]`,
},
},
{
expr: `exp(vector_matching_a - 20)`,
output: []string{
`{l="x"} => 4.5399929762484854e-05 @[%v]`,
`{l="y"} => 1 @[%v]`,
},
},
{
expr: `ln(vector_matching_a)`,
output: []string{
`{l="x"} => 2.302585092994046 @[%v]`,
`{l="y"} => 2.995732273553991 @[%v]`,
},
},
{
expr: `ln(vector_matching_a - 10)`,
output: []string{
`{l="y"} => 2.302585092994046 @[%v]`,
`{l="x"} => -Inf @[%v]`,
},
},
{
expr: `ln(vector_matching_a - 20)`,
output: []string{
`{l="y"} => -Inf @[%v]`,
`{l="x"} => NaN @[%v]`,
},
},
{
expr: `exp(ln(vector_matching_a))`,
output: []string{
`{l="y"} => 20 @[%v]`,
`{l="x"} => 10 @[%v]`,
},
},
{
expr: `log2(vector_matching_a)`,
output: []string{
`{l="x"} => 3.3219280948873626 @[%v]`,
`{l="y"} => 4.321928094887363 @[%v]`,
},
},
{
expr: `log2(vector_matching_a - 10)`,
output: []string{
`{l="y"} => 3.3219280948873626 @[%v]`,
`{l="x"} => -Inf @[%v]`,
},
},
{
expr: `log2(vector_matching_a - 20)`,
output: []string{
`{l="x"} => NaN @[%v]`,
`{l="y"} => -Inf @[%v]`,
},
},
{
expr: `log10(vector_matching_a)`,
output: []string{
`{l="x"} => 1 @[%v]`,
`{l="y"} => 1.301029995663981 @[%v]`,
},
},
{
expr: `log10(vector_matching_a - 10)`,
output: []string{
`{l="y"} => 1 @[%v]`,
`{l="x"} => -Inf @[%v]`,
},
},
{
expr: `log10(vector_matching_a - 20)`,
output: []string{
`{l="x"} => NaN @[%v]`,
`{l="y"} => -Inf @[%v]`,
},
},
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
}
Use AST query analyzer and views with tiered storage.
2013-03-21 17:06:15 +00:00
Initial experimental snapshot of next-gen storage. Change-Id: Ifb8709960dbedd1d9f5efd88cdd359ee9fa9d26d
2014-06-06 09:55:53 +00:00
storage, closer := newTestStorage(t)
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
defer closer.Close()
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
Add sort() and sort_desc() expression language functions.
2013-04-10 08:44:13 +00:00
for i, exprTest := range expressionTests {
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
expectedLines := annotateWithTime(exprTest.output, testEvalTime)
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
Allow grammar to parse both rules and single expressions.
2013-01-11 00:17:37 +00:00
testExpr, err := LoadExprFromString(exprTest.expr)
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
if err != nil {
Allow grammar to parse both rules and single expressions.
2013-01-11 00:17:37 +00:00
if exprTest.shouldFail {
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
continue
}
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
t.Errorf("%d. Error during parsing: %v", i, err)
t.Errorf("%d. Expression: %v", i, exprTest.expr)
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
} else {
Use AST query analyzer and views with tiered storage.
2013-03-21 17:06:15 +00:00
if exprTest.shouldFail {
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
t.Errorf("%d. Test should fail, but didn't", i)
Use AST query analyzer and views with tiered storage.
2013-03-21 17:06:15 +00:00
}
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
failed := false
Add OR operation and vector matching options. This commits implements the OR operation between two vectors. Vector matching using the ON clause is added to limit the set of labels that define a match between two elements. Group modifiers (GROUP_LEFT/GROUP_RIGHT) to request many-to-one matching are added.
2015-03-03 09:58:28 +00:00
Rename remaining all-caps constants in AST layer. Change-Id: Ibe97e30981969056ffcdb89e63c1468ea1ffa140
2014-12-25 00:28:35 +00:00
resultStr := ast.EvalToString(testExpr, testEvalTime, ast.Text, storage, stats.NewTimerGroup())
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
resultLines := strings.Split(resultStr, "\n")
Add OR operation and vector matching options. This commits implements the OR operation between two vectors. Vector matching using the ON clause is added to limit the set of labels that define a match between two elements. Group modifiers (GROUP_LEFT/GROUP_RIGHT) to request many-to-one matching are added.
2015-03-03 09:58:28 +00:00
if len(exprTest.output) == 0 && strings.Trim(resultStr, "\n") == "" {
// expected and received empty vector, everything is fine
continue
} else if len(exprTest.output) != len(resultLines) {
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
t.Errorf("%d. Number of samples in expected and actual output don't match", i)
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
failed = true
}
Add sort() and sort_desc() expression language functions.
2013-04-10 08:44:13 +00:00
if exprTest.checkOrder {
for j, expectedSample := range expectedLines {
if resultLines[j] != expectedSample {
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
t.Errorf("%d.%d. Expected sample '%v', got '%v'", i, j, resultLines[j], expectedSample)
Add sort() and sort_desc() expression language functions.
2013-04-10 08:44:13 +00:00
failed = true
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
}
}
Add sort() and sort_desc() expression language functions.
2013-04-10 08:44:13 +00:00
} else {
for j, expectedSample := range expectedLines {
found := false
for _, actualSample := range resultLines {
Add the histogram_quantile function. Since we are now getting really deep into floating point calculation, the tests had to take into account the precision loss. Since the rule tests are based on direct line matching in the output, implementing the "almost equal" semantics was pretty cumbersome, but here we are.
2015-02-19 18:56:45 +00:00
if samplesAlmostEqual(actualSample, expectedSample) {
Add sort() and sort_desc() expression language functions.
2013-04-10 08:44:13 +00:00
found = true
}
}
if !found {
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
t.Errorf("%d.%d. Couldn't find expected sample in output: '%v'", i, j, expectedSample)
Add sort() and sort_desc() expression language functions.
2013-04-10 08:44:13 +00:00
failed = true
}
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
}
}
Use AST query analyzer and views with tiered storage.
2013-03-21 17:06:15 +00:00
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
if failed {
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
t.Errorf("%d. Expression: %v\n%v", i, exprTest.expr, vectorComparisonString(expectedLines, resultLines))
Add initial config and rule language implementation.
2013-01-07 22:24:26 +00:00
}
}
}
}
Implement initial no-op alert parsing and rule parsing tests.
2013-04-22 22:26:59 +00:00
Add regression tests for metrics mutations in AST. It turned out in the end, that only drop_common_metrics() produced any erroneous output in the old system. The second expression in the test ("sum(testmetric) keeping_extra") already worked in the old code, but why not keep it in... The way to test ranged evaluations is a bit clumsy so far, so I want to build a nicer test framework in the end, where all the test cases can be specified as text files which specify desired inputs, outputs, query step widths, etc. Change-Id: I821859789e69b8232bededf670a1b76e9e8c8ca4
2014-12-12 19:01:32 +00:00
func TestRangedEvaluationRegressions(t *testing.T) {
scenarios := []struct {
in ast.Matrix
out ast.Matrix
expr string
}{
{
// Testing COWMetric behavior in drop_common_labels.
in: ast.Matrix{
{
Metric: clientmodel.COWMetric{
Metric: clientmodel.Metric{
clientmodel.MetricNameLabel: "testmetric",
"testlabel": "1",
},
},
Values: metric.Values{
{
Timestamp: testStartTime,
Value: 1,
},
{
Timestamp: testStartTime.Add(time.Hour),
Value: 1,
},
},
},
{
Metric: clientmodel.COWMetric{
Metric: clientmodel.Metric{
clientmodel.MetricNameLabel: "testmetric",
"testlabel": "2",
},
},
Values: metric.Values{
{
Timestamp: testStartTime.Add(time.Hour),
Value: 2,
},
},
},
},
out: ast.Matrix{
{
Metric: clientmodel.COWMetric{
Metric: clientmodel.Metric{
clientmodel.MetricNameLabel: "testmetric",
},
},
Values: metric.Values{
{
Timestamp: testStartTime,
Value: 1,
},
},
},
{
Metric: clientmodel.COWMetric{
Metric: clientmodel.Metric{
clientmodel.MetricNameLabel: "testmetric",
"testlabel": "1",
},
},
Values: metric.Values{
{
Timestamp: testStartTime.Add(time.Hour),
Value: 1,
},
},
},
{
Metric: clientmodel.COWMetric{
Metric: clientmodel.Metric{
clientmodel.MetricNameLabel: "testmetric",
"testlabel": "2",
},
},
Values: metric.Values{
{
Timestamp: testStartTime.Add(time.Hour),
Value: 2,
},
},
},
},
expr: "drop_common_labels(testmetric)",
},
{
// Testing COWMetric behavior in vector aggregation.
in: ast.Matrix{
{
Metric: clientmodel.COWMetric{
Metric: clientmodel.Metric{
clientmodel.MetricNameLabel: "testmetric",
"testlabel": "1",
},
},
Values: metric.Values{
{
Timestamp: testStartTime,
Value: 1,
},
{
Timestamp: testStartTime.Add(time.Hour),
Value: 1,
},
},
},
{
Metric: clientmodel.COWMetric{
Metric: clientmodel.Metric{
clientmodel.MetricNameLabel: "testmetric",
"testlabel": "2",
},
},
Values: metric.Values{
{
Timestamp: testStartTime,
Value: 2,
},
},
},
},
out: ast.Matrix{
{
Metric: clientmodel.COWMetric{
Metric: clientmodel.Metric{},
},
Values: metric.Values{
{
Timestamp: testStartTime,
Value: 3,
},
},
},
{
Metric: clientmodel.COWMetric{
Metric: clientmodel.Metric{
"testlabel": "1",
},
},
Values: metric.Values{
{
Timestamp: testStartTime.Add(time.Hour),
Value: 1,
},
},
},
},
expr: "sum(testmetric) keeping_extra",
},
Replace labelsToKey() with metric Fingerprint (fixes grouping bug).
2015-02-21 16:45:47 +00:00
{
// Testing metric fingerprint grouping behavior.
in: ast.Matrix{
{
Metric: clientmodel.COWMetric{
Metric: clientmodel.Metric{
clientmodel.MetricNameLabel: "testmetric",
"aa": "bb",
},
},
Values: metric.Values{
{
Timestamp: testStartTime,
Value: 1,
},
},
},
{
Metric: clientmodel.COWMetric{
Metric: clientmodel.Metric{
clientmodel.MetricNameLabel: "testmetric",
"a": "abb",
},
},
Values: metric.Values{
{
Timestamp: testStartTime,
Value: 2,
},
},
},
},
out: ast.Matrix{
{
Metric: clientmodel.COWMetric{
Metric: clientmodel.Metric{
clientmodel.MetricNameLabel: "testmetric",
"aa": "bb",
},
},
Values: metric.Values{
{
Timestamp: testStartTime,
Value: 1,
},
},
},
{
Metric: clientmodel.COWMetric{
Metric: clientmodel.Metric{
clientmodel.MetricNameLabel: "testmetric",
"a": "abb",
},
},
Values: metric.Values{
{
Timestamp: testStartTime,
Value: 2,
},
},
},
},
expr: "testmetric",
},
Add regression tests for metrics mutations in AST. It turned out in the end, that only drop_common_metrics() produced any erroneous output in the old system. The second expression in the test ("sum(testmetric) keeping_extra") already worked in the old code, but why not keep it in... The way to test ranged evaluations is a bit clumsy so far, so I want to build a nicer test framework in the end, where all the test cases can be specified as text files which specify desired inputs, outputs, query step widths, etc. Change-Id: I821859789e69b8232bededf670a1b76e9e8c8ca4
2014-12-12 19:01:32 +00:00
}
for i, s := range scenarios {
Implement double-delta encoded chunks.
2015-03-04 12:40:18 +00:00
storage, closer := local.NewTestStorage(t, 1)
Add regression tests for metrics mutations in AST. It turned out in the end, that only drop_common_metrics() produced any erroneous output in the old system. The second expression in the test ("sum(testmetric) keeping_extra") already worked in the old code, but why not keep it in... The way to test ranged evaluations is a bit clumsy so far, so I want to build a nicer test framework in the end, where all the test cases can be specified as text files which specify desired inputs, outputs, query step widths, etc. Change-Id: I821859789e69b8232bededf670a1b76e9e8c8ca4
2014-12-12 19:01:32 +00:00
storeMatrix(storage, s.in)
expr, err := LoadExprFromString(s.expr)
if err != nil {
t.Fatalf("%d. Error parsing expression: %v", i, err)
}
got, err := ast.EvalVectorRange(
expr.(ast.VectorNode),
testStartTime,
testStartTime.Add(time.Hour),
time.Hour,
storage,
stats.NewTimerGroup(),
)
if err != nil {
t.Fatalf("%d. Error evaluating expression: %v", i, err)
}
if got.String() != s.out.String() {
t.Fatalf("%d. Expression: %s\n\ngot:\n=====\n%v\n====\n\nwant:\n=====\n%v\n=====\n", i, s.expr, got.String(), s.out.String())
}
closer.Close()
}
}
Implement initial no-op alert parsing and rule parsing tests.
2013-04-22 22:26:59 +00:00
var ruleTests = []struct {
inputFile string
shouldFail bool
errContains string
numRecordingRules int
numAlertingRules int
}{
{
inputFile: "empty.rules",
numRecordingRules: 0,
numAlertingRules: 0,
}, {
inputFile: "mixed.rules",
numRecordingRules: 2,
numAlertingRules: 2,
},
{
inputFile: "syntax_error.rules",
shouldFail: true,
Swap rules lexer for much faster one. This swaps github.com/kivikakk/golex for github.com/cznic/golex. The old lexer would have taken 3.5 years to load a set of 5000 test rules (quadratic time complexity for input length), whereas this one takes only 32ms. Furthermore, since the new lexer is embedded differently, this gets rid of the global parser variables and makes the rule loader fully reentrant without a lock.
2013-07-11 16:38:44 +00:00
errContains: "Error parsing rules at line 5",
Implement initial no-op alert parsing and rule parsing tests.
2013-04-22 22:26:59 +00:00
},
{
inputFile: "non_vector.rules",
shouldFail: true,
errContains: "does not evaluate to vector type",
},
}
func TestRules(t *testing.T) {
for i, ruleTest := range ruleTests {
testRules, err := LoadRulesFromFile(path.Join(fixturesPath, ruleTest.inputFile))
if err != nil {
if !ruleTest.shouldFail {
t.Fatalf("%d. Error parsing rules file %v: %v", i, ruleTest.inputFile, err)
} else {
if !strings.Contains(err.Error(), ruleTest.errContains) {
t.Fatalf("%d. Expected error containing '%v', got: %v", i, ruleTest.errContains, err)
}
}
} else {
numRecordingRules := 0
numAlertingRules := 0
for j, rule := range testRules {
switch rule.(type) {
case *RecordingRule:
numRecordingRules++
case *AlertingRule:
numAlertingRules++
default:
t.Fatalf("%d.%d. Unknown rule type!", i, j)
}
}
if numRecordingRules != ruleTest.numRecordingRules {
t.Fatalf("%d. Expected %d recording rules, got %d", i, ruleTest.numRecordingRules, numRecordingRules)
}
if numAlertingRules != ruleTest.numAlertingRules {
t.Fatalf("%d. Expected %d alerting rules, got %d", i, ruleTest.numAlertingRules, numAlertingRules)
}
// TODO(julius): add more complex checks on the parsed rules here.
}
}
}
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
func TestAlertingRule(t *testing.T) {
// Labels in expected output need to be alphabetically sorted.
var evalOutputs = [][]string{
{
Add alertmanager notification support to Prometheus. Alert definitions now also have mandatory SUMMARY and DESCRIPTION fields that get sent along a firing alert to the alert manager.
2013-07-30 15:18:07 +00:00
`ALERTS{alertname="HttpRequestRateLow", alertstate="pending", group="canary", instance="0", job="app-server", severity="critical"} => 1 @[%v]`,
`ALERTS{alertname="HttpRequestRateLow", alertstate="pending", group="canary", instance="1", job="app-server", severity="critical"} => 1 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
{
Add alertmanager notification support to Prometheus. Alert definitions now also have mandatory SUMMARY and DESCRIPTION fields that get sent along a firing alert to the alert manager.
2013-07-30 15:18:07 +00:00
`ALERTS{alertname="HttpRequestRateLow", alertstate="pending", group="canary", instance="0", job="app-server", severity="critical"} => 0 @[%v]`,
`ALERTS{alertname="HttpRequestRateLow", alertstate="firing", group="canary", instance="0", job="app-server", severity="critical"} => 1 @[%v]`,
`ALERTS{alertname="HttpRequestRateLow", alertstate="pending", group="canary", instance="1", job="app-server", severity="critical"} => 0 @[%v]`,
`ALERTS{alertname="HttpRequestRateLow", alertstate="firing", group="canary", instance="1", job="app-server", severity="critical"} => 1 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
{
Add alertmanager notification support to Prometheus. Alert definitions now also have mandatory SUMMARY and DESCRIPTION fields that get sent along a firing alert to the alert manager.
2013-07-30 15:18:07 +00:00
`ALERTS{alertname="HttpRequestRateLow", alertstate="firing", group="canary", instance="1", job="app-server", severity="critical"} => 0 @[%v]`,
`ALERTS{alertname="HttpRequestRateLow", alertstate="firing", group="canary", instance="0", job="app-server", severity="critical"} => 0 @[%v]`,
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
},
{
/* empty */
},
{
/* empty */
},
}
Initial experimental snapshot of next-gen storage. Change-Id: Ifb8709960dbedd1d9f5efd88cdd359ee9fa9d26d
2014-06-06 09:55:53 +00:00
storage, closer := newTestStorage(t)
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
defer closer.Close()
Improve printing of rules and expressions.
2013-06-11 09:01:36 +00:00
alertExpr, err := LoadExprFromString(`http_requests{group="canary", job="app-server"} < 100`)
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
if err != nil {
t.Fatalf("Unable to parse alert expression: %s", err)
}
alertName := "HttpRequestRateLow"
WIP - Snapshot of Moving to Client Model.
2013-06-25 12:02:27 +00:00
alertLabels := clientmodel.LabelSet{
Add alertmanager notification support to Prometheus. Alert definitions now also have mandatory SUMMARY and DESCRIPTION fields that get sent along a firing alert to the alert manager.
2013-07-30 15:18:07 +00:00
"severity": "critical",
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
}
Add alertmanager notification support to Prometheus. Alert definitions now also have mandatory SUMMARY and DESCRIPTION fields that get sent along a firing alert to the alert manager.
2013-07-30 15:18:07 +00:00
rule := NewAlertingRule(alertName, alertExpr.(ast.VectorNode), time.Minute, alertLabels, "summary", "description")
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
for i, expected := range evalOutputs {
evalTime := testStartTime.Add(testSampleInterval * time.Duration(i))
Initial experimental snapshot of next-gen storage. Change-Id: Ifb8709960dbedd1d9f5efd88cdd359ee9fa9d26d
2014-06-06 09:55:53 +00:00
actual, err := rule.Eval(evalTime, storage)
Track alerts over time and write out alert timeseries.
2013-04-24 09:51:40 +00:00
if err != nil {
t.Fatalf("Error during alerting rule evaluation: %s", err)
}
actualLines := strings.Split(actual.String(), "\n")
expectedLines := annotateWithTime(expected, evalTime)
if actualLines[0] == "" {
actualLines = []string{}
}
failed := false
if len(actualLines) != len(expectedLines) {
t.Errorf("%d. Number of samples in expected and actual output don't match (%d vs. %d)", i, len(expectedLines), len(actualLines))
failed = true
}
for j, expectedSample := range expectedLines {
found := false
for _, actualSample := range actualLines {
if actualSample == expectedSample {
found = true
}
}
if !found {
t.Errorf("%d.%d. Couldn't find expected sample in output: '%v'", i, j, expectedSample)
failed = true
}
}
if failed {
t.Fatalf("%d. Expected and actual outputs don't match:\n%v", i, vectorComparisonString(expectedLines, actualLines))
}
}
}