mudhorn/prometheus
1
0
Fork 0
mirror of https://github.com/prometheus/prometheus.git synced 2024-11-09 15:14:04 -08:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Name float values as "floats", not as "values"

Browse source 
In the past, every sample value was a float, so it was fine to call a
variable holding such a float "value" or "sample". With native
histograms, a sample might have a histogram value. And a histogram
value is still a value. Calling a float value just "value" or "sample"
or "V" is therefore misleading. Over the last few commits, I already
renamed many variables, but this cleans up a few more places where the
changes are more invasive.

Note that we do not to attempt naming in the JSON APIs or in the
protobufs. That would be quite a disruption. However, internally, we
can call variables as we want, and we should go with the option of
avoiding misunderstandings.

Signed-off-by: beorn7 <beorn@grafana.com>
This commit is contained in:
beorn7 2023-03-30 19:50:13 +02:00
parent 462240bc78
commit 817a2396cb
18 changed files with 313 additions and 313 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
promql/functions.go
View file

@ -70,7 +70,7 @@ func extrapolatedRate(vals []parser.Value, args parser.Expressions, enh *EvalNod
samples = vals[0].(Matrix)[0]
rangeStart = enh.Ts - durationMilliseconds(ms.Range+vs.Offset)
rangeEnd = enh.Ts - durationMilliseconds(vs.Offset)
resultValue float64
resultFloat float64
resultHistogram *histogram.FloatHistogram
firstT, lastT int64
numSamplesMinusOne int
@ -99,7 +99,7 @@ func extrapolatedRate(vals []parser.Value, args parser.Expressions, enh *EvalNod
numSamplesMinusOne = len(samples.Floats) - 1
firstT = samples.Floats[0].T
lastT = samples.Floats[numSamplesMinusOne].T
resultValue = samples.Floats[numSamplesMinusOne].F - samples.Floats[0].F
resultFloat = samples.Floats[numSamplesMinusOne].F - samples.Floats[0].F
if !isCounter {
break
}
@ -107,7 +107,7 @@ func extrapolatedRate(vals []parser.Value, args parser.Expressions, enh *EvalNod
prevValue := samples.Floats[0].F
for _, currPoint := range samples.Floats[1:] {
if currPoint.F < prevValue {
resultValue += prevValue
resultFloat += prevValue
}
prevValue = currPoint.F
}
@ -124,14 +124,14 @@ func extrapolatedRate(vals []parser.Value, args parser.Expressions, enh *EvalNod
averageDurationBetweenSamples := sampledInterval / float64(numSamplesMinusOne)
// TODO(beorn7): Do this for histograms, too.
if isCounter && resultValue > 0 && len(samples.Floats) > 0 && samples.Floats[0].F >= 0 {
if isCounter && resultFloat > 0 && len(samples.Floats) > 0 && samples.Floats[0].F >= 0 {
// Counters cannot be negative. If we have any slope at all
// (i.e. resultValue went up), we can extrapolate the zero point
// (i.e. resultFloat went up), we can extrapolate the zero point
// of the counter. If the duration to the zero point is shorter
// than the durationToStart, we take the zero point as the start
// of the series, thereby avoiding extrapolation to negative
// counter values.
durationToZero := sampledInterval * (samples.Floats[0].F / resultValue)
durationToZero := sampledInterval * (samples.Floats[0].F / resultFloat)
if durationToZero < durationToStart {
durationToStart = durationToZero
}
@ -159,12 +159,12 @@ func extrapolatedRate(vals []parser.Value, args parser.Expressions, enh *EvalNod
factor /= ms.Range.Seconds()
}
if resultHistogram == nil {
resultValue *= factor
resultFloat *= factor
} else {
resultHistogram.Scale(factor)
}
return append(enh.Out, Sample{F: resultValue, H: resultHistogram})
return append(enh.Out, Sample{F: resultFloat, H: resultHistogram})
}
// histogramRate is a helper function for extrapolatedRate. It requires
@ -418,10 +418,10 @@ func funcRound(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelper
toNearestInverse := 1.0 / toNearest
for _, el := range vec {
v := math.Floor(el.F*toNearestInverse+0.5) / toNearestInverse
f := math.Floor(el.F*toNearestInverse+0.5) / toNearestInverse
enh.Out = append(enh.Out, Sample{
Metric: enh.DropMetricName(el.Metric),
F: v,
F: f,
})
}
return enh.Out

8
storage/buffer.go
View file

@ -173,7 +173,7 @@ func (s fSample) T() int64 {
return s.t
}
func (s fSample) V() float64 {
func (s fSample) F() float64 {
return s.f
}
@ -198,7 +198,7 @@ func (s hSample) T() int64 {
return s.t
}
func (s hSample) V() float64 {
func (s hSample) F() float64 {
panic("F() called for hSample")
}
@ -223,7 +223,7 @@ func (s fhSample) T() int64 {
return s.t
}
func (s fhSample) V() float64 {
func (s fhSample) F() float64 {
panic("F() called for fhSample")
}
@ -337,7 +337,7 @@ func (it *sampleRingIterator) Next() chunkenc.ValueType {
it.fh = s.FH()
return chunkenc.ValFloatHistogram
default:
it.f = s.V()
it.f = s.F()
return chunkenc.ValFloat
}
}

4
storage/buffer_test.go
View file

@ -73,7 +73,7 @@ func TestSampleRing(t *testing.T) {
for _, sold := range input[:i] {
found := false
for _, bs := range buffered {
if bs.T() == sold.t && bs.V() == sold.f {
if bs.T() == sold.t && bs.F() == sold.f {
found = true
break
}
@ -110,7 +110,7 @@ func TestBufferedSeriesIterator(t *testing.T) {
s, ok := it.PeekBack(1)
require.Equal(t, eok, ok, "exist mismatch")
require.Equal(t, ets, s.T(), "timestamp mismatch")
require.Equal(t, ev, s.V(), "value mismatch")
require.Equal(t, ev, s.F(), "value mismatch")
}
it = NewBufferIterator(NewListSeriesIterator(samples{

2
storage/series.go
View file

@ -109,7 +109,7 @@ func (it *listSeriesIterator) Reset(samples Samples) {
func (it *listSeriesIterator) At() (int64, float64) {
s := it.samples.Get(it.idx)
return s.T(), s.V()
return s.T(), s.F()
}
func (it *listSeriesIterator) AtHistogram() (int64, *histogram.Histogram) {

6
tsdb/agent/db_test.go
View file

@ -133,13 +133,13 @@ func TestCommit(t *testing.T) {
for i := 0; i < numDatapoints; i++ {
sample := tsdbutil.GenerateSamples(0, 1)
ref, err := app.Append(0, lset, sample[0].T(), sample[0].V())
ref, err := app.Append(0, lset, sample[0].T(), sample[0].F())
require.NoError(t, err)
e := exemplar.Exemplar{
Labels: lset,
Ts: sample[0].T() + int64(i),
Value: sample[0].V(),
Value: sample[0].F(),
HasTs: true,
}
_, err = app.AppendExemplar(ref, lset, e)
@ -248,7 +248,7 @@ func TestRollback(t *testing.T) {
for i := 0; i < numDatapoints; i++ {
sample := tsdbutil.GenerateSamples(0, 1)
_, err := app.Append(0, lset, sample[0].T(), sample[0].V())
_, err := app.Append(0, lset, sample[0].T(), sample[0].F())
require.NoError(t, err)
}
}

16
tsdb/block_test.go
View file

@ -353,14 +353,14 @@ func TestReadIndexFormatV1(t *testing.T) {
q, err := NewBlockQuerier(block, 0, 1000)
require.NoError(t, err)
require.Equal(t, query(t, q, labels.MustNewMatcher(labels.MatchEqual, "foo", "bar")),
map[string][]tsdbutil.Sample{`{foo="bar"}`: {sample{t: 1, v: 2}}})
map[string][]tsdbutil.Sample{`{foo="bar"}`: {sample{t: 1, f: 2}}})
q, err = NewBlockQuerier(block, 0, 1000)
require.NoError(t, err)
require.Equal(t, query(t, q, labels.MustNewMatcher(labels.MatchNotRegexp, "foo", "^.?$")),
map[string][]tsdbutil.Sample{
`{foo="bar"}`: {sample{t: 1, v: 2}},
`{foo="baz"}`: {sample{t: 3, v: 4}},
`{foo="bar"}`: {sample{t: 1, f: 2}},
`{foo="baz"}`: {sample{t: 3, f: 4}},
})
}
@ -568,7 +568,7 @@ func createHeadWithOOOSamples(tb testing.TB, w *wlog.WL, series []storage.Series
count++
t, v := it.At()
if count%oooSampleFrequency == 0 {
os = append(os, sample{t: t, v: v})
os = append(os, sample{t: t, f: v})
continue
}
ref, err = app.Append(ref, lset, t, v)
@ -589,7 +589,7 @@ func createHeadWithOOOSamples(tb testing.TB, w *wlog.WL, series []storage.Series
for i, lset := range oooSampleLabels {
ref := storage.SeriesRef(0)
for _, sample := range oooSamples[i] {
ref, err = app.Append(ref, lset, sample.T(), sample.V())
ref, err = app.Append(ref, lset, sample.T(), sample.F())
require.NoError(tb, err)
oooSamplesAppended++
}
@ -613,7 +613,7 @@ const (
// genSeries generates series of float64 samples with a given number of labels and values.
func genSeries(totalSeries, labelCount int, mint, maxt int64) []storage.Series {
return genSeriesFromSampleGenerator(totalSeries, labelCount, mint, maxt, 1, func(ts int64) tsdbutil.Sample {
return sample{t: ts, v: rand.Float64()}
return sample{t: ts, f: rand.Float64()}
})
}
@ -657,7 +657,7 @@ func genHistogramAndFloatSeries(totalSeries, labelCount int, mint, maxt, step in
count++
var s sample
if floatSample {
s = sample{t: ts, v: rand.Float64()}
s = sample{t: ts, f: rand.Float64()}
} else {
h := &histogram.Histogram{
Count: 5 + uint64(ts*4),
@ -729,7 +729,7 @@ func populateSeries(lbls []map[string]string, mint, maxt int64) []storage.Series
}
samples := make([]tsdbutil.Sample, 0, maxt-mint+1)
for t := mint; t <= maxt; t++ {
samples = append(samples, sample{t: t, v: rand.Float64()})
samples = append(samples, sample{t: t, f: rand.Float64()})
}
series = append(series, storage.NewListSeries(labels.FromMap(lbl), samples))
}

4
tsdb/blockwriter_test.go
View file

@ -52,8 +52,8 @@ func TestBlockWriter(t *testing.T) {
q, err := NewBlockQuerier(b, math.MinInt64, math.MaxInt64)
require.NoError(t, err)
series := query(t, q, labels.MustNewMatcher(labels.MatchRegexp, "", ".*"))
sample1 := []tsdbutil.Sample{sample{t: ts1, v: v1}}
sample2 := []tsdbutil.Sample{sample{t: ts2, v: v2}}
sample1 := []tsdbutil.Sample{sample{t: ts1, f: v1}}
sample2 := []tsdbutil.Sample{sample{t: ts2, f: v2}}
expectedSeries := map[string][]tsdbutil.Sample{"{a=\"b\"}": sample1, "{c=\"d\"}": sample2}
require.Equal(t, expectedSeries, series)

4
tsdb/compact_test.go
View file

@ -975,7 +975,7 @@ func TestCompaction_populateBlock(t *testing.T) {
s sample
)
for iter.Next() == chunkenc.ValFloat {
s.t, s.v = iter.At()
s.t, s.f = iter.At()
if firstTs == math.MaxInt64 {
firstTs = s.t
}
@ -1350,7 +1350,7 @@ func TestHeadCompactionWithHistograms(t *testing.T) {
for tsMinute := from; tsMinute <= to; tsMinute++ {
_, err := app.Append(0, lbls, minute(tsMinute), float64(tsMinute))
require.NoError(t, err)
*exp = append(*exp, sample{t: minute(tsMinute), v: float64(tsMinute)})
*exp = append(*exp, sample{t: minute(tsMinute), f: float64(tsMinute)})
}
require.NoError(t, app.Commit())
}

66
tsdb/db_test.go
View file

@ -104,7 +104,7 @@ func query(t testing.TB, q storage.Querier, matchers ...*labels.Matcher) map[str
switch typ {
case chunkenc.ValFloat:
ts, v := it.At()
samples = append(samples, sample{t: ts, v: v})
samples = append(samples, sample{t: ts, f: v})
case chunkenc.ValHistogram:
ts, h := it.AtHistogram()
samples = append(samples, sample{t: ts, h: h})
@ -233,7 +233,7 @@ func TestDataAvailableOnlyAfterCommit(t *testing.T) {
seriesSet = query(t, querier, labels.MustNewMatcher(labels.MatchEqual, "foo", "bar"))
require.Equal(t, map[string][]tsdbutil.Sample{`{foo="bar"}`: {sample{t: 0, v: 0}}}, seriesSet)
require.Equal(t, map[string][]tsdbutil.Sample{`{foo="bar"}`: {sample{t: 0, f: 0}}}, seriesSet)
}
// TestNoPanicAfterWALCorruption ensures that querying the db after a WAL corruption doesn't cause a panic.
@ -251,7 +251,7 @@ func TestNoPanicAfterWALCorruption(t *testing.T) {
for i := 0; i < 121; i++ {
app := db.Appender(ctx)
_, err := app.Append(0, labels.FromStrings("foo", "bar"), maxt, 0)
expSamples = append(expSamples, sample{t: maxt, v: 0})
expSamples = append(expSamples, sample{t: maxt, f: 0})
require.NoError(t, err)
require.NoError(t, app.Commit())
maxt++
@ -364,11 +364,11 @@ func TestDBAppenderAddRef(t *testing.T) {
require.Equal(t, map[string][]tsdbutil.Sample{
labels.FromStrings("a", "b").String(): {
sample{t: 123, v: 0},
sample{t: 124, v: 1},
sample{t: 125, v: 0},
sample{t: 133, v: 1},
sample{t: 143, v: 2},
sample{t: 123, f: 0},
sample{t: 124, f: 1},
sample{t: 125, f: 0},
sample{t: 133, f: 1},
sample{t: 143, f: 2},
},
}, res)
}
@ -1740,7 +1740,7 @@ func expandSeriesSet(ss storage.SeriesSet) ([]labels.Labels, map[string][]sample
it = series.Iterator(it)
for it.Next() == chunkenc.ValFloat {
t, v := it.At()
samples = append(samples, sample{t: t, v: v})
samples = append(samples, sample{t: t, f: v})
}
resultLabels = append(resultLabels, series.Labels())
resultSamples[series.Labels().String()] = samples
@ -2617,7 +2617,7 @@ func TestDBCannotSeePartialCommits(t *testing.T) {
values := map[float64]struct{}{}
for _, series := range seriesSet {
values[series[len(series)-1].v] = struct{}{}
values[series[len(series)-1].f] = struct{}{}
}
if len(values) != 1 {
inconsistencies++
@ -2693,7 +2693,7 @@ func TestDBQueryDoesntSeeAppendsAfterCreation(t *testing.T) {
_, seriesSet, ws, err = expandSeriesSet(ss)
require.NoError(t, err)
require.Equal(t, 0, len(ws))
require.Equal(t, map[string][]sample{`{foo="bar"}`: {{t: 0, v: 0}}}, seriesSet)
require.Equal(t, map[string][]sample{`{foo="bar"}`: {{t: 0, f: 0}}}, seriesSet)
}
// TestChunkWriter_ReadAfterWrite ensures that chunk segment are cut at the set segment size and
@ -4575,7 +4575,7 @@ func Test_Querier_OOOQuery(t *testing.T) {
for min := fromMins; min <= toMins; min += time.Minute.Milliseconds() {
_, err := app.Append(0, series1, min, float64(min))
if min >= queryMinT && min <= queryMaxT {
expSamples = append(expSamples, sample{t: min, v: float64(min)})
expSamples = append(expSamples, sample{t: min, f: float64(min)})
}
require.NoError(t, err)
totalAppended++
@ -4660,7 +4660,7 @@ func Test_ChunkQuerier_OOOQuery(t *testing.T) {
for min := fromMins; min <= toMins; min += time.Minute.Milliseconds() {
_, err := app.Append(0, series1, min, float64(min))
if min >= queryMinT && min <= queryMaxT {
expSamples = append(expSamples, sample{t: min, v: float64(min)})
expSamples = append(expSamples, sample{t: min, f: float64(min)})
}
require.NoError(t, err)
totalAppended++
@ -4730,7 +4730,7 @@ func Test_ChunkQuerier_OOOQuery(t *testing.T) {
it := chunk.Chunk.Iterator(nil)
for it.Next() == chunkenc.ValFloat {
ts, v := it.At()
gotSamples = append(gotSamples, sample{t: ts, v: v})
gotSamples = append(gotSamples, sample{t: ts, f: v})
}
}
require.Equal(t, expSamples, gotSamples)
@ -4766,7 +4766,7 @@ func TestOOOAppendAndQuery(t *testing.T) {
require.Error(t, err)
} else {
require.NoError(t, err)
appendedSamples[key] = append(appendedSamples[key], sample{t: min, v: val})
appendedSamples[key] = append(appendedSamples[key], sample{t: min, f: val})
totalSamples++
}
}
@ -4889,7 +4889,7 @@ func TestOOODisabled(t *testing.T) {
failedSamples++
} else {
require.NoError(t, err)
expSamples[key] = append(expSamples[key], sample{t: min, v: val})
expSamples[key] = append(expSamples[key], sample{t: min, f: val})
totalSamples++
}
}
@ -4952,7 +4952,7 @@ func TestWBLAndMmapReplay(t *testing.T) {
val := rand.Float64()
_, err := app.Append(0, lbls, min, val)
require.NoError(t, err)
expSamples[key] = append(expSamples[key], sample{t: min, v: val})
expSamples[key] = append(expSamples[key], sample{t: min, f: val})
totalSamples++
}
require.NoError(t, app.Commit())
@ -4995,7 +4995,7 @@ func TestWBLAndMmapReplay(t *testing.T) {
it := chk.Iterator(nil)
for it.Next() == chunkenc.ValFloat {
ts, val := it.At()
s1MmapSamples = append(s1MmapSamples, sample{t: ts, v: val})
s1MmapSamples = append(s1MmapSamples, sample{t: ts, f: val})
}
}
require.Greater(t, len(s1MmapSamples), 0)
@ -5273,9 +5273,9 @@ func TestWBLCorruption(t *testing.T) {
ts := min * time.Minute.Milliseconds()
_, err := app.Append(0, series1, ts, float64(ts))
require.NoError(t, err)
allSamples = append(allSamples, sample{t: ts, v: float64(ts)})
allSamples = append(allSamples, sample{t: ts, f: float64(ts)})
if afterRestart {
expAfterRestart = append(expAfterRestart, sample{t: ts, v: float64(ts)})
expAfterRestart = append(expAfterRestart, sample{t: ts, f: float64(ts)})
}
}
require.NoError(t, app.Commit())
@ -5419,9 +5419,9 @@ func TestOOOMmapCorruption(t *testing.T) {
ts := min * time.Minute.Milliseconds()
_, err := app.Append(0, series1, ts, float64(ts))
require.NoError(t, err)
allSamples = append(allSamples, sample{t: ts, v: float64(ts)})
allSamples = append(allSamples, sample{t: ts, f: float64(ts)})
if inMmapAfterCorruption {
expInMmapChunks = append(expInMmapChunks, sample{t: ts, v: float64(ts)})
expInMmapChunks = append(expInMmapChunks, sample{t: ts, f: float64(ts)})
}
}
require.NoError(t, app.Commit())
@ -5555,7 +5555,7 @@ func TestOutOfOrderRuntimeConfig(t *testing.T) {
_, err := app.Append(0, series1, ts, float64(ts))
if success {
require.NoError(t, err)
allSamples = append(allSamples, sample{t: ts, v: float64(ts)})
allSamples = append(allSamples, sample{t: ts, f: float64(ts)})
} else {
require.Error(t, err)
}
@ -5769,7 +5769,7 @@ func TestNoGapAfterRestartWithOOO(t *testing.T) {
var expSamples []tsdbutil.Sample
for min := fromMins; min <= toMins; min++ {
ts := min * time.Minute.Milliseconds()
expSamples = append(expSamples, sample{t: ts, v: float64(ts)})
expSamples = append(expSamples, sample{t: ts, f: float64(ts)})
}
expRes := map[string][]tsdbutil.Sample{
@ -5876,7 +5876,7 @@ func TestWblReplayAfterOOODisableAndRestart(t *testing.T) {
ts := min * time.Minute.Milliseconds()
_, err := app.Append(0, series1, ts, float64(ts))
require.NoError(t, err)
allSamples = append(allSamples, sample{t: ts, v: float64(ts)})
allSamples = append(allSamples, sample{t: ts, f: float64(ts)})
}
require.NoError(t, app.Commit())
}
@ -5935,7 +5935,7 @@ func TestPanicOnApplyConfig(t *testing.T) {
ts := min * time.Minute.Milliseconds()
_, err := app.Append(0, series1, ts, float64(ts))
require.NoError(t, err)
allSamples = append(allSamples, sample{t: ts, v: float64(ts)})
allSamples = append(allSamples, sample{t: ts, f: float64(ts)})
}
require.NoError(t, app.Commit())
}
@ -5983,7 +5983,7 @@ func TestDiskFillingUpAfterDisablingOOO(t *testing.T) {
ts := min * time.Minute.Milliseconds()
_, err := app.Append(0, series1, ts, float64(ts))
require.NoError(t, err)
allSamples = append(allSamples, sample{t: ts, v: float64(ts)})
allSamples = append(allSamples, sample{t: ts, f: float64(ts)})
}
require.NoError(t, app.Commit())
}
@ -6090,7 +6090,7 @@ func testHistogramAppendAndQueryHelper(t *testing.T, floatHistogram bool) {
_, err := app.Append(0, lbls, minute(tsMinute), val)
require.NoError(t, err)
require.NoError(t, app.Commit())
*exp = append(*exp, sample{t: minute(tsMinute), v: val})
*exp = append(*exp, sample{t: minute(tsMinute), f: val})
}
testQuery := func(name, value string, exp map[string][]tsdbutil.Sample) {
@ -6346,7 +6346,7 @@ func TestQueryHistogramFromBlocksWithCompaction(t *testing.T) {
switch typ {
case chunkenc.ValFloat:
ts, v := it.At()
slice = append(slice, sample{t: ts, v: v})
slice = append(slice, sample{t: ts, f: v})
case chunkenc.ValHistogram:
ts, h := it.AtHistogram()
slice = append(slice, sample{t: ts, h: h})
@ -6418,7 +6418,7 @@ func TestQueryHistogramFromBlocksWithCompaction(t *testing.T) {
testBlockQuerying(t,
genHistogramSeries(10, 5, minute(0), minute(119), minute(1), floatHistogram),
genSeriesFromSampleGenerator(10, 5, minute(120), minute(239), minute(1), func(ts int64) tsdbutil.Sample {
return sample{t: ts, v: rand.Float64()}
return sample{t: ts, f: rand.Float64()}
}),
genHistogramSeries(10, 5, minute(240), minute(359), minute(1), floatHistogram),
)
@ -6430,7 +6430,7 @@ func TestQueryHistogramFromBlocksWithCompaction(t *testing.T) {
genHistogramSeries(10, 5, minute(61), minute(120), minute(1), floatHistogram),
genHistogramAndFloatSeries(10, 5, minute(121), minute(180), minute(1), floatHistogram),
genSeriesFromSampleGenerator(10, 5, minute(181), minute(240), minute(1), func(ts int64) tsdbutil.Sample {
return sample{t: ts, v: rand.Float64()}
return sample{t: ts, f: rand.Float64()}
}),
)
})
@ -6447,7 +6447,7 @@ func TestQueryHistogramFromBlocksWithCompaction(t *testing.T) {
testBlockQuerying(t,
genHistogramSeries(10, 5, minute(0), minute(120), minute(3), floatHistogram),
genSeriesFromSampleGenerator(10, 5, minute(1), minute(120), minute(3), func(ts int64) tsdbutil.Sample {
return sample{t: ts, v: rand.Float64()}
return sample{t: ts, f: rand.Float64()}
}),
genHistogramSeries(10, 5, minute(2), minute(120), minute(3), floatHistogram),
)
@ -6459,7 +6459,7 @@ func TestQueryHistogramFromBlocksWithCompaction(t *testing.T) {
genHistogramSeries(10, 5, minute(46), minute(100), minute(3), floatHistogram),
genHistogramAndFloatSeries(10, 5, minute(89), minute(140), minute(3), floatHistogram),
genSeriesFromSampleGenerator(10, 5, minute(126), minute(200), minute(3), func(ts int64) tsdbutil.Sample {
return sample{t: ts, v: rand.Float64()}
return sample{t: ts, f: rand.Float64()}
}),
)
})

4
tsdb/head.go
View file

@ -1864,7 +1864,7 @@ func (s *stripeSeries) getOrSet(hash uint64, lset labels.Labels, createSeries fu
type sample struct {
t int64
v float64
f float64
h *histogram.Histogram
fh *histogram.FloatHistogram
}
@ -1874,7 +1874,7 @@ func newSample(t int64, v float64, h *histogram.Histogram, fh *histogram.FloatHi
}
func (s sample) T() int64 { return s.t }
func (s sample) V() float64 { return s.v }
func (s sample) F() float64 { return s.f }
func (s sample) H() *histogram.Histogram { return s.h }
func (s sample) FH() *histogram.FloatHistogram { return s.fh }

42
tsdb/head_test.go
View file

@ -465,8 +465,8 @@ func TestHead_HighConcurrencyReadAndWrite(t *testing.T) {
if sample.T() != int64(expectedValue) {
return false, fmt.Errorf("expected sample %d to have ts %d, got %d", sampleIdx, expectedValue, sample.T())
}
if sample.V() != float64(expectedValue) {
return false, fmt.Errorf("expected sample %d to have value %d, got %f", sampleIdx, expectedValue, sample.V())
if sample.F() != float64(expectedValue) {
return false, fmt.Errorf("expected sample %d to have value %d, got %f", sampleIdx, expectedValue, sample.F())
}
}
@ -575,7 +575,7 @@ func TestHead_ReadWAL(t *testing.T) {
expandChunk := func(c chunkenc.Iterator) (x []sample) {
for c.Next() == chunkenc.ValFloat {
t, v := c.At()
x = append(x, sample{t: t, v: v})
x = append(x, sample{t: t, f: v})
}
require.NoError(t, c.Err())
return x
@ -870,7 +870,7 @@ func TestHeadDeleteSimple(t *testing.T) {
buildSmpls := func(s []int64) []sample {
ss := make([]sample, 0, len(s))
for _, t := range s {
ss = append(ss, sample{t: t, v: float64(t)})
ss = append(ss, sample{t: t, f: float64(t)})
}
return ss
}
@ -925,7 +925,7 @@ func TestHeadDeleteSimple(t *testing.T) {
app := head.Appender(context.Background())
for _, smpl := range smplsAll {
_, err := app.Append(0, lblsDefault, smpl.t, smpl.v)
_, err := app.Append(0, lblsDefault, smpl.t, smpl.f)
require.NoError(t, err)
}
@ -939,7 +939,7 @@ func TestHeadDeleteSimple(t *testing.T) {
// Add more samples.
app = head.Appender(context.Background())
for _, smpl := range c.addSamples {
_, err := app.Append(0, lblsDefault, smpl.t, smpl.v)
_, err := app.Append(0, lblsDefault, smpl.t, smpl.f)
require.NoError(t, err)
}
@ -1924,7 +1924,7 @@ func TestMemSeriesIsolation(t *testing.T) {
require.Equal(t, 0, len(ws))
for _, series := range seriesSet {
return int(series[len(series)-1].v)
return int(series[len(series)-1].f)
}
return -1
}
@ -3088,7 +3088,7 @@ func TestHistogramInWALAndMmapChunk(t *testing.T) {
ts++
_, err := app.Append(0, s2, int64(ts), float64(ts))
require.NoError(t, err)
exp[k2] = append(exp[k2], sample{t: int64(ts), v: float64(ts)})
exp[k2] = append(exp[k2], sample{t: int64(ts), f: float64(ts)})
}
require.NoError(t, app.Commit())
app = head.Appender(context.Background())
@ -3125,7 +3125,7 @@ func TestHistogramInWALAndMmapChunk(t *testing.T) {
ts++
_, err := app.Append(0, s2, int64(ts), float64(ts))
require.NoError(t, err)
exp[k2] = append(exp[k2], sample{t: int64(ts), v: float64(ts)})
exp[k2] = append(exp[k2], sample{t: int64(ts), f: float64(ts)})
}
require.NoError(t, app.Commit())
app = head.Appender(context.Background())
@ -3812,7 +3812,7 @@ func TestAppendingDifferentEncodingToSameSeries(t *testing.T) {
expChunks: 1,
},
{
samples: []tsdbutil.Sample{sample{t: 200, v: 2}},
samples: []tsdbutil.Sample{sample{t: 200, f: 2}},
expChunks: 2,
},
{
@ -3836,7 +3836,7 @@ func TestAppendingDifferentEncodingToSameSeries(t *testing.T) {
expChunks: 6,
},
{
samples: []tsdbutil.Sample{sample{t: 100, v: 2}},
samples: []tsdbutil.Sample{sample{t: 100, f: 2}},
err: storage.ErrOutOfOrderSample,
},
{
@ -3847,13 +3847,13 @@ func TestAppendingDifferentEncodingToSameSeries(t *testing.T) {
// Combination of histograms and float64 in the same commit. The behaviour is undefined, but we want to also
// verify how TSDB would behave. Here the histogram is appended at the end, hence will be considered as out of order.
samples: []tsdbutil.Sample{
sample{t: 400, v: 4},
sample{t: 400, f: 4},
sample{t: 500, h: hists[5]}, // This won't be committed.
sample{t: 600, v: 6},
sample{t: 600, f: 6},
},
addToExp: []tsdbutil.Sample{
sample{t: 400, v: 4},
sample{t: 600, v: 6},
sample{t: 400, f: 4},
sample{t: 600, f: 6},
},
expChunks: 7, // Only 1 new chunk for float64.
},
@ -3861,11 +3861,11 @@ func TestAppendingDifferentEncodingToSameSeries(t *testing.T) {
// Here the histogram is appended at the end, hence the first histogram is out of order.
samples: []tsdbutil.Sample{
sample{t: 700, h: hists[7]}, // Out of order w.r.t. the next float64 sample that is appended first.
sample{t: 800, v: 8},
sample{t: 800, f: 8},
sample{t: 900, h: hists[9]},
},
addToExp: []tsdbutil.Sample{
sample{t: 800, v: 8},
sample{t: 800, f: 8},
sample{t: 900, h: hists[9].Copy()},
},
expChunks: 8, // float64 added to old chunk, only 1 new for histograms.
@ -3890,7 +3890,7 @@ func TestAppendingDifferentEncodingToSameSeries(t *testing.T) {
if s.H() != nil || s.FH() != nil {
_, err = app.AppendHistogram(0, lbls, s.T(), s.H(), s.FH())
} else {
_, err = app.Append(0, lbls, s.T(), s.V())
_, err = app.Append(0, lbls, s.T(), s.F())
}
require.Equal(t, a.err, err)
}
@ -4056,7 +4056,7 @@ func TestOOOWalReplay(t *testing.T) {
require.NoError(t, app.Commit())
if isOOO {
expOOOSamples = append(expOOOSamples, sample{t: ts, v: v})
expOOOSamples = append(expOOOSamples, sample{t: ts, f: v})
}
}
@ -4100,7 +4100,7 @@ func TestOOOWalReplay(t *testing.T) {
actOOOSamples := make([]sample, 0, len(expOOOSamples))
for it.Next() == chunkenc.ValFloat {
ts, v := it.At()
actOOOSamples = append(actOOOSamples, sample{t: ts, v: v})
actOOOSamples = append(actOOOSamples, sample{t: ts, f: v})
}
// OOO chunk will be sorted. Hence sort the expected samples.
@ -4360,7 +4360,7 @@ func TestReplayAfterMmapReplayError(t *testing.T) {
var ref storage.SeriesRef
for i := 0; i < numSamples; i++ {
ref, err = app.Append(ref, lbls, lastTs, float64(lastTs))
expSamples = append(expSamples, sample{t: lastTs, v: float64(lastTs)})
expSamples = append(expSamples, sample{t: lastTs, f: float64(lastTs)})
require.NoError(t, err)
lastTs += itvl
if i%10 == 0 {

4
tsdb/ooo_head.go
View file

@ -78,7 +78,7 @@ func (o *OOOChunk) ToXOR() (*chunkenc.XORChunk, error) {
return nil, err
}
for _, s := range o.samples {
app.Append(s.t, s.v)
app.Append(s.t, s.f)
}
return x, nil
}
@ -96,7 +96,7 @@ func (o *OOOChunk) ToXORBetweenTimestamps(mint, maxt int64) (*chunkenc.XORChunk,
if s.t > maxt {
break
}
app.Append(s.t, s.v)
app.Append(s.t, s.f)
}
return x, nil
}

402
tsdb/ooo_head_read_test.go
View file

@ -504,8 +504,8 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
queryMaxT: minutes(100),
firstInOrderSampleAt: minutes(120),
inputSamples: tsdbutil.SampleSlice{
sample{t: minutes(30), v: float64(0)},
sample{t: minutes(40), v: float64(0)},
sample{t: minutes(30), f: float64(0)},
sample{t: minutes(40), f: float64(0)},
},
expChunkError: false,
// ts (in minutes) 0 10 20 30 40 50 60 70 80 90 100
@ -514,8 +514,8 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
// Output Graphically [--------] (With 2 samples)
expChunksSamples: []tsdbutil.SampleSlice{
{
sample{t: minutes(30), v: float64(0)},
sample{t: minutes(40), v: float64(0)},
sample{t: minutes(30), f: float64(0)},
sample{t: minutes(40), f: float64(0)},
},
},
},
@ -526,15 +526,15 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
firstInOrderSampleAt: minutes(120),
inputSamples: tsdbutil.SampleSlice{
// opts.OOOCapMax is 5 so these will be mmapped to the first mmapped chunk
sample{t: minutes(41), v: float64(0)},
sample{t: minutes(42), v: float64(0)},
sample{t: minutes(43), v: float64(0)},
sample{t: minutes(44), v: float64(0)},
sample{t: minutes(45), v: float64(0)},
sample{t: minutes(41), f: float64(0)},
sample{t: minutes(42), f: float64(0)},
sample{t: minutes(43), f: float64(0)},
sample{t: minutes(44), f: float64(0)},
sample{t: minutes(45), f: float64(0)},
// The following samples will go to the head chunk, and we want it
// to overlap with the previous chunk
sample{t: minutes(30), v: float64(1)},
sample{t: minutes(50), v: float64(1)},
sample{t: minutes(30), f: float64(1)},
sample{t: minutes(50), f: float64(1)},
},
expChunkError: false,
// ts (in minutes) 0 10 20 30 40 50 60 70 80 90 100
@ -544,13 +544,13 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
// Output Graphically [-----------------] (With 7 samples)
expChunksSamples: []tsdbutil.SampleSlice{
{
sample{t: minutes(30), v: float64(1)},
sample{t: minutes(41), v: float64(0)},
sample{t: minutes(42), v: float64(0)},
sample{t: minutes(43), v: float64(0)},
sample{t: minutes(44), v: float64(0)},
sample{t: minutes(45), v: float64(0)},
sample{t: minutes(50), v: float64(1)},
sample{t: minutes(30), f: float64(1)},
sample{t: minutes(41), f: float64(0)},
sample{t: minutes(42), f: float64(0)},
sample{t: minutes(43), f: float64(0)},
sample{t: minutes(44), f: float64(0)},
sample{t: minutes(45), f: float64(0)},
sample{t: minutes(50), f: float64(1)},
},
},
},
@ -561,26 +561,26 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
firstInOrderSampleAt: minutes(120),
inputSamples: tsdbutil.SampleSlice{
// Chunk 0
sample{t: minutes(10), v: float64(0)},
sample{t: minutes(12), v: float64(0)},
sample{t: minutes(14), v: float64(0)},
sample{t: minutes(16), v: float64(0)},
sample{t: minutes(20), v: float64(0)},
sample{t: minutes(10), f: float64(0)},
sample{t: minutes(12), f: float64(0)},
sample{t: minutes(14), f: float64(0)},
sample{t: minutes(16), f: float64(0)},
sample{t: minutes(20), f: float64(0)},
// Chunk 1
sample{t: minutes(20), v: float64(1)},
sample{t: minutes(22), v: float64(1)},
sample{t: minutes(24), v: float64(1)},
sample{t: minutes(26), v: float64(1)},
sample{t: minutes(29), v: float64(1)},
sample{t: minutes(20), f: float64(1)},
sample{t: minutes(22), f: float64(1)},
sample{t: minutes(24), f: float64(1)},
sample{t: minutes(26), f: float64(1)},
sample{t: minutes(29), f: float64(1)},
// Chunk 2
sample{t: minutes(30), v: float64(2)},
sample{t: minutes(32), v: float64(2)},
sample{t: minutes(34), v: float64(2)},
sample{t: minutes(36), v: float64(2)},
sample{t: minutes(40), v: float64(2)},
sample{t: minutes(30), f: float64(2)},
sample{t: minutes(32), f: float64(2)},
sample{t: minutes(34), f: float64(2)},
sample{t: minutes(36), f: float64(2)},
sample{t: minutes(40), f: float64(2)},
// Head
sample{t: minutes(40), v: float64(3)},
sample{t: minutes(50), v: float64(3)},
sample{t: minutes(40), f: float64(3)},
sample{t: minutes(50), f: float64(3)},
},
expChunkError: false,
// ts (in minutes) 0 10 20 30 40 50 60 70 80 90 100
@ -592,23 +592,23 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
// Output Graphically [----------------][-----------------]
expChunksSamples: []tsdbutil.SampleSlice{
{
sample{t: minutes(10), v: float64(0)},
sample{t: minutes(12), v: float64(0)},
sample{t: minutes(14), v: float64(0)},
sample{t: minutes(16), v: float64(0)},
sample{t: minutes(20), v: float64(1)},
sample{t: minutes(22), v: float64(1)},
sample{t: minutes(24), v: float64(1)},
sample{t: minutes(26), v: float64(1)},
sample{t: minutes(29), v: float64(1)},
sample{t: minutes(10), f: float64(0)},
sample{t: minutes(12), f: float64(0)},
sample{t: minutes(14), f: float64(0)},
sample{t: minutes(16), f: float64(0)},
sample{t: minutes(20), f: float64(1)},
sample{t: minutes(22), f: float64(1)},
sample{t: minutes(24), f: float64(1)},
sample{t: minutes(26), f: float64(1)},
sample{t: minutes(29), f: float64(1)},
},
{
sample{t: minutes(30), v: float64(2)},
sample{t: minutes(32), v: float64(2)},
sample{t: minutes(34), v: float64(2)},
sample{t: minutes(36), v: float64(2)},
sample{t: minutes(40), v: float64(3)},
sample{t: minutes(50), v: float64(3)},
sample{t: minutes(30), f: float64(2)},
sample{t: minutes(32), f: float64(2)},
sample{t: minutes(34), f: float64(2)},
sample{t: minutes(36), f: float64(2)},
sample{t: minutes(40), f: float64(3)},
sample{t: minutes(50), f: float64(3)},
},
},
},
@ -619,26 +619,26 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
firstInOrderSampleAt: minutes(120),
inputSamples: tsdbutil.SampleSlice{
// Chunk 0
sample{t: minutes(40), v: float64(0)},
sample{t: minutes(42), v: float64(0)},
sample{t: minutes(44), v: float64(0)},
sample{t: minutes(46), v: float64(0)},
sample{t: minutes(50), v: float64(0)},
sample{t: minutes(40), f: float64(0)},
sample{t: minutes(42), f: float64(0)},
sample{t: minutes(44), f: float64(0)},
sample{t: minutes(46), f: float64(0)},
sample{t: minutes(50), f: float64(0)},
// Chunk 1
sample{t: minutes(30), v: float64(1)},
sample{t: minutes(32), v: float64(1)},
sample{t: minutes(34), v: float64(1)},
sample{t: minutes(36), v: float64(1)},
sample{t: minutes(40), v: float64(1)},
sample{t: minutes(30), f: float64(1)},
sample{t: minutes(32), f: float64(1)},
sample{t: minutes(34), f: float64(1)},
sample{t: minutes(36), f: float64(1)},
sample{t: minutes(40), f: float64(1)},
// Chunk 2
sample{t: minutes(20), v: float64(2)},
sample{t: minutes(22), v: float64(2)},
sample{t: minutes(24), v: float64(2)},
sample{t: minutes(26), v: float64(2)},
sample{t: minutes(29), v: float64(2)},
sample{t: minutes(20), f: float64(2)},
sample{t: minutes(22), f: float64(2)},
sample{t: minutes(24), f: float64(2)},
sample{t: minutes(26), f: float64(2)},
sample{t: minutes(29), f: float64(2)},
// Head
sample{t: minutes(10), v: float64(3)},
sample{t: minutes(20), v: float64(3)},
sample{t: minutes(10), f: float64(3)},
sample{t: minutes(20), f: float64(3)},
},
expChunkError: false,
// ts (in minutes) 0 10 20 30 40 50 60 70 80 90 100
@ -650,23 +650,23 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
// Output Graphically [----------------][-----------------]
expChunksSamples: []tsdbutil.SampleSlice{
{
sample{t: minutes(10), v: float64(3)},
sample{t: minutes(20), v: float64(2)},
sample{t: minutes(22), v: float64(2)},
sample{t: minutes(24), v: float64(2)},
sample{t: minutes(26), v: float64(2)},
sample{t: minutes(29), v: float64(2)},
sample{t: minutes(10), f: float64(3)},
sample{t: minutes(20), f: float64(2)},
sample{t: minutes(22), f: float64(2)},
sample{t: minutes(24), f: float64(2)},
sample{t: minutes(26), f: float64(2)},
sample{t: minutes(29), f: float64(2)},
},
{
sample{t: minutes(30), v: float64(1)},
sample{t: minutes(32), v: float64(1)},
sample{t: minutes(34), v: float64(1)},
sample{t: minutes(36), v: float64(1)},
sample{t: minutes(40), v: float64(0)},
sample{t: minutes(42), v: float64(0)},
sample{t: minutes(44), v: float64(0)},
sample{t: minutes(46), v: float64(0)},
sample{t: minutes(50), v: float64(0)},
sample{t: minutes(30), f: float64(1)},
sample{t: minutes(32), f: float64(1)},
sample{t: minutes(34), f: float64(1)},
sample{t: minutes(36), f: float64(1)},
sample{t: minutes(40), f: float64(0)},
sample{t: minutes(42), f: float64(0)},
sample{t: minutes(44), f: float64(0)},
sample{t: minutes(46), f: float64(0)},
sample{t: minutes(50), f: float64(0)},
},
},
},
@ -677,26 +677,26 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
firstInOrderSampleAt: minutes(120),
inputSamples: tsdbutil.SampleSlice{
// Chunk 0
sample{t: minutes(10), v: float64(0)},
sample{t: minutes(12), v: float64(0)},
sample{t: minutes(14), v: float64(0)},
sample{t: minutes(16), v: float64(0)},
sample{t: minutes(18), v: float64(0)},
sample{t: minutes(10), f: float64(0)},
sample{t: minutes(12), f: float64(0)},
sample{t: minutes(14), f: float64(0)},
sample{t: minutes(16), f: float64(0)},
sample{t: minutes(18), f: float64(0)},
// Chunk 1
sample{t: minutes(20), v: float64(1)},
sample{t: minutes(22), v: float64(1)},
sample{t: minutes(24), v: float64(1)},
sample{t: minutes(26), v: float64(1)},
sample{t: minutes(28), v: float64(1)},
sample{t: minutes(20), f: float64(1)},
sample{t: minutes(22), f: float64(1)},
sample{t: minutes(24), f: float64(1)},
sample{t: minutes(26), f: float64(1)},
sample{t: minutes(28), f: float64(1)},
// Chunk 2
sample{t: minutes(30), v: float64(2)},
sample{t: minutes(32), v: float64(2)},
sample{t: minutes(34), v: float64(2)},
sample{t: minutes(36), v: float64(2)},
sample{t: minutes(38), v: float64(2)},
sample{t: minutes(30), f: float64(2)},
sample{t: minutes(32), f: float64(2)},
sample{t: minutes(34), f: float64(2)},
sample{t: minutes(36), f: float64(2)},
sample{t: minutes(38), f: float64(2)},
// Head
sample{t: minutes(40), v: float64(3)},
sample{t: minutes(42), v: float64(3)},
sample{t: minutes(40), f: float64(3)},
sample{t: minutes(42), f: float64(3)},
},
expChunkError: false,
// ts (in minutes) 0 10 20 30 40 50 60 70 80 90 100
@ -708,29 +708,29 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
// Output Graphically [-------][-------][-------][--------]
expChunksSamples: []tsdbutil.SampleSlice{
{
sample{t: minutes(10), v: float64(0)},
sample{t: minutes(12), v: float64(0)},
sample{t: minutes(14), v: float64(0)},
sample{t: minutes(16), v: float64(0)},
sample{t: minutes(18), v: float64(0)},
sample{t: minutes(10), f: float64(0)},
sample{t: minutes(12), f: float64(0)},
sample{t: minutes(14), f: float64(0)},
sample{t: minutes(16), f: float64(0)},
sample{t: minutes(18), f: float64(0)},
},
{
sample{t: minutes(20), v: float64(1)},
sample{t: minutes(22), v: float64(1)},
sample{t: minutes(24), v: float64(1)},
sample{t: minutes(26), v: float64(1)},
sample{t: minutes(28), v: float64(1)},
sample{t: minutes(20), f: float64(1)},
sample{t: minutes(22), f: float64(1)},
sample{t: minutes(24), f: float64(1)},
sample{t: minutes(26), f: float64(1)},
sample{t: minutes(28), f: float64(1)},
},
{
sample{t: minutes(30), v: float64(2)},
sample{t: minutes(32), v: float64(2)},
sample{t: minutes(34), v: float64(2)},
sample{t: minutes(36), v: float64(2)},
sample{t: minutes(38), v: float64(2)},
sample{t: minutes(30), f: float64(2)},
sample{t: minutes(32), f: float64(2)},
sample{t: minutes(34), f: float64(2)},
sample{t: minutes(36), f: float64(2)},
sample{t: minutes(38), f: float64(2)},
},
{
sample{t: minutes(40), v: float64(3)},
sample{t: minutes(42), v: float64(3)},
sample{t: minutes(40), f: float64(3)},
sample{t: minutes(42), f: float64(3)},
},
},
},
@ -741,20 +741,20 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
firstInOrderSampleAt: minutes(120),
inputSamples: tsdbutil.SampleSlice{
// Chunk 0
sample{t: minutes(10), v: float64(0)},
sample{t: minutes(15), v: float64(0)},
sample{t: minutes(20), v: float64(0)},
sample{t: minutes(25), v: float64(0)},
sample{t: minutes(30), v: float64(0)},
sample{t: minutes(10), f: float64(0)},
sample{t: minutes(15), f: float64(0)},
sample{t: minutes(20), f: float64(0)},
sample{t: minutes(25), f: float64(0)},
sample{t: minutes(30), f: float64(0)},
// Chunk 1
sample{t: minutes(20), v: float64(1)},
sample{t: minutes(25), v: float64(1)},
sample{t: minutes(30), v: float64(1)},
sample{t: minutes(35), v: float64(1)},
sample{t: minutes(42), v: float64(1)},
sample{t: minutes(20), f: float64(1)},
sample{t: minutes(25), f: float64(1)},
sample{t: minutes(30), f: float64(1)},
sample{t: minutes(35), f: float64(1)},
sample{t: minutes(42), f: float64(1)},
// Chunk 2 Head
sample{t: minutes(32), v: float64(2)},
sample{t: minutes(50), v: float64(2)},
sample{t: minutes(32), f: float64(2)},
sample{t: minutes(50), f: float64(2)},
},
expChunkError: false,
// ts (in minutes) 0 10 20 30 40 50 60 70 80 90 100
@ -765,15 +765,15 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
// Output Graphically [-----------------------------------]
expChunksSamples: []tsdbutil.SampleSlice{
{
sample{t: minutes(10), v: float64(0)},
sample{t: minutes(15), v: float64(0)},
sample{t: minutes(20), v: float64(1)},
sample{t: minutes(25), v: float64(1)},
sample{t: minutes(30), v: float64(1)},
sample{t: minutes(32), v: float64(2)},
sample{t: minutes(35), v: float64(1)},
sample{t: minutes(42), v: float64(1)},
sample{t: minutes(50), v: float64(2)},
sample{t: minutes(10), f: float64(0)},
sample{t: minutes(15), f: float64(0)},
sample{t: minutes(20), f: float64(1)},
sample{t: minutes(25), f: float64(1)},
sample{t: minutes(30), f: float64(1)},
sample{t: minutes(32), f: float64(2)},
sample{t: minutes(35), f: float64(1)},
sample{t: minutes(42), f: float64(1)},
sample{t: minutes(50), f: float64(2)},
},
},
},
@ -784,20 +784,20 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
firstInOrderSampleAt: minutes(120),
inputSamples: tsdbutil.SampleSlice{
// Chunk 0
sample{t: minutes(10), v: float64(0)},
sample{t: minutes(15), v: float64(0)},
sample{t: minutes(20), v: float64(0)},
sample{t: minutes(25), v: float64(0)},
sample{t: minutes(30), v: float64(0)},
sample{t: minutes(10), f: float64(0)},
sample{t: minutes(15), f: float64(0)},
sample{t: minutes(20), f: float64(0)},
sample{t: minutes(25), f: float64(0)},
sample{t: minutes(30), f: float64(0)},
// Chunk 1
sample{t: minutes(20), v: float64(1)},
sample{t: minutes(25), v: float64(1)},
sample{t: minutes(30), v: float64(1)},
sample{t: minutes(35), v: float64(1)},
sample{t: minutes(42), v: float64(1)},
sample{t: minutes(20), f: float64(1)},
sample{t: minutes(25), f: float64(1)},
sample{t: minutes(30), f: float64(1)},
sample{t: minutes(35), f: float64(1)},
sample{t: minutes(42), f: float64(1)},
// Chunk 2 Head
sample{t: minutes(32), v: float64(2)},
sample{t: minutes(50), v: float64(2)},
sample{t: minutes(32), f: float64(2)},
sample{t: minutes(50), f: float64(2)},
},
expChunkError: false,
// ts (in minutes) 0 10 20 30 40 50 60 70 80 90 100
@ -808,15 +808,15 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
// Output Graphically [-----------------------------------]
expChunksSamples: []tsdbutil.SampleSlice{
{
sample{t: minutes(10), v: float64(0)},
sample{t: minutes(15), v: float64(0)},
sample{t: minutes(20), v: float64(1)},
sample{t: minutes(25), v: float64(1)},
sample{t: minutes(30), v: float64(1)},
sample{t: minutes(32), v: float64(2)},
sample{t: minutes(35), v: float64(1)},
sample{t: minutes(42), v: float64(1)},
sample{t: minutes(50), v: float64(2)},
sample{t: minutes(10), f: float64(0)},
sample{t: minutes(15), f: float64(0)},
sample{t: minutes(20), f: float64(1)},
sample{t: minutes(25), f: float64(1)},
sample{t: minutes(30), f: float64(1)},
sample{t: minutes(32), f: float64(2)},
sample{t: minutes(35), f: float64(1)},
sample{t: minutes(42), f: float64(1)},
sample{t: minutes(50), f: float64(2)},
},
},
},
@ -833,7 +833,7 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
// OOO few samples for s1.
app = db.Appender(context.Background())
for _, s := range tc.inputSamples {
appendSample(app, s1, s.T(), s.V())
appendSample(app, s1, s.T(), s.F())
}
require.NoError(t, app.Commit())
@ -855,7 +855,7 @@ func TestOOOHeadChunkReader_Chunk(t *testing.T) {
it := c.Iterator(nil)
for it.Next() == chunkenc.ValFloat {
t, v := it.At()
resultSamples = append(resultSamples, sample{t: t, v: v})
resultSamples = append(resultSamples, sample{t: t, f: v})
}
require.Equal(t, tc.expChunksSamples[i], resultSamples)
}
@ -902,19 +902,19 @@ func TestOOOHeadChunkReader_Chunk_ConsistentQueryResponseDespiteOfHeadExpanding(
firstInOrderSampleAt: minutes(120),
initialSamples: tsdbutil.SampleSlice{
// Chunk 0
sample{t: minutes(20), v: float64(0)},
sample{t: minutes(22), v: float64(0)},
sample{t: minutes(24), v: float64(0)},
sample{t: minutes(26), v: float64(0)},
sample{t: minutes(30), v: float64(0)},
sample{t: minutes(20), f: float64(0)},
sample{t: minutes(22), f: float64(0)},
sample{t: minutes(24), f: float64(0)},
sample{t: minutes(26), f: float64(0)},
sample{t: minutes(30), f: float64(0)},
// Chunk 1 Head
sample{t: minutes(25), v: float64(1)},
sample{t: minutes(35), v: float64(1)},
sample{t: minutes(25), f: float64(1)},
sample{t: minutes(35), f: float64(1)},
},
samplesAfterSeriesCall: tsdbutil.SampleSlice{
sample{t: minutes(10), v: float64(1)},
sample{t: minutes(32), v: float64(1)},
sample{t: minutes(50), v: float64(1)},
sample{t: minutes(10), f: float64(1)},
sample{t: minutes(32), f: float64(1)},
sample{t: minutes(50), f: float64(1)},
},
expChunkError: false,
// ts (in minutes) 0 10 20 30 40 50 60 70 80 90 100
@ -926,14 +926,14 @@ func TestOOOHeadChunkReader_Chunk_ConsistentQueryResponseDespiteOfHeadExpanding(
// Output Graphically [------------] (With 8 samples, samples newer than lastmint or older than lastmaxt are omitted but the ones in between are kept)
expChunksSamples: []tsdbutil.SampleSlice{
{
sample{t: minutes(20), v: float64(0)},
sample{t: minutes(22), v: float64(0)},
sample{t: minutes(24), v: float64(0)},
sample{t: minutes(25), v: float64(1)},
sample{t: minutes(26), v: float64(0)},
sample{t: minutes(30), v: float64(0)},
sample{t: minutes(32), v: float64(1)}, // This sample was added after Series() but before Chunk() and its in between the lastmint and maxt so it should be kept
sample{t: minutes(35), v: float64(1)},
sample{t: minutes(20), f: float64(0)},
sample{t: minutes(22), f: float64(0)},
sample{t: minutes(24), f: float64(0)},
sample{t: minutes(25), f: float64(1)},
sample{t: minutes(26), f: float64(0)},
sample{t: minutes(30), f: float64(0)},
sample{t: minutes(32), f: float64(1)}, // This sample was added after Series() but before Chunk() and its in between the lastmint and maxt so it should be kept
sample{t: minutes(35), f: float64(1)},
},
},
},
@ -944,22 +944,22 @@ func TestOOOHeadChunkReader_Chunk_ConsistentQueryResponseDespiteOfHeadExpanding(
firstInOrderSampleAt: minutes(120),
initialSamples: tsdbutil.SampleSlice{
// Chunk 0
sample{t: minutes(20), v: float64(0)},
sample{t: minutes(22), v: float64(0)},
sample{t: minutes(24), v: float64(0)},
sample{t: minutes(26), v: float64(0)},
sample{t: minutes(30), v: float64(0)},
sample{t: minutes(20), f: float64(0)},
sample{t: minutes(22), f: float64(0)},
sample{t: minutes(24), f: float64(0)},
sample{t: minutes(26), f: float64(0)},
sample{t: minutes(30), f: float64(0)},
// Chunk 1 Head
sample{t: minutes(25), v: float64(1)},
sample{t: minutes(35), v: float64(1)},
sample{t: minutes(25), f: float64(1)},
sample{t: minutes(35), f: float64(1)},
},
samplesAfterSeriesCall: tsdbutil.SampleSlice{
sample{t: minutes(10), v: float64(1)},
sample{t: minutes(32), v: float64(1)},
sample{t: minutes(50), v: float64(1)},
sample{t: minutes(10), f: float64(1)},
sample{t: minutes(32), f: float64(1)},
sample{t: minutes(50), f: float64(1)},
// Chunk 1 gets mmapped and Chunk 2, the new head is born
sample{t: minutes(25), v: float64(2)},
sample{t: minutes(31), v: float64(2)},
sample{t: minutes(25), f: float64(2)},
sample{t: minutes(31), f: float64(2)},
},
expChunkError: false,
// ts (in minutes) 0 10 20 30 40 50 60 70 80 90 100
@ -972,14 +972,14 @@ func TestOOOHeadChunkReader_Chunk_ConsistentQueryResponseDespiteOfHeadExpanding(
// Output Graphically [------------] (8 samples) It has 5 from Chunk 0 and 3 from Chunk 1
expChunksSamples: []tsdbutil.SampleSlice{
{
sample{t: minutes(20), v: float64(0)},
sample{t: minutes(22), v: float64(0)},
sample{t: minutes(24), v: float64(0)},
sample{t: minutes(25), v: float64(1)},
sample{t: minutes(26), v: float64(0)},
sample{t: minutes(30), v: float64(0)},
sample{t: minutes(32), v: float64(1)}, // This sample was added after Series() but before Chunk() and its in between the lastmint and maxt so it should be kept
sample{t: minutes(35), v: float64(1)},
sample{t: minutes(20), f: float64(0)},
sample{t: minutes(22), f: float64(0)},
sample{t: minutes(24), f: float64(0)},
sample{t: minutes(25), f: float64(1)},
sample{t: minutes(26), f: float64(0)},
sample{t: minutes(30), f: float64(0)},
sample{t: minutes(32), f: float64(1)}, // This sample was added after Series() but before Chunk() and its in between the lastmint and maxt so it should be kept
sample{t: minutes(35), f: float64(1)},
},
},
},
@ -996,7 +996,7 @@ func TestOOOHeadChunkReader_Chunk_ConsistentQueryResponseDespiteOfHeadExpanding(
// OOO few samples for s1.
app = db.Appender(context.Background())
for _, s := range tc.initialSamples {
appendSample(app, s1, s.T(), s.V())
appendSample(app, s1, s.T(), s.F())
}
require.NoError(t, app.Commit())
@ -1013,7 +1013,7 @@ func TestOOOHeadChunkReader_Chunk_ConsistentQueryResponseDespiteOfHeadExpanding(
// OOO few samples for s1.
app = db.Appender(context.Background())
for _, s := range tc.samplesAfterSeriesCall {
appendSample(app, s1, s.T(), s.V())
appendSample(app, s1, s.T(), s.F())
}
require.NoError(t, app.Commit())
@ -1026,7 +1026,7 @@ func TestOOOHeadChunkReader_Chunk_ConsistentQueryResponseDespiteOfHeadExpanding(
it := c.Iterator(nil)
for it.Next() == chunkenc.ValFloat {
ts, v := it.At()
resultSamples = append(resultSamples, sample{t: ts, v: v})
resultSamples = append(resultSamples, sample{t: ts, f: v})
}
require.Equal(t, tc.expChunksSamples[i], resultSamples)
}

6
tsdb/ooo_head_test.go
View file

@ -52,7 +52,7 @@ func TestOOOInsert(t *testing.T) {
chunk := NewOOOChunk()
chunk.samples = makeEvenSampleSlice(numPreExisting)
newSample := samplify(valOdd(insertPos))
chunk.Insert(newSample.t, newSample.v)
chunk.Insert(newSample.t, newSample.f)
var expSamples []sample
// Our expected new samples slice, will be first the original samples.
@ -81,9 +81,9 @@ func TestOOOInsertDuplicate(t *testing.T) {
chunk.samples = makeEvenSampleSlice(num)
dupSample := chunk.samples[dupPos]
dupSample.v = 0.123
dupSample.f = 0.123
ok := chunk.Insert(dupSample.t, dupSample.v)
ok := chunk.Insert(dupSample.t, dupSample.f)
expSamples := makeEvenSampleSlice(num) // We expect no change.
require.False(t, ok)

16
tsdb/querier_test.go
View file

@ -132,7 +132,7 @@ func createIdxChkReaders(t *testing.T, tc []seriesSamples) (IndexReader, ChunkRe
chunk := chunkenc.NewXORChunk()
app, _ := chunk.Appender()
for _, smpl := range chk {
app.Append(smpl.t, smpl.v)
app.Append(smpl.t, smpl.f)
}
chkReader[chunkRef] = chunk
chunkRef++
@ -479,7 +479,7 @@ func TestBlockQuerier_AgainstHeadWithOpenChunks(t *testing.T) {
for _, s := range testData {
for _, chk := range s.chunks {
for _, sample := range chk {
_, err = app.Append(0, labels.FromMap(s.lset), sample.t, sample.v)
_, err = app.Append(0, labels.FromMap(s.lset), sample.t, sample.f)
require.NoError(t, err)
}
}
@ -882,7 +882,7 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) {
if tc.seekSuccess {
// After successful seek iterator is ready. Grab the value.
t, v := it.At()
r = append(r, sample{t: t, v: v})
r = append(r, sample{t: t, f: v})
}
}
expandedResult, err := storage.ExpandSamples(it, newSample)
@ -1054,8 +1054,8 @@ func TestDeletedIterator(t *testing.T) {
act := make([]sample, 1000)
for i := 0; i < 1000; i++ {
act[i].t = int64(i)
act[i].v = rand.Float64()
app.Append(act[i].t, act[i].v)
act[i].f = rand.Float64()
app.Append(act[i].t, act[i].f)
}
cases := []struct {
@ -1090,7 +1090,7 @@ func TestDeletedIterator(t *testing.T) {
ts, v := it.At()
require.Equal(t, act[i].t, ts)
require.Equal(t, act[i].v, v)
require.Equal(t, act[i].f, v)
}
// There has been an extra call to Next().
i++
@ -1114,8 +1114,8 @@ func TestDeletedIterator_WithSeek(t *testing.T) {
act := make([]sample, 1000)
for i := 0; i < 1000; i++ {
act[i].t = int64(i)
act[i].v = float64(i)
app.Append(act[i].t, act[i].v)
act[i].f = float64(i)
app.Append(act[i].t, act[i].f)
}
cases := []struct {

14
tsdb/tsdbutil/chunks.go
View file

@ -28,7 +28,7 @@ type Samples interface {
type Sample interface {
T() int64
V() float64 // TODO(beorn7): Rename to F().
F() float64
H() *histogram.Histogram
FH() *histogram.FloatHistogram
Type() chunkenc.ValueType
@ -69,7 +69,7 @@ func ChunkFromSamplesGeneric(s Samples) chunks.Meta {
for i := 0; i < s.Len(); i++ {
switch sampleType {
case chunkenc.ValFloat:
ca.Append(s.Get(i).T(), s.Get(i).V())
ca.Append(s.Get(i).T(), s.Get(i).F())
case chunkenc.ValHistogram:
ca.AppendHistogram(s.Get(i).T(), s.Get(i).H())
case chunkenc.ValFloatHistogram:
@ -87,7 +87,7 @@ func ChunkFromSamplesGeneric(s Samples) chunks.Meta {
type sample struct {
t int64
v float64
f float64
h *histogram.Histogram
fh *histogram.FloatHistogram
}
@ -96,8 +96,8 @@ func (s sample) T() int64 {
return s.t
}
func (s sample) V() float64 {
return s.v
func (s sample) F() float64 {
return s.f
}
func (s sample) H() *histogram.Histogram {
@ -123,7 +123,7 @@ func (s sample) Type() chunkenc.ValueType {
func PopulatedChunk(numSamples int, minTime int64) chunks.Meta {
samples := make([]Sample, numSamples)
for i := 0; i < numSamples; i++ {
samples[i] = sample{t: minTime + int64(i*1000), v: 1.0}
samples[i] = sample{t: minTime + int64(i*1000), f: 1.0}
}
return ChunkFromSamples(samples)
}
@ -133,7 +133,7 @@ func GenerateSamples(start, numSamples int) []Sample {
return generateSamples(start, numSamples, func(i int) Sample {
return sample{
t: int64(i),
v: float64(i),
f: float64(i),
}
})
}

6
util/jsonutil/marshal.go
View file

@ -45,12 +45,12 @@ func MarshalTimestamp(t int64, stream *jsoniter.Stream) {
}
// MarshalFloat marshals a float value using the passed jsoniter stream.
func MarshalFloat(v float64, stream *jsoniter.Stream) {
func MarshalFloat(f float64, stream *jsoniter.Stream) {
stream.WriteRaw(`"`)
// Taken from https://github.com/json-iterator/go/blob/master/stream_float.go#L71 as a workaround
// to https://github.com/json-iterator/go/issues/365 (jsoniter, to follow json standard, doesn't allow inf/nan).
buf := stream.Buffer()
abs := math.Abs(v)
abs := math.Abs(f)
fmt := byte('f')
// Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
if abs != 0 {
@ -58,7 +58,7 @@ func MarshalFloat(v float64, stream *jsoniter.Stream) {
fmt = 'e'
}
}
buf = strconv.AppendFloat(buf, v, fmt, -1, 64)
buf = strconv.AppendFloat(buf, f, fmt, -1, 64)
stream.SetBuffer(buf)
stream.WriteRaw(`"`)
}

2
web/federate.go
View file

@ -132,7 +132,7 @@ Loop:
t = sample.T()
switch sample.Type() {
case chunkenc.ValFloat:
f = sample.V()
f = sample.F()
case chunkenc.ValHistogram:
fh = sample.H().ToFloat()
case chunkenc.ValFloatHistogram: