diff --git a/cmd/prometheus/main.go b/cmd/prometheus/main.go
index 688d2c8774..e74e677d5c 100644
--- a/cmd/prometheus/main.go
+++ b/cmd/prometheus/main.go
@@ -1639,7 +1639,7 @@ func (s *readyStorage) Appender(ctx context.Context) storage.Appender {
 
 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
 }
 
diff --git a/cmd/promtool/backfill.go b/cmd/promtool/backfill.go
index eb21a4b08e..84c25bdbe1 100644
--- a/cmd/promtool/backfill.go
+++ b/cmd/promtool/backfill.go
@@ -27,6 +27,7 @@ import (
 
 	"github.com/prometheus/prometheus/model/labels"
 	"github.com/prometheus/prometheus/model/textparse"
+	"github.com/prometheus/prometheus/storage"
 	"github.com/prometheus/prometheus/tsdb"
 	tsdb_errors "github.com/prometheus/prometheus/tsdb/errors"
 )
@@ -171,7 +172,7 @@ func createBlocks(input []byte, mint, maxt, maxBlockDuration int64, maxSamplesIn
 				}
 				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)
 				}
 
diff --git a/rules/group.go b/rules/group.go
index 6695642a2a..54b9c21d8a 100644
--- a/rules/group.go
+++ b/rules/group.go
@@ -564,7 +564,7 @@ func (g *Group) Eval(ctx context.Context, ts time.Time) {
 				if s.H != nil {
 					_, err = app.AppendHistogram(0, s.Metric, s.T, nil, s.H, nil)
 				} 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 {
@@ -606,7 +606,7 @@ func (g *Group) Eval(ctx context.Context, ts time.Time) {
 			for metric, lset := range g.seriesInPreviousEval[i] {
 				if _, ok := seriesReturned[metric]; !ok {
 					// 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)
 					if unwrappedErr == nil {
 						unwrappedErr = err
@@ -663,7 +663,7 @@ func (g *Group) cleanupStaleSeries(ctx context.Context, ts time.Time) {
 	queryOffset := g.QueryOffset()
 	for _, s := range g.staleSeries {
 		// 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)
 		if unwrappedErr == nil {
 			unwrappedErr = err
diff --git a/scrape/helpers_test.go b/scrape/helpers_test.go
index 696e4200df..d03f9d3ee1 100644
--- a/scrape/helpers_test.go
+++ b/scrape/helpers_test.go
@@ -43,7 +43,7 @@ func (a nopAppendable) Appender(_ context.Context) storage.Appender {
 
 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
 }
 
@@ -114,7 +114,7 @@ type collectResultAppender struct {
 	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()
 	defer a.mtx.Unlock()
 	a.pendingFloats = append(a.pendingFloats, floatSample{
diff --git a/scrape/scrape.go b/scrape/scrape.go
index 9cd67d042d..a3f8d0e9d3 100644
--- a/scrape/scrape.go
+++ b/scrape/scrape.go
@@ -1752,7 +1752,7 @@ loop:
 					ref, err = app.AppendHistogram(ref, lset, t, nil, fh, nil)
 				}
 			} 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 {
 		sl.cache.forEachStale(func(lset labels.Labels) bool {
 			// 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 {
 			case errors.Is(err, storage.ErrOutOfOrderSample), errors.Is(err, storage.ErrDuplicateSampleForTimestamp):
 				// 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())
 	}
 
-	ref, err := app.Append(ref, lset, t, v, nil)
+	ref, err := app.Append(ref, lset, t, v, storage.AppendHints{})
 	switch {
 	case err == nil:
 		if !ok {
diff --git a/scrape/scrape_test.go b/scrape/scrape_test.go
index 78178efc02..b333db4b69 100644
--- a/scrape/scrape_test.go
+++ b/scrape/scrape_test.go
@@ -2328,7 +2328,7 @@ type errorAppender struct {
 	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) {
 	case "out_of_order":
 		return 0, storage.ErrOutOfOrderSample
diff --git a/scrape/target.go b/scrape/target.go
index b81d97f576..dbbba7e0d8 100644
--- a/scrape/target.go
+++ b/scrape/target.go
@@ -323,14 +323,14 @@ type limitAppender struct {
 	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) {
 		app.i++
 		if app.i > app.limit {
 			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 {
 		return 0, err
 	}
@@ -343,12 +343,12 @@ type timeLimitAppender struct {
 	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 {
 		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 {
 		return 0, err
 	}
diff --git a/storage/fanout.go b/storage/fanout.go
index 677d5080b0..9103f1171c 100644
--- a/storage/fanout.go
+++ b/storage/fanout.go
@@ -147,14 +147,14 @@ type fanoutAppender struct {
 	secondaries []Appender
 }
 
-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)
+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, AppendHints{})
 	if err != nil {
 		return ref, err
 	}
 
 	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
 		}
 	}
diff --git a/storage/interface.go b/storage/interface.go
index a591285d90..9ac4a23a5d 100644
--- a/storage/interface.go
+++ b/storage/interface.go
@@ -265,7 +265,7 @@ type Appender interface {
 	// to Append() at any point. Adding the sample via Append() returns a new
 	// reference number.
 	// 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
 	// returns a non-nil error, it also rolls back all modifications made in
diff --git a/storage/remote/write.go b/storage/remote/write.go
index d14f27e2b9..c2c9657405 100644
--- a/storage/remote/write.go
+++ b/storage/remote/write.go
@@ -286,7 +286,7 @@ type timestampTracker struct {
 }
 
 // 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++
 	if ts > t.highestTimestamp {
 		t.highestTimestamp = ts
diff --git a/storage/remote/write_handler.go b/storage/remote/write_handler.go
index 29005608c5..531339bb36 100644
--- a/storage/remote/write_handler.go
+++ b/storage/remote/write_handler.go
@@ -287,7 +287,7 @@ func (h *writeHandler) appendV1Samples(app storage.Appender, ss []prompb.Sample,
 	var ref storage.SeriesRef
 	var err error
 	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 errors.Is(err, storage.ErrOutOfOrderSample) ||
 				errors.Is(err, storage.ErrOutOfBounds) ||
@@ -395,7 +395,7 @@ func (h *writeHandler) appendV2(app storage.Appender, req *writev2.Request, rs *
 
 		// 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 {
 				rs.Samples++
 				continue
@@ -548,12 +548,12 @@ type timeLimitAppender struct {
 	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 {
 		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 {
 		return 0, err
 	}
diff --git a/storage/remote/write_handler_test.go b/storage/remote/write_handler_test.go
index a6fa6d1802..07a1cdcdf3 100644
--- a/storage/remote/write_handler_test.go
+++ b/storage/remote/write_handler_test.go
@@ -833,7 +833,7 @@ func (m *mockAppendable) Appender(_ context.Context) storage.Appender {
 	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 {
 		return 0, m.appendSampleErr
 	}
diff --git a/tsdb/agent/db.go b/tsdb/agent/db.go
index 61eaafe214..9060306b3f 100644
--- a/tsdb/agent/db.go
+++ b/tsdb/agent/db.go
@@ -783,7 +783,7 @@ type appender struct {
 	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.
 	headRef := chunks.HeadSeriesRef(ref)
 
diff --git a/tsdb/agent/db_test.go b/tsdb/agent/db_test.go
index 9331c0051d..b1b4d7693b 100644
--- a/tsdb/agent/db_test.go
+++ b/tsdb/agent/db_test.go
@@ -47,10 +47,10 @@ func TestDB_InvalidSeries(t *testing.T) {
 	app := s.Appender(context.Background())
 
 	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")
 
-		_, 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")
 	})
 
@@ -63,7 +63,7 @@ func TestDB_InvalidSeries(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")
 
 		_, err = app.AppendExemplar(0, labels.EmptyLabels(), exemplar.Exemplar{}, nil)
@@ -134,7 +134,7 @@ func TestCommit(t *testing.T) {
 
 		for i := 0; i < numDatapoints; i++ {
 			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)
 
 			e := exemplar.Exemplar{
@@ -249,7 +249,7 @@ func TestRollback(t *testing.T) {
 
 		for i := 0; i < numDatapoints; i++ {
 			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)
 		}
 	}
@@ -365,7 +365,7 @@ func TestFullTruncateWAL(t *testing.T) {
 		lset := labels.New(l...)
 
 		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, app.Commit())
@@ -427,7 +427,7 @@ func TestPartialTruncateWAL(t *testing.T) {
 		lset := labels.New(l...)
 
 		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, app.Commit())
@@ -466,7 +466,7 @@ func TestPartialTruncateWAL(t *testing.T) {
 		lset := labels.New(l...)
 
 		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, app.Commit())
@@ -521,7 +521,7 @@ func TestWALReplay(t *testing.T) {
 		lset := labels.New(l...)
 
 		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)
 		}
 	}
@@ -618,7 +618,7 @@ func Test_ExistingWAL_NextRef(t *testing.T) {
 	app := db.Appender(context.Background())
 	for i := 0; i < seriesCount; 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)
 	}
 
@@ -707,7 +707,7 @@ func TestStorage_DuplicateExemplarsIgnored(t *testing.T) {
 	app := s.Appender(context.Background())
 	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")
 
 	// Write a few exemplars to our appender and call Commit().
@@ -774,7 +774,7 @@ func TestDBAllowOOOSamples(t *testing.T) {
 		lset := labels.New(l...)
 
 		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)
 
 			e := exemplar.Exemplar{
@@ -838,7 +838,7 @@ func TestDBAllowOOOSamples(t *testing.T) {
 		lset := labels.New(l...)
 
 		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)
 
 			e := exemplar.Exemplar{
@@ -914,11 +914,11 @@ func TestDBOutOfOrderTimeWindow(t *testing.T) {
 
 			lbls = labelsForTest(t.Name(), 1)
 			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)
 			err = app.Commit()
 			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)
 
 			expectedAppendedSamples := float64(2)
diff --git a/tsdb/block_test.go b/tsdb/block_test.go
index 7c98616dbf..bc3792caf9 100644
--- a/tsdb/block_test.go
+++ b/tsdb/block_test.go
@@ -680,7 +680,7 @@ func createHead(tb testing.TB, w *wlog.WL, series []storage.Series, chunkDir str
 			switch typ {
 			case chunkenc.ValFloat:
 				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:
 				t, h := it.AtHistogram(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})
 				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, it.Err())
@@ -744,7 +744,7 @@ func createHeadWithOOOSamples(tb testing.TB, w *wlog.WL, series []storage.Series
 	for i, lset := range oooSampleLabels {
 		ref := storage.SeriesRef(0)
 		for _, sample := range oooSamples[i] {
-			ref, err = app.Append(ref, lset, sample.T(), sample.F(), nil)
+			ref, err = app.Append(ref, lset, sample.T(), sample.F(), storage.AppendHints{})
 			require.NoError(tb, err)
 			oooSamplesAppended++
 		}
diff --git a/tsdb/blockwriter_test.go b/tsdb/blockwriter_test.go
index 971d43d6cb..1bad3abc98 100644
--- a/tsdb/blockwriter_test.go
+++ b/tsdb/blockwriter_test.go
@@ -24,6 +24,7 @@ import (
 	"github.com/prometheus/common/promslog"
 
 	"github.com/prometheus/prometheus/model/labels"
+	"github.com/prometheus/prometheus/storage"
 	"github.com/prometheus/prometheus/tsdb/chunks"
 )
 
@@ -36,10 +37,10 @@ func TestBlockWriter(t *testing.T) {
 	// Add some series.
 	app := w.Appender(ctx)
 	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)
 	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, app.Commit())
 	id, err := w.Flush(ctx)
diff --git a/tsdb/compact_test.go b/tsdb/compact_test.go
index 66b403aff7..89ce95069b 100644
--- a/tsdb/compact_test.go
+++ b/tsdb/compact_test.go
@@ -1190,7 +1190,7 @@ func BenchmarkCompactionFromHead(b *testing.B) {
 			for ln := 0; ln < labelNames; ln++ {
 				app := h.Appender(context.Background())
 				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())
 			}
@@ -1223,10 +1223,10 @@ func BenchmarkCompactionFromOOOHead(b *testing.B) {
 				app := h.Appender(context.Background())
 				for lv := 0; lv < labelValues; lv++ {
 					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)
 					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)
 					}
 				}
@@ -1263,9 +1263,9 @@ func TestDisableAutoCompactions(t *testing.T) {
 	db.DisableCompactions()
 	app := db.Appender(context.Background())
 	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)
-		_, 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, app.Commit())
@@ -1379,11 +1379,11 @@ func TestDeleteCompactionBlockAfterFailedReload(t *testing.T) {
 
 			// Add some data to the head that is enough to trigger a compaction.
 			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)
-			_, err = app.Append(0, defaultLabel, 2, 0, nil)
+			_, err = app.Append(0, defaultLabel, 2, 0, storage.AppendHints{})
 			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, app.Commit())
 
@@ -1489,7 +1489,7 @@ func TestHeadCompactionWithHistograms(t *testing.T) {
 				t.Helper()
 				app := head.Appender(ctx)
 				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)
 					*exp = append(*exp, sample{t: minute(tsMinute), f: float64(tsMinute)})
 				}
@@ -1711,20 +1711,20 @@ func TestSparseHistogramSpaceSavings(t *testing.T) {
 								numOldSeriesPerHistogram++
 								b := it.At()
 								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)
 								itIdx++
 							}
 							baseName := ah.baseLabels.Get(labels.MetricName)
 							// _count metric.
 							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)
 							numOldSeriesPerHistogram++
 
 							// _sum metric.
 							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)
 							numOldSeriesPerHistogram++
 						}
@@ -1999,11 +1999,11 @@ func TestDelayedCompaction(t *testing.T) {
 			// The first compaction is expected to result in 1 block.
 			db.DisableCompactions()
 			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)
-			_, err = app.Append(0, label, 11, 0, nil)
+			_, err = app.Append(0, label, 11, 0, storage.AppendHints{})
 			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, app.Commit())
 
@@ -2030,9 +2030,9 @@ func TestDelayedCompaction(t *testing.T) {
 			// This also ensures that no delay happens between consecutive compactions.
 			db.DisableCompactions()
 			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)
-			_, err = app.Append(0, label, 41, 0, nil)
+			_, err = app.Append(0, label, 41, 0, storage.AppendHints{})
 			require.NoError(t, err)
 			require.NoError(t, app.Commit())
 
@@ -2065,7 +2065,7 @@ func TestDelayedCompaction(t *testing.T) {
 
 			db.DisableCompactions()
 			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, app.Commit())
 
@@ -2133,9 +2133,9 @@ func TestDelayedCompactionDoesNotBlockUnrelatedOps(t *testing.T) {
 			if c.whenCompactable {
 				label := labels.FromStrings("foo", "bar")
 				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)
-				_, err = app.Append(0, label, 317, 0, nil)
+				_, err = app.Append(0, label, 317, 0, storage.AppendHints{})
 				require.NoError(t, err)
 				require.NoError(t, app.Commit())
 				// The Head is compactable and will still be at the end.
diff --git a/tsdb/db_test.go b/tsdb/db_test.go
index 15ab41c795..ead781dc9d 100644
--- a/tsdb/db_test.go
+++ b/tsdb/db_test.go
@@ -216,7 +216,7 @@ func TestDataAvailableOnlyAfterCommit(t *testing.T) {
 	ctx := context.Background()
 	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)
 
 	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.
 		for i := 0; i < 121; i++ {
 			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})
 			require.NoError(t, err)
 			require.NoError(t, app.Commit())
@@ -300,7 +300,7 @@ func TestDataNotAvailableAfterRollback(t *testing.T) {
 	}()
 
 	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)
 
 	err = app.Rollback()
@@ -324,11 +324,11 @@ func TestDBAppenderAddRef(t *testing.T) {
 	ctx := context.Background()
 	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)
 
 	// 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.Equal(t, ref1, ref2)
 
@@ -338,21 +338,21 @@ func TestDBAppenderAddRef(t *testing.T) {
 	app2 := db.Appender(ctx)
 
 	// 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.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.Equal(t, ref1, ref4)
 
 	// 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.Equal(t, ref1, ref5)
 
 	// 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.NoError(t, app2.Commit())
@@ -382,11 +382,11 @@ func TestAppendEmptyLabelsIgnored(t *testing.T) {
 	ctx := context.Background()
 	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)
 
 	// 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)
 
 	// Should be the same series.
@@ -438,7 +438,7 @@ Outer:
 		smpls := make([]float64, numSamples)
 		for i := int64(0); i < numSamples; i++ {
 			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())
@@ -494,14 +494,14 @@ func TestAmendHistogramDatapointCausesError(t *testing.T) {
 
 	ctx := context.Background()
 	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, app.Commit())
 
 	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)
-	_, 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.NoError(t, app.Rollback())
 
@@ -555,12 +555,12 @@ func TestDuplicateNaNDatapointNoAmendError(t *testing.T) {
 
 	ctx := context.Background()
 	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, app.Commit())
 
 	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)
 }
 
@@ -572,12 +572,12 @@ func TestNonDuplicateNaNDatapointsCausesAmendError(t *testing.T) {
 
 	ctx := context.Background()
 	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, app.Commit())
 
 	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)
 }
 
@@ -589,7 +589,7 @@ func TestEmptyLabelsetCausesError(t *testing.T) {
 
 	ctx := context.Background()
 	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.Equal(t, "empty labelset: invalid sample", err.Error())
 }
@@ -603,9 +603,9 @@ func TestSkippingInvalidValuesInSameTxn(t *testing.T) {
 	// Append AmendedValue.
 	ctx := context.Background()
 	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)
-	_, 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, app.Commit())
 
@@ -621,9 +621,9 @@ func TestSkippingInvalidValuesInSameTxn(t *testing.T) {
 
 	// Append Out of Order Value.
 	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)
-	_, 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, app.Commit())
 
@@ -645,7 +645,7 @@ func TestDB_Snapshot(t *testing.T) {
 	app := db.Appender(ctx)
 	mint := int64(1414141414000)
 	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, app.Commit())
@@ -691,7 +691,7 @@ func TestDB_Snapshot_ChunksOutsideOfCompactedRange(t *testing.T) {
 	app := db.Appender(ctx)
 	mint := int64(1414141414000)
 	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, app.Commit())
@@ -744,7 +744,7 @@ func TestDB_SnapshotWithDelete(t *testing.T) {
 	smpls := make([]float64, numSamples)
 	for i := int64(0); i < numSamples; i++ {
 		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())
@@ -892,7 +892,7 @@ func TestDB_e2e(t *testing.T) {
 
 			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)
 
 			ts += rand.Int63n(timeInterval) + 1
@@ -987,7 +987,7 @@ func TestWALFlushedOnDBClose(t *testing.T) {
 
 	ctx := context.Background()
 	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, app.Commit())
 
@@ -1065,10 +1065,10 @@ func TestWALSegmentSizeOptions(t *testing.T) {
 
 			for i := int64(0); i < 155; i++ {
 				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)
 				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, app.Commit())
@@ -1127,7 +1127,7 @@ func testWALReplayRaceOnSamplesLoggedBeforeSeries(t *testing.T, numSamplesBefore
 		lbls := labels.FromStrings("series_id", strconv.Itoa(seriesRef))
 
 		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, app.Commit())
@@ -1179,7 +1179,7 @@ func TestTombstoneClean(t *testing.T) {
 	smpls := make([]float64, numSamples)
 	for i := int64(0); i < numSamples; i++ {
 		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())
@@ -1273,7 +1273,7 @@ func TestTombstoneCleanResultEmptyBlock(t *testing.T) {
 	smpls := make([]float64, numSamples)
 	for i := int64(0); i < numSamples; i++ {
 		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())
@@ -1573,7 +1573,7 @@ func TestSizeRetention(t *testing.T) {
 			it = s.Iterator(it)
 			for it.Next() == chunkenc.ValFloat {
 				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, it.Err())
@@ -1631,7 +1631,7 @@ func TestSizeRetention(t *testing.T) {
 	// Add some out of order samples to check the size of WBL.
 	headApp = db.Head().Appender(context.Background())
 	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, headApp.Commit())
@@ -1714,7 +1714,7 @@ func TestNotMatcherSelectsLabelsUnsetSeries(t *testing.T) {
 	ctx := context.Background()
 	app := db.Appender(ctx)
 	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, app.Commit())
@@ -1900,9 +1900,9 @@ func TestChunkAtBlockBoundary(t *testing.T) {
 	label := labels.FromStrings("foo", "bar")
 
 	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)
-		_, 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)
 	}
 
@@ -1956,9 +1956,9 @@ func TestQuerierWithBoundaryChunks(t *testing.T) {
 	label := labels.FromStrings("foo", "bar")
 
 	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)
-		_, 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)
 	}
 
@@ -2003,7 +2003,7 @@ func TestInitializeHeadTimestamp(t *testing.T) {
 		// First added sample initializes the writable range.
 		ctx := context.Background()
 		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.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) {
 		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)
-		_, err = app.Append(0, defaultLabel, 2, 0, nil)
+		_, err = app.Append(0, defaultLabel, 2, 0, storage.AppendHints{})
 		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, app.Commit())
 		require.NoError(t, db.Delete(ctx, math.MinInt64, math.MaxInt64, defaultMatcher))
@@ -2129,16 +2129,16 @@ func TestNoEmptyBlocks(t *testing.T) {
 		require.Empty(t, actBlocks)
 
 		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")
 
 		// Adding new blocks.
 		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)
-		_, err = app.Append(0, defaultLabel, currentTime+1, 0, nil)
+		_, err = app.Append(0, defaultLabel, currentTime+1, 0, storage.AppendHints{})
 		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, app.Commit())
 
@@ -2155,11 +2155,11 @@ func TestNoEmptyBlocks(t *testing.T) {
 		oldBlocks := db.Blocks()
 		app := db.Appender(ctx)
 		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)
-		_, err = app.Append(0, defaultLabel, currentTime+1, 0, nil)
+		_, err = app.Append(0, defaultLabel, currentTime+1, 0, storage.AppendHints{})
 		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, app.Commit())
 		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 _, tuple := range sampleLabels {
 				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)
 			}
 		}
@@ -2310,7 +2310,7 @@ func TestCorrectNumTombstones(t *testing.T) {
 	app := db.Appender(ctx)
 	for i := int64(0); i < 3; i++ {
 		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)
 		}
 	}
@@ -2362,14 +2362,14 @@ func TestBlockRanges(t *testing.T) {
 
 	app := db.Appender(ctx)
 	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")
-	_, 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)
-	_, 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)
 	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, app.Commit())
