refactor: simplify interpolateAt to match Prometheus v0.310.0

Remove the leftEdge parameter from interpolateAt. Counter resets during
interpolation now always set y1=0 for both edges, matching the upstream
simplification in prometheus/prometheus v0.310.0 (promql/functions.go).

The old v0.308.0 behavior was asymmetric: left edge zeroed y1, right
edge added y1 to y2. The new unified approach is cleaner and correctly
models counters as starting from 0 post-reset regardless of which
boundary is being interpolated.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Signed-off-by: Sylvain Rabot <sylvain@abstraction.fr>

Author: sylr

engine/engine.go

@@ -187,7 +187,7 @@ func NewWithScanners(opts Opts, scanners engstorage.Scanners) *Engine {
 		scanners:           scanners,
 		activeQueryTracker: queryTracker,
 
-		disableDuplicateLabelChecks:   opts.DisableDuplicateLabelChecks,
+		disableDuplicateLabelChecks:  opts.DisableDuplicateLabelChecks,
 		enableExtendedRangeSelectors: opts.EnableExtendedRangeSelectors,
 
 		logger:             opts.Logger,
@@ -218,7 +218,7 @@ type Engine struct {
 	scanners           engstorage.Scanners
 	activeQueryTracker promql.QueryTracker
 
-	disableDuplicateLabelChecks     bool
+	disableDuplicateLabelChecks  bool
 	enableExtendedRangeSelectors bool
 
 	logger             *slog.Logger

engine/extended_range_test.go

@@ -10,18 +10,18 @@ import (
 	"testing"
 	"time"
 
-	"github.com/efficientgo/core/testutil"
-	"github.com/prometheus/prometheus/promql"
-	"github.com/prometheus/prometheus/promql/parser"
-	"github.com/prometheus/prometheus/promql/promqltest"
-	promstorage "github.com/prometheus/prometheus/storage"
-
 	"github.com/thanos-io/promql-engine/engine"
 	"github.com/thanos-io/promql-engine/execution/model"
 	"github.com/thanos-io/promql-engine/logicalplan"
 	"github.com/thanos-io/promql-engine/query"
 	engstorage "github.com/thanos-io/promql-engine/storage"
 	promscan "github.com/thanos-io/promql-engine/storage/prometheus"
+
+	"github.com/efficientgo/core/testutil"
+	"github.com/prometheus/prometheus/promql"
+	"github.com/prometheus/prometheus/promql/parser"
+	"github.com/prometheus/prometheus/promql/promqltest"
+	promstorage "github.com/prometheus/prometheus/storage"
 )
 
 func TestAnchoredSmoothedModifiers(t *testing.T) {
@@ -47,119 +47,119 @@ func TestAnchoredSmoothedModifiers(t *testing.T) {
 		{
 			name: "anchored rate on linear counter",
 			load: `load 10s
-				http_total 0 10 20 30 40 50 60 70 80 90 100`,
+			    http_total 0 10 20 30 40 50 60 70 80 90 100`,
 			query: `rate(http_total[30s] anchored)`,
 		},
 		{
 			name: "anchored increase on linear counter",
 			load: `load 10s
-				http_total 0 10 20 30 40 50 60 70 80 90 100`,
+			    http_total 0 10 20 30 40 50 60 70 80 90 100`,
 			query: `increase(http_total[30s] anchored)`,
 		},
 		{
 			name: "anchored delta on gauge",
 			load: `load 10s
-				temperature 20 22 21 23 25 24 26 28 27 29 30`,
+			    temperature 20 22 21 23 25 24 26 28 27 29 30`,
 			query: `delta(temperature[30s] anchored)`,
 		},
 		// Smoothed rate/increase/delta on a linear counter.
 		{
 			name: "smoothed rate on linear counter",
 			load: `load 10s
-				http_total 0 10 20 30 40 50 60 70 80 90 100`,
+			    http_total 0 10 20 30 40 50 60 70 80 90 100`,
 			query: `rate(http_total[30s] smoothed)`,
 		},
 		{
 			name: "smoothed increase on linear counter",
 			load: `load 10s
-				http_total 0 10 20 30 40 50 60 70 80 90 100`,
+			    http_total 0 10 20 30 40 50 60 70 80 90 100`,
 			query: `increase(http_total[30s] smoothed)`,
 		},
 		{
 			name: "smoothed delta on gauge",
 			load: `load 10s
-				temperature 20 22 21 23 25 24 26 28 27 29 30`,
+			    temperature 20 22 21 23 25 24 26 28 27 29 30`,
 			query: `delta(temperature[30s] smoothed)`,
 		},
 		// Anchored with counter resets.
 		{
 			name: "anchored increase with counter reset",
 			load: `load 10s
-				resets_total 0 10 20 5 15 25 10 20 30 40 50`,
+			    resets_total 0 10 20 5 15 25 10 20 30 40 50`,
 			query: `increase(resets_total[30s] anchored)`,
 		},
 		{
 			name: "anchored rate with counter reset",
 			load: `load 10s
-				resets_total 0 10 20 5 15 25 10 20 30 40 50`,
+			    resets_total 0 10 20 5 15 25 10 20 30 40 50`,
 			query: `rate(resets_total[30s] anchored)`,
 		},
 		// Smoothed with counter resets.
 		{
 			name: "smoothed increase with counter reset",
 			load: `load 10s
-				resets_total 0 10 20 5 15 25 10 20 30 40 50`,
+			    resets_total 0 10 20 5 15 25 10 20 30 40 50`,
 			query: `increase(resets_total[30s] smoothed)`,
 		},
 		{
 			name: "smoothed rate with counter reset",
 			load: `load 10s
-				resets_total 0 10 20 5 15 25 10 20 30 40 50`,
+			    resets_total 0 10 20 5 15 25 10 20 30 40 50`,
 			query: `rate(resets_total[30s] smoothed)`,
 		},
 		// Anchored resets and changes (only supported for anchored).
 		{
 			name: "anchored resets",
 			load: `load 10s
-				resets_total 0 10 20 5 15 25 10 20 30 40 50`,
+			    resets_total 0 10 20 5 15 25 10 20 30 40 50`,
 			query: `resets(resets_total[30s] anchored)`,
 		},
 		{
 			name: "anchored changes",
 			load: `load 10s
-				metric 1 1 2 2 3 3 4 4 5 5 6`,
+			    metric 1 1 2 2 3 3 4 4 5 5 6`,
 			query: `changes(metric[30s] anchored)`,
 		},
 		// Counter reset at range boundary (regression test: smoothed interpolation
 		// must handle counter resets to avoid negative increase values).
 		{
 			name: "smoothed increase counter reset at boundary",
 			load: `load 10s
-				counter_boundary 0 4 5 1 6 11`,
+			    counter_boundary 0 4 5 1 6 11`,
 			query: `increase(counter_boundary[10s] smoothed)`,
 		},
 		{
 			name: "smoothed rate counter reset at boundary",
 			load: `load 10s
-				counter_boundary 0 4 5 1 6 11`,
+			    counter_boundary 0 4 5 1 6 11`,
 			query: `rate(counter_boundary[10s] smoothed)`,
 		},
 		// Non-linear data.
 		{
 			name: "anchored rate on quadratic counter",
 			load: `load 10s
-				quadratic 0 1 4 9 16 25 36 49 64 81 100`,
+			    quadratic 0 1 4 9 16 25 36 49 64 81 100`,
 			query: `rate(quadratic[30s] anchored)`,
 		},
 		{
 			name: "smoothed rate on quadratic counter",
 			load: `load 10s
-				quadratic 0 1 4 9 16 25 36 49 64 81 100`,
+			    quadratic 0 1 4 9 16 25 36 49 64 81 100`,
 			query: `rate(quadratic[30s] smoothed)`,
 		},
 		// Multiple series.
 		{
 			name: "anchored increase multiple series",
 			load: `load 10s
-				http_total{path="/foo"} 0 5 10 15 20 25 30 35 40 45 50
-				http_total{path="/bar"} 0 10 20 30 40 50 60 70 80 90 100`,
+			    http_total{path="/foo"} 0 5 10 15 20 25 30 35 40 45 50
+			    http_total{path="/bar"} 0 10 20 30 40 50 60 70 80 90 100`,
 			query: `increase(http_total[30s] anchored)`,
 		},
 		{
 			name: "smoothed increase multiple series",
 			load: `load 10s
-				http_total{path="/foo"} 0 5 10 15 20 25 30 35 40 45 50
-				http_total{path="/bar"} 0 10 20 30 40 50 60 70 80 90 100`,
+			    http_total{path="/foo"} 0 5 10 15 20 25 30 35 40 45 50
+			    http_total{path="/bar"} 0 10 20 30 40 50 60 70 80 90 100`,
 			query: `increase(http_total[30s] smoothed)`,
 		},
 	}

ringbuffer/functions.go

@@ -7,12 +7,12 @@ import (
 	"math"
 	"sort"
 
-	"github.com/efficientgo/core/errors"
-	"github.com/prometheus/prometheus/model/histogram"
-
 	"github.com/thanos-io/promql-engine/compute"
 	"github.com/thanos-io/promql-engine/execution/parse"
 	"github.com/thanos-io/promql-engine/warnings"
+
+	"github.com/efficientgo/core/errors"
+	"github.com/prometheus/prometheus/model/histogram"
 )
 
 type SamplesBuffer GenericRingBuffer
@@ -672,12 +672,9 @@ func extendedRangeRate(samples []Sample, isCounter, isRate bool, stepTime, selec
 	rangeStart := rangeEnd - selectRange
 
 	// Find firstSampleIndex: the last sample at or before rangeStart, clamped to 0.
-	firstSampleIndex := sort.Search(lastSampleIndex, func(i int) bool {
+	firstSampleIndex := max(sort.Search(lastSampleIndex, func(i int) bool {
 		return samples[i].T > rangeStart
-	}) - 1
-	if firstSampleIndex < 0 {
-		firstSampleIndex = 0
-	}
+	})-1, 0)
 
 	// For smoothed, extend lastSampleIndex to include the first sample at or after rangeEnd.
 	if smoothed {
@@ -732,7 +729,7 @@ func extendedRangeRate(samples []Sample, isCounter, isRate bool, stepTime, selec
 // If no sample exists before rangeStart, the first sample value is used.
 func pickOrInterpolateLeft(samples []Sample, first int, rangeStart int64, smoothed, isCounter bool) float64 {
 	if smoothed && samples[first].T < rangeStart && first+1 < len(samples) {
-		return interpolateAt(samples[first], samples[first+1], rangeStart, isCounter, true)
+		return interpolateAt(samples[first], samples[first+1], rangeStart, isCounter)
 	}
 	return samples[first].V.F
 }
@@ -744,26 +741,21 @@ func pickOrInterpolateLeft(samples []Sample, first int, rangeStart int64, smooth
 // If no sample exists after rangeEnd, the last sample value is used.
 func pickOrInterpolateRight(samples []Sample, last int, rangeEnd int64, smoothed, isCounter bool) float64 {
 	if smoothed && last > 0 && samples[last].T > rangeEnd {
-		return interpolateAt(samples[last-1], samples[last], rangeEnd, isCounter, false)
+		return interpolateAt(samples[last-1], samples[last], rangeEnd, isCounter)
 	}
 	return samples[last].V.F
 }
 
 // interpolateAt performs linear interpolation between two samples at the given timestamp.
-// If isCounter is true and there is a counter reset (right < left):
-//   - on the left edge, it sets the left value to 0
-//   - on the right edge, it adds the left value to the right value
+// If isCounter is true and there is a counter reset (y2 < y1), it models the
+// counter as starting from 0 post-reset by setting y1 to 0.
 //
-// This matches Prometheus' interpolate function in promql/functions.go.
-func interpolateAt(left, right Sample, timestamp int64, isCounter, leftEdge bool) float64 {
+// This matches Prometheus v0.310.0's interpolate function in promql/functions.go.
+func interpolateAt(left, right Sample, timestamp int64, isCounter bool) float64 {
 	y1 := left.V.F
 	y2 := right.V.F
 	if isCounter && y2 < y1 {
-		if leftEdge {
-			y1 = 0
-		} else {
-			y2 += y1
-		}
+		y1 = 0
 	}
 	return y1 + (y2-y1)*float64(timestamp-left.T)/float64(right.T-left.T)
 }