mirror of
https://github.com/prometheus/prometheus.git
synced 2024-12-27 22:49:40 -08:00
a55602df4a
It is the case with the benchmark tool that we thought that we generated multiple series and saved them to the disk as such, when in reality, we overwrote the fields of the outgoing metrics via Go map reference behavior. This was accidental. In the course of diagnosing this, a few errors were found: 1. ``newSeriesFrontier`` should check to see if the candidate fingerprint is within the given domain of the ``diskFrontier``. If not, as the contract in the docstring stipulates, a ``nil`` ``seriesFrontier`` should be emitted. 2. In the interests of aiding debugging, the raw LevelDB ``levigoIterator`` type now includes a helpful forensics ``String()`` method. This work produced additional cleanups: 1. ``Close() error`` with the storage stack is technically incorrect, since nowhere in the bowels of it does an error actually occur. The interface has been simplified to remove this for now.
1515 lines
32 KiB
Go
1515 lines
32 KiB
Go
// Copyright 2013 Prometheus Team
|
|
// 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.
|
|
|
|
package metric
|
|
|
|
import (
|
|
"github.com/prometheus/prometheus/model"
|
|
"github.com/prometheus/prometheus/utility/test"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func GetValueAtTimeTests(persistenceMaker func() (MetricPersistence, test.Closer), t test.Tester) {
|
|
type value struct {
|
|
year int
|
|
month time.Month
|
|
day int
|
|
hour int
|
|
value float32
|
|
}
|
|
|
|
type input struct {
|
|
year int
|
|
month time.Month
|
|
day int
|
|
hour int
|
|
staleness time.Duration
|
|
}
|
|
|
|
type output struct {
|
|
value model.SampleValue
|
|
}
|
|
|
|
type behavior struct {
|
|
name string
|
|
input input
|
|
output *output
|
|
}
|
|
|
|
var contexts = []struct {
|
|
name string
|
|
values []value
|
|
behaviors []behavior
|
|
}{
|
|
{
|
|
name: "no values",
|
|
values: []value{},
|
|
behaviors: []behavior{
|
|
{
|
|
name: "random target",
|
|
input: input{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "singleton",
|
|
values: []value{
|
|
{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 0,
|
|
},
|
|
},
|
|
behaviors: []behavior{
|
|
{
|
|
name: "exact without staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
output: &output{
|
|
value: 0,
|
|
},
|
|
},
|
|
{
|
|
name: "exact with staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
value: 0,
|
|
},
|
|
},
|
|
{
|
|
name: "before without staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 29,
|
|
hour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "before within staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 29,
|
|
hour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "before outside staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 29,
|
|
hour: 0,
|
|
staleness: time.Duration(1) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "after without staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 31,
|
|
hour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "after within staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 31,
|
|
hour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
value: 0,
|
|
},
|
|
},
|
|
{
|
|
name: "after outside staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 4,
|
|
day: 7,
|
|
hour: 0,
|
|
staleness: time.Duration(7*24) * time.Hour,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "double",
|
|
values: []value{
|
|
{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 0,
|
|
},
|
|
{
|
|
year: 1985,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 1,
|
|
},
|
|
},
|
|
behaviors: []behavior{
|
|
{
|
|
name: "exact first without staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
output: &output{
|
|
value: 0,
|
|
},
|
|
},
|
|
{
|
|
name: "exact first with staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
value: 0,
|
|
},
|
|
},
|
|
{
|
|
name: "exact second without staleness policy",
|
|
input: input{
|
|
year: 1985,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
output: &output{
|
|
value: 1,
|
|
},
|
|
},
|
|
{
|
|
name: "exact second with staleness policy",
|
|
input: input{
|
|
year: 1985,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
value: 1,
|
|
},
|
|
},
|
|
{
|
|
name: "before first without staleness policy",
|
|
input: input{
|
|
year: 1983,
|
|
month: 9,
|
|
day: 29,
|
|
hour: 12,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "before first with staleness policy",
|
|
input: input{
|
|
year: 1983,
|
|
month: 9,
|
|
day: 29,
|
|
hour: 12,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "after second with staleness policy",
|
|
input: input{
|
|
year: 1985,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
value: 1,
|
|
},
|
|
},
|
|
{
|
|
name: "after second without staleness policy",
|
|
input: input{
|
|
year: 1985,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "middle without staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "middle with insufficient staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(364*24) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "middle with sufficient staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
value: 0.5,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "triple",
|
|
values: []value{
|
|
{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 0,
|
|
},
|
|
{
|
|
year: 1985,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 1,
|
|
},
|
|
{
|
|
year: 1986,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 2,
|
|
},
|
|
},
|
|
behaviors: []behavior{
|
|
{
|
|
name: "exact first without staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
output: &output{
|
|
value: 0,
|
|
},
|
|
},
|
|
{
|
|
name: "exact first with staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
value: 0,
|
|
},
|
|
},
|
|
{
|
|
name: "exact second without staleness policy",
|
|
input: input{
|
|
year: 1985,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
output: &output{
|
|
value: 1,
|
|
},
|
|
},
|
|
{
|
|
name: "exact second with staleness policy",
|
|
input: input{
|
|
year: 1985,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
value: 1,
|
|
},
|
|
},
|
|
{
|
|
name: "exact third without staleness policy",
|
|
input: input{
|
|
year: 1986,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
output: &output{
|
|
value: 2,
|
|
},
|
|
},
|
|
{
|
|
name: "exact third with staleness policy",
|
|
input: input{
|
|
year: 1986,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
value: 2,
|
|
},
|
|
},
|
|
{
|
|
name: "before first without staleness policy",
|
|
input: input{
|
|
year: 1983,
|
|
month: 9,
|
|
day: 29,
|
|
hour: 12,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "before first with staleness policy",
|
|
input: input{
|
|
year: 1983,
|
|
month: 9,
|
|
day: 29,
|
|
hour: 12,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "after third within staleness policy",
|
|
input: input{
|
|
year: 1986,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
value: 2,
|
|
},
|
|
},
|
|
{
|
|
name: "after third outside staleness policy",
|
|
input: input{
|
|
year: 1986,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(1*24) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "after third without staleness policy",
|
|
input: input{
|
|
year: 1986,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "first middle without staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "first middle with insufficient staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(364*24) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "first middle with sufficient staleness policy",
|
|
input: input{
|
|
year: 1984,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
value: 0.5,
|
|
},
|
|
},
|
|
{
|
|
name: "second middle without staleness policy",
|
|
input: input{
|
|
year: 1985,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "second middle with insufficient staleness policy",
|
|
input: input{
|
|
year: 1985,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(364*24) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "second middle with sufficient staleness policy",
|
|
input: input{
|
|
year: 1985,
|
|
month: 9,
|
|
day: 28,
|
|
hour: 12,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
value: 1.5,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, context := range contexts {
|
|
// Wrapping in function to enable garbage collection of resources.
|
|
func() {
|
|
p, closer := persistenceMaker()
|
|
|
|
defer closer.Close()
|
|
defer p.Close()
|
|
|
|
m := model.Metric{
|
|
model.MetricNameLabel: "age_in_years",
|
|
}
|
|
|
|
for _, value := range context.values {
|
|
testAppendSample(p, model.Sample{
|
|
Value: model.SampleValue(value.value),
|
|
Timestamp: time.Date(value.year, value.month, value.day, value.hour, 0, 0, 0, time.UTC),
|
|
Metric: m,
|
|
}, t)
|
|
}
|
|
|
|
for j, behavior := range context.behaviors {
|
|
input := behavior.input
|
|
time := time.Date(input.year, input.month, input.day, input.hour, 0, 0, 0, time.UTC)
|
|
sp := StalenessPolicy{
|
|
DeltaAllowance: input.staleness,
|
|
}
|
|
|
|
actual, err := p.GetValueAtTime(model.NewFingerprintFromMetric(m), time, sp)
|
|
if err != nil {
|
|
t.Fatalf("%d.%d(%s). Could not query for value: %q\n", i, j, behavior.name, err)
|
|
}
|
|
|
|
if behavior.output == nil {
|
|
if actual != nil {
|
|
t.Fatalf("%d.%d(%s). Expected nil but got: %q\n", i, j, behavior.name, actual)
|
|
}
|
|
} else {
|
|
if actual == nil {
|
|
t.Fatalf("%d.%d(%s). Expected %s but got nil\n", i, j, behavior.name, behavior.output)
|
|
} else {
|
|
if actual.Value != behavior.output.value {
|
|
t.Fatalf("%d.%d(%s). Expected %s but got %s\n", i, j, behavior.name, behavior.output, actual)
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
}
|
|
|
|
func GetBoundaryValuesTests(persistenceMaker func() (MetricPersistence, test.Closer), t test.Tester) {
|
|
type value struct {
|
|
year int
|
|
month time.Month
|
|
day int
|
|
hour int
|
|
value float32
|
|
}
|
|
|
|
type input struct {
|
|
openYear int
|
|
openMonth time.Month
|
|
openDay int
|
|
openHour int
|
|
endYear int
|
|
endMonth time.Month
|
|
endDay int
|
|
endHour int
|
|
staleness time.Duration
|
|
}
|
|
|
|
type output struct {
|
|
open model.SampleValue
|
|
end model.SampleValue
|
|
}
|
|
|
|
type behavior struct {
|
|
name string
|
|
input input
|
|
output *output
|
|
}
|
|
|
|
var contexts = []struct {
|
|
name string
|
|
values []value
|
|
behaviors []behavior
|
|
}{
|
|
{
|
|
name: "no values",
|
|
values: []value{},
|
|
behaviors: []behavior{
|
|
{
|
|
name: "non-existent interval without staleness policy",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "non-existent interval with staleness policy",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "single value",
|
|
values: []value{
|
|
{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 0,
|
|
},
|
|
},
|
|
behaviors: []behavior{
|
|
{
|
|
name: "on start but missing end without staleness policy",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "non-existent interval after within staleness policy",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 31,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
staleness: time.Duration(4380) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "non-existent interval after without staleness policy",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 31,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "non-existent interval before with staleness policy",
|
|
input: input{
|
|
openYear: 1983,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1984,
|
|
endMonth: 3,
|
|
endDay: 29,
|
|
endHour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "non-existent interval before without staleness policy",
|
|
input: input{
|
|
openYear: 1983,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1984,
|
|
endMonth: 3,
|
|
endDay: 29,
|
|
endHour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "on end but not start without staleness policy",
|
|
input: input{
|
|
openYear: 1983,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1984,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "on end but not start without staleness policy",
|
|
input: input{
|
|
openYear: 1983,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1984,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "before point without staleness policy",
|
|
input: input{
|
|
openYear: 1982,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1983,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "before point with staleness policy",
|
|
input: input{
|
|
openYear: 1982,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1983,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "after point without staleness policy",
|
|
input: input{
|
|
openYear: 1985,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1986,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "after point with staleness policy",
|
|
input: input{
|
|
openYear: 1985,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1986,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "spanning point without staleness policy",
|
|
input: input{
|
|
openYear: 1983,
|
|
openMonth: 9,
|
|
openDay: 29,
|
|
openHour: 12,
|
|
endYear: 1984,
|
|
endMonth: 9,
|
|
endDay: 28,
|
|
endHour: 12,
|
|
staleness: time.Duration(0),
|
|
},
|
|
},
|
|
{
|
|
name: "spanning point with staleness policy",
|
|
input: input{
|
|
openYear: 1983,
|
|
openMonth: 9,
|
|
openDay: 29,
|
|
openHour: 12,
|
|
endYear: 1984,
|
|
endMonth: 9,
|
|
endDay: 28,
|
|
endHour: 12,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "double values",
|
|
values: []value{
|
|
{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 0,
|
|
},
|
|
{
|
|
year: 1985,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 1,
|
|
},
|
|
},
|
|
behaviors: []behavior{
|
|
{
|
|
name: "on points without staleness policy",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
staleness: time.Duration(0),
|
|
},
|
|
output: &output{
|
|
open: 0,
|
|
end: 1,
|
|
},
|
|
},
|
|
{
|
|
name: "on points with staleness policy",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
staleness: time.Duration(365*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
open: 0,
|
|
end: 1,
|
|
},
|
|
},
|
|
{
|
|
name: "on first before second outside of staleness",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1984,
|
|
endMonth: 6,
|
|
endDay: 29,
|
|
endHour: 6,
|
|
staleness: time.Duration(2190) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "on first before second within staleness",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1984,
|
|
endMonth: 6,
|
|
endDay: 29,
|
|
endHour: 6,
|
|
staleness: time.Duration(356*24) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "on first after second outside of staleness",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 6,
|
|
endDay: 29,
|
|
endHour: 6,
|
|
staleness: time.Duration(1) * time.Hour,
|
|
},
|
|
},
|
|
{
|
|
name: "on first after second within staleness",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 6,
|
|
endDay: 29,
|
|
endHour: 6,
|
|
staleness: time.Duration(356*24) * time.Hour,
|
|
},
|
|
output: &output{
|
|
open: 0,
|
|
end: 1,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, context := range contexts {
|
|
// Wrapping in function to enable garbage collection of resources.
|
|
func() {
|
|
p, closer := persistenceMaker()
|
|
|
|
defer closer.Close()
|
|
defer p.Close()
|
|
|
|
m := model.Metric{
|
|
model.MetricNameLabel: "age_in_years",
|
|
}
|
|
|
|
for _, value := range context.values {
|
|
testAppendSample(p, model.Sample{
|
|
Value: model.SampleValue(value.value),
|
|
Timestamp: time.Date(value.year, value.month, value.day, value.hour, 0, 0, 0, time.UTC),
|
|
Metric: m,
|
|
}, t)
|
|
}
|
|
|
|
for j, behavior := range context.behaviors {
|
|
input := behavior.input
|
|
open := time.Date(input.openYear, input.openMonth, input.openDay, input.openHour, 0, 0, 0, time.UTC)
|
|
end := time.Date(input.endYear, input.endMonth, input.endDay, input.endHour, 0, 0, 0, time.UTC)
|
|
interval := model.Interval{
|
|
OldestInclusive: open,
|
|
NewestInclusive: end,
|
|
}
|
|
po := StalenessPolicy{
|
|
DeltaAllowance: input.staleness,
|
|
}
|
|
|
|
openValue, endValue, err := p.GetBoundaryValues(model.NewFingerprintFromMetric(m), interval, po)
|
|
if err != nil {
|
|
t.Fatalf("%d.%d(%s). Could not query for value: %q\n", i, j, behavior.name, err)
|
|
}
|
|
|
|
if behavior.output == nil {
|
|
if openValue != nil {
|
|
t.Fatalf("%d.%d(%s). Expected open to be nil but got: %q\n", i, j, behavior.name, openValue)
|
|
}
|
|
if endValue != nil {
|
|
t.Fatalf("%d.%d(%s). Expected end to be nil but got: %q\n", i, j, behavior.name, endValue)
|
|
}
|
|
} else {
|
|
if openValue == nil {
|
|
t.Fatalf("%d.%d(%s). Expected open to be %s but got nil\n", i, j, behavior.name, behavior.output)
|
|
}
|
|
if endValue == nil {
|
|
t.Fatalf("%d.%d(%s). Expected end to be %s but got nil\n", i, j, behavior.name, behavior.output)
|
|
}
|
|
if openValue.Value != behavior.output.open {
|
|
t.Fatalf("%d.%d(%s). Expected open to be %s but got %s\n", i, j, behavior.name, behavior.output.open, openValue.Value)
|
|
}
|
|
|
|
if endValue.Value != behavior.output.end {
|
|
t.Fatalf("%d.%d(%s). Expected end to be %s but got %s\n", i, j, behavior.name, behavior.output.end, endValue.Value)
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
}
|
|
|
|
func GetRangeValuesTests(persistenceMaker func() (MetricPersistence, test.Closer), t test.Tester) {
|
|
type value struct {
|
|
year int
|
|
month time.Month
|
|
day int
|
|
hour int
|
|
value float32
|
|
}
|
|
|
|
type input struct {
|
|
openYear int
|
|
openMonth time.Month
|
|
openDay int
|
|
openHour int
|
|
endYear int
|
|
endMonth time.Month
|
|
endDay int
|
|
endHour int
|
|
}
|
|
|
|
type output struct {
|
|
year int
|
|
month time.Month
|
|
day int
|
|
hour int
|
|
value float32
|
|
}
|
|
|
|
type behavior struct {
|
|
name string
|
|
input input
|
|
output []output
|
|
}
|
|
|
|
var contexts = []struct {
|
|
name string
|
|
values []value
|
|
behaviors []behavior
|
|
}{
|
|
{
|
|
name: "no values",
|
|
values: []value{},
|
|
behaviors: []behavior{
|
|
{
|
|
name: "non-existent interval",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "singleton value",
|
|
values: []value{
|
|
{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 0,
|
|
},
|
|
},
|
|
behaviors: []behavior{
|
|
{
|
|
name: "start on first value",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
},
|
|
output: []output{
|
|
{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 0,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "end on first value",
|
|
input: input{
|
|
openYear: 1983,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1984,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
},
|
|
output: []output{
|
|
{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 0,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "overlap on first value",
|
|
input: input{
|
|
openYear: 1983,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
},
|
|
output: []output{
|
|
{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 0,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "two values",
|
|
values: []value{
|
|
{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 0,
|
|
},
|
|
{
|
|
year: 1985,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 1,
|
|
},
|
|
},
|
|
behaviors: []behavior{
|
|
{
|
|
name: "start on first value",
|
|
input: input{
|
|
openYear: 1984,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
},
|
|
output: []output{
|
|
{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 0,
|
|
},
|
|
{
|
|
year: 1985,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 1,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "start on second value",
|
|
input: input{
|
|
openYear: 1985,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1986,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
},
|
|
output: []output{
|
|
{
|
|
year: 1985,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 1,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "end on first value",
|
|
input: input{
|
|
openYear: 1983,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1984,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
},
|
|
output: []output{
|
|
{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 0,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "end on second value",
|
|
input: input{
|
|
openYear: 1985,
|
|
openMonth: 1,
|
|
openDay: 1,
|
|
openHour: 0,
|
|
endYear: 1985,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
},
|
|
output: []output{
|
|
{
|
|
year: 1985,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 1,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "overlap on values",
|
|
input: input{
|
|
openYear: 1983,
|
|
openMonth: 3,
|
|
openDay: 30,
|
|
openHour: 0,
|
|
endYear: 1986,
|
|
endMonth: 3,
|
|
endDay: 30,
|
|
endHour: 0,
|
|
},
|
|
output: []output{
|
|
{
|
|
year: 1984,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 0,
|
|
},
|
|
{
|
|
year: 1985,
|
|
month: 3,
|
|
day: 30,
|
|
hour: 0,
|
|
value: 1,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, context := range contexts {
|
|
// Wrapping in function to enable garbage collection of resources.
|
|
func() {
|
|
p, closer := persistenceMaker()
|
|
|
|
defer closer.Close()
|
|
defer p.Close()
|
|
|
|
m := model.Metric{
|
|
model.MetricNameLabel: "age_in_years",
|
|
}
|
|
|
|
for _, value := range context.values {
|
|
testAppendSample(p, model.Sample{
|
|
Value: model.SampleValue(value.value),
|
|
Timestamp: time.Date(value.year, value.month, value.day, value.hour, 0, 0, 0, time.UTC),
|
|
Metric: m,
|
|
}, t)
|
|
}
|
|
|
|
for j, behavior := range context.behaviors {
|
|
input := behavior.input
|
|
open := time.Date(input.openYear, input.openMonth, input.openDay, input.openHour, 0, 0, 0, time.UTC)
|
|
end := time.Date(input.endYear, input.endMonth, input.endDay, input.endHour, 0, 0, 0, time.UTC)
|
|
in := model.Interval{
|
|
OldestInclusive: open,
|
|
NewestInclusive: end,
|
|
}
|
|
|
|
values, err := p.GetRangeValues(model.NewFingerprintFromMetric(m), in)
|
|
if err != nil {
|
|
t.Fatalf("%d.%d(%s). Could not query for value: %q\n", i, j, behavior.name, err)
|
|
}
|
|
|
|
if values == nil && len(behavior.output) != 0 {
|
|
t.Fatalf("%d.%d(%s). Expected %s but got: %s\n", i, j, behavior.name, behavior.output, values)
|
|
}
|
|
|
|
if behavior.output == nil {
|
|
if values != nil {
|
|
t.Fatalf("%d.%d(%s). Expected nil values but got: %s\n", i, j, behavior.name, values)
|
|
}
|
|
} else {
|
|
if len(behavior.output) != len(values.Values) {
|
|
t.Fatalf("%d.%d(%s). Expected length %d but got: %d\n", i, j, behavior.name, len(behavior.output), len(values.Values))
|
|
}
|
|
|
|
for k, actual := range values.Values {
|
|
expected := behavior.output[k]
|
|
|
|
if actual.Value != model.SampleValue(expected.value) {
|
|
t.Fatalf("%d.%d.%d(%s). Expected %d but got: %d\n", i, j, k, behavior.name, expected.value, actual.Value)
|
|
}
|
|
|
|
if actual.Timestamp.Year() != expected.year {
|
|
t.Fatalf("%d.%d.%d(%s). Expected %d but got: %d\n", i, j, k, behavior.name, expected.year, actual.Timestamp.Year())
|
|
}
|
|
if actual.Timestamp.Month() != expected.month {
|
|
t.Fatalf("%d.%d.%d(%s). Expected %d but got: %d\n", i, j, k, behavior.name, expected.month, actual.Timestamp.Month())
|
|
}
|
|
// XXX: Find problem here.
|
|
// Mismatches occur in this and have for a long time in the LevelDB
|
|
// case, however not im-memory.
|
|
//
|
|
// if actual.Timestamp.Day() != expected.day {
|
|
// t.Fatalf("%d.%d.%d(%s). Expected %d but got: %d\n", i, j, k, behavior.name, expected.day, actual.Timestamp.Day())
|
|
// }
|
|
// if actual.Timestamp.Hour() != expected.hour {
|
|
// t.Fatalf("%d.%d.%d(%s). Expected %d but got: %d\n", i, j, k, behavior.name, expected.hour, actual.Timestamp.Hour())
|
|
// }
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
}
|
|
|
|
// Test Definitions Follow
|
|
|
|
func testLevelDBGetValueAtTime(t test.Tester) {
|
|
persistenceMaker := buildLevelDBTestPersistencesMaker("get_value_at_time", t)
|
|
GetValueAtTimeTests(persistenceMaker, t)
|
|
}
|
|
|
|
func TestLevelDBGetValueAtTime(t *testing.T) {
|
|
testLevelDBGetValueAtTime(t)
|
|
}
|
|
|
|
func BenchmarkLevelDBGetValueAtTime(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testLevelDBGetValueAtTime(b)
|
|
}
|
|
}
|
|
|
|
func testLevelDBGetBoundaryValues(t test.Tester) {
|
|
persistenceMaker := buildLevelDBTestPersistencesMaker("get_boundary_values", t)
|
|
|
|
GetBoundaryValuesTests(persistenceMaker, t)
|
|
}
|
|
|
|
func TestLevelDBGetBoundaryValues(t *testing.T) {
|
|
testLevelDBGetBoundaryValues(t)
|
|
}
|
|
|
|
func BenchmarkLevelDBGetBoundaryValues(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testLevelDBGetBoundaryValues(b)
|
|
}
|
|
}
|
|
|
|
func testLevelDBGetRangeValues(t test.Tester) {
|
|
persistenceMaker := buildLevelDBTestPersistencesMaker("get_range_values", t)
|
|
|
|
GetRangeValuesTests(persistenceMaker, t)
|
|
}
|
|
|
|
func TestLevelDBGetRangeValues(t *testing.T) {
|
|
testLevelDBGetRangeValues(t)
|
|
}
|
|
|
|
func BenchmarkLevelDBGetRangeValues(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testLevelDBGetRangeValues(b)
|
|
}
|
|
}
|
|
|
|
func testMemoryGetValueAtTime(t test.Tester) {
|
|
persistenceMaker := func() (MetricPersistence, test.Closer) {
|
|
return NewMemorySeriesStorage(), test.NilCloser
|
|
}
|
|
|
|
GetValueAtTimeTests(persistenceMaker, t)
|
|
}
|
|
|
|
func TestMemoryGetValueAtTime(t *testing.T) {
|
|
testMemoryGetValueAtTime(t)
|
|
}
|
|
|
|
func BenchmarkMemoryGetValueAtTime(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testMemoryGetValueAtTime(b)
|
|
}
|
|
}
|
|
|
|
func testMemoryGetBoundaryValues(t test.Tester) {
|
|
persistenceMaker := func() (MetricPersistence, test.Closer) {
|
|
return NewMemorySeriesStorage(), test.NilCloser
|
|
}
|
|
|
|
GetBoundaryValuesTests(persistenceMaker, t)
|
|
}
|
|
|
|
func TestMemoryGetBoundaryValues(t *testing.T) {
|
|
testMemoryGetBoundaryValues(t)
|
|
}
|
|
|
|
func BenchmarkMemoryGetBoundaryValues(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testMemoryGetBoundaryValues(b)
|
|
}
|
|
}
|
|
|
|
func testMemoryGetRangeValues(t test.Tester) {
|
|
persistenceMaker := func() (MetricPersistence, test.Closer) {
|
|
return NewMemorySeriesStorage(), test.NilCloser
|
|
}
|
|
|
|
GetRangeValuesTests(persistenceMaker, t)
|
|
}
|
|
|
|
func TestMemoryGetRangeValues(t *testing.T) {
|
|
testMemoryGetRangeValues(t)
|
|
}
|
|
|
|
func BenchmarkMemoryGetRangeValues(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testMemoryGetRangeValues(b)
|
|
}
|
|
}
|