@@ -2388,13 +2388,13 @@ func TestBlockRanges(t *testing.T) {
 	// and compaction doesn't create an overlapping block.
 	app = db.Appender(ctx)
 	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)
-	_, 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)
-	_, 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)
-	_, 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, app.Commit())
 	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")
 
 	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, app.Commit())
 	for x := 0; x < 100; x++ {
@@ -2472,7 +2472,7 @@ func TestDBReadOnly(t *testing.T) {
 		dbSizeBeforeAppend, err := fileutil.DirSize(dbWritable.Dir())
 		require.NoError(t, err)
 		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, app.Commit())
 
@@ -2583,7 +2583,7 @@ func TestDBReadOnly_FlushWAL(t *testing.T) {
 		app := db.Appender(ctx)
 		maxt = 1000
 		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, app.Commit())
@@ -2668,7 +2668,7 @@ func TestDBReadOnly_Querier_NoAlteration(t *testing.T) {
 		// Append until the first mmapped head chunk.
 		for i := 0; i < 121; i++ {
 			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, app.Commit())
 		}
@@ -2725,7 +2725,7 @@ func TestDBCannotSeePartialCommits(t *testing.T) {
 			app := db.Appender(ctx)
 
 			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)
 			}
 			err = app.Commit()
@@ -2791,7 +2791,7 @@ func TestDBQueryDoesntSeeAppendsAfterCreation(t *testing.T) {
 
 	ctx := context.Background()
 	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)
 
 	querierAfterAddButBeforeCommit, err := db.Querier(0, 1000000)
@@ -3119,7 +3119,7 @@ func TestCompactHead(t *testing.T) {
 	maxt := 100
 	for i := 0; i < maxt; i++ {
 		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)
 		expSamples = append(expSamples, sample{int64(i), val, nil, nil})
 	}
@@ -3165,7 +3165,7 @@ func TestCompactHeadWithDeletion(t *testing.T) {
 	ctx := context.Background()
 
 	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, app.Commit())
 
@@ -3341,9 +3341,9 @@ func TestOneCheckpointPerCompactCall(t *testing.T) {
 	// Append samples spanning 59 block ranges.
 	app := db.Appender(context.Background())
 	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)
-		_, 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)
 		// Rotate the WAL file so that there is >3 files for checkpoint to happen.
 		_, err = db.head.wal.NextSegment()
@@ -3401,7 +3401,7 @@ func TestOneCheckpointPerCompactCall(t *testing.T) {
 
 	// Adding sample way into the future.
 	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, app.Commit())
 
@@ -3507,7 +3507,7 @@ func testQuerierShouldNotPanicIfHeadChunkIsTruncatedWhileReadingQueriedChunks(t
 		app := db.Appender(ctx)
 
 		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)
 		}
 
@@ -3523,7 +3523,7 @@ func testQuerierShouldNotPanicIfHeadChunkIsTruncatedWhileReadingQueriedChunks(t
 		app := db.Appender(ctx)
 
 		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)
 		}
 
@@ -3643,7 +3643,7 @@ func testChunkQuerierShouldNotPanicIfHeadChunkIsTruncatedWhileReadingQueriedChun
 		app := db.Appender(ctx)
 
 		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)
 		}
 
@@ -3659,7 +3659,7 @@ func testChunkQuerierShouldNotPanicIfHeadChunkIsTruncatedWhileReadingQueriedChun
 		app := db.Appender(ctx)
 
 		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)
 		}
 
@@ -3746,7 +3746,7 @@ func TestQuerierShouldNotFailIfOOOCompactionOccursAfterRetrievingQuerier(t *test
 	// Push samples after the OOO sample we'll write below.
 	for ; ts < 10*interval; ts += interval {
 		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, app.Commit())
 		samplesWritten++
@@ -3754,7 +3754,7 @@ func TestQuerierShouldNotFailIfOOOCompactionOccursAfterRetrievingQuerier(t *test
 
 	// Push a single OOO sample.
 	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, app.Commit())
 	samplesWritten++
@@ -3840,7 +3840,7 @@ func TestQuerierShouldNotFailIfOOOCompactionOccursAfterSelecting(t *testing.T) {
 	// Push samples after the OOO sample we'll write below.
 	for ; ts < 10*interval; ts += interval {
 		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, app.Commit())
 		samplesWritten++
@@ -3848,7 +3848,7 @@ func TestQuerierShouldNotFailIfOOOCompactionOccursAfterSelecting(t *testing.T) {
 
 	// Push a single OOO sample.
 	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, app.Commit())
 	samplesWritten++
@@ -3922,7 +3922,7 @@ func TestQuerierShouldNotFailIfOOOCompactionOccursAfterRetrievingIterators(t *te
 	// Push samples after the OOO sample we'll write below.
 	for ; ts < 10*interval; ts += interval {
 		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, app.Commit())
 		samplesWritten++
@@ -3930,7 +3930,7 @@ func TestQuerierShouldNotFailIfOOOCompactionOccursAfterRetrievingIterators(t *te
 
 	// Push a single OOO sample.
 	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, app.Commit())
 	samplesWritten++
@@ -4009,7 +4009,7 @@ func TestOOOWALWrite(t *testing.T) {
 	}{
 		"float": {
 			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)
 				return seriesRef, nil
 			},
@@ -4416,7 +4416,7 @@ func TestDBPanicOnMmappingHeadChunk(t *testing.T) {
 		var ref storage.SeriesRef
 		lbls := labels.FromStrings("__name__", "testing", "foo", "bar")
 		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)
 			lastTs += itvl
 			if i%10 == 0 {
@@ -4474,7 +4474,7 @@ func TestMetadataInWAL(t *testing.T) {
 	s4 := labels.FromStrings("g", "h")
 
 	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, app.Commit())
@@ -4540,7 +4540,7 @@ func TestMetadataCheckpointingOnlyKeepsLatestEntry(t *testing.T) {
 	s4 := labels.FromStrings("g", "h")
 
 	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, app.Commit())
@@ -4643,7 +4643,7 @@ func TestMetadataAssertInMemoryData(t *testing.T) {
 	s4 := labels.FromStrings("g", "h")
 
 	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, app.Commit())
@@ -4730,7 +4730,7 @@ func TestMultipleEncodingsCommitOrder(t *testing.T) {
 
 	addSample := func(app storage.Appender, ts int64, valType chunkenc.ValueType) chunks.Sample {
 		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)
 			return sample{t: ts, f: float64(ts)}
 		}
@@ -5418,7 +5418,7 @@ func TestQuerierOOOQuery(t *testing.T) {
 	}{
 		"float": {
 			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 {
 				return sample{t: ts, f: float64(ts)}
@@ -5734,7 +5734,7 @@ func TestChunkQuerierOOOQuery(t *testing.T) {
 	}{
 		"float": {
 			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 {
 				return sample{t: ts, f: float64(ts)}
@@ -7186,7 +7186,7 @@ func TestWBLCorruption(t *testing.T) {
 		app := db.Appender(context.Background())
 		for m := fromMins; m <= toMins; m++ {
 			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)
 			allSamples = append(allSamples, sample{t: ts, f: float64(ts)})
 			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) {
 		t.Helper()
 		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, app.Commit())
 		*exp = append(*exp, sample{t: minute(tsMinute), f: val})
@@ -8672,7 +8672,7 @@ func TestChunkQuerierReadWriteRace(t *testing.T) {
 			app := db.Appender(context.Background())
 			for j := 0; j < 10; j++ {
 				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 {
 					return err
 				}
diff --git a/tsdb/example_test.go b/tsdb/example_test.go
index 3bce640f3c..f2d496b1ff 100644
--- a/tsdb/example_test.go
+++ b/tsdb/example_test.go
@@ -21,6 +21,7 @@ import (
 	"time"
 
 	"github.com/prometheus/prometheus/model/labels"
+	"github.com/prometheus/prometheus/storage"
 	"github.com/prometheus/prometheus/tsdb/chunkenc"
 )
 
@@ -40,13 +41,13 @@ func Example() {
 	series := labels.FromStrings("foo", "bar")
 
 	// 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)
 
 	// Another append for a second later.
 	// Re-using the ref from above since it's the same series, makes append faster.
 	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)
 
 	// Commit to storage.
diff --git a/tsdb/head_append.go b/tsdb/head_append.go
index f5440a3044..06fc66d8af 100644
--- a/tsdb/head_append.go
+++ b/tsdb/head_append.go
@@ -40,14 +40,14 @@ type initAppender struct {
 
 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 {
-		return a.app.Append(ref, lset, t, v, nil)
+		return a.app.Append(ref, l, t, v, storage.AppendHints{})
 	}
 
 	a.head.initTime(t)
 	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) {
@@ -328,7 +328,7 @@ type headAppender struct {
 	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.
 	// 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 {
@@ -339,7 +339,7 @@ func (a *headAppender) Append(ref storage.SeriesRef, lset labels.Labels, t int64
 	s := a.head.series.getByID(chunks.HeadSeriesRef(ref))
 	if s == nil {
 		var err error
-		s, _, err = a.getOrCreate(lset)
+		s, _, err = a.getOrCreate(l)
 		if err != nil {
 			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().
 		switch {
 		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:
-			return a.AppendHistogram(ref, lset, t, nil, &histogram.FloatHistogram{Sum: v}, nil)
+			return a.AppendHistogram(ref, l, t, nil, &histogram.FloatHistogram{Sum: v}, nil)
 		}
 	}
 
diff --git a/tsdb/head_read_test.go b/tsdb/head_read_test.go
index beff329e7c..087b7a9178 100644
--- a/tsdb/head_read_test.go
+++ b/tsdb/head_read_test.go
@@ -21,6 +21,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/prometheus/prometheus/model/labels"
+	"github.com/prometheus/prometheus/storage"
 	"github.com/prometheus/prometheus/tsdb/chunkenc"
 	"github.com/prometheus/prometheus/tsdb/chunks"
 )
@@ -421,7 +422,7 @@ func TestHeadIndexReader_PostingsForLabelMatching(t *testing.T) {
 		})
 		app := h.Appender(context.Background())
 		for _, s := range series {
-			app.Append(0, s, 0, 0, nil)
+			app.Append(0, s, 0, 0, storage.AppendHints{})
 		}
 		require.NoError(t, app.Commit())
 
diff --git a/tsdb/head_test.go b/tsdb/head_test.go
index 20f0a9da2f..05ea96eb5a 100644
--- a/tsdb/head_test.go
+++ b/tsdb/head_test.go
@@ -107,6 +107,9 @@ func BenchmarkCreateSeries(b *testing.B) {
 func BenchmarkHeadAppender_Append_Commit_ExistingSeries(b *testing.B) {
 	seriesCounts := []int{100, 1000, 10000}
 	series := genSeries(10000, 10, 0, 0)
+	hints := storage.AppendHints{
+		DiscardOutOfOrder: false,
+	}
 
 	for _, seriesCount := range seriesCounts {
 		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] {
 							var ref storage.SeriesRef
 							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 {
 									return err
 								}
@@ -536,7 +539,7 @@ func TestHead_HighConcurrencyReadAndWrite(t *testing.T) {
 				app := head.Appender(ctx)
 				for i := 0; i < len(workerLabelSets); i++ {
 					// 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 {
 						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))
 
 	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, app.Commit())
 	require.Equal(t, 1.0, prom_testutil.ToFloat64(head.metrics.chunksCreated))
 
 	// Add another sample outside chunk range to mmap a chunk.
 	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, app.Commit())
 	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))
 
 	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, app.Commit())
 	require.Equal(t, 3.0, prom_testutil.ToFloat64(head.metrics.chunksCreated))
 
 	// Add another sample outside chunk range to mmap a chunk.
 	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, app.Commit())
 	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.
 	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.Equal(t, 1.0, prom_testutil.ToFloat64(head.metrics.activeAppenders))
 	require.NoError(t, app.Rollback())
@@ -827,7 +830,7 @@ func TestHead_ActiveAppenders(t *testing.T) {
 
 	// Now commit with one sample.
 	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, app.Commit())
 	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())
 				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, app.Commit())
@@ -1326,7 +1329,7 @@ func TestHeadDeleteSimple(t *testing.T) {
 				// Add more samples.
 				app = head.Appender(context.Background())
 				for _, smpl := range c.addSamples {
-					_, err := app.Append(0, lblsDefault, smpl.t, smpl.f, nil)
+					_, err := app.Append(0, lblsDefault, smpl.t, smpl.f, storage.AppendHints{})
 					require.NoError(t, err)
 				}
 				require.NoError(t, app.Commit())
@@ -1397,7 +1400,7 @@ func TestDeleteUntilCurMax(t *testing.T) {
 	smpls := make([]float64, numSamples)
 	for i := int64(0); i < numSamples; i++ {
 		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, app.Commit())
@@ -1418,7 +1421,7 @@ func TestDeleteUntilCurMax(t *testing.T) {
 
 	// Add again and test for presence.
 	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, app.Commit())
 	q, err = NewBlockQuerier(hb, 0, 100000)
@@ -1444,7 +1447,7 @@ func TestDeletedSamplesAndSeriesStillInWALAfterCheckpoint(t *testing.T) {
 
 	for i := 0; i < numSamples; i++ {
 		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, app.Commit())
 	}
@@ -1544,7 +1547,7 @@ func TestDelete_e2e(t *testing.T) {
 		ts := rand.Int63n(300)
 		for i := 0; i < numDatapoints; i++ {
 			v := rand.Float64()
-			_, err := app.Append(0, ls, ts, v, nil)
+			_, err := app.Append(0, ls, ts, v, storage.AppendHints{})
 			require.NoError(t, err)
 			series = append(series, sample{ts, v, nil, nil})
 			ts += rand.Int63n(timeInterval) + 1
@@ -2027,7 +2030,7 @@ func TestUncommittedSamplesNotLostOnTruncate(t *testing.T) {
 
 	app := h.appender()
 	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, h.Truncate(2000))
@@ -2057,7 +2060,7 @@ func TestRemoveSeriesAfterRollbackAndTruncate(t *testing.T) {
 
 	app := h.appender()
 	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, h.Truncate(2000))
@@ -2087,7 +2090,7 @@ func TestHead_LogRollback(t *testing.T) {
 			}()
 
 			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, app.Rollback())
@@ -2117,7 +2120,7 @@ func TestHead_ReturnsSortedLabelValues(t *testing.T) {
 				"__name__", fmt.Sprintf("metric_%d", i),
 				"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)
 		}
 	}
@@ -2382,7 +2385,7 @@ func TestNewWalSegmentOnTruncate(t *testing.T) {
 	}()
 	add := func(ts int64) {
 		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, app.Commit())
 	}
@@ -2413,7 +2416,7 @@ func TestAddDuplicateLabelName(t *testing.T) {
 
 	add := func(labels labels.Labels, labelName string) {
 		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))
 	}
 
@@ -2477,7 +2480,7 @@ func TestMemSeriesIsolation(t *testing.T) {
 				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, app.Commit())
 			h.mmapHeadChunks()
@@ -2506,7 +2509,7 @@ func TestMemSeriesIsolation(t *testing.T) {
 	// Cleanup appendIDs below 500.
 	app := hb.appender()
 	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, app.Commit())
 	i++
@@ -2525,7 +2528,7 @@ func TestMemSeriesIsolation(t *testing.T) {
 	// the only thing with appendIDs.
 	app = hb.appender()
 	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, app.Commit())
 	require.Equal(t, 999, lastValue(hb, 998))
@@ -2539,7 +2542,7 @@ func TestMemSeriesIsolation(t *testing.T) {
 	// Cleanup appendIDs below 1001, but with a rollback.
 	app = hb.appender()
 	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, app.Rollback())
 	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
 	// the only thing with appendIDs.
 	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++
 	require.NoError(t, err)
 	require.NoError(t, app.Commit())
@@ -2588,7 +2591,7 @@ func TestMemSeriesIsolation(t *testing.T) {
 
 	// Cleanup appendIDs below 1002, but with a rollback.
 	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, app.Rollback())
 	require.Equal(t, 1001, lastValue(hb, 999))
@@ -2610,21 +2613,21 @@ func TestIsolationRollback(t *testing.T) {
 	}()
 
 	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, app.Commit())
 	require.Equal(t, uint64(1), hb.iso.lowWatermark())
 
 	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)
-	_, 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.NoError(t, app.Rollback())
 	require.Equal(t, uint64(2), hb.iso.lowWatermark())
 
 	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, app.Commit())
 	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())
-	_, 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, app1.Commit())
 	require.Equal(t, uint64(1), hb.iso.lowWatermark(), "Low watermark should by 1 after 1st append.")
 
 	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.Equal(t, uint64(2), hb.iso.lowWatermark(), "Low watermark should be two, even if append is not committed yet.")
 
 	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, app2.Commit())
 	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())
 
 	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, app.Commit())
 
@@ -2835,10 +2838,10 @@ func testHeadSeriesChunkRace(t *testing.T) {
 	require.NoError(t, h.Init(0))
 	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)
 	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, app.Commit())
@@ -2886,7 +2889,7 @@ func TestHeadLabelNamesValuesWithMinMaxRange(t *testing.T) {
 
 	app := head.Appender(ctx)
 	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, app.Commit())
@@ -2934,7 +2937,7 @@ func TestHeadLabelValuesWithMatchers(t *testing.T) {
 		_, err := app.Append(0, labels.FromStrings(
 			"tens", fmt.Sprintf("value%d", i/10),
 			"unique", fmt.Sprintf("value%d", i),
-		), 100, 0, nil)
+		), 100, 0, storage.AppendHints{})
 		require.NoError(t, err)
 	}
 	require.NoError(t, app.Commit())
@@ -3009,14 +3012,14 @@ func TestHeadLabelNamesWithMatchers(t *testing.T) {
 	for i := 0; i < 100; i++ {
 		_, err := app.Append(0, labels.FromStrings(
 			"unique", fmt.Sprintf("value%d", i),
-		), 100, 0, nil)
+		), 100, 0, storage.AppendHints{})
 		require.NoError(t, err)
 
 		if i%10 == 0 {
 			_, err := app.Append(0, labels.FromStrings(
 				"tens", fmt.Sprintf("value%d", i/10),
 				"unique", fmt.Sprintf("value%d", i),
-			), 100, 0, nil)
+			), 100, 0, storage.AppendHints{})
 			require.NoError(t, err)
 		}
 
@@ -3025,7 +3028,7 @@ func TestHeadLabelNamesWithMatchers(t *testing.T) {
 				"tens", fmt.Sprintf("value%d", i/10),
 				"twenties", fmt.Sprintf("value%d", i/20),
 				"unique", fmt.Sprintf("value%d", i),
-			), 100, 0, nil)
+			), 100, 0, storage.AppendHints{})
 			require.NoError(t, err)
 		}
 	}
@@ -3080,7 +3083,7 @@ func TestHeadShardedPostings(t *testing.T) {
 	// Append some series.
 	app := head.Appender(ctx)
 	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, app.Commit())
@@ -3139,28 +3142,28 @@ func TestErrReuseAppender(t *testing.T) {
 	}()
 
 	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, app.Commit())
 	require.Error(t, app.Commit())
 	require.Error(t, app.Rollback())
 
 	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, app.Rollback())
 	require.Error(t, app.Rollback())
 	require.Error(t, app.Commit())
 
 	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, app.Commit())
 	require.Error(t, app.Rollback())
 	require.Error(t, app.Commit())
 
 	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, app.Rollback())
 	require.Error(t, app.Commit())
@@ -3172,11 +3175,11 @@ func TestHeadMintAfterTruncation(t *testing.T) {
 	head, _ := newTestHead(t, chunkRange, wlog.CompressionNone, false)
 
 	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)
