mudhorn/prometheus
1
0
Fork 0
mirror of https://github.com/prometheus/prometheus.git synced 2025-03-05 20:59:13 -08:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

wip passing struct

Browse source 
Signed-off-by: Jesus Vazquez <jesusvzpg@gmail.com>
This commit is contained in:
Jesus Vazquez 2024-10-22 12:29:49 +02:00
parent a68557dd9c
commit b1e9aad594
No known key found for this signature in database
GPG key ID: E2492C7B8442A95B
26 changed files with 272 additions and 265 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
cmd/prometheus/main.go
View file

@ -1639,7 +1639,7 @@ func (s *readyStorage) Appender(ctx context.Context) storage.Appender {
type notReadyAppender struct{} type notReadyAppender struct{}
func (n notReadyAppender) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64, hints *storage.AppendHints) (storage.SeriesRef, error) { func (n notReadyAppender) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64, hints storage.AppendHints) (storage.SeriesRef, error) {
return 0, tsdb.ErrNotReady return 0, tsdb.ErrNotReady
} }

3
cmd/promtool/backfill.go
View file

@ -27,6 +27,7 @@ import (
"github.com/prometheus/prometheus/model/labels" "github.com/prometheus/prometheus/model/labels"
"github.com/prometheus/prometheus/model/textparse" "github.com/prometheus/prometheus/model/textparse"
"github.com/prometheus/prometheus/storage"
"github.com/prometheus/prometheus/tsdb" "github.com/prometheus/prometheus/tsdb"
tsdb_errors "github.com/prometheus/prometheus/tsdb/errors" tsdb_errors "github.com/prometheus/prometheus/tsdb/errors"
) )
@ -171,7 +172,7 @@ func createBlocks(input []byte, mint, maxt, maxBlockDuration int64, maxSamplesIn
} }
lbls := lb.Labels() lbls := lb.Labels()
if _, err := app.Append(0, lbls, *ts, v, nil); err != nil { if _, err := app.Append(0, lbls, *ts, v, storage.AppendHints{}); err != nil {
return fmt.Errorf("add sample: %w", err) return fmt.Errorf("add sample: %w", err)
} }

6
rules/group.go
View file

@ -564,7 +564,7 @@ func (g *Group) Eval(ctx context.Context, ts time.Time) {
if s.H != nil { if s.H != nil {
_, err = app.AppendHistogram(0, s.Metric, s.T, nil, s.H, nil) _, err = app.AppendHistogram(0, s.Metric, s.T, nil, s.H, nil)
} else { } else {
_, err = app.Append(0, s.Metric, s.T, s.F, nil) _, err = app.Append(0, s.Metric, s.T, s.F, storage.AppendHints{})
} }
if err != nil { if err != nil {
@ -606,7 +606,7 @@ func (g *Group) Eval(ctx context.Context, ts time.Time) {
for metric, lset := range g.seriesInPreviousEval[i] { for metric, lset := range g.seriesInPreviousEval[i] {
if _, ok := seriesReturned[metric]; !ok { if _, ok := seriesReturned[metric]; !ok {
// Series no longer exposed, mark it stale. // Series no longer exposed, mark it stale.
_, err = app.Append(0, lset, timestamp.FromTime(ts.Add(-ruleQueryOffset)), math.Float64frombits(value.StaleNaN), nil) _, err = app.Append(0, lset, timestamp.FromTime(ts.Add(-ruleQueryOffset)), math.Float64frombits(value.StaleNaN), storage.AppendHints{})
unwrappedErr := errors.Unwrap(err) unwrappedErr := errors.Unwrap(err)
if unwrappedErr == nil { if unwrappedErr == nil {
unwrappedErr = err unwrappedErr = err
@ -663,7 +663,7 @@ func (g *Group) cleanupStaleSeries(ctx context.Context, ts time.Time) {
queryOffset := g.QueryOffset() queryOffset := g.QueryOffset()
for _, s := range g.staleSeries { for _, s := range g.staleSeries {
// Rule that produced series no longer configured, mark it stale. // Rule that produced series no longer configured, mark it stale.
_, err := app.Append(0, s, timestamp.FromTime(ts.Add(-queryOffset)), math.Float64frombits(value.StaleNaN), nil) _, err := app.Append(0, s, timestamp.FromTime(ts.Add(-queryOffset)), math.Float64frombits(value.StaleNaN), storage.AppendHints{})
unwrappedErr := errors.Unwrap(err) unwrappedErr := errors.Unwrap(err)
if unwrappedErr == nil { if unwrappedErr == nil {
unwrappedErr = err unwrappedErr = err

4
scrape/helpers_test.go
View file

@ -43,7 +43,7 @@ func (a nopAppendable) Appender(_ context.Context) storage.Appender {
type nopAppender struct{} type nopAppender struct{}
func (a nopAppender) Append(storage.SeriesRef, labels.Labels, int64, float64, *storage.AppendHints) (storage.SeriesRef, error) { func (a nopAppender) Append(storage.SeriesRef, labels.Labels, int64, float64, storage.AppendHints) (storage.SeriesRef, error) {
return 0, nil return 0, nil
} }
@ -114,7 +114,7 @@ type collectResultAppender struct {
pendingMetadata []metadata.Metadata pendingMetadata []metadata.Metadata
} }
func (a *collectResultAppender) Append(ref storage.SeriesRef, lset labels.Labels, t int64, v float64, hints *storage.AppendHints) (storage.SeriesRef, error) { func (a *collectResultAppender) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64, hints storage.AppendHints) (storage.SeriesRef, error) {
a.mtx.Lock() a.mtx.Lock()
defer a.mtx.Unlock() defer a.mtx.Unlock()
a.pendingFloats = append(a.pendingFloats, floatSample{ a.pendingFloats = append(a.pendingFloats, floatSample{

6
scrape/scrape.go
View file

@ -1752,7 +1752,7 @@ loop:
ref, err = app.AppendHistogram(ref, lset, t, nil, fh, nil) ref, err = app.AppendHistogram(ref, lset, t, nil, fh, nil)
} }
} else { } else {
ref, err = app.Append(ref, lset, t, val, nil) ref, err = app.Append(ref, lset, t, val, storage.AppendHints{})
} }
} }
@ -1864,7 +1864,7 @@ loop:
if err == nil { if err == nil {
sl.cache.forEachStale(func(lset labels.Labels) bool { sl.cache.forEachStale(func(lset labels.Labels) bool {
// Series no longer exposed, mark it stale. // Series no longer exposed, mark it stale.
_, err = app.Append(0, lset, defTime, math.Float64frombits(value.StaleNaN), nil) _, err = app.Append(0, lset, defTime, math.Float64frombits(value.StaleNaN), storage.AppendHints{})
switch { switch {
case errors.Is(err, storage.ErrOutOfOrderSample), errors.Is(err, storage.ErrDuplicateSampleForTimestamp): case errors.Is(err, storage.ErrOutOfOrderSample), errors.Is(err, storage.ErrDuplicateSampleForTimestamp):
// Do not count these in logging, as this is expected if a target // Do not count these in logging, as this is expected if a target
@ -2019,7 +2019,7 @@ func (sl *scrapeLoop) addReportSample(app storage.Appender, s []byte, t int64, v
lset = sl.reportSampleMutator(b.Labels()) lset = sl.reportSampleMutator(b.Labels())
} }
ref, err := app.Append(ref, lset, t, v, nil) ref, err := app.Append(ref, lset, t, v, storage.AppendHints{})
switch { switch {
case err == nil: case err == nil:
if !ok { if !ok {

2
scrape/scrape_test.go
View file

@ -2328,7 +2328,7 @@ type errorAppender struct {
collectResultAppender collectResultAppender
} }
func (app *errorAppender) Append(ref storage.SeriesRef, lset labels.Labels, t int64, v float64, hints *storage.AppendHints) (storage.SeriesRef, error) { func (app *errorAppender) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64, hints storage.AppendHints) (storage.SeriesRef, error) {
switch lset.Get(model.MetricNameLabel) { switch lset.Get(model.MetricNameLabel) {
case "out_of_order": case "out_of_order":
return 0, storage.ErrOutOfOrderSample return 0, storage.ErrOutOfOrderSample

8
scrape/target.go
View file

@ -323,14 +323,14 @@ type limitAppender struct {
i int i int
} }
func (app *limitAppender) Append(ref storage.SeriesRef, lset labels.Labels, t int64, v float64, hints *storage.AppendHints) (storage.SeriesRef, error) { func (app *limitAppender) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64, hints storage.AppendHints) (storage.SeriesRef, error) {
if !value.IsStaleNaN(v) { if !value.IsStaleNaN(v) {
app.i++ app.i++
if app.i > app.limit { if app.i > app.limit {
return 0, errSampleLimit return 0, errSampleLimit
} }
} }
ref, err := app.Appender.Append(ref, lset, t, v, nil) ref, err := app.Appender.Append(ref, l, t, v, storage.AppendHints{})
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -343,12 +343,12 @@ type timeLimitAppender struct {
maxTime int64 maxTime int64
} }
func (app *timeLimitAppender) Append(ref storage.SeriesRef, lset labels.Labels, t int64, v float64, hints *storage.AppendHints) (storage.SeriesRef, error) { func (app *timeLimitAppender) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64, hints storage.AppendHints) (storage.SeriesRef, error) {
if t > app.maxTime { if t > app.maxTime {
return 0, storage.ErrOutOfBounds return 0, storage.ErrOutOfBounds
} }
ref, err := app.Appender.Append(ref, lset, t, v, nil) ref, err := app.Appender.Append(ref, l, t, v, storage.AppendHints{})
if err != nil { if err != nil {
return 0, err return 0, err
} }

6
storage/fanout.go
View file

@ -147,14 +147,14 @@ type fanoutAppender struct {
secondaries []Appender secondaries []Appender
} }
func (f *fanoutAppender) Append(ref SeriesRef, l labels.Labels, t int64, v float64, hints *AppendHints) (SeriesRef, error) { func (f *fanoutAppender) Append(ref SeriesRef, l labels.Labels, t int64, v float64, hints AppendHints) (SeriesRef, error) {
ref, err := f.primary.Append(ref, l, t, v, nil) ref, err := f.primary.Append(ref, l, t, v, AppendHints{})
if err != nil { if err != nil {
return ref, err return ref, err
} }
for _, appender := range f.secondaries { for _, appender := range f.secondaries {
if _, err := appender.Append(ref, l, t, v, nil); err != nil { if _, err := appender.Append(ref, l, t, v, AppendHints{}); err != nil {
return 0, err return 0, err
} }
} }

2
storage/interface.go
View file

@ -265,7 +265,7 @@ type Appender interface {
// to Append() at any point. Adding the sample via Append() returns a new // to Append() at any point. Adding the sample via Append() returns a new
// reference number. // reference number.
// If the reference is 0 it must not be used for caching. // If the reference is 0 it must not be used for caching.
Append(ref SeriesRef, l labels.Labels, t int64, v float64, hints *AppendHints) (SeriesRef, error) Append(ref SeriesRef, l labels.Labels, t int64, v float64, hints AppendHints) (SeriesRef, error)
// Commit submits the collected samples and purges the batch. If Commit // Commit submits the collected samples and purges the batch. If Commit
// returns a non-nil error, it also rolls back all modifications made in // returns a non-nil error, it also rolls back all modifications made in

2
storage/remote/write.go
View file

@ -286,7 +286,7 @@ type timestampTracker struct {
} }
// Append implements storage.Appender. // Append implements storage.Appender.
func (t *timestampTracker) Append(ref storage.SeriesRef, l labels.Labels, ts int64, v float64, hints *storage.AppendHints) (storage.SeriesRef, error) { func (t *timestampTracker) Append(ref storage.SeriesRef, l labels.Labels, ts int64, v float64, hints storage.AppendHints) (storage.SeriesRef, error) {
t.samples++ t.samples++
if ts > t.highestTimestamp { if ts > t.highestTimestamp {
t.highestTimestamp = ts t.highestTimestamp = ts

8
storage/remote/write_handler.go
View file

@ -287,7 +287,7 @@ func (h *writeHandler) appendV1Samples(app storage.Appender, ss []prompb.Sample,
var ref storage.SeriesRef var ref storage.SeriesRef
var err error var err error
for _, s := range ss { for _, s := range ss {
ref, err = app.Append(ref, labels, s.GetTimestamp(), s.GetValue(), nil) ref, err = app.Append(ref, labels, s.GetTimestamp(), s.GetValue(), storage.AppendHints{})
if err != nil { if err != nil {
if errors.Is(err, storage.ErrOutOfOrderSample) || if errors.Is(err, storage.ErrOutOfOrderSample) ||
errors.Is(err, storage.ErrOutOfBounds) || errors.Is(err, storage.ErrOutOfBounds) ||
@ -395,7 +395,7 @@ func (h *writeHandler) appendV2(app storage.Appender, req *writev2.Request, rs *
// Samples. // Samples.
for _, s := range ts.Samples { for _, s := range ts.Samples {
ref, err = app.Append(ref, ls, s.GetTimestamp(), s.GetValue(), nil) ref, err = app.Append(ref, ls, s.GetTimestamp(), s.GetValue(), storage.AppendHints{})
if err == nil { if err == nil {
rs.Samples++ rs.Samples++
continue continue
@ -548,12 +548,12 @@ type timeLimitAppender struct {
maxTime int64 maxTime int64
} }
func (app *timeLimitAppender) Append(ref storage.SeriesRef, lset labels.Labels, t int64, v float64, hints *storage.AppendHints) (storage.SeriesRef, error) { func (app *timeLimitAppender) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64, hints storage.AppendHints) (storage.SeriesRef, error) {
if t > app.maxTime { if t > app.maxTime {
return 0, fmt.Errorf("%w: timestamp is too far in the future", storage.ErrOutOfBounds) return 0, fmt.Errorf("%w: timestamp is too far in the future", storage.ErrOutOfBounds)
} }
ref, err := app.Appender.Append(ref, lset, t, v, nil) ref, err := app.Appender.Append(ref, l, t, v, storage.AppendHints{})
if err != nil { if err != nil {
return 0, err return 0, err
} }

2
storage/remote/write_handler_test.go
View file

@ -833,7 +833,7 @@ func (m *mockAppendable) Appender(_ context.Context) storage.Appender {
return m return m
} }
func (m *mockAppendable) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64, hints *storage.AppendHints) (storage.SeriesRef, error) { func (m *mockAppendable) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64, hints storage.AppendHints) (storage.SeriesRef, error) {
if m.appendSampleErr != nil { if m.appendSampleErr != nil {
return 0, m.appendSampleErr return 0, m.appendSampleErr
} }

2
tsdb/agent/db.go
View file

@ -783,7 +783,7 @@ type appender struct {
floatHistogramSeries []*memSeries floatHistogramSeries []*memSeries
} }
func (a *appender) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64, hints *storage.AppendHints) (storage.SeriesRef, error) { func (a *appender) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64, hints storage.AppendHints) (storage.SeriesRef, error) {
// series references and chunk references are identical for agent mode. // series references and chunk references are identical for agent mode.
headRef := chunks.HeadSeriesRef(ref) headRef := chunks.HeadSeriesRef(ref)

30
tsdb/agent/db_test.go
View file

@ -47,10 +47,10 @@ func TestDB_InvalidSeries(t *testing.T) {
app := s.Appender(context.Background()) app := s.Appender(context.Background())
t.Run("Samples", func(t *testing.T) { t.Run("Samples", func(t *testing.T) {
_, err := app.Append(0, labels.Labels{}, 0, 0, nil) _, err := app.Append(0, labels.Labels{}, 0, 0, storage.AppendHints{})
require.ErrorIs(t, err, tsdb.ErrInvalidSample, "should reject empty labels") require.ErrorIs(t, err, tsdb.ErrInvalidSample, "should reject empty labels")
_, err = app.Append(0, labels.FromStrings("a", "1", "a", "2"), 0, 0, nil) _, err = app.Append(0, labels.FromStrings("a", "1", "a", "2"), 0, 0, storage.AppendHints{})
require.ErrorIs(t, err, tsdb.ErrInvalidSample, "should reject duplicate labels") require.ErrorIs(t, err, tsdb.ErrInvalidSample, "should reject duplicate labels")
}) })
@ -63,7 +63,7 @@ func TestDB_InvalidSeries(t *testing.T) {
}) })
t.Run("Exemplars", func(t *testing.T) { t.Run("Exemplars", func(t *testing.T) {
sRef, err := app.Append(0, labels.FromStrings("a", "1"), 0, 0, nil) sRef, err := app.Append(0, labels.FromStrings("a", "1"), 0, 0, storage.AppendHints{})
require.NoError(t, err, "should not reject valid series") require.NoError(t, err, "should not reject valid series")
_, err = app.AppendExemplar(0, labels.EmptyLabels(), exemplar.Exemplar{}, nil) _, err = app.AppendExemplar(0, labels.EmptyLabels(), exemplar.Exemplar{}, nil)
@ -134,7 +134,7 @@ func TestCommit(t *testing.T) {
for i := 0; i < numDatapoints; i++ { for i := 0; i < numDatapoints; i++ {
sample := chunks.GenerateSamples(0, 1) sample := chunks.GenerateSamples(0, 1)
ref, err := app.Append(0, lset, sample[0].T(), sample[0].F(), nil) ref, err := app.Append(0, lset, sample[0].T(), sample[0].F(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
e := exemplar.Exemplar{ e := exemplar.Exemplar{
@ -249,7 +249,7 @@ func TestRollback(t *testing.T) {
for i := 0; i < numDatapoints; i++ { for i := 0; i < numDatapoints; i++ {
sample := chunks.GenerateSamples(0, 1) sample := chunks.GenerateSamples(0, 1)
_, err := app.Append(0, lset, sample[0].T(), sample[0].F(), nil) _, err := app.Append(0, lset, sample[0].T(), sample[0].F(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
} }
@ -365,7 +365,7 @@ func TestFullTruncateWAL(t *testing.T) {
lset := labels.New(l...) lset := labels.New(l...)
for i := 0; i < numDatapoints; i++ { for i := 0; i < numDatapoints; i++ {
_, err := app.Append(0, lset, int64(lastTs), 0, nil) _, err := app.Append(0, lset, int64(lastTs), 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -427,7 +427,7 @@ func TestPartialTruncateWAL(t *testing.T) {
lset := labels.New(l...) lset := labels.New(l...)
for i := 0; i < numDatapoints; i++ { for i := 0; i < numDatapoints; i++ {
_, err := app.Append(0, lset, lastTs, 0, nil) _, err := app.Append(0, lset, lastTs, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -466,7 +466,7 @@ func TestPartialTruncateWAL(t *testing.T) {
lset := labels.New(l...) lset := labels.New(l...)
for i := 0; i < numDatapoints; i++ { for i := 0; i < numDatapoints; i++ {
_, err := app.Append(0, lset, lastTs, 0, nil) _, err := app.Append(0, lset, lastTs, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -521,7 +521,7 @@ func TestWALReplay(t *testing.T) {
lset := labels.New(l...) lset := labels.New(l...)
for i := 0; i < numDatapoints; i++ { for i := 0; i < numDatapoints; i++ {
_, err := app.Append(0, lset, lastTs, 0, nil) _, err := app.Append(0, lset, lastTs, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
} }
@ -618,7 +618,7 @@ func Test_ExistingWAL_NextRef(t *testing.T) {
app := db.Appender(context.Background()) app := db.Appender(context.Background())
for i := 0; i < seriesCount; i++ { for i := 0; i < seriesCount; i++ {
lset := labels.FromStrings(model.MetricNameLabel, fmt.Sprintf("series_%d", i)) lset := labels.FromStrings(model.MetricNameLabel, fmt.Sprintf("series_%d", i))
_, err := app.Append(0, lset, 0, 100, nil) _, err := app.Append(0, lset, 0, 100, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
@ -707,7 +707,7 @@ func TestStorage_DuplicateExemplarsIgnored(t *testing.T) {
app := s.Appender(context.Background()) app := s.Appender(context.Background())
defer s.Close() defer s.Close()
sRef, err := app.Append(0, labels.FromStrings("a", "1"), 0, 0, nil) sRef, err := app.Append(0, labels.FromStrings("a", "1"), 0, 0, storage.AppendHints{})
require.NoError(t, err, "should not reject valid series") require.NoError(t, err, "should not reject valid series")
// Write a few exemplars to our appender and call Commit(). // Write a few exemplars to our appender and call Commit().
@ -774,7 +774,7 @@ func TestDBAllowOOOSamples(t *testing.T) {
lset := labels.New(l...) lset := labels.New(l...)
for i := offset; i < numDatapoints+offset; i++ { for i := offset; i < numDatapoints+offset; i++ {
ref, err := app.Append(0, lset, int64(i), float64(i), nil) ref, err := app.Append(0, lset, int64(i), float64(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
e := exemplar.Exemplar{ e := exemplar.Exemplar{
@ -838,7 +838,7 @@ func TestDBAllowOOOSamples(t *testing.T) {
lset := labels.New(l...) lset := labels.New(l...)
for i := 0; i < numDatapoints; i++ { for i := 0; i < numDatapoints; i++ {
ref, err := app.Append(0, lset, int64(i), float64(i), nil) ref, err := app.Append(0, lset, int64(i), float64(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
e := exemplar.Exemplar{ e := exemplar.Exemplar{
@ -914,11 +914,11 @@ func TestDBOutOfOrderTimeWindow(t *testing.T) {
lbls = labelsForTest(t.Name(), 1) lbls = labelsForTest(t.Name(), 1)
lset = labels.New(lbls[0]...) lset = labels.New(lbls[0]...)
_, err = app.Append(0, lset, c.firstTs, 0, nil) _, err = app.Append(0, lset, c.firstTs, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
err = app.Commit() err = app.Commit()
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, lset, c.secondTs, 0, nil) _, err = app.Append(0, lset, c.secondTs, 0, storage.AppendHints{})
require.ErrorIs(t, err, c.expectedError) require.ErrorIs(t, err, c.expectedError)
expectedAppendedSamples := float64(2) expectedAppendedSamples := float64(2)

6
tsdb/block_test.go
View file

@ -680,7 +680,7 @@ func createHead(tb testing.TB, w *wlog.WL, series []storage.Series, chunkDir str
switch typ { switch typ {
case chunkenc.ValFloat: case chunkenc.ValFloat:
t, v := it.At() t, v := it.At()
ref, err = app.Append(ref, lset, t, v, nil) ref, err = app.Append(ref, lset, t, v, storage.AppendHints{})
case chunkenc.ValHistogram: case chunkenc.ValHistogram:
t, h := it.AtHistogram(nil) t, h := it.AtHistogram(nil)
ref, err = app.AppendHistogram(ref, lset, t, h, nil, nil) ref, err = app.AppendHistogram(ref, lset, t, h, nil, nil)
@ -726,7 +726,7 @@ func createHeadWithOOOSamples(tb testing.TB, w *wlog.WL, series []storage.Series
os = append(os, sample{t: t, f: v}) os = append(os, sample{t: t, f: v})
continue continue
} }
ref, err = app.Append(ref, lset, t, v, nil) ref, err = app.Append(ref, lset, t, v, storage.AppendHints{})
require.NoError(tb, err) require.NoError(tb, err)
} }
require.NoError(tb, it.Err()) require.NoError(tb, it.Err())
@ -744,7 +744,7 @@ func createHeadWithOOOSamples(tb testing.TB, w *wlog.WL, series []storage.Series
for i, lset := range oooSampleLabels { for i, lset := range oooSampleLabels {
ref := storage.SeriesRef(0) ref := storage.SeriesRef(0)
for _, sample := range oooSamples[i] { for _, sample := range oooSamples[i] {
ref, err = app.Append(ref, lset, sample.T(), sample.F(), nil) ref, err = app.Append(ref, lset, sample.T(), sample.F(), storage.AppendHints{})
require.NoError(tb, err) require.NoError(tb, err)
oooSamplesAppended++ oooSamplesAppended++
} }

5
tsdb/blockwriter_test.go
View file

@ -24,6 +24,7 @@ import (
"github.com/prometheus/common/promslog" "github.com/prometheus/common/promslog"
"github.com/prometheus/prometheus/model/labels" "github.com/prometheus/prometheus/model/labels"
"github.com/prometheus/prometheus/storage"
"github.com/prometheus/prometheus/tsdb/chunks" "github.com/prometheus/prometheus/tsdb/chunks"
) )
@ -36,10 +37,10 @@ func TestBlockWriter(t *testing.T) {
// Add some series. // Add some series.
app := w.Appender(ctx) app := w.Appender(ctx)
ts1, v1 := int64(44), float64(7) ts1, v1 := int64(44), float64(7)
_, err = app.Append(0, labels.FromStrings("a", "b"), ts1, v1, nil) _, err = app.Append(0, labels.FromStrings("a", "b"), ts1, v1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
ts2, v2 := int64(55), float64(12) ts2, v2 := int64(55), float64(12)
_, err = app.Append(0, labels.FromStrings("c", "d"), ts2, v2, nil) _, err = app.Append(0, labels.FromStrings("c", "d"), ts2, v2, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
id, err := w.Flush(ctx) id, err := w.Flush(ctx)

40
tsdb/compact_test.go
View file

@ -1190,7 +1190,7 @@ func BenchmarkCompactionFromHead(b *testing.B) {
for ln := 0; ln < labelNames; ln++ { for ln := 0; ln < labelNames; ln++ {
app := h.Appender(context.Background()) app := h.Appender(context.Background())
for lv := 0; lv < labelValues; lv++ { for lv := 0; lv < labelValues; lv++ {
app.Append(0, labels.FromStrings(strconv.Itoa(ln), fmt.Sprintf("%d%s%d", lv, postingsBenchSuffix, ln)), 0, 0, nil) app.Append(0, labels.FromStrings(strconv.Itoa(ln), fmt.Sprintf("%d%s%d", lv, postingsBenchSuffix, ln)), 0, 0, storage.AppendHints{})
} }
require.NoError(b, app.Commit()) require.NoError(b, app.Commit())
} }
@ -1223,10 +1223,10 @@ func BenchmarkCompactionFromOOOHead(b *testing.B) {
app := h.Appender(context.Background()) app := h.Appender(context.Background())
for lv := 0; lv < labelValues; lv++ { for lv := 0; lv < labelValues; lv++ {
lbls := labels.FromStrings(strconv.Itoa(ln), fmt.Sprintf("%d%s%d", lv, postingsBenchSuffix, ln)) lbls := labels.FromStrings(strconv.Itoa(ln), fmt.Sprintf("%d%s%d", lv, postingsBenchSuffix, ln))
_, err = app.Append(0, lbls, int64(totalSamples), 0, nil) _, err = app.Append(0, lbls, int64(totalSamples), 0, storage.AppendHints{})
require.NoError(b, err) require.NoError(b, err)
for ts := 0; ts < totalSamples; ts++ { for ts := 0; ts < totalSamples; ts++ {
_, err = app.Append(0, lbls, int64(ts), float64(ts), nil) _, err = app.Append(0, lbls, int64(ts), float64(ts), storage.AppendHints{})
require.NoError(b, err) require.NoError(b, err)
} }
} }
@ -1263,9 +1263,9 @@ func TestDisableAutoCompactions(t *testing.T) {
db.DisableCompactions() db.DisableCompactions()
app := db.Appender(context.Background()) app := db.Appender(context.Background())
for i := int64(0); i < 3; i++ { for i := int64(0); i < 3; i++ {
_, err := app.Append(0, label, i*blockRange, 0, nil) _, err := app.Append(0, label, i*blockRange, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, label, i*blockRange+1000, 0, nil) _, err = app.Append(0, label, i*blockRange+1000, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -1379,11 +1379,11 @@ func TestDeleteCompactionBlockAfterFailedReload(t *testing.T) {
// Add some data to the head that is enough to trigger a compaction. // Add some data to the head that is enough to trigger a compaction.
app := db.Appender(context.Background()) app := db.Appender(context.Background())
_, err := app.Append(0, defaultLabel, 1, 0, nil) _, err := app.Append(0, defaultLabel, 1, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, defaultLabel, 2, 0, nil) _, err = app.Append(0, defaultLabel, 2, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, defaultLabel, 3+rangeToTriggerCompaction, 0, nil) _, err = app.Append(0, defaultLabel, 3+rangeToTriggerCompaction, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -1489,7 +1489,7 @@ func TestHeadCompactionWithHistograms(t *testing.T) {
t.Helper() t.Helper()
app := head.Appender(ctx) app := head.Appender(ctx)
for tsMinute := from; tsMinute <= to; tsMinute++ { for tsMinute := from; tsMinute <= to; tsMinute++ {
_, err := app.Append(0, lbls, minute(tsMinute), float64(tsMinute), nil) _, err := app.Append(0, lbls, minute(tsMinute), float64(tsMinute), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
*exp = append(*exp, sample{t: minute(tsMinute), f: float64(tsMinute)}) *exp = append(*exp, sample{t: minute(tsMinute), f: float64(tsMinute)})
} }
@ -1711,20 +1711,20 @@ func TestSparseHistogramSpaceSavings(t *testing.T) {
numOldSeriesPerHistogram++ numOldSeriesPerHistogram++
b := it.At() b := it.At()
lbls := labels.NewBuilder(ah.baseLabels).Set("le", fmt.Sprintf("%.16f", b.Upper)).Labels() lbls := labels.NewBuilder(ah.baseLabels).Set("le", fmt.Sprintf("%.16f", b.Upper)).Labels()
refs[itIdx], err = oldApp.Append(refs[itIdx], lbls, ts, float64(b.Count), nil) refs[itIdx], err = oldApp.Append(refs[itIdx], lbls, ts, float64(b.Count), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
itIdx++ itIdx++
} }
baseName := ah.baseLabels.Get(labels.MetricName) baseName := ah.baseLabels.Get(labels.MetricName)
// _count metric. // _count metric.
countLbls := labels.NewBuilder(ah.baseLabels).Set(labels.MetricName, baseName+"_count").Labels() countLbls := labels.NewBuilder(ah.baseLabels).Set(labels.MetricName, baseName+"_count").Labels()
_, err = oldApp.Append(0, countLbls, ts, float64(h.Count), nil) _, err = oldApp.Append(0, countLbls, ts, float64(h.Count), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
numOldSeriesPerHistogram++ numOldSeriesPerHistogram++
// _sum metric. // _sum metric.
sumLbls := labels.NewBuilder(ah.baseLabels).Set(labels.MetricName, baseName+"_sum").Labels() sumLbls := labels.NewBuilder(ah.baseLabels).Set(labels.MetricName, baseName+"_sum").Labels()
_, err = oldApp.Append(0, sumLbls, ts, h.Sum, nil) _, err = oldApp.Append(0, sumLbls, ts, h.Sum, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
numOldSeriesPerHistogram++ numOldSeriesPerHistogram++
} }
@ -1999,11 +1999,11 @@ func TestDelayedCompaction(t *testing.T) {
// The first compaction is expected to result in 1 block. // The first compaction is expected to result in 1 block.
db.DisableCompactions() db.DisableCompactions()
app := db.Appender(context.Background()) app := db.Appender(context.Background())
_, err := app.Append(0, label, 0, 0, nil) _, err := app.Append(0, label, 0, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, label, 11, 0, nil) _, err = app.Append(0, label, 11, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, label, 21, 0, nil) _, err = app.Append(0, label, 21, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -2030,9 +2030,9 @@ func TestDelayedCompaction(t *testing.T) {
// This also ensures that no delay happens between consecutive compactions. // This also ensures that no delay happens between consecutive compactions.
db.DisableCompactions() db.DisableCompactions()
app = db.Appender(context.Background()) app = db.Appender(context.Background())
_, err = app.Append(0, label, 31, 0, nil) _, err = app.Append(0, label, 31, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, label, 41, 0, nil) _, err = app.Append(0, label, 41, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -2065,7 +2065,7 @@ func TestDelayedCompaction(t *testing.T) {
db.DisableCompactions() db.DisableCompactions()
app = db.Appender(context.Background()) app = db.Appender(context.Background())
_, err = app.Append(0, label, 51, 0, nil) _, err = app.Append(0, label, 51, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -2133,9 +2133,9 @@ func TestDelayedCompactionDoesNotBlockUnrelatedOps(t *testing.T) {
if c.whenCompactable { if c.whenCompactable {
label := labels.FromStrings("foo", "bar") label := labels.FromStrings("foo", "bar")
app := db.Appender(context.Background()) app := db.Appender(context.Background())
_, err := app.Append(0, label, 301, 0, nil) _, err := app.Append(0, label, 301, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, label, 317, 0, nil) _, err = app.Append(0, label, 317, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
// The Head is compactable and will still be at the end. // The Head is compactable and will still be at the end.

188
tsdb/db_test.go
View file

@ -216,7 +216,7 @@ func TestDataAvailableOnlyAfterCommit(t *testing.T) {
ctx := context.Background() ctx := context.Background()
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, labels.FromStrings("foo", "bar"), 0, 0, nil) _, err := app.Append(0, labels.FromStrings("foo", "bar"), 0, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
querier, err := db.Querier(0, 1) querier, err := db.Querier(0, 1)
@ -250,7 +250,7 @@ func TestNoPanicAfterWALCorruption(t *testing.T) {
// Appending 121 samples because on the 121st a new chunk will be created. // Appending 121 samples because on the 121st a new chunk will be created.
for i := 0; i < 121; i++ { for i := 0; i < 121; i++ {
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, labels.FromStrings("foo", "bar"), maxt, 0, nil) _, err := app.Append(0, labels.FromStrings("foo", "bar"), maxt, 0, storage.AppendHints{})
expSamples = append(expSamples, sample{t: maxt, f: 0}) expSamples = append(expSamples, sample{t: maxt, f: 0})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -300,7 +300,7 @@ func TestDataNotAvailableAfterRollback(t *testing.T) {
}() }()
app := db.Appender(context.Background()) app := db.Appender(context.Background())
_, err := app.Append(0, labels.FromStrings("foo", "bar"), 0, 0, nil) _, err := app.Append(0, labels.FromStrings("foo", "bar"), 0, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
err = app.Rollback() err = app.Rollback()
@ -324,11 +324,11 @@ func TestDBAppenderAddRef(t *testing.T) {
ctx := context.Background() ctx := context.Background()
app1 := db.Appender(ctx) app1 := db.Appender(ctx)
ref1, err := app1.Append(0, labels.FromStrings("a", "b"), 123, 0, nil) ref1, err := app1.Append(0, labels.FromStrings("a", "b"), 123, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
// Reference should already work before commit. // Reference should already work before commit.
ref2, err := app1.Append(ref1, labels.EmptyLabels(), 124, 1, nil) ref2, err := app1.Append(ref1, labels.EmptyLabels(), 124, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, ref1, ref2) require.Equal(t, ref1, ref2)
@ -338,21 +338,21 @@ func TestDBAppenderAddRef(t *testing.T) {
app2 := db.Appender(ctx) app2 := db.Appender(ctx)
// first ref should already work in next transaction. // first ref should already work in next transaction.
ref3, err := app2.Append(ref1, labels.EmptyLabels(), 125, 0, nil) ref3, err := app2.Append(ref1, labels.EmptyLabels(), 125, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, ref1, ref3) require.Equal(t, ref1, ref3)
ref4, err := app2.Append(ref1, labels.FromStrings("a", "b"), 133, 1, nil) ref4, err := app2.Append(ref1, labels.FromStrings("a", "b"), 133, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, ref1, ref4) require.Equal(t, ref1, ref4)
// Reference must be valid to add another sample. // Reference must be valid to add another sample.
ref5, err := app2.Append(ref2, labels.EmptyLabels(), 143, 2, nil) ref5, err := app2.Append(ref2, labels.EmptyLabels(), 143, 2, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, ref1, ref5) require.Equal(t, ref1, ref5)
// Missing labels & invalid refs should fail. // Missing labels & invalid refs should fail.
_, err = app2.Append(9999999, labels.EmptyLabels(), 1, 1, nil) _, err = app2.Append(9999999, labels.EmptyLabels(), 1, 1, storage.AppendHints{})
require.ErrorIs(t, err, ErrInvalidSample) require.ErrorIs(t, err, ErrInvalidSample)
require.NoError(t, app2.Commit()) require.NoError(t, app2.Commit())
@ -382,11 +382,11 @@ func TestAppendEmptyLabelsIgnored(t *testing.T) {
ctx := context.Background() ctx := context.Background()
app1 := db.Appender(ctx) app1 := db.Appender(ctx)
ref1, err := app1.Append(0, labels.FromStrings("a", "b"), 123, 0, nil) ref1, err := app1.Append(0, labels.FromStrings("a", "b"), 123, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
// Add with empty label. // Add with empty label.
ref2, err := app1.Append(0, labels.FromStrings("a", "b", "c", ""), 124, 0, nil) ref2, err := app1.Append(0, labels.FromStrings("a", "b", "c", ""), 124, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
// Should be the same series. // Should be the same series.
@ -438,7 +438,7 @@ Outer:
smpls := make([]float64, numSamples) smpls := make([]float64, numSamples)
for i := int64(0); i < numSamples; i++ { for i := int64(0); i < numSamples; i++ {
smpls[i] = rand.Float64() smpls[i] = rand.Float64()
app.Append(0, labels.FromStrings("a", "b"), i, smpls[i], nil) app.Append(0, labels.FromStrings("a", "b"), i, smpls[i], storage.AppendHints{})
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -494,14 +494,14 @@ func TestAmendHistogramDatapointCausesError(t *testing.T) {
ctx := context.Background() ctx := context.Background()
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, labels.FromStrings("a", "b"), 0, 0, nil) _, err := app.Append(0, labels.FromStrings("a", "b"), 0, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
app = db.Appender(ctx) app = db.Appender(ctx)
_, err = app.Append(0, labels.FromStrings("a", "b"), 0, 0, nil) _, err = app.Append(0, labels.FromStrings("a", "b"), 0, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, labels.FromStrings("a", "b"), 0, 1, nil) _, err = app.Append(0, labels.FromStrings("a", "b"), 0, 1, storage.AppendHints{})
require.ErrorIs(t, err, storage.ErrDuplicateSampleForTimestamp) require.ErrorIs(t, err, storage.ErrDuplicateSampleForTimestamp)
require.NoError(t, app.Rollback()) require.NoError(t, app.Rollback())
@ -555,12 +555,12 @@ func TestDuplicateNaNDatapointNoAmendError(t *testing.T) {
ctx := context.Background() ctx := context.Background()
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, labels.FromStrings("a", "b"), 0, math.NaN(), nil) _, err := app.Append(0, labels.FromStrings("a", "b"), 0, math.NaN(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
app = db.Appender(ctx) app = db.Appender(ctx)
_, err = app.Append(0, labels.FromStrings("a", "b"), 0, math.NaN(), nil) _, err = app.Append(0, labels.FromStrings("a", "b"), 0, math.NaN(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
@ -572,12 +572,12 @@ func TestNonDuplicateNaNDatapointsCausesAmendError(t *testing.T) {
ctx := context.Background() ctx := context.Background()
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, labels.FromStrings("a", "b"), 0, math.Float64frombits(0x7ff0000000000001), nil) _, err := app.Append(0, labels.FromStrings("a", "b"), 0, math.Float64frombits(0x7ff0000000000001), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
app = db.Appender(ctx) app = db.Appender(ctx)
_, err = app.Append(0, labels.FromStrings("a", "b"), 0, math.Float64frombits(0x7ff0000000000002), nil) _, err = app.Append(0, labels.FromStrings("a", "b"), 0, math.Float64frombits(0x7ff0000000000002), storage.AppendHints{})
require.ErrorIs(t, err, storage.ErrDuplicateSampleForTimestamp) require.ErrorIs(t, err, storage.ErrDuplicateSampleForTimestamp)
} }
@ -589,7 +589,7 @@ func TestEmptyLabelsetCausesError(t *testing.T) {
ctx := context.Background() ctx := context.Background()
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, labels.Labels{}, 0, 0, nil) _, err := app.Append(0, labels.Labels{}, 0, 0, storage.AppendHints{})
require.Error(t, err) require.Error(t, err)
require.Equal(t, "empty labelset: invalid sample", err.Error()) require.Equal(t, "empty labelset: invalid sample", err.Error())
} }
@ -603,9 +603,9 @@ func TestSkippingInvalidValuesInSameTxn(t *testing.T) {
// Append AmendedValue. // Append AmendedValue.
ctx := context.Background() ctx := context.Background()
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, labels.FromStrings("a", "b"), 0, 1, nil) _, err := app.Append(0, labels.FromStrings("a", "b"), 0, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, labels.FromStrings("a", "b"), 0, 2, nil) _, err = app.Append(0, labels.FromStrings("a", "b"), 0, 2, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -621,9 +621,9 @@ func TestSkippingInvalidValuesInSameTxn(t *testing.T) {
// Append Out of Order Value. // Append Out of Order Value.
app = db.Appender(ctx) app = db.Appender(ctx)
_, err = app.Append(0, labels.FromStrings("a", "b"), 10, 3, nil) _, err = app.Append(0, labels.FromStrings("a", "b"), 10, 3, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, labels.FromStrings("a", "b"), 7, 5, nil) _, err = app.Append(0, labels.FromStrings("a", "b"), 7, 5, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -645,7 +645,7 @@ func TestDB_Snapshot(t *testing.T) {
app := db.Appender(ctx) app := db.Appender(ctx)
mint := int64(1414141414000) mint := int64(1414141414000)
for i := 0; i < 1000; i++ { for i := 0; i < 1000; i++ {
_, err := app.Append(0, labels.FromStrings("foo", "bar"), mint+int64(i), 1.0, nil) _, err := app.Append(0, labels.FromStrings("foo", "bar"), mint+int64(i), 1.0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -691,7 +691,7 @@ func TestDB_Snapshot_ChunksOutsideOfCompactedRange(t *testing.T) {
app := db.Appender(ctx) app := db.Appender(ctx)
mint := int64(1414141414000) mint := int64(1414141414000)
for i := 0; i < 1000; i++ { for i := 0; i < 1000; i++ {
_, err := app.Append(0, labels.FromStrings("foo", "bar"), mint+int64(i), 1.0, nil) _, err := app.Append(0, labels.FromStrings("foo", "bar"), mint+int64(i), 1.0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -744,7 +744,7 @@ func TestDB_SnapshotWithDelete(t *testing.T) {
smpls := make([]float64, numSamples) smpls := make([]float64, numSamples)
for i := int64(0); i < numSamples; i++ { for i := int64(0); i < numSamples; i++ {
smpls[i] = rand.Float64() smpls[i] = rand.Float64()
app.Append(0, labels.FromStrings("a", "b"), i, smpls[i], nil) app.Append(0, labels.FromStrings("a", "b"), i, smpls[i], storage.AppendHints{})
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -892,7 +892,7 @@ func TestDB_e2e(t *testing.T) {
series = append(series, sample{ts, v, nil, nil}) series = append(series, sample{ts, v, nil, nil})
_, err := app.Append(0, lset, ts, v, nil) _, err := app.Append(0, lset, ts, v, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
ts += rand.Int63n(timeInterval) + 1 ts += rand.Int63n(timeInterval) + 1
@ -987,7 +987,7 @@ func TestWALFlushedOnDBClose(t *testing.T) {
ctx := context.Background() ctx := context.Background()
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, lbls, 0, 1, nil) _, err := app.Append(0, lbls, 0, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -1065,10 +1065,10 @@ func TestWALSegmentSizeOptions(t *testing.T) {
for i := int64(0); i < 155; i++ { for i := int64(0); i < 155; i++ {
app := db.Appender(context.Background()) app := db.Appender(context.Background())
ref, err := app.Append(0, labels.FromStrings("wal"+strconv.Itoa(int(i)), "size"), i, rand.Float64(), nil) ref, err := app.Append(0, labels.FromStrings("wal"+strconv.Itoa(int(i)), "size"), i, rand.Float64(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
for j := int64(1); j <= 78; j++ { for j := int64(1); j <= 78; j++ {
_, err := app.Append(ref, labels.EmptyLabels(), i+j, rand.Float64(), nil) _, err := app.Append(ref, labels.EmptyLabels(), i+j, rand.Float64(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -1127,7 +1127,7 @@ func testWALReplayRaceOnSamplesLoggedBeforeSeries(t *testing.T, numSamplesBefore
lbls := labels.FromStrings("series_id", strconv.Itoa(seriesRef)) lbls := labels.FromStrings("series_id", strconv.Itoa(seriesRef))
for ts := numSamplesBeforeSeriesCreation; ts < numSamplesBeforeSeriesCreation+numSamplesAfterSeriesCreation; ts++ { for ts := numSamplesBeforeSeriesCreation; ts < numSamplesBeforeSeriesCreation+numSamplesAfterSeriesCreation; ts++ {
_, err := app.Append(0, lbls, int64(ts), float64(ts), nil) _, err := app.Append(0, lbls, int64(ts), float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -1179,7 +1179,7 @@ func TestTombstoneClean(t *testing.T) {
smpls := make([]float64, numSamples) smpls := make([]float64, numSamples)
for i := int64(0); i < numSamples; i++ { for i := int64(0); i < numSamples; i++ {
smpls[i] = rand.Float64() smpls[i] = rand.Float64()
app.Append(0, labels.FromStrings("a", "b"), i, smpls[i], nil) app.Append(0, labels.FromStrings("a", "b"), i, smpls[i], storage.AppendHints{})
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -1273,7 +1273,7 @@ func TestTombstoneCleanResultEmptyBlock(t *testing.T) {
smpls := make([]float64, numSamples) smpls := make([]float64, numSamples)
for i := int64(0); i < numSamples; i++ { for i := int64(0); i < numSamples; i++ {
smpls[i] = rand.Float64() smpls[i] = rand.Float64()
app.Append(0, labels.FromStrings("a", "b"), i, smpls[i], nil) app.Append(0, labels.FromStrings("a", "b"), i, smpls[i], storage.AppendHints{})
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -1573,7 +1573,7 @@ func TestSizeRetention(t *testing.T) {
it = s.Iterator(it) it = s.Iterator(it)
for it.Next() == chunkenc.ValFloat { for it.Next() == chunkenc.ValFloat {
tim, v := it.At() tim, v := it.At()
_, err := headApp.Append(0, s.Labels(), tim, v, nil) _, err := headApp.Append(0, s.Labels(), tim, v, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, it.Err()) require.NoError(t, it.Err())
@ -1631,7 +1631,7 @@ func TestSizeRetention(t *testing.T) {
// Add some out of order samples to check the size of WBL. // Add some out of order samples to check the size of WBL.
headApp = db.Head().Appender(context.Background()) headApp = db.Head().Appender(context.Background())
for ts := int64(750); ts < 800; ts++ { for ts := int64(750); ts < 800; ts++ {
_, err := headApp.Append(0, aSeries, ts, float64(ts), nil) _, err := headApp.Append(0, aSeries, ts, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, headApp.Commit()) require.NoError(t, headApp.Commit())
@ -1714,7 +1714,7 @@ func TestNotMatcherSelectsLabelsUnsetSeries(t *testing.T) {
ctx := context.Background() ctx := context.Background()
app := db.Appender(ctx) app := db.Appender(ctx)
for _, lbls := range labelpairs { for _, lbls := range labelpairs {
_, err := app.Append(0, lbls, 0, 1, nil) _, err := app.Append(0, lbls, 0, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -1900,9 +1900,9 @@ func TestChunkAtBlockBoundary(t *testing.T) {
label := labels.FromStrings("foo", "bar") label := labels.FromStrings("foo", "bar")
for i := int64(0); i < 3; i++ { for i := int64(0); i < 3; i++ {
_, err := app.Append(0, label, i*blockRange, 0, nil) _, err := app.Append(0, label, i*blockRange, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, label, i*blockRange+1000, 0, nil) _, err = app.Append(0, label, i*blockRange+1000, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
@ -1956,9 +1956,9 @@ func TestQuerierWithBoundaryChunks(t *testing.T) {
label := labels.FromStrings("foo", "bar") label := labels.FromStrings("foo", "bar")
for i := int64(0); i < 5; i++ { for i := int64(0); i < 5; i++ {
_, err := app.Append(0, label, i*blockRange, 0, nil) _, err := app.Append(0, label, i*blockRange, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, labels.FromStrings("blockID", strconv.FormatInt(i, 10)), i*blockRange, 0, nil) _, err = app.Append(0, labels.FromStrings("blockID", strconv.FormatInt(i, 10)), i*blockRange, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
@ -2003,7 +2003,7 @@ func TestInitializeHeadTimestamp(t *testing.T) {
// First added sample initializes the writable range. // First added sample initializes the writable range.
ctx := context.Background() ctx := context.Background()
app := db.Appender(ctx) app := db.Appender(ctx)
_, err = app.Append(0, labels.FromStrings("a", "b"), 1000, 1, nil) _, err = app.Append(0, labels.FromStrings("a", "b"), 1000, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, int64(1000), db.head.MinTime()) require.Equal(t, int64(1000), db.head.MinTime())
@ -2112,11 +2112,11 @@ func TestNoEmptyBlocks(t *testing.T) {
t.Run("Test no blocks after deleting all samples from head.", func(t *testing.T) { t.Run("Test no blocks after deleting all samples from head.", func(t *testing.T) {
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, defaultLabel, 1, 0, nil) _, err := app.Append(0, defaultLabel, 1, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, defaultLabel, 2, 0, nil) _, err = app.Append(0, defaultLabel, 2, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, defaultLabel, 3+rangeToTriggerCompaction, 0, nil) _, err = app.Append(0, defaultLabel, 3+rangeToTriggerCompaction, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
require.NoError(t, db.Delete(ctx, math.MinInt64, math.MaxInt64, defaultMatcher)) require.NoError(t, db.Delete(ctx, math.MinInt64, math.MaxInt64, defaultMatcher))
@ -2129,16 +2129,16 @@ func TestNoEmptyBlocks(t *testing.T) {
require.Empty(t, actBlocks) require.Empty(t, actBlocks)
app = db.Appender(ctx) app = db.Appender(ctx)
_, err = app.Append(0, defaultLabel, 1, 0, nil) _, err = app.Append(0, defaultLabel, 1, 0, storage.AppendHints{})
require.Equal(t, storage.ErrOutOfBounds, err, "the head should be truncated so no samples in the past should be allowed") require.Equal(t, storage.ErrOutOfBounds, err, "the head should be truncated so no samples in the past should be allowed")
// Adding new blocks. // Adding new blocks.
currentTime := db.Head().MaxTime() currentTime := db.Head().MaxTime()
_, err = app.Append(0, defaultLabel, currentTime, 0, nil) _, err = app.Append(0, defaultLabel, currentTime, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, defaultLabel, currentTime+1, 0, nil) _, err = app.Append(0, defaultLabel, currentTime+1, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, defaultLabel, currentTime+rangeToTriggerCompaction, 0, nil) _, err = app.Append(0, defaultLabel, currentTime+rangeToTriggerCompaction, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -2155,11 +2155,11 @@ func TestNoEmptyBlocks(t *testing.T) {
oldBlocks := db.Blocks() oldBlocks := db.Blocks()
app := db.Appender(ctx) app := db.Appender(ctx)
currentTime := db.Head().MaxTime() currentTime := db.Head().MaxTime()
_, err := app.Append(0, defaultLabel, currentTime, 0, nil) _, err := app.Append(0, defaultLabel, currentTime, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, defaultLabel, currentTime+1, 0, nil) _, err = app.Append(0, defaultLabel, currentTime+1, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, defaultLabel, currentTime+rangeToTriggerCompaction, 0, nil) _, err = app.Append(0, defaultLabel, currentTime+rangeToTriggerCompaction, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
require.NoError(t, db.head.Delete(ctx, math.MinInt64, math.MaxInt64, defaultMatcher)) require.NoError(t, db.head.Delete(ctx, math.MinInt64, math.MaxInt64, defaultMatcher))
@ -2241,7 +2241,7 @@ func TestDB_LabelNames(t *testing.T) {
for i := mint; i <= maxt; i++ { for i := mint; i <= maxt; i++ {
for _, tuple := range sampleLabels { for _, tuple := range sampleLabels {
label := labels.FromStrings(tuple[0], tuple[1]) label := labels.FromStrings(tuple[0], tuple[1])
_, err := app.Append(0, label, i*blockRange, 0, nil) _, err := app.Append(0, label, i*blockRange, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
} }
@ -2310,7 +2310,7 @@ func TestCorrectNumTombstones(t *testing.T) {
app := db.Appender(ctx) app := db.Appender(ctx)
for i := int64(0); i < 3; i++ { for i := int64(0); i < 3; i++ {
for j := int64(0); j < 15; j++ { for j := int64(0); j < 15; j++ {
_, err := app.Append(0, defaultLabel, i*blockRange+j, 0, nil) _, err := app.Append(0, defaultLabel, i*blockRange+j, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
} }
@ -2362,14 +2362,14 @@ func TestBlockRanges(t *testing.T) {
app := db.Appender(ctx) app := db.Appender(ctx)
lbl := labels.FromStrings("a", "b") lbl := labels.FromStrings("a", "b")
_, err = app.Append(0, lbl, firstBlockMaxT-1, rand.Float64(), nil) _, err = app.Append(0, lbl, firstBlockMaxT-1, rand.Float64(), storage.AppendHints{})
require.Error(t, err, "appending a sample with a timestamp covered by a previous block shouldn't be possible") require.Error(t, err, "appending a sample with a timestamp covered by a previous block shouldn't be possible")
_, err = app.Append(0, lbl, firstBlockMaxT+1, rand.Float64(), nil) _, err = app.Append(0, lbl, firstBlockMaxT+1, rand.Float64(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, lbl, firstBlockMaxT+2, rand.Float64(), nil) _, err = app.Append(0, lbl, firstBlockMaxT+2, rand.Float64(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
secondBlockMaxt := firstBlockMaxT + rangeToTriggerCompaction secondBlockMaxt := firstBlockMaxT + rangeToTriggerCompaction
_, err = app.Append(0, lbl, secondBlockMaxt, rand.Float64(), nil) // Add samples to trigger a new compaction _, err = app.Append(0, lbl, secondBlockMaxt, rand.Float64(), storage.AppendHints{}) // Add samples to trigger a new compaction
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -2388,13 +2388,13 @@ func TestBlockRanges(t *testing.T) {
// and compaction doesn't create an overlapping block. // and compaction doesn't create an overlapping block.
app = db.Appender(ctx) app = db.Appender(ctx)
db.DisableCompactions() db.DisableCompactions()
_, err = app.Append(0, lbl, secondBlockMaxt+1, rand.Float64(), nil) _, err = app.Append(0, lbl, secondBlockMaxt+1, rand.Float64(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, lbl, secondBlockMaxt+2, rand.Float64(), nil) _, err = app.Append(0, lbl, secondBlockMaxt+2, rand.Float64(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, lbl, secondBlockMaxt+3, rand.Float64(), nil) _, err = app.Append(0, lbl, secondBlockMaxt+3, rand.Float64(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, lbl, secondBlockMaxt+4, rand.Float64(), nil) _, err = app.Append(0, lbl, secondBlockMaxt+4, rand.Float64(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
require.NoError(t, db.Close()) require.NoError(t, db.Close())
@ -2410,7 +2410,7 @@ func TestBlockRanges(t *testing.T) {
require.Equal(t, db.Blocks()[2].Meta().MaxTime, thirdBlockMaxt, "unexpected maxt of the last block") require.Equal(t, db.Blocks()[2].Meta().MaxTime, thirdBlockMaxt, "unexpected maxt of the last block")
app = db.Appender(ctx) app = db.Appender(ctx)
_, err = app.Append(0, lbl, thirdBlockMaxt+rangeToTriggerCompaction, rand.Float64(), nil) // Trigger a compaction _, err = app.Append(0, lbl, thirdBlockMaxt+rangeToTriggerCompaction, rand.Float64(), storage.AppendHints{}) // Trigger a compaction
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
for x := 0; x < 100; x++ { for x := 0; x < 100; x++ {
@ -2472,7 +2472,7 @@ func TestDBReadOnly(t *testing.T) {
dbSizeBeforeAppend, err := fileutil.DirSize(dbWritable.Dir()) dbSizeBeforeAppend, err := fileutil.DirSize(dbWritable.Dir())
require.NoError(t, err) require.NoError(t, err)
app := dbWritable.Appender(context.Background()) app := dbWritable.Appender(context.Background())
_, err = app.Append(0, labels.FromStrings("foo", "bar"), dbWritable.Head().MaxTime()+1, 0, nil) _, err = app.Append(0, labels.FromStrings("foo", "bar"), dbWritable.Head().MaxTime()+1, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -2583,7 +2583,7 @@ func TestDBReadOnly_FlushWAL(t *testing.T) {
app := db.Appender(ctx) app := db.Appender(ctx)
maxt = 1000 maxt = 1000
for i := 0; i < maxt; i++ { for i := 0; i < maxt; i++ {
_, err := app.Append(0, labels.FromStrings(defaultLabelName, "flush"), int64(i), 1.0, nil) _, err := app.Append(0, labels.FromStrings(defaultLabelName, "flush"), int64(i), 1.0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -2668,7 +2668,7 @@ func TestDBReadOnly_Querier_NoAlteration(t *testing.T) {
// Append until the first mmapped head chunk. // Append until the first mmapped head chunk.
for i := 0; i < 121; i++ { for i := 0; i < 121; i++ {
app := db.Appender(context.Background()) app := db.Appender(context.Background())
_, err := app.Append(0, labels.FromStrings("foo", "bar"), int64(i), 0, nil) _, err := app.Append(0, labels.FromStrings("foo", "bar"), int64(i), 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
} }
@ -2725,7 +2725,7 @@ func TestDBCannotSeePartialCommits(t *testing.T) {
app := db.Appender(ctx) app := db.Appender(ctx)
for j := 0; j < 100; j++ { for j := 0; j < 100; j++ {
_, err := app.Append(0, labels.FromStrings("foo", "bar", "a", strconv.Itoa(j)), int64(iter), float64(iter), nil) _, err := app.Append(0, labels.FromStrings("foo", "bar", "a", strconv.Itoa(j)), int64(iter), float64(iter), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
err = app.Commit() err = app.Commit()
@ -2791,7 +2791,7 @@ func TestDBQueryDoesntSeeAppendsAfterCreation(t *testing.T) {
ctx := context.Background() ctx := context.Background()
app := db.Appender(ctx) app := db.Appender(ctx)
_, err = app.Append(0, labels.FromStrings("foo", "bar"), 0, 0, nil) _, err = app.Append(0, labels.FromStrings("foo", "bar"), 0, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
querierAfterAddButBeforeCommit, err := db.Querier(0, 1000000) querierAfterAddButBeforeCommit, err := db.Querier(0, 1000000)
@ -3119,7 +3119,7 @@ func TestCompactHead(t *testing.T) {
maxt := 100 maxt := 100
for i := 0; i < maxt; i++ { for i := 0; i < maxt; i++ {
val := rand.Float64() val := rand.Float64()
_, err := app.Append(0, labels.FromStrings("a", "b"), int64(i), val, nil) _, err := app.Append(0, labels.FromStrings("a", "b"), int64(i), val, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
expSamples = append(expSamples, sample{int64(i), val, nil, nil}) expSamples = append(expSamples, sample{int64(i), val, nil, nil})
} }
@ -3165,7 +3165,7 @@ func TestCompactHeadWithDeletion(t *testing.T) {
ctx := context.Background() ctx := context.Background()
app := db.Appender(ctx) app := db.Appender(ctx)
_, err = app.Append(0, labels.FromStrings("a", "b"), 10, rand.Float64(), nil) _, err = app.Append(0, labels.FromStrings("a", "b"), 10, rand.Float64(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -3341,9 +3341,9 @@ func TestOneCheckpointPerCompactCall(t *testing.T) {
// Append samples spanning 59 block ranges. // Append samples spanning 59 block ranges.
app := db.Appender(context.Background()) app := db.Appender(context.Background())
for i := int64(0); i < 60; i++ { for i := int64(0); i < 60; i++ {
_, err := app.Append(0, lbls, blockRange*i, rand.Float64(), nil) _, err := app.Append(0, lbls, blockRange*i, rand.Float64(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, lbls, (blockRange*i)+blockRange/2, rand.Float64(), nil) _, err = app.Append(0, lbls, (blockRange*i)+blockRange/2, rand.Float64(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
// Rotate the WAL file so that there is >3 files for checkpoint to happen. // Rotate the WAL file so that there is >3 files for checkpoint to happen.
_, err = db.head.wal.NextSegment() _, err = db.head.wal.NextSegment()
@ -3401,7 +3401,7 @@ func TestOneCheckpointPerCompactCall(t *testing.T) {
// Adding sample way into the future. // Adding sample way into the future.
app = db.Appender(context.Background()) app = db.Appender(context.Background())
_, err = app.Append(0, lbls, blockRange*120, rand.Float64(), nil) _, err = app.Append(0, lbls, blockRange*120, rand.Float64(), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -3507,7 +3507,7 @@ func testQuerierShouldNotPanicIfHeadChunkIsTruncatedWhileReadingQueriedChunks(t
app := db.Appender(ctx) app := db.Appender(ctx)
for _, metric := range metrics { for _, metric := range metrics {
_, err := app.Append(0, metric, ts, float64(ts), nil) _, err := app.Append(0, metric, ts, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
@ -3523,7 +3523,7 @@ func testQuerierShouldNotPanicIfHeadChunkIsTruncatedWhileReadingQueriedChunks(t
app := db.Appender(ctx) app := db.Appender(ctx)
for _, metric := range metrics { for _, metric := range metrics {
_, err := app.Append(0, metric, ts, float64(ts), nil) _, err := app.Append(0, metric, ts, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
@ -3643,7 +3643,7 @@ func testChunkQuerierShouldNotPanicIfHeadChunkIsTruncatedWhileReadingQueriedChun
app := db.Appender(ctx) app := db.Appender(ctx)
for _, metric := range metrics { for _, metric := range metrics {
_, err := app.Append(0, metric, ts, float64(ts), nil) _, err := app.Append(0, metric, ts, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
@ -3659,7 +3659,7 @@ func testChunkQuerierShouldNotPanicIfHeadChunkIsTruncatedWhileReadingQueriedChun
app := db.Appender(ctx) app := db.Appender(ctx)
for _, metric := range metrics { for _, metric := range metrics {
_, err := app.Append(0, metric, ts, float64(ts), nil) _, err := app.Append(0, metric, ts, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
@ -3746,7 +3746,7 @@ func TestQuerierShouldNotFailIfOOOCompactionOccursAfterRetrievingQuerier(t *test
// Push samples after the OOO sample we'll write below. // Push samples after the OOO sample we'll write below.
for ; ts < 10*interval; ts += interval { for ; ts < 10*interval; ts += interval {
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, metric, ts, float64(ts), nil) _, err := app.Append(0, metric, ts, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
samplesWritten++ samplesWritten++
@ -3754,7 +3754,7 @@ func TestQuerierShouldNotFailIfOOOCompactionOccursAfterRetrievingQuerier(t *test
// Push a single OOO sample. // Push a single OOO sample.
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, metric, oooTS, float64(ts), nil) _, err := app.Append(0, metric, oooTS, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
samplesWritten++ samplesWritten++
@ -3840,7 +3840,7 @@ func TestQuerierShouldNotFailIfOOOCompactionOccursAfterSelecting(t *testing.T) {
// Push samples after the OOO sample we'll write below. // Push samples after the OOO sample we'll write below.
for ; ts < 10*interval; ts += interval { for ; ts < 10*interval; ts += interval {
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, metric, ts, float64(ts), nil) _, err := app.Append(0, metric, ts, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
samplesWritten++ samplesWritten++
@ -3848,7 +3848,7 @@ func TestQuerierShouldNotFailIfOOOCompactionOccursAfterSelecting(t *testing.T) {
// Push a single OOO sample. // Push a single OOO sample.
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, metric, oooTS, float64(ts), nil) _, err := app.Append(0, metric, oooTS, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
samplesWritten++ samplesWritten++
@ -3922,7 +3922,7 @@ func TestQuerierShouldNotFailIfOOOCompactionOccursAfterRetrievingIterators(t *te
// Push samples after the OOO sample we'll write below. // Push samples after the OOO sample we'll write below.
for ; ts < 10*interval; ts += interval { for ; ts < 10*interval; ts += interval {
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, metric, ts, float64(ts), nil) _, err := app.Append(0, metric, ts, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
samplesWritten++ samplesWritten++
@ -3930,7 +3930,7 @@ func TestQuerierShouldNotFailIfOOOCompactionOccursAfterRetrievingIterators(t *te
// Push a single OOO sample. // Push a single OOO sample.
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, metric, oooTS, float64(ts), nil) _, err := app.Append(0, metric, oooTS, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
samplesWritten++ samplesWritten++
@ -4009,7 +4009,7 @@ func TestOOOWALWrite(t *testing.T) {
}{ }{
"float": { "float": {
appendSample: func(app storage.Appender, l labels.Labels, mins int64) (storage.SeriesRef, error) { appendSample: func(app storage.Appender, l labels.Labels, mins int64) (storage.SeriesRef, error) {
seriesRef, err := app.Append(0, l, minutes(mins), float64(mins), nil) seriesRef, err := app.Append(0, l, minutes(mins), float64(mins), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
return seriesRef, nil return seriesRef, nil
}, },
@ -4416,7 +4416,7 @@ func TestDBPanicOnMmappingHeadChunk(t *testing.T) {
var ref storage.SeriesRef var ref storage.SeriesRef
lbls := labels.FromStrings("__name__", "testing", "foo", "bar") lbls := labels.FromStrings("__name__", "testing", "foo", "bar")
for i := 0; i < numSamples; i++ { for i := 0; i < numSamples; i++ {
ref, err = app.Append(ref, lbls, lastTs, float64(lastTs), nil) ref, err = app.Append(ref, lbls, lastTs, float64(lastTs), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
lastTs += itvl lastTs += itvl
if i%10 == 0 { if i%10 == 0 {
@ -4474,7 +4474,7 @@ func TestMetadataInWAL(t *testing.T) {
s4 := labels.FromStrings("g", "h") s4 := labels.FromStrings("g", "h")
for _, s := range []labels.Labels{s1, s2, s3, s4} { for _, s := range []labels.Labels{s1, s2, s3, s4} {
_, err := app.Append(0, s, 0, 0, nil) _, err := app.Append(0, s, 0, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -4540,7 +4540,7 @@ func TestMetadataCheckpointingOnlyKeepsLatestEntry(t *testing.T) {
s4 := labels.FromStrings("g", "h") s4 := labels.FromStrings("g", "h")
for _, s := range []labels.Labels{s1, s2, s3, s4} { for _, s := range []labels.Labels{s1, s2, s3, s4} {
_, err := app.Append(0, s, 0, 0, nil) _, err := app.Append(0, s, 0, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -4643,7 +4643,7 @@ func TestMetadataAssertInMemoryData(t *testing.T) {
s4 := labels.FromStrings("g", "h") s4 := labels.FromStrings("g", "h")
for _, s := range []labels.Labels{s1, s2, s3, s4} { for _, s := range []labels.Labels{s1, s2, s3, s4} {
_, err := app.Append(0, s, 0, 0, nil) _, err := app.Append(0, s, 0, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -4730,7 +4730,7 @@ func TestMultipleEncodingsCommitOrder(t *testing.T) {
addSample := func(app storage.Appender, ts int64, valType chunkenc.ValueType) chunks.Sample { addSample := func(app storage.Appender, ts int64, valType chunkenc.ValueType) chunks.Sample {
if valType == chunkenc.ValFloat { if valType == chunkenc.ValFloat {
_, err := app.Append(0, labels.FromStrings("foo", "bar1"), ts, float64(ts), nil) _, err := app.Append(0, labels.FromStrings("foo", "bar1"), ts, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
return sample{t: ts, f: float64(ts)} return sample{t: ts, f: float64(ts)}
} }
@ -5418,7 +5418,7 @@ func TestQuerierOOOQuery(t *testing.T) {
}{ }{
"float": { "float": {
appendFunc: func(app storage.Appender, ts int64, counterReset bool) (storage.SeriesRef, error) { appendFunc: func(app storage.Appender, ts int64, counterReset bool) (storage.SeriesRef, error) {
return app.Append(0, labels.FromStrings("foo", "bar1"), ts, float64(ts), nil) return app.Append(0, labels.FromStrings("foo", "bar1"), ts, float64(ts), storage.AppendHints{})
}, },
sampleFunc: func(ts int64) chunks.Sample { sampleFunc: func(ts int64) chunks.Sample {
return sample{t: ts, f: float64(ts)} return sample{t: ts, f: float64(ts)}
@ -5734,7 +5734,7 @@ func TestChunkQuerierOOOQuery(t *testing.T) {
}{ }{
"float": { "float": {
appendFunc: func(app storage.Appender, ts int64, counterReset bool) (storage.SeriesRef, error) { appendFunc: func(app storage.Appender, ts int64, counterReset bool) (storage.SeriesRef, error) {
return app.Append(0, labels.FromStrings("foo", "bar1"), ts, float64(ts), nil) return app.Append(0, labels.FromStrings("foo", "bar1"), ts, float64(ts), storage.AppendHints{})
}, },
sampleFunc: func(ts int64) chunks.Sample { sampleFunc: func(ts int64) chunks.Sample {
return sample{t: ts, f: float64(ts)} return sample{t: ts, f: float64(ts)}
@ -7186,7 +7186,7 @@ func TestWBLCorruption(t *testing.T) {
app := db.Appender(context.Background()) app := db.Appender(context.Background())
for m := fromMins; m <= toMins; m++ { for m := fromMins; m <= toMins; m++ {
ts := m * time.Minute.Milliseconds() ts := m * time.Minute.Milliseconds()
_, err := app.Append(0, series1, ts, float64(ts), nil) _, err := app.Append(0, series1, ts, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
allSamples = append(allSamples, sample{t: ts, f: float64(ts)}) allSamples = append(allSamples, sample{t: ts, f: float64(ts)})
if afterRestart { if afterRestart {
@ -8068,7 +8068,7 @@ func testHistogramAppendAndQueryHelper(t *testing.T, floatHistogram bool) {
appendFloat := func(lbls labels.Labels, tsMinute int, val float64, exp *[]chunks.Sample) { appendFloat := func(lbls labels.Labels, tsMinute int, val float64, exp *[]chunks.Sample) {
t.Helper() t.Helper()
app := db.Appender(ctx) app := db.Appender(ctx)
_, err := app.Append(0, lbls, minute(tsMinute), val, nil) _, err := app.Append(0, lbls, minute(tsMinute), val, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
*exp = append(*exp, sample{t: minute(tsMinute), f: val}) *exp = append(*exp, sample{t: minute(tsMinute), f: val})
@ -8672,7 +8672,7 @@ func TestChunkQuerierReadWriteRace(t *testing.T) {
app := db.Appender(context.Background()) app := db.Appender(context.Background())
for j := 0; j < 10; j++ { for j := 0; j < 10; j++ {
ts++ ts++
_, err := app.Append(0, lbls, int64(ts), float64(ts*100), nil) _, err := app.Append(0, lbls, int64(ts), float64(ts*100), storage.AppendHints{})
if err != nil { if err != nil {
return err return err
} }

5
tsdb/example_test.go
View file

@ -21,6 +21,7 @@ import (
"time" "time"
"github.com/prometheus/prometheus/model/labels" "github.com/prometheus/prometheus/model/labels"
"github.com/prometheus/prometheus/storage"
"github.com/prometheus/prometheus/tsdb/chunkenc" "github.com/prometheus/prometheus/tsdb/chunkenc"
) )
@ -40,13 +41,13 @@ func Example() {
series := labels.FromStrings("foo", "bar") series := labels.FromStrings("foo", "bar")
// Ref is 0 for the first append since we don't know the reference for the series. // Ref is 0 for the first append since we don't know the reference for the series.
ref, err := app.Append(0, series, time.Now().Unix(), 123, nil) ref, err := app.Append(0, series, time.Now().Unix(), 123, storage.AppendHints{})
noErr(err) noErr(err)
// Another append for a second later. // Another append for a second later.
// Re-using the ref from above since it's the same series, makes append faster. // Re-using the ref from above since it's the same series, makes append faster.
time.Sleep(time.Second) time.Sleep(time.Second)
_, err = app.Append(ref, series, time.Now().Unix(), 124, nil) _, err = app.Append(ref, series, time.Now().Unix(), 124, storage.AppendHints{})
noErr(err) noErr(err)
// Commit to storage. // Commit to storage.

14
tsdb/head_append.go
View file

@ -40,14 +40,14 @@ type initAppender struct {
var _ storage.GetRef = &initAppender{} var _ storage.GetRef = &initAppender{}
func (a *initAppender) Append(ref storage.SeriesRef, lset labels.Labels, t int64, v float64, hints *storage.AppendHints) (storage.SeriesRef, error) { func (a *initAppender) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64, hints storage.AppendHints) (storage.SeriesRef, error) {
if a.app != nil { if a.app != nil {
return a.app.Append(ref, lset, t, v, nil) return a.app.Append(ref, l, t, v, storage.AppendHints{})
} }
a.head.initTime(t) a.head.initTime(t)
a.app = a.head.appender() a.app = a.head.appender()
return a.app.Append(ref, lset, t, v, nil) return a.app.Append(ref, l, t, v, storage.AppendHints{})
} }
func (a *initAppender) AppendExemplar(ref storage.SeriesRef, l labels.Labels, e exemplar.Exemplar, hints *storage.AppendHints) (storage.SeriesRef, error) { func (a *initAppender) AppendExemplar(ref storage.SeriesRef, l labels.Labels, e exemplar.Exemplar, hints *storage.AppendHints) (storage.SeriesRef, error) {
@ -328,7 +328,7 @@ type headAppender struct {
closed bool closed bool
} }
func (a *headAppender) Append(ref storage.SeriesRef, lset labels.Labels, t int64, v float64, hints *storage.AppendHints) (storage.SeriesRef, error) { func (a *headAppender) Append(ref storage.SeriesRef, l labels.Labels, t int64, v float64, hints storage.AppendHints) (storage.SeriesRef, error) {
// Fail fast if OOO is disabled and the sample is out of bounds. // Fail fast if OOO is disabled and the sample is out of bounds.
// Otherwise a full check will be done later to decide if the sample is in-order or out-of-order. // Otherwise a full check will be done later to decide if the sample is in-order or out-of-order.
if a.oooTimeWindow == 0 && t < a.minValidTime { if a.oooTimeWindow == 0 && t < a.minValidTime {
@ -339,7 +339,7 @@ func (a *headAppender) Append(ref storage.SeriesRef, lset labels.Labels, t int64
s := a.head.series.getByID(chunks.HeadSeriesRef(ref)) s := a.head.series.getByID(chunks.HeadSeriesRef(ref))
if s == nil { if s == nil {
var err error var err error
s, _, err = a.getOrCreate(lset) s, _, err = a.getOrCreate(l)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -352,9 +352,9 @@ func (a *headAppender) Append(ref storage.SeriesRef, lset labels.Labels, t int64
// in commit. This code should move into Commit(). // in commit. This code should move into Commit().
switch { switch {
case s.lastHistogramValue != nil: case s.lastHistogramValue != nil:
return a.AppendHistogram(ref, lset, t, &histogram.Histogram{Sum: v}, nil, nil) return a.AppendHistogram(ref, l, t, &histogram.Histogram{Sum: v}, nil, nil)
case s.lastFloatHistogramValue != nil: case s.lastFloatHistogramValue != nil:
return a.AppendHistogram(ref, lset, t, nil, &histogram.FloatHistogram{Sum: v}, nil) return a.AppendHistogram(ref, l, t, nil, &histogram.FloatHistogram{Sum: v}, nil)
} }
} }

3
tsdb/head_read_test.go
View file

@ -21,6 +21,7 @@ import (
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/prometheus/prometheus/model/labels" "github.com/prometheus/prometheus/model/labels"
"github.com/prometheus/prometheus/storage"
"github.com/prometheus/prometheus/tsdb/chunkenc" "github.com/prometheus/prometheus/tsdb/chunkenc"
"github.com/prometheus/prometheus/tsdb/chunks" "github.com/prometheus/prometheus/tsdb/chunks"
) )
@ -421,7 +422,7 @@ func TestHeadIndexReader_PostingsForLabelMatching(t *testing.T) {
}) })
app := h.Appender(context.Background()) app := h.Appender(context.Background())
for _, s := range series { for _, s := range series {
app.Append(0, s, 0, 0, nil) app.Append(0, s, 0, 0, storage.AppendHints{})
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())

161
tsdb/head_test.go
View file

@ -107,6 +107,9 @@ func BenchmarkCreateSeries(b *testing.B) {
func BenchmarkHeadAppender_Append_Commit_ExistingSeries(b *testing.B) { func BenchmarkHeadAppender_Append_Commit_ExistingSeries(b *testing.B) {
seriesCounts := []int{100, 1000, 10000} seriesCounts := []int{100, 1000, 10000}
series := genSeries(10000, 10, 0, 0) series := genSeries(10000, 10, 0, 0)
hints := storage.AppendHints{
DiscardOutOfOrder: false,
}
for _, seriesCount := range seriesCounts { for _, seriesCount := range seriesCounts {
b.Run(fmt.Sprintf("%d series", seriesCount), func(b *testing.B) { b.Run(fmt.Sprintf("%d series", seriesCount), func(b *testing.B) {
@ -122,7 +125,7 @@ func BenchmarkHeadAppender_Append_Commit_ExistingSeries(b *testing.B) {
for _, s := range series[:seriesCount] { for _, s := range series[:seriesCount] {
var ref storage.SeriesRef var ref storage.SeriesRef
for sampleIndex := int64(0); sampleIndex < samplesPerAppend; sampleIndex++ { for sampleIndex := int64(0); sampleIndex < samplesPerAppend; sampleIndex++ {
ref, err = app.Append(ref, s.Labels(), ts+sampleIndex, float64(ts+sampleIndex), nil) ref, err = app.Append(ref, s.Labels(), ts+sampleIndex, float64(ts+sampleIndex), hints)
if err != nil { if err != nil {
return err return err
} }
@ -536,7 +539,7 @@ func TestHead_HighConcurrencyReadAndWrite(t *testing.T) {
app := head.Appender(ctx) app := head.Appender(ctx)
for i := 0; i < len(workerLabelSets); i++ { for i := 0; i < len(workerLabelSets); i++ {
// We also use the timestamp as the sample value. // We also use the timestamp as the sample value.
_, err := app.Append(0, workerLabelSets[i], int64(ts), float64(ts), nil) _, err := app.Append(0, workerLabelSets[i], int64(ts), float64(ts), storage.AppendHints{})
if err != nil { if err != nil {
return false, fmt.Errorf("Error when appending to head: %w", err) return false, fmt.Errorf("Error when appending to head: %w", err)
} }
@ -746,14 +749,14 @@ func TestHead_WALMultiRef(t *testing.T) {
require.NoError(t, head.Init(0)) require.NoError(t, head.Init(0))
app := head.Appender(context.Background()) app := head.Appender(context.Background())
ref1, err := app.Append(0, labels.FromStrings("foo", "bar"), 100, 1, nil) ref1, err := app.Append(0, labels.FromStrings("foo", "bar"), 100, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
require.Equal(t, 1.0, prom_testutil.ToFloat64(head.metrics.chunksCreated)) require.Equal(t, 1.0, prom_testutil.ToFloat64(head.metrics.chunksCreated))
// Add another sample outside chunk range to mmap a chunk. // Add another sample outside chunk range to mmap a chunk.
app = head.Appender(context.Background()) app = head.Appender(context.Background())
_, err = app.Append(0, labels.FromStrings("foo", "bar"), 1500, 2, nil) _, err = app.Append(0, labels.FromStrings("foo", "bar"), 1500, 2, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
require.Equal(t, 2.0, prom_testutil.ToFloat64(head.metrics.chunksCreated)) require.Equal(t, 2.0, prom_testutil.ToFloat64(head.metrics.chunksCreated))
@ -761,14 +764,14 @@ func TestHead_WALMultiRef(t *testing.T) {
require.NoError(t, head.Truncate(1600)) require.NoError(t, head.Truncate(1600))
app = head.Appender(context.Background()) app = head.Appender(context.Background())
ref2, err := app.Append(0, labels.FromStrings("foo", "bar"), 1700, 3, nil) ref2, err := app.Append(0, labels.FromStrings("foo", "bar"), 1700, 3, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
require.Equal(t, 3.0, prom_testutil.ToFloat64(head.metrics.chunksCreated)) require.Equal(t, 3.0, prom_testutil.ToFloat64(head.metrics.chunksCreated))
// Add another sample outside chunk range to mmap a chunk. // Add another sample outside chunk range to mmap a chunk.
app = head.Appender(context.Background()) app = head.Appender(context.Background())
_, err = app.Append(0, labels.FromStrings("foo", "bar"), 2000, 4, nil) _, err = app.Append(0, labels.FromStrings("foo", "bar"), 2000, 4, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
require.Equal(t, 4.0, prom_testutil.ToFloat64(head.metrics.chunksCreated)) require.Equal(t, 4.0, prom_testutil.ToFloat64(head.metrics.chunksCreated))
@ -819,7 +822,7 @@ func TestHead_ActiveAppenders(t *testing.T) {
// Now rollback with one sample. // Now rollback with one sample.
app = head.Appender(context.Background()) app = head.Appender(context.Background())
_, err := app.Append(0, labels.FromStrings("foo", "bar"), 100, 1, nil) _, err := app.Append(0, labels.FromStrings("foo", "bar"), 100, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, 1.0, prom_testutil.ToFloat64(head.metrics.activeAppenders)) require.Equal(t, 1.0, prom_testutil.ToFloat64(head.metrics.activeAppenders))
require.NoError(t, app.Rollback()) require.NoError(t, app.Rollback())
@ -827,7 +830,7 @@ func TestHead_ActiveAppenders(t *testing.T) {
// Now commit with one sample. // Now commit with one sample.
app = head.Appender(context.Background()) app = head.Appender(context.Background())
_, err = app.Append(0, labels.FromStrings("foo", "bar"), 100, 1, nil) _, err = app.Append(0, labels.FromStrings("foo", "bar"), 100, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
require.Equal(t, 0.0, prom_testutil.ToFloat64(head.metrics.activeAppenders)) require.Equal(t, 0.0, prom_testutil.ToFloat64(head.metrics.activeAppenders))
@ -1313,7 +1316,7 @@ func TestHeadDeleteSimple(t *testing.T) {
app := head.Appender(context.Background()) app := head.Appender(context.Background())
for _, smpl := range smplsAll { for _, smpl := range smplsAll {
_, err := app.Append(0, lblsDefault, smpl.t, smpl.f, nil) _, err := app.Append(0, lblsDefault, smpl.t, smpl.f, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -1326,7 +1329,7 @@ func TestHeadDeleteSimple(t *testing.T) {
// Add more samples. // Add more samples.
app = head.Appender(context.Background()) app = head.Appender(context.Background())
for _, smpl := range c.addSamples { for _, smpl := range c.addSamples {
_, err := app.Append(0, lblsDefault, smpl.t, smpl.f, nil) _, err := app.Append(0, lblsDefault, smpl.t, smpl.f, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -1397,7 +1400,7 @@ func TestDeleteUntilCurMax(t *testing.T) {
smpls := make([]float64, numSamples) smpls := make([]float64, numSamples)
for i := int64(0); i < numSamples; i++ { for i := int64(0); i < numSamples; i++ {
smpls[i] = rand.Float64() smpls[i] = rand.Float64()
_, err := app.Append(0, labels.FromStrings("a", "b"), i, smpls[i], nil) _, err := app.Append(0, labels.FromStrings("a", "b"), i, smpls[i], storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -1418,7 +1421,7 @@ func TestDeleteUntilCurMax(t *testing.T) {
// Add again and test for presence. // Add again and test for presence.
app = hb.Appender(context.Background()) app = hb.Appender(context.Background())
_, err = app.Append(0, labels.FromStrings("a", "b"), 11, 1, nil) _, err = app.Append(0, labels.FromStrings("a", "b"), 11, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
q, err = NewBlockQuerier(hb, 0, 100000) q, err = NewBlockQuerier(hb, 0, 100000)
@ -1444,7 +1447,7 @@ func TestDeletedSamplesAndSeriesStillInWALAfterCheckpoint(t *testing.T) {
for i := 0; i < numSamples; i++ { for i := 0; i < numSamples; i++ {
app := hb.Appender(context.Background()) app := hb.Appender(context.Background())
_, err := app.Append(0, labels.FromStrings("a", "b"), int64(i), 0, nil) _, err := app.Append(0, labels.FromStrings("a", "b"), int64(i), 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
} }
@ -1544,7 +1547,7 @@ func TestDelete_e2e(t *testing.T) {
ts := rand.Int63n(300) ts := rand.Int63n(300)
for i := 0; i < numDatapoints; i++ { for i := 0; i < numDatapoints; i++ {
v := rand.Float64() v := rand.Float64()
_, err := app.Append(0, ls, ts, v, nil) _, err := app.Append(0, ls, ts, v, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
series = append(series, sample{ts, v, nil, nil}) series = append(series, sample{ts, v, nil, nil})
ts += rand.Int63n(timeInterval) + 1 ts += rand.Int63n(timeInterval) + 1
@ -2027,7 +2030,7 @@ func TestUncommittedSamplesNotLostOnTruncate(t *testing.T) {
app := h.appender() app := h.appender()
lset := labels.FromStrings("a", "1") lset := labels.FromStrings("a", "1")
_, err := app.Append(0, lset, 2100, 1, nil) _, err := app.Append(0, lset, 2100, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, h.Truncate(2000)) require.NoError(t, h.Truncate(2000))
@ -2057,7 +2060,7 @@ func TestRemoveSeriesAfterRollbackAndTruncate(t *testing.T) {
app := h.appender() app := h.appender()
lset := labels.FromStrings("a", "1") lset := labels.FromStrings("a", "1")
_, err := app.Append(0, lset, 2100, 1, nil) _, err := app.Append(0, lset, 2100, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, h.Truncate(2000)) require.NoError(t, h.Truncate(2000))
@ -2087,7 +2090,7 @@ func TestHead_LogRollback(t *testing.T) {
}() }()
app := h.Appender(context.Background()) app := h.Appender(context.Background())
_, err := app.Append(0, labels.FromStrings("a", "b"), 1, 2, nil) _, err := app.Append(0, labels.FromStrings("a", "b"), 1, 2, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Rollback()) require.NoError(t, app.Rollback())
@ -2117,7 +2120,7 @@ func TestHead_ReturnsSortedLabelValues(t *testing.T) {
"__name__", fmt.Sprintf("metric_%d", i), "__name__", fmt.Sprintf("metric_%d", i),
"label", fmt.Sprintf("value_%d", j), "label", fmt.Sprintf("value_%d", j),
) )
_, err := app.Append(0, lset, 2100, 1, nil) _, err := app.Append(0, lset, 2100, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
} }
@ -2382,7 +2385,7 @@ func TestNewWalSegmentOnTruncate(t *testing.T) {
}() }()
add := func(ts int64) { add := func(ts int64) {
app := h.Appender(context.Background()) app := h.Appender(context.Background())
_, err := app.Append(0, labels.FromStrings("a", "b"), ts, 0, nil) _, err := app.Append(0, labels.FromStrings("a", "b"), ts, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
} }
@ -2413,7 +2416,7 @@ func TestAddDuplicateLabelName(t *testing.T) {
add := func(labels labels.Labels, labelName string) { add := func(labels labels.Labels, labelName string) {
app := h.Appender(context.Background()) app := h.Appender(context.Background())
_, err := app.Append(0, labels, 0, 0, nil) _, err := app.Append(0, labels, 0, 0, storage.AppendHints{})
require.EqualError(t, err, fmt.Sprintf(`label name "%s" is not unique: invalid sample`, labelName)) require.EqualError(t, err, fmt.Sprintf(`label name "%s" is not unique: invalid sample`, labelName))
} }
@ -2477,7 +2480,7 @@ func TestMemSeriesIsolation(t *testing.T) {
app = a app = a
} }
_, err := app.Append(0, labels.FromStrings("foo", "bar"), int64(i), float64(i), nil) _, err := app.Append(0, labels.FromStrings("foo", "bar"), int64(i), float64(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
h.mmapHeadChunks() h.mmapHeadChunks()
@ -2506,7 +2509,7 @@ func TestMemSeriesIsolation(t *testing.T) {
// Cleanup appendIDs below 500. // Cleanup appendIDs below 500.
app := hb.appender() app := hb.appender()
app.cleanupAppendIDsBelow = 500 app.cleanupAppendIDsBelow = 500
_, err := app.Append(0, labels.FromStrings("foo", "bar"), int64(i), float64(i), nil) _, err := app.Append(0, labels.FromStrings("foo", "bar"), int64(i), float64(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
i++ i++
@ -2525,7 +2528,7 @@ func TestMemSeriesIsolation(t *testing.T) {
// the only thing with appendIDs. // the only thing with appendIDs.
app = hb.appender() app = hb.appender()
app.cleanupAppendIDsBelow = 1000 app.cleanupAppendIDsBelow = 1000
_, err = app.Append(0, labels.FromStrings("foo", "bar"), int64(i), float64(i), nil) _, err = app.Append(0, labels.FromStrings("foo", "bar"), int64(i), float64(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
require.Equal(t, 999, lastValue(hb, 998)) require.Equal(t, 999, lastValue(hb, 998))
@ -2539,7 +2542,7 @@ func TestMemSeriesIsolation(t *testing.T) {
// Cleanup appendIDs below 1001, but with a rollback. // Cleanup appendIDs below 1001, but with a rollback.
app = hb.appender() app = hb.appender()
app.cleanupAppendIDsBelow = 1001 app.cleanupAppendIDsBelow = 1001
_, err = app.Append(0, labels.FromStrings("foo", "bar"), int64(i), float64(i), nil) _, err = app.Append(0, labels.FromStrings("foo", "bar"), int64(i), float64(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Rollback()) require.NoError(t, app.Rollback())
require.Equal(t, 1000, lastValue(hb, 999)) require.Equal(t, 1000, lastValue(hb, 999))
@ -2575,7 +2578,7 @@ func TestMemSeriesIsolation(t *testing.T) {
// Cleanup appendIDs below 1000, which means the sample buffer is // Cleanup appendIDs below 1000, which means the sample buffer is
// the only thing with appendIDs. // the only thing with appendIDs.
app = hb.appender() app = hb.appender()
_, err = app.Append(0, labels.FromStrings("foo", "bar"), int64(i), float64(i), nil) _, err = app.Append(0, labels.FromStrings("foo", "bar"), int64(i), float64(i), storage.AppendHints{})
i++ i++
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -2588,7 +2591,7 @@ func TestMemSeriesIsolation(t *testing.T) {
// Cleanup appendIDs below 1002, but with a rollback. // Cleanup appendIDs below 1002, but with a rollback.
app = hb.appender() app = hb.appender()
_, err = app.Append(0, labels.FromStrings("foo", "bar"), int64(i), float64(i), nil) _, err = app.Append(0, labels.FromStrings("foo", "bar"), int64(i), float64(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Rollback()) require.NoError(t, app.Rollback())
require.Equal(t, 1001, lastValue(hb, 999)) require.Equal(t, 1001, lastValue(hb, 999))
@ -2610,21 +2613,21 @@ func TestIsolationRollback(t *testing.T) {
}() }()
app := hb.Appender(context.Background()) app := hb.Appender(context.Background())
_, err := app.Append(0, labels.FromStrings("foo", "bar"), 0, 0, nil) _, err := app.Append(0, labels.FromStrings("foo", "bar"), 0, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
require.Equal(t, uint64(1), hb.iso.lowWatermark()) require.Equal(t, uint64(1), hb.iso.lowWatermark())
app = hb.Appender(context.Background()) app = hb.Appender(context.Background())
_, err = app.Append(0, labels.FromStrings("foo", "bar"), 1, 1, nil) _, err = app.Append(0, labels.FromStrings("foo", "bar"), 1, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, labels.FromStrings("foo", "bar", "foo", "baz"), 2, 2, nil) _, err = app.Append(0, labels.FromStrings("foo", "bar", "foo", "baz"), 2, 2, storage.AppendHints{})
require.Error(t, err) require.Error(t, err)
require.NoError(t, app.Rollback()) require.NoError(t, app.Rollback())
require.Equal(t, uint64(2), hb.iso.lowWatermark()) require.Equal(t, uint64(2), hb.iso.lowWatermark())
app = hb.Appender(context.Background()) app = hb.Appender(context.Background())
_, err = app.Append(0, labels.FromStrings("foo", "bar"), 3, 3, nil) _, err = app.Append(0, labels.FromStrings("foo", "bar"), 3, 3, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
require.Equal(t, uint64(3), hb.iso.lowWatermark(), "Low watermark should proceed to 3 even if append #2 was rolled back.") require.Equal(t, uint64(3), hb.iso.lowWatermark(), "Low watermark should proceed to 3 even if append #2 was rolled back.")
@ -2641,18 +2644,18 @@ func TestIsolationLowWatermarkMonotonous(t *testing.T) {
}() }()
app1 := hb.Appender(context.Background()) app1 := hb.Appender(context.Background())
_, err := app1.Append(0, labels.FromStrings("foo", "bar"), 0, 0, nil) _, err := app1.Append(0, labels.FromStrings("foo", "bar"), 0, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app1.Commit()) require.NoError(t, app1.Commit())
require.Equal(t, uint64(1), hb.iso.lowWatermark(), "Low watermark should by 1 after 1st append.") require.Equal(t, uint64(1), hb.iso.lowWatermark(), "Low watermark should by 1 after 1st append.")
app1 = hb.Appender(context.Background()) app1 = hb.Appender(context.Background())
_, err = app1.Append(0, labels.FromStrings("foo", "bar"), 1, 1, nil) _, err = app1.Append(0, labels.FromStrings("foo", "bar"), 1, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, uint64(2), hb.iso.lowWatermark(), "Low watermark should be two, even if append is not committed yet.") require.Equal(t, uint64(2), hb.iso.lowWatermark(), "Low watermark should be two, even if append is not committed yet.")
app2 := hb.Appender(context.Background()) app2 := hb.Appender(context.Background())
_, err = app2.Append(0, labels.FromStrings("foo", "baz"), 1, 1, nil) _, err = app2.Append(0, labels.FromStrings("foo", "baz"), 1, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app2.Commit()) require.NoError(t, app2.Commit())
require.Equal(t, uint64(2), hb.iso.lowWatermark(), "Low watermark should stay two because app1 is not committed yet.") require.Equal(t, uint64(2), hb.iso.lowWatermark(), "Low watermark should stay two because app1 is not committed yet.")
@ -2712,7 +2715,7 @@ func TestIsolationWithoutAdd(t *testing.T) {
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
app = hb.Appender(context.Background()) app = hb.Appender(context.Background())
_, err := app.Append(0, labels.FromStrings("foo", "baz"), 1, 1, nil) _, err := app.Append(0, labels.FromStrings("foo", "baz"), 1, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -2835,10 +2838,10 @@ func testHeadSeriesChunkRace(t *testing.T) {
require.NoError(t, h.Init(0)) require.NoError(t, h.Init(0))
app := h.Appender(context.Background()) app := h.Appender(context.Background())
s2, err := app.Append(0, labels.FromStrings("foo2", "bar"), 5, 0, nil) s2, err := app.Append(0, labels.FromStrings("foo2", "bar"), 5, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
for ts := int64(6); ts < 11; ts++ { for ts := int64(6); ts < 11; ts++ {
_, err = app.Append(s2, labels.EmptyLabels(), ts, 0, nil) _, err = app.Append(s2, labels.EmptyLabels(), ts, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -2886,7 +2889,7 @@ func TestHeadLabelNamesValuesWithMinMaxRange(t *testing.T) {
app := head.Appender(ctx) app := head.Appender(ctx)
for i, name := range expectedLabelNames { for i, name := range expectedLabelNames {
_, err := app.Append(0, labels.FromStrings(name, expectedLabelValues[i]), seriesTimestamps[i], 0, nil) _, err := app.Append(0, labels.FromStrings(name, expectedLabelValues[i]), seriesTimestamps[i], 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -2934,7 +2937,7 @@ func TestHeadLabelValuesWithMatchers(t *testing.T) {
_, err := app.Append(0, labels.FromStrings( _, err := app.Append(0, labels.FromStrings(
"tens", fmt.Sprintf("value%d", i/10), "tens", fmt.Sprintf("value%d", i/10),
"unique", fmt.Sprintf("value%d", i), "unique", fmt.Sprintf("value%d", i),
), 100, 0, nil) ), 100, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -3009,14 +3012,14 @@ func TestHeadLabelNamesWithMatchers(t *testing.T) {
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
_, err := app.Append(0, labels.FromStrings( _, err := app.Append(0, labels.FromStrings(
"unique", fmt.Sprintf("value%d", i), "unique", fmt.Sprintf("value%d", i),
), 100, 0, nil) ), 100, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
if i%10 == 0 { if i%10 == 0 {
_, err := app.Append(0, labels.FromStrings( _, err := app.Append(0, labels.FromStrings(
"tens", fmt.Sprintf("value%d", i/10), "tens", fmt.Sprintf("value%d", i/10),
"unique", fmt.Sprintf("value%d", i), "unique", fmt.Sprintf("value%d", i),
), 100, 0, nil) ), 100, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
@ -3025,7 +3028,7 @@ func TestHeadLabelNamesWithMatchers(t *testing.T) {
"tens", fmt.Sprintf("value%d", i/10), "tens", fmt.Sprintf("value%d", i/10),
"twenties", fmt.Sprintf("value%d", i/20), "twenties", fmt.Sprintf("value%d", i/20),
"unique", fmt.Sprintf("value%d", i), "unique", fmt.Sprintf("value%d", i),
), 100, 0, nil) ), 100, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
} }
@ -3080,7 +3083,7 @@ func TestHeadShardedPostings(t *testing.T) {
// Append some series. // Append some series.
app := head.Appender(ctx) app := head.Appender(ctx)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
_, err := app.Append(0, labels.FromStrings("unique", fmt.Sprintf("value%d", i), "const", "1"), 100, 0, nil) _, err := app.Append(0, labels.FromStrings("unique", fmt.Sprintf("value%d", i), "const", "1"), 100, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -3139,28 +3142,28 @@ func TestErrReuseAppender(t *testing.T) {
}() }()
app := head.Appender(context.Background()) app := head.Appender(context.Background())
_, err := app.Append(0, labels.FromStrings("test", "test"), 0, 0, nil) _, err := app.Append(0, labels.FromStrings("test", "test"), 0, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
require.Error(t, app.Commit()) require.Error(t, app.Commit())
require.Error(t, app.Rollback()) require.Error(t, app.Rollback())
app = head.Appender(context.Background()) app = head.Appender(context.Background())
_, err = app.Append(0, labels.FromStrings("test", "test"), 1, 0, nil) _, err = app.Append(0, labels.FromStrings("test", "test"), 1, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Rollback()) require.NoError(t, app.Rollback())
require.Error(t, app.Rollback()) require.Error(t, app.Rollback())
require.Error(t, app.Commit()) require.Error(t, app.Commit())
app = head.Appender(context.Background()) app = head.Appender(context.Background())
_, err = app.Append(0, labels.FromStrings("test", "test"), 2, 0, nil) _, err = app.Append(0, labels.FromStrings("test", "test"), 2, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
require.Error(t, app.Rollback()) require.Error(t, app.Rollback())
require.Error(t, app.Commit()) require.Error(t, app.Commit())
app = head.Appender(context.Background()) app = head.Appender(context.Background())
_, err = app.Append(0, labels.FromStrings("test", "test"), 3, 0, nil) _, err = app.Append(0, labels.FromStrings("test", "test"), 3, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Rollback()) require.NoError(t, app.Rollback())
require.Error(t, app.Commit()) require.Error(t, app.Commit())
@ -3172,11 +3175,11 @@ func TestHeadMintAfterTruncation(t *testing.T) {
head, _ := newTestHead(t, chunkRange, wlog.CompressionNone, false) head, _ := newTestHead(t, chunkRange, wlog.CompressionNone, false)
app := head.Appender(context.Background()) app := head.Appender(context.Background())
_, err := app.Append(0, labels.FromStrings("a", "b"), 100, 100, nil) _, err := app.Append(0, labels.FromStrings("a", "b"), 100, 100, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, labels.FromStrings("a", "b"), 4000, 200, nil) _, err = app.Append(0, labels.FromStrings("a", "b"), 4000, 200, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.Append(0, labels.FromStrings("a", "b"), 8000, 300, nil) _, err = app.Append(0, labels.FromStrings("a", "b"), 8000, 300, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -3210,7 +3213,7 @@ func TestHeadExemplars(t *testing.T) {
// It is perfectly valid to add Exemplars before the current start time - // It is perfectly valid to add Exemplars before the current start time -
// histogram buckets that haven't been update in a while could still be // histogram buckets that haven't been update in a while could still be
// exported exemplars from an hour ago. // exported exemplars from an hour ago.
ref, err := app.Append(0, labels.FromStrings("a", "b"), 100, 100, nil) ref, err := app.Append(0, labels.FromStrings("a", "b"), 100, 100, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
_, err = app.AppendExemplar(ref, l, exemplar.Exemplar{ _, err = app.AppendExemplar(ref, l, exemplar.Exemplar{
Labels: l, Labels: l,
@ -3238,7 +3241,7 @@ func BenchmarkHeadLabelValuesWithMatchers(b *testing.B) {
"a_unique", fmt.Sprintf("value%d", i), "a_unique", fmt.Sprintf("value%d", i),
"b_tens", fmt.Sprintf("value%d", i/(metricCount/10)), "b_tens", fmt.Sprintf("value%d", i/(metricCount/10)),
"c_ninety", fmt.Sprintf("value%d", i/(metricCount/10)/9), // "0" for the first 90%, then "1" "c_ninety", fmt.Sprintf("value%d", i/(metricCount/10)/9), // "0" for the first 90%, then "1"
), 100, 0, nil) ), 100, 0, storage.AppendHints{})
require.NoError(b, err) require.NoError(b, err)
} }
require.NoError(b, app.Commit()) require.NoError(b, app.Commit())
@ -3339,7 +3342,7 @@ func TestChunkNotFoundHeadGCRace(t *testing.T) {
// 7 chunks with 15s scrape interval. // 7 chunks with 15s scrape interval.
for i := int64(0); i <= 120*7; i++ { for i := int64(0); i <= 120*7; i++ {
ts := i * DefaultBlockDuration / (4 * 120) ts := i * DefaultBlockDuration / (4 * 120)
ref, err = app.Append(ref, labels.FromStrings("a", "b"), ts, float64(i), nil) ref, err = app.Append(ref, labels.FromStrings("a", "b"), ts, float64(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
maxt = ts maxt = ts
} }
@ -3406,7 +3409,7 @@ func TestDataMissingOnQueryDuringCompaction(t *testing.T) {
// 7 chunks with 15s scrape interval. // 7 chunks with 15s scrape interval.
for i := int64(0); i <= 120*7; i++ { for i := int64(0); i <= 120*7; i++ {
ts := i * DefaultBlockDuration / (4 * 120) ts := i * DefaultBlockDuration / (4 * 120)
ref, err = app.Append(ref, labels.FromStrings("a", "b"), ts, float64(i), nil) ref, err = app.Append(ref, labels.FromStrings("a", "b"), ts, float64(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
maxt = ts maxt = ts
expSamples = append(expSamples, sample{ts, float64(i), nil, nil}) expSamples = append(expSamples, sample{ts, float64(i), nil, nil})
@ -3448,7 +3451,7 @@ func TestIsQuerierCollidingWithTruncation(t *testing.T) {
) )
for i := int64(0); i <= 3000; i++ { for i := int64(0); i <= 3000; i++ {
ref, err = app.Append(ref, labels.FromStrings("a", "b"), i, float64(i), nil) ref, err = app.Append(ref, labels.FromStrings("a", "b"), i, float64(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -3496,7 +3499,7 @@ func TestWaitForPendingReadersInTimeRange(t *testing.T) {
for i := int64(0); i <= 3000; i++ { for i := int64(0); i <= 3000; i++ {
ts := sampleTs(i) ts := sampleTs(i)
ref, err = app.Append(ref, labels.FromStrings("a", "b"), ts, float64(i), nil) ref, err = app.Append(ref, labels.FromStrings("a", "b"), ts, float64(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -3611,12 +3614,12 @@ func testQueryOOOHeadDuringTruncate(t *testing.T, makeQuerier func(db *DB, minT,
) )
// Add in-order samples at every 100ms starting at 0ms. // Add in-order samples at every 100ms starting at 0ms.
for i := int64(0); i < maxT; i += 100 { for i := int64(0); i < maxT; i += 100 {
_, err := app.Append(ref, labels.FromStrings("a", "b"), i, 0, nil) _, err := app.Append(ref, labels.FromStrings("a", "b"), i, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
// Add out-of-order samples at every 100ms starting at 50ms. // Add out-of-order samples at every 100ms starting at 50ms.
for i := int64(50); i < maxT; i += 100 { for i := int64(50); i < maxT; i += 100 {
_, err := app.Append(ref, labels.FromStrings("a", "b"), i, 0, nil) _, err := app.Append(ref, labels.FromStrings("a", "b"), i, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -3875,7 +3878,7 @@ func TestHistogramInWALAndMmapChunk(t *testing.T) {
// Add some float. // Add some float.
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
ts++ ts++
_, err := app.Append(0, s2, ts, float64(ts), nil) _, err := app.Append(0, s2, ts, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
exp[k2] = append(exp[k2], sample{t: ts, f: float64(ts)}) exp[k2] = append(exp[k2], sample{t: ts, f: float64(ts)})
} }
@ -3911,7 +3914,7 @@ func TestHistogramInWALAndMmapChunk(t *testing.T) {
// Add some float. // Add some float.
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
ts++ ts++
_, err := app.Append(0, s2, ts, float64(ts), nil) _, err := app.Append(0, s2, ts, float64(ts), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
exp[k2] = append(exp[k2], sample{t: ts, f: float64(ts)}) exp[k2] = append(exp[k2], sample{t: ts, f: float64(ts)})
} }
@ -4075,7 +4078,7 @@ func TestChunkSnapshot(t *testing.T) {
for ts := int64(1); ts <= 240; ts++ { for ts := int64(1); ts <= 240; ts++ {
val := rand.Float64() val := rand.Float64()
expSeries[lblStr] = append(expSeries[lblStr], sample{ts, val, nil, nil}) expSeries[lblStr] = append(expSeries[lblStr], sample{ts, val, nil, nil})
ref, err := app.Append(0, lbls, ts, val, nil) ref, err := app.Append(0, lbls, ts, val, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
hist := histograms[int(ts)] hist := histograms[int(ts)]
@ -4149,7 +4152,7 @@ func TestChunkSnapshot(t *testing.T) {
for ts := int64(241); ts <= 480; ts++ { for ts := int64(241); ts <= 480; ts++ {
val := rand.Float64() val := rand.Float64()
expSeries[lblStr] = append(expSeries[lblStr], sample{ts, val, nil, nil}) expSeries[lblStr] = append(expSeries[lblStr], sample{ts, val, nil, nil})
ref, err := app.Append(0, lbls, ts, val, nil) ref, err := app.Append(0, lbls, ts, val, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
hist := histograms[int(ts)] hist := histograms[int(ts)]
@ -4250,7 +4253,7 @@ func TestSnapshotError(t *testing.T) {
// Add a sample. // Add a sample.
app := head.Appender(context.Background()) app := head.Appender(context.Background())
lbls := labels.FromStrings("foo", "bar") lbls := labels.FromStrings("foo", "bar")
_, err := app.Append(0, lbls, 99, 99, nil) _, err := app.Append(0, lbls, 99, 99, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
// Add histograms // Add histograms
@ -4499,7 +4502,7 @@ func testHistogramStaleSampleHelper(t *testing.T, floatHistogram bool) {
require.NoError(t, err) require.NoError(t, err)
} }
// +1 so that delta-of-delta is not 0. // +1 so that delta-of-delta is not 0.
_, err := app.Append(0, l, 100*int64(len(expHistograms))+1, math.Float64frombits(value.StaleNaN), nil) _, err := app.Append(0, l, 100*int64(len(expHistograms))+1, math.Float64frombits(value.StaleNaN), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
if floatHistogram { if floatHistogram {
expHistograms = append(expHistograms, timedHistogram{t: 100*int64(len(expHistograms)) + 1, fh: &histogram.FloatHistogram{Sum: math.Float64frombits(value.StaleNaN)}}) expHistograms = append(expHistograms, timedHistogram{t: 100*int64(len(expHistograms)) + 1, fh: &histogram.FloatHistogram{Sum: math.Float64frombits(value.StaleNaN)}})
@ -4533,7 +4536,7 @@ func testHistogramStaleSampleHelper(t *testing.T, floatHistogram bool) {
app = head.Appender(context.Background()) app = head.Appender(context.Background())
// +1 so that delta-of-delta is not 0. // +1 so that delta-of-delta is not 0.
_, err = app.Append(0, l, 100*int64(len(expHistograms))+1, math.Float64frombits(value.StaleNaN), nil) _, err = app.Append(0, l, 100*int64(len(expHistograms))+1, math.Float64frombits(value.StaleNaN), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
if floatHistogram { if floatHistogram {
expHistograms = append(expHistograms, timedHistogram{t: 100*int64(len(expHistograms)) + 1, fh: &histogram.FloatHistogram{Sum: math.Float64frombits(value.StaleNaN)}}) expHistograms = append(expHistograms, timedHistogram{t: 100*int64(len(expHistograms)) + 1, fh: &histogram.FloatHistogram{Sum: math.Float64frombits(value.StaleNaN)}})
@ -4951,7 +4954,7 @@ func TestAppendingDifferentEncodingToSameSeries(t *testing.T) {
if s.H() != nil || s.FH() != nil { if s.H() != nil || s.FH() != nil {
_, err = app.AppendHistogram(0, lbls, s.T(), s.H(), s.FH(), nil) _, err = app.AppendHistogram(0, lbls, s.T(), s.H(), s.FH(), nil)
} else { } else {
_, err = app.Append(0, lbls, s.T(), s.F(), nil) _, err = app.Append(0, lbls, s.T(), s.F(), storage.AppendHints{})
} }
require.Equal(t, a.err, err) require.Equal(t, a.err, err)
} }
@ -5074,7 +5077,7 @@ func TestChunkSnapshotTakenAfterIncompleteSnapshot(t *testing.T) {
// Add some samples for the snapshot. // Add some samples for the snapshot.
app := head.Appender(context.Background()) app := head.Appender(context.Background())
_, err = app.Append(0, labels.FromStrings("foo", "bar"), 10, 10, nil) _, err = app.Append(0, labels.FromStrings("foo", "bar"), 10, 10, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -5290,7 +5293,7 @@ func TestHeadInit_DiscardChunksWithUnsupportedEncoding(t *testing.T) {
var seriesRef storage.SeriesRef var seriesRef storage.SeriesRef
var err error var err error
for i := 0; i < 400; i++ { for i := 0; i < 400; i++ {
seriesRef, err = app.Append(0, seriesLabels, int64(i), float64(i), nil) seriesRef, err = app.Append(0, seriesLabels, int64(i), float64(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
@ -5303,7 +5306,7 @@ func TestHeadInit_DiscardChunksWithUnsupportedEncoding(t *testing.T) {
app = h.Appender(ctx) app = h.Appender(ctx)
for i := 700; i < 1200; i++ { for i := 700; i < 1200; i++ {
_, err := app.Append(0, seriesLabels, int64(i), float64(i), nil) _, err := app.Append(0, seriesLabels, int64(i), float64(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
@ -5376,7 +5379,7 @@ func TestMmapPanicAfterMmapReplayCorruption(t *testing.T) {
interval := DefaultBlockDuration / (4 * 120) interval := DefaultBlockDuration / (4 * 120)
app := h.Appender(context.Background()) app := h.Appender(context.Background())
for i := 0; i < 250; i++ { for i := 0; i < 250; i++ {
ref, err = app.Append(ref, lbls, lastTs, float64(lastTs), nil) ref, err = app.Append(ref, lbls, lastTs, float64(lastTs), storage.AppendHints{})
lastTs += interval lastTs += interval
if i%10 == 0 { if i%10 == 0 {
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -5439,7 +5442,7 @@ func TestReplayAfterMmapReplayError(t *testing.T) {
app := h.Appender(context.Background()) app := h.Appender(context.Background())
var ref storage.SeriesRef var ref storage.SeriesRef
for i := 0; i < numSamples; i++ { for i := 0; i < numSamples; i++ {
ref, err = app.Append(ref, lbls, lastTs, float64(lastTs), nil) ref, err = app.Append(ref, lbls, lastTs, float64(lastTs), storage.AppendHints{})
expSamples = append(expSamples, sample{t: lastTs, f: float64(lastTs)}) expSamples = append(expSamples, sample{t: lastTs, f: float64(lastTs)})
require.NoError(t, err) require.NoError(t, err)
lastTs += itvl lastTs += itvl
@ -5793,7 +5796,7 @@ func TestSnapshotAheadOfWALError(t *testing.T) {
head.opts.EnableMemorySnapshotOnShutdown = true head.opts.EnableMemorySnapshotOnShutdown = true
// Add a sample to fill WAL. // Add a sample to fill WAL.
app := head.Appender(context.Background()) app := head.Appender(context.Background())
_, err := app.Append(0, labels.FromStrings("foo", "bar"), 10, 10, nil) _, err := app.Append(0, labels.FromStrings("foo", "bar"), 10, 10, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
@ -5817,7 +5820,7 @@ func TestSnapshotAheadOfWALError(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
// Add a sample to fill WAL. // Add a sample to fill WAL.
app = head.Appender(context.Background()) app = head.Appender(context.Background())
_, err = app.Append(0, labels.FromStrings("foo", "bar"), 10, 10, nil) _, err = app.Append(0, labels.FromStrings("foo", "bar"), 10, 10, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
lastSegment, _, _ := w.LastSegmentAndOffset() lastSegment, _, _ := w.LastSegmentAndOffset()
@ -5980,7 +5983,7 @@ func TestCuttingNewHeadChunks(t *testing.T) {
for i := 0; i < tc.numTotalSamples; i++ { for i := 0; i < tc.numTotalSamples; i++ {
if tc.floatValFunc != nil { if tc.floatValFunc != nil {
_, err := a.Append(0, lbls, ts, tc.floatValFunc(i), nil) _, err := a.Append(0, lbls, ts, tc.floatValFunc(i), storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} else if tc.histValFunc != nil { } else if tc.histValFunc != nil {
_, err := a.AppendHistogram(0, lbls, ts, tc.histValFunc(i), nil, nil) _, err := a.AppendHistogram(0, lbls, ts, tc.histValFunc(i), nil, nil)
@ -6045,7 +6048,7 @@ func TestHeadDetectsDuplicateSampleAtSizeLimit(t *testing.T) {
vals := []float64{math.MaxFloat64, 0x00} // Use the worst case scenario for the XOR encoding. Otherwise we hit the sample limit before the size limit. vals := []float64{math.MaxFloat64, 0x00} // Use the worst case scenario for the XOR encoding. Otherwise we hit the sample limit before the size limit.
for i := 0; i < numSamples; i++ { for i := 0; i < numSamples; i++ {
ts := baseTS + int64(i/2)*10000 ts := baseTS + int64(i/2)*10000
a.Append(0, labels.FromStrings("foo", "bar"), ts, vals[(i/2)%len(vals)], nil) a.Append(0, labels.FromStrings("foo", "bar"), ts, vals[(i/2)%len(vals)], storage.AppendHints{})
err = a.Commit() err = a.Commit()
require.NoError(t, err) require.NoError(t, err)
a = h.Appender(context.Background()) a = h.Appender(context.Background())
@ -6082,7 +6085,7 @@ func TestWALSampleAndExemplarOrder(t *testing.T) {
}{ }{
"float sample": { "float sample": {
appendF: func(app storage.Appender, ts int64) (storage.SeriesRef, error) { appendF: func(app storage.Appender, ts int64) (storage.SeriesRef, error) {
return app.Append(0, lbls, ts, 1.0, nil) return app.Append(0, lbls, ts, 1.0, storage.AppendHints{})
}, },
expectedType: reflect.TypeOf([]record.RefSample{}), expectedType: reflect.TypeOf([]record.RefSample{}),
}, },
@ -6142,7 +6145,7 @@ func TestHeadCompactionWhileAppendAndCommitExemplar(t *testing.T) {
h, _ := newTestHead(t, DefaultBlockDuration, wlog.CompressionNone, false) h, _ := newTestHead(t, DefaultBlockDuration, wlog.CompressionNone, false)
app := h.Appender(context.Background()) app := h.Appender(context.Background())
lbls := labels.FromStrings("foo", "bar") lbls := labels.FromStrings("foo", "bar")
ref, err := app.Append(0, lbls, 1, 1, nil) ref, err := app.Append(0, lbls, 1, 1, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
app.Commit() app.Commit()
// Not adding a sample here to trigger the fault. // Not adding a sample here to trigger the fault.
@ -6260,7 +6263,7 @@ func TestHeadAppender_AppendFloatWithSameTimestampAsPreviousHistogram(t *testing
{ {
// Append a float 10.0 @ 1_000 // Append a float 10.0 @ 1_000
app := head.Appender(context.Background()) app := head.Appender(context.Background())
_, err := app.Append(0, ls, 1_000, 10.0, nil) _, err := app.Append(0, ls, 1_000, 10.0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
} }
@ -6275,7 +6278,7 @@ func TestHeadAppender_AppendFloatWithSameTimestampAsPreviousHistogram(t *testing
} }
app := head.Appender(context.Background()) app := head.Appender(context.Background())
_, err := app.Append(0, ls, 2_000, 10.0, nil) _, err := app.Append(0, ls, 2_000, 10.0, storage.AppendHints{})
require.Error(t, err) require.Error(t, err)
require.ErrorIs(t, err, storage.NewDuplicateHistogramToFloatErr(2_000, 10.0)) require.ErrorIs(t, err, storage.NewDuplicateHistogramToFloatErr(2_000, 10.0))
} }
@ -6479,7 +6482,7 @@ func TestHeadAppender_AppendCT(t *testing.T) {
if sample.fSample != 0 { if sample.fSample != 0 {
_, err := a.AppendCTZeroSample(0, lbls, sample.ts, sample.ct) _, err := a.AppendCTZeroSample(0, lbls, sample.ts, sample.ct)
require.NoError(t, err) require.NoError(t, err)
_, err = a.Append(0, lbls, sample.ts, sample.fSample, nil) _, err = a.Append(0, lbls, sample.ts, sample.fSample, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }

8
tsdb/querier_bench_test.go
View file

@ -43,7 +43,7 @@ func BenchmarkQuerier(b *testing.B) {
app := h.Appender(context.Background()) app := h.Appender(context.Background())
addSeries := func(l labels.Labels) { addSeries := func(l labels.Labels) {
app.Append(0, l, 0, 0, nil) app.Append(0, l, 0, 0, storage.AppendHints{})
} }
for n := 0; n < 10; n++ { for n := 0; n < 10; n++ {
@ -298,7 +298,7 @@ func benchmarkSelect(b *testing.B, queryable storage.Queryable, numSeries int, s
func BenchmarkQuerierSelect(b *testing.B) { func BenchmarkQuerierSelect(b *testing.B) {
numSeries := 1000000 numSeries := 1000000
h, db := createHeadForBenchmarkSelect(b, numSeries, func(app storage.Appender, i int) { h, db := createHeadForBenchmarkSelect(b, numSeries, func(app storage.Appender, i int) {
_, err := app.Append(0, labels.FromStrings("foo", "bar", "i", fmt.Sprintf("%d%s", i, postingsBenchSuffix)), int64(i), 0, nil) _, err := app.Append(0, labels.FromStrings("foo", "bar", "i", fmt.Sprintf("%d%s", i, postingsBenchSuffix)), int64(i), 0, storage.AppendHints{})
if err != nil { if err != nil {
b.Fatal(err) b.Fatal(err)
} }
@ -336,11 +336,11 @@ func BenchmarkQuerierSelectWithOutOfOrder(b *testing.B) {
numSeries := 1000000 numSeries := 1000000
_, db := createHeadForBenchmarkSelect(b, numSeries, func(app storage.Appender, i int) { _, db := createHeadForBenchmarkSelect(b, numSeries, func(app storage.Appender, i int) {
l := labels.FromStrings("foo", "bar", "i", fmt.Sprintf("%d%s", i, postingsBenchSuffix)) l := labels.FromStrings("foo", "bar", "i", fmt.Sprintf("%d%s", i, postingsBenchSuffix))
ref, err := app.Append(0, l, int64(i+1), 0, nil) ref, err := app.Append(0, l, int64(i+1), 0, storage.AppendHints{})
if err != nil { if err != nil {
b.Fatal(err) b.Fatal(err)
} }
_, err = app.Append(ref, l, int64(i), 1, nil) // Out of order sample _, err = app.Append(ref, l, int64(i), 1, storage.AppendHints{}) // Out of order sample
if err != nil { if err != nil {
b.Fatal(err) b.Fatal(err)
} }

20
tsdb/querier_test.go
View file

@ -506,7 +506,7 @@ func TestBlockQuerier_AgainstHeadWithOpenChunks(t *testing.T) {
for _, s := range testData { for _, s := range testData {
for _, chk := range s.chunks { for _, chk := range s.chunks {
for _, sample := range chk { for _, sample := range chk {
_, err = app.Append(0, labels.FromMap(s.lset), sample.t, sample.f, nil) _, err = app.Append(0, labels.FromMap(s.lset), sample.t, sample.f, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
} }
} }
@ -2686,12 +2686,12 @@ func TestPostingsForMatchers(t *testing.T) {
}() }()
app := h.Appender(context.Background()) app := h.Appender(context.Background())
app.Append(0, labels.FromStrings("n", "1"), 0, 0, nil) app.Append(0, labels.FromStrings("n", "1"), 0, 0, storage.AppendHints{})
app.Append(0, labels.FromStrings("n", "1", "i", "a"), 0, 0, nil) app.Append(0, labels.FromStrings("n", "1", "i", "a"), 0, 0, storage.AppendHints{})
app.Append(0, labels.FromStrings("n", "1", "i", "b"), 0, 0, nil) app.Append(0, labels.FromStrings("n", "1", "i", "b"), 0, 0, storage.AppendHints{})
app.Append(0, labels.FromStrings("n", "1", "i", "\n"), 0, 0, nil) app.Append(0, labels.FromStrings("n", "1", "i", "\n"), 0, 0, storage.AppendHints{})
app.Append(0, labels.FromStrings("n", "2"), 0, 0, nil) app.Append(0, labels.FromStrings("n", "2"), 0, 0, storage.AppendHints{})
app.Append(0, labels.FromStrings("n", "2.5"), 0, 0, nil) app.Append(0, labels.FromStrings("n", "2.5"), 0, 0, storage.AppendHints{})
require.NoError(t, app.Commit()) require.NoError(t, app.Commit())
cases := []struct { cases := []struct {
@ -3103,7 +3103,7 @@ func appendSeries(t *testing.T, ctx context.Context, wg *sync.WaitGroup, h *Head
for i := 0; ctx.Err() == nil; i++ { for i := 0; ctx.Err() == nil; i++ {
app := h.Appender(context.Background()) app := h.Appender(context.Background())
_, err := app.Append(0, labels.FromStrings(labels.MetricName, "metric", "seq", strconv.Itoa(i), "always_0", "0"), 0, 0, nil) _, err := app.Append(0, labels.FromStrings(labels.MetricName, "metric", "seq", strconv.Itoa(i), "always_0", "0"), 0, 0, storage.AppendHints{})
require.NoError(t, err) require.NoError(t, err)
err = app.Commit() err = app.Commit()
require.NoError(t, err) require.NoError(t, err)
@ -3485,7 +3485,7 @@ func BenchmarkHeadChunkQuerier(b *testing.B) {
require.NoError(b, app.Commit()) require.NoError(b, app.Commit())
app = db.Appender(context.Background()) app = db.Appender(context.Background())
} }
_, err := app.Append(0, lbls, int64(i*15)*time.Second.Milliseconds(), float64(i*100), nil) _, err := app.Append(0, lbls, int64(i*15)*time.Second.Milliseconds(), float64(i*100), storage.AppendHints{})
require.NoError(b, err) require.NoError(b, err)
} }
} }
@ -3530,7 +3530,7 @@ func BenchmarkHeadQuerier(b *testing.B) {
require.NoError(b, app.Commit()) require.NoError(b, app.Commit())
app = db.Appender(context.Background()) app = db.Appender(context.Background())
} }
_, err := app.Append(0, lbls, int64(i*15)*time.Second.Milliseconds(), float64(i*100), nil) _, err := app.Append(0, lbls, int64(i*15)*time.Second.Milliseconds(), float64(i*100), storage.AppendHints{})
require.NoError(b, err) require.NoError(b, err)
} }
} }

2
tsdb/testutil.go
View file

@ -53,7 +53,7 @@ var sampleTypeScenarios = map[string]sampleTypeScenario{
sampleType: sampleMetricTypeFloat, sampleType: sampleMetricTypeFloat,
appendFunc: func(appender storage.Appender, lbls labels.Labels, ts, value int64) (storage.SeriesRef, sample, error) { appendFunc: func(appender storage.Appender, lbls labels.Labels, ts, value int64) (storage.SeriesRef, sample, error) {
s := sample{t: ts, f: float64(value)} s := sample{t: ts, f: float64(value)}
ref, err := appender.Append(0, lbls, ts, s.f, nil) ref, err := appender.Append(0, lbls, ts, s.f, storage.AppendHints{})
return ref, s, err return ref, s, err
}, },
sampleFunc: func(ts, value int64) sample { sampleFunc: func(ts, value int64) sample {

2
tsdb/tsdbblockutil.go
View file

@ -70,7 +70,7 @@ func CreateBlock(series []storage.Series, dir string, chunkRange int64, logger *
switch typ { switch typ {
case chunkenc.ValFloat: case chunkenc.ValFloat:
t, v := it.At() t, v := it.At()
ref, err = app.Append(ref, lset, t, v, nil) ref, err = app.Append(ref, lset, t, v, storage.AppendHints{})
case chunkenc.ValHistogram: case chunkenc.ValHistogram:
t, h := it.AtHistogram(nil) t, h := it.AtHistogram(nil)
ref, err = app.AppendHistogram(ref, lset, t, h, nil, nil) ref, err = app.AppendHistogram(ref, lset, t, h, nil, nil)