-	_, 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)
-	_, 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, app.Commit())
 
@@ -3210,7 +3213,7 @@ func TestHeadExemplars(t *testing.T) {
 	// 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
 	// 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)
 	_, err = app.AppendExemplar(ref, l, exemplar.Exemplar{
 		Labels: l,
@@ -3238,7 +3241,7 @@ func BenchmarkHeadLabelValuesWithMatchers(b *testing.B) {
 			"a_unique", fmt.Sprintf("value%d", i),
 			"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"
-		), 100, 0, nil)
+		), 100, 0, storage.AppendHints{})
 		require.NoError(b, err)
 	}
 	require.NoError(b, app.Commit())
@@ -3339,7 +3342,7 @@ func TestChunkNotFoundHeadGCRace(t *testing.T) {
 	// 7 chunks with 15s scrape interval.
 	for i := int64(0); i <= 120*7; i++ {
 		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)
 		maxt = ts
 	}
@@ -3406,7 +3409,7 @@ func TestDataMissingOnQueryDuringCompaction(t *testing.T) {
 	// 7 chunks with 15s scrape interval.
 	for i := int64(0); i <= 120*7; i++ {
 		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)
 		maxt = ts
 		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++ {
-		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, app.Commit())
@@ -3496,7 +3499,7 @@ func TestWaitForPendingReadersInTimeRange(t *testing.T) {
 
 	for i := int64(0); i <= 3000; 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, 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.
 	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)
 	}
 	// Add out-of-order samples at every 100ms starting at 50ms.
 	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, app.Commit())
@@ -3875,7 +3878,7 @@ func TestHistogramInWALAndMmapChunk(t *testing.T) {
 				// Add some float.
 				for i := 0; i < 10; i++ {
 					ts++
-					_, err := app.Append(0, s2, ts, float64(ts), nil)
+					_, err := app.Append(0, s2, ts, float64(ts), storage.AppendHints{})
 					require.NoError(t, err)
 					exp[k2] = append(exp[k2], sample{t: ts, f: float64(ts)})
 				}
@@ -3911,7 +3914,7 @@ func TestHistogramInWALAndMmapChunk(t *testing.T) {
 				// Add some float.
 				for i := 0; i < 10; i++ {
 					ts++
-					_, err := app.Append(0, s2, ts, float64(ts), nil)
+					_, err := app.Append(0, s2, ts, float64(ts), storage.AppendHints{})
 					require.NoError(t, err)
 					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++ {
 				val := rand.Float64()
 				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)
 
 				hist := histograms[int(ts)]
@@ -4149,7 +4152,7 @@ func TestChunkSnapshot(t *testing.T) {
 			for ts := int64(241); ts <= 480; ts++ {
 				val := rand.Float64()
 				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)
 
 				hist := histograms[int(ts)]
@@ -4250,7 +4253,7 @@ func TestSnapshotError(t *testing.T) {
 	// Add a sample.
 	app := head.Appender(context.Background())
 	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)
 
 	// Add histograms
@@ -4499,7 +4502,7 @@ func testHistogramStaleSampleHelper(t *testing.T, floatHistogram bool) {
 		require.NoError(t, err)
 	}
 	// +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)
 	if floatHistogram {
 		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())
 	// +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)
 	if floatHistogram {
 		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 {
 				_, err = app.AppendHistogram(0, lbls, s.T(), s.H(), s.FH(), nil)
 			} 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)
 		}
@@ -5074,7 +5077,7 @@ func TestChunkSnapshotTakenAfterIncompleteSnapshot(t *testing.T) {
 
 	// Add some samples for the snapshot.
 	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, app.Commit())
 
@@ -5290,7 +5293,7 @@ func TestHeadInit_DiscardChunksWithUnsupportedEncoding(t *testing.T) {
 	var seriesRef storage.SeriesRef
 	var err error
 	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)
 	}
 
@@ -5303,7 +5306,7 @@ func TestHeadInit_DiscardChunksWithUnsupportedEncoding(t *testing.T) {
 
 	app = h.Appender(ctx)
 	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)
 	}
 
@@ -5376,7 +5379,7 @@ func TestMmapPanicAfterMmapReplayCorruption(t *testing.T) {
 		interval := DefaultBlockDuration / (4 * 120)
 		app := h.Appender(context.Background())
 		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
 			if i%10 == 0 {
 				require.NoError(t, app.Commit())
@@ -5439,7 +5442,7 @@ func TestReplayAfterMmapReplayError(t *testing.T) {
 		app := h.Appender(context.Background())
 		var ref storage.SeriesRef
 		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)})
 			require.NoError(t, err)
 			lastTs += itvl
@@ -5793,7 +5796,7 @@ func TestSnapshotAheadOfWALError(t *testing.T) {
 	head.opts.EnableMemorySnapshotOnShutdown = true
 	// Add a sample to fill WAL.
 	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, app.Commit())
 
@@ -5817,7 +5820,7 @@ func TestSnapshotAheadOfWALError(t *testing.T) {
 	require.NoError(t, err)
 	// Add a sample to fill WAL.
 	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, app.Commit())
 	lastSegment, _, _ := w.LastSegmentAndOffset()
@@ -5980,7 +5983,7 @@ func TestCuttingNewHeadChunks(t *testing.T) {
 
 			for i := 0; i < tc.numTotalSamples; i++ {
 				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)
 				} else if tc.histValFunc != 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.
 	for i := 0; i < numSamples; i++ {
 		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()
 		require.NoError(t, err)
 		a = h.Appender(context.Background())
@@ -6082,7 +6085,7 @@ func TestWALSampleAndExemplarOrder(t *testing.T) {
 	}{
 		"float sample": {
 			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{}),
 		},
@@ -6142,7 +6145,7 @@ func TestHeadCompactionWhileAppendAndCommitExemplar(t *testing.T) {
 	h, _ := newTestHead(t, DefaultBlockDuration, wlog.CompressionNone, false)
 	app := h.Appender(context.Background())
 	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)
 	app.Commit()
 	// 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
 		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, app.Commit())
 	}
@@ -6275,7 +6278,7 @@ func TestHeadAppender_AppendFloatWithSameTimestampAsPreviousHistogram(t *testing
 	}
 
 	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.ErrorIs(t, err, storage.NewDuplicateHistogramToFloatErr(2_000, 10.0))
 }
@@ -6479,7 +6482,7 @@ func TestHeadAppender_AppendCT(t *testing.T) {
 				if sample.fSample != 0 {
 					_, err := a.AppendCTZeroSample(0, lbls, sample.ts, sample.ct)
 					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)
 				}
 
diff --git a/tsdb/querier_bench_test.go b/tsdb/querier_bench_test.go
index 81800b7d47..7801fd7cd6 100644
--- a/tsdb/querier_bench_test.go
+++ b/tsdb/querier_bench_test.go
@@ -43,7 +43,7 @@ func BenchmarkQuerier(b *testing.B) {
 
 	app := h.Appender(context.Background())
 	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++ {
@@ -298,7 +298,7 @@ func benchmarkSelect(b *testing.B, queryable storage.Queryable, numSeries int, s
 func BenchmarkQuerierSelect(b *testing.B) {
 	numSeries := 1000000
 	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 {
 			b.Fatal(err)
 		}
@@ -336,11 +336,11 @@ func BenchmarkQuerierSelectWithOutOfOrder(b *testing.B) {
 	numSeries := 1000000
 	_, db := createHeadForBenchmarkSelect(b, numSeries, func(app storage.Appender, i int) {
 		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 {
 			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 {
 			b.Fatal(err)
 		}
diff --git a/tsdb/querier_test.go b/tsdb/querier_test.go
index fb18c6a88b..808686df30 100644
--- a/tsdb/querier_test.go
+++ b/tsdb/querier_test.go
@@ -506,7 +506,7 @@ func TestBlockQuerier_AgainstHeadWithOpenChunks(t *testing.T) {
 			for _, s := range testData {
 				for _, chk := range s.chunks {
 					for _, sample := range chk {
-						_, err = app.Append(0, labels.FromMap(s.lset), sample.t, sample.f, nil)
+						_, err = app.Append(0, labels.FromMap(s.lset), sample.t, sample.f, storage.AppendHints{})
 						require.NoError(t, err)
 					}
 				}
@@ -2686,12 +2686,12 @@ func TestPostingsForMatchers(t *testing.T) {
 	}()
 
 	app := h.Appender(context.Background())
-	app.Append(0, labels.FromStrings("n", "1"), 0, 0, nil)
-	app.Append(0, labels.FromStrings("n", "1", "i", "a"), 0, 0, nil)
-	app.Append(0, labels.FromStrings("n", "1", "i", "b"), 0, 0, nil)
-	app.Append(0, labels.FromStrings("n", "1", "i", "\n"), 0, 0, nil)
-	app.Append(0, labels.FromStrings("n", "2"), 0, 0, nil)
-	app.Append(0, labels.FromStrings("n", "2.5"), 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, storage.AppendHints{})
+	app.Append(0, labels.FromStrings("n", "1", "i", "b"), 0, 0, storage.AppendHints{})
+	app.Append(0, labels.FromStrings("n", "1", "i", "\n"), 0, 0, storage.AppendHints{})
+	app.Append(0, labels.FromStrings("n", "2"), 0, 0, storage.AppendHints{})
+	app.Append(0, labels.FromStrings("n", "2.5"), 0, 0, storage.AppendHints{})
 	require.NoError(t, app.Commit())
 
 	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++ {
 		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)
 		err = app.Commit()
 		require.NoError(t, err)
@@ -3485,7 +3485,7 @@ func BenchmarkHeadChunkQuerier(b *testing.B) {
 				require.NoError(b, app.Commit())
 				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)
 		}
 	}
@@ -3530,7 +3530,7 @@ func BenchmarkHeadQuerier(b *testing.B) {
 				require.NoError(b, app.Commit())
 				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)
 		}
 	}
diff --git a/tsdb/testutil.go b/tsdb/testutil.go
index 1b34a4da2f..4bd64c1973 100644
--- a/tsdb/testutil.go
+++ b/tsdb/testutil.go
@@ -53,7 +53,7 @@ var sampleTypeScenarios = map[string]sampleTypeScenario{
 		sampleType: sampleMetricTypeFloat,
 		appendFunc: func(appender storage.Appender, lbls labels.Labels, ts, value int64) (storage.SeriesRef, sample, error) {
 			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
 		},
 		sampleFunc: func(ts, value int64) sample {
diff --git a/tsdb/tsdbblockutil.go b/tsdb/tsdbblockutil.go
index a4d8bcec6c..9427fe5f57 100644
--- a/tsdb/tsdbblockutil.go
+++ b/tsdb/tsdbblockutil.go
@@ -70,7 +70,7 @@ func CreateBlock(series []storage.Series, dir string, chunkRange int64, logger *
 			switch typ {
 			case chunkenc.ValFloat:
 				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:
 				t, h := it.AtHistogram(nil)
 				ref, err = app.AppendHistogram(ref, lset, t, h, nil, nil)