Prometheus: Introduce prometheus backend library (#83952)

* Move files to prometheus-library * refactor core prometheus to use prometheus-library * modify client transport options * mock * have a type * import aliases * rename * call the right method * remove unrelated test from the library * update codeowners * go work sync * update go.work.sum * make swagger-clean && make openapi3-gen * add promlib to makefile * remove clilogger * Export the function * update unit test * add prometheus_test.go * fix mock type * use mapUtil from grafana-plugin-sdk-go
2024-03-11 17:22:33 +01:00
parent cfc7ea92da
commit 3fb6319d1b
114 changed files with 672 additions and 340 deletions
@@ -0,0 +1,361 @@
+package models
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana-plugin-sdk-go/backend/gtime"
+	"github.com/prometheus/prometheus/model/labels"
+	"github.com/prometheus/prometheus/promql/parser"
+
+	"github.com/grafana/grafana/pkg/promlib/intervalv2"
+)
+
+// PromQueryFormat defines model for PromQueryFormat.
+// +enum
+type PromQueryFormat string
+
+const (
+	PromQueryFormatTimeSeries PromQueryFormat = "time_series"
+	PromQueryFormatTable      PromQueryFormat = "table"
+	PromQueryFormatHeatmap    PromQueryFormat = "heatmap"
+)
+
+// QueryEditorMode defines model for QueryEditorMode.
+// +enum
+type QueryEditorMode string
+
+const (
+	QueryEditorModeBuilder QueryEditorMode = "builder"
+	QueryEditorModeCode    QueryEditorMode = "code"
+)
+
+// PrometheusQueryProperties defines the specific properties used for prometheus
+type PrometheusQueryProperties struct {
+	// The response format
+	Format PromQueryFormat `json:"format,omitempty"`
+
+	// The actual expression/query that will be evaluated by Prometheus
+	Expr string `json:"expr"`
+
+	// Returns a Range vector, comprised of a set of time series containing a range of data points over time for each time series
+	Range bool `json:"range,omitempty"`
+
+	// Returns only the latest value that Prometheus has scraped for the requested time series
+	Instant bool `json:"instant,omitempty"`
+
+	// Execute an additional query to identify interesting raw samples relevant for the given expr
+	Exemplar bool `json:"exemplar,omitempty"`
+
+	// what we should show in the editor
+	EditorMode QueryEditorMode `json:"editorMode,omitempty"`
+
+	// Used to specify how many times to divide max data points by. We use max data points under query options
+	// See https://github.com/grafana/grafana/issues/48081
+	// Deprecated: use interval
+	IntervalFactor int64 `json:"intervalFactor,omitempty"`
+
+	// Series name override or template. Ex. {{hostname}} will be replaced with label value for hostname
+	LegendFormat string `json:"legendFormat,omitempty"`
+
+	// ???
+	Scope *struct {
+		Matchers string `json:"matchers"`
+	} `json:"scope,omitempty"`
+}
+
+// Internal interval and range variables
+const (
+	varInterval       = "$__interval"
+	varIntervalMs     = "$__interval_ms"
+	varRange          = "$__range"
+	varRangeS         = "$__range_s"
+	varRangeMs        = "$__range_ms"
+	varRateInterval   = "$__rate_interval"
+	varRateIntervalMs = "$__rate_interval_ms"
+)
+
+// Internal interval and range variables with {} syntax
+// Repetitive code, we should have functionality to unify these
+const (
+	varIntervalAlt       = "${__interval}"
+	varIntervalMsAlt     = "${__interval_ms}"
+	varRangeAlt          = "${__range}"
+	varRangeSAlt         = "${__range_s}"
+	varRangeMsAlt        = "${__range_ms}"
+	varRateIntervalAlt   = "${__rate_interval}"
+	varRateIntervalMsAlt = "${__rate_interval_ms}"
+)
+
+type TimeSeriesQueryType string
+
+const (
+	RangeQueryType    TimeSeriesQueryType = "range"
+	InstantQueryType  TimeSeriesQueryType = "instant"
+	ExemplarQueryType TimeSeriesQueryType = "exemplar"
+	UnknownQueryType  TimeSeriesQueryType = "unknown"
+)
+
+var safeResolution = 11000
+
+// QueryModel includes both the common and specific values
+type QueryModel struct {
+	PrometheusQueryProperties `json:",inline"`
+	CommonQueryProperties     `json:",inline"`
+
+	// The following properties may be part of the request payload, however they are not saved in panel JSON
+	// Timezone offset to align start & end time on backend
+	UtcOffsetSec int64  `json:"utcOffsetSec,omitempty"`
+	Interval     string `json:"interval,omitempty"`
+}
+
+// CommonQueryProperties is properties applied to all queries
+// NOTE: this will soon be replaced with a struct from the SDK
+type CommonQueryProperties struct {
+	RefId      string `json:"refId,omitempty"`
+	IntervalMs int64  `json:"intervalMs,omitempty"`
+}
+
+type TimeRange struct {
+	Start time.Time
+	End   time.Time
+	Step  time.Duration
+}
+
+// The internal query object
+type Query struct {
+	Expr          string
+	Step          time.Duration
+	LegendFormat  string
+	Start         time.Time
+	End           time.Time
+	RefId         string
+	InstantQuery  bool
+	RangeQuery    bool
+	ExemplarQuery bool
+	UtcOffsetSec  int64
+	Scope         Scope
+}
+
+type Scope struct {
+	Matchers []*labels.Matcher
+}
+
+func Parse(query backend.DataQuery, dsScrapeInterval string, intervalCalculator intervalv2.Calculator, fromAlert bool, enableScope bool) (*Query, error) {
+	model := &QueryModel{}
+	if err := json.Unmarshal(query.JSON, model); err != nil {
+		return nil, err
+	}
+
+	// Final step value for prometheus
+	calculatedStep, err := calculatePrometheusInterval(model.Interval, dsScrapeInterval, model.IntervalMs, model.IntervalFactor, query, intervalCalculator)
+	if err != nil {
+		return nil, err
+	}
+
+	// Interpolate variables in expr
+	timeRange := query.TimeRange.To.Sub(query.TimeRange.From)
+	expr := interpolateVariables(
+		model.Expr,
+		query.Interval,
+		calculatedStep,
+		model.Interval,
+		dsScrapeInterval,
+		timeRange,
+	)
+	var matchers []*labels.Matcher
+	if enableScope && model.Scope != nil && model.Scope.Matchers != "" {
+		matchers, err = parser.ParseMetricSelector(model.Scope.Matchers)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse metric selector %v in scope", model.Scope.Matchers)
+		}
+		expr, err = ApplyQueryScope(expr, matchers)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if !model.Instant && !model.Range {
+		// In older dashboards, we were not setting range query param and !range && !instant was run as range query
+		model.Range = true
+	}
+
+	// We never want to run exemplar query for alerting
+	if fromAlert {
+		model.Exemplar = false
+	}
+
+	return &Query{
+		Expr:          expr,
+		Step:          calculatedStep,
+		LegendFormat:  model.LegendFormat,
+		Start:         query.TimeRange.From,
+		End:           query.TimeRange.To,
+		RefId:         query.RefID,
+		InstantQuery:  model.Instant,
+		RangeQuery:    model.Range,
+		ExemplarQuery: model.Exemplar,
+		UtcOffsetSec:  model.UtcOffsetSec,
+	}, nil
+}
+
+func (query *Query) Type() TimeSeriesQueryType {
+	if query.InstantQuery {
+		return InstantQueryType
+	}
+	if query.RangeQuery {
+		return RangeQueryType
+	}
+	if query.ExemplarQuery {
+		return ExemplarQueryType
+	}
+	return UnknownQueryType
+}
+
+func (query *Query) TimeRange() TimeRange {
+	return TimeRange{
+		Step: query.Step,
+		// Align query range to step. It rounds start and end down to a multiple of step.
+		Start: AlignTimeRange(query.Start, query.Step, query.UtcOffsetSec),
+		End:   AlignTimeRange(query.End, query.Step, query.UtcOffsetSec),
+	}
+}
+
+func calculatePrometheusInterval(
+	queryInterval, dsScrapeInterval string,
+	intervalMs, intervalFactor int64,
+	query backend.DataQuery,
+	intervalCalculator intervalv2.Calculator,
+) (time.Duration, error) {
+	// we need to compare the original query model after it is overwritten below to variables so that we can
+	// calculate the rateInterval if it is equal to $__rate_interval or ${__rate_interval}
+	originalQueryInterval := queryInterval
+
+	// If we are using variable for interval/step, we will replace it with calculated interval
+	if isVariableInterval(queryInterval) {
+		queryInterval = ""
+	}
+
+	minInterval, err := gtime.GetIntervalFrom(dsScrapeInterval, queryInterval, intervalMs, 15*time.Second)
+	if err != nil {
+		return time.Duration(0), err
+	}
+	calculatedInterval := intervalCalculator.Calculate(query.TimeRange, minInterval, query.MaxDataPoints)
+	safeInterval := intervalCalculator.CalculateSafeInterval(query.TimeRange, int64(safeResolution))
+
+	adjustedInterval := safeInterval.Value
+	if calculatedInterval.Value > safeInterval.Value {
+		adjustedInterval = calculatedInterval.Value
+	}
+
+	// here is where we compare for $__rate_interval or ${__rate_interval}
+	if originalQueryInterval == varRateInterval || originalQueryInterval == varRateIntervalAlt {
+		// Rate interval is final and is not affected by resolution
+		return calculateRateInterval(adjustedInterval, dsScrapeInterval), nil
+	} else {
+		queryIntervalFactor := intervalFactor
+		if queryIntervalFactor == 0 {
+			queryIntervalFactor = 1
+		}
+		return time.Duration(int64(adjustedInterval) * queryIntervalFactor), nil
+	}
+}
+
+// calculateRateInterval calculates the $__rate_interval value
+// queryInterval is the value calculated range / maxDataPoints on the frontend
+// queryInterval is shown on the Query Options Panel above the query editor
+// requestedMinStep is the data source scrape interval (default 15s)
+// requestedMinStep can be changed by setting "Min Step" value in Options panel below the code editor
+func calculateRateInterval(
+	queryInterval time.Duration,
+	requestedMinStep string,
+) time.Duration {
+	scrape := requestedMinStep
+	if scrape == "" {
+		scrape = "15s"
+	}
+
+	scrapeIntervalDuration, err := gtime.ParseIntervalStringToTimeDuration(scrape)
+	if err != nil {
+		return time.Duration(0)
+	}
+
+	rateInterval := time.Duration(int64(math.Max(float64(queryInterval+scrapeIntervalDuration), float64(4)*float64(scrapeIntervalDuration))))
+	return rateInterval
+}
+
+// interpolateVariables interpolates built-in variables
+// expr                         PromQL query
+// queryInterval                Requested interval in milliseconds. This value may be overridden by MinStep in query options
+// calculatedStep               Calculated final step value. It was calculated in calculatePrometheusInterval
+// requestedMinStep             Requested minimum step value. QueryModel.interval
+// dsScrapeInterval             Data source scrape interval in the config
+// timeRange                    Requested time range for query
+func interpolateVariables(
+	expr string,
+	queryInterval time.Duration,
+	calculatedStep time.Duration,
+	requestedMinStep string,
+	dsScrapeInterval string,
+	timeRange time.Duration,
+) string {
+	rangeMs := timeRange.Milliseconds()
+	rangeSRounded := int64(math.Round(float64(rangeMs) / 1000.0))
+
+	var rateInterval time.Duration
+	if requestedMinStep == varRateInterval || requestedMinStep == varRateIntervalAlt {
+		rateInterval = calculatedStep
+	} else {
+		if requestedMinStep == varInterval || requestedMinStep == varIntervalAlt {
+			requestedMinStep = calculatedStep.String()
+		}
+		if requestedMinStep == "" {
+			requestedMinStep = dsScrapeInterval
+		}
+		rateInterval = calculateRateInterval(queryInterval, requestedMinStep)
+	}
+
+	expr = strings.ReplaceAll(expr, varIntervalMs, strconv.FormatInt(int64(calculatedStep/time.Millisecond), 10))
+	expr = strings.ReplaceAll(expr, varInterval, gtime.FormatInterval(calculatedStep))
+	expr = strings.ReplaceAll(expr, varRangeMs, strconv.FormatInt(rangeMs, 10))
+	expr = strings.ReplaceAll(expr, varRangeS, strconv.FormatInt(rangeSRounded, 10))
+	expr = strings.ReplaceAll(expr, varRange, strconv.FormatInt(rangeSRounded, 10)+"s")
+	expr = strings.ReplaceAll(expr, varRateIntervalMs, strconv.FormatInt(int64(rateInterval/time.Millisecond), 10))
+	expr = strings.ReplaceAll(expr, varRateInterval, rateInterval.String())
+
+	// Repetitive code, we should have functionality to unify these
+	expr = strings.ReplaceAll(expr, varIntervalMsAlt, strconv.FormatInt(int64(calculatedStep/time.Millisecond), 10))
+	expr = strings.ReplaceAll(expr, varIntervalAlt, gtime.FormatInterval(calculatedStep))
+	expr = strings.ReplaceAll(expr, varRangeMsAlt, strconv.FormatInt(rangeMs, 10))
+	expr = strings.ReplaceAll(expr, varRangeSAlt, strconv.FormatInt(rangeSRounded, 10))
+	expr = strings.ReplaceAll(expr, varRangeAlt, strconv.FormatInt(rangeSRounded, 10)+"s")
+	expr = strings.ReplaceAll(expr, varRateIntervalMsAlt, strconv.FormatInt(int64(rateInterval/time.Millisecond), 10))
+	expr = strings.ReplaceAll(expr, varRateIntervalAlt, rateInterval.String())
+	return expr
+}
+
+func isVariableInterval(interval string) bool {
+	if interval == varInterval || interval == varIntervalMs || interval == varRateInterval || interval == varRateIntervalMs {
+		return true
+	}
+	// Repetitive code, we should have functionality to unify these
+	if interval == varIntervalAlt || interval == varIntervalMsAlt || interval == varRateIntervalAlt || interval == varRateIntervalMsAlt {
+		return true
+	}
+	return false
+}
+
+// AlignTimeRange aligns query range to step and handles the time offset.
+// It rounds start and end down to a multiple of step.
+// Prometheus caching is dependent on the range being aligned with the step.
+// Rounding to the step can significantly change the start and end of the range for larger steps, i.e. a week.
+// In rounding the range to a 1w step the range will always start on a Thursday.
+func AlignTimeRange(t time.Time, step time.Duration, offset int64) time.Time {
+	offsetNano := float64(offset * 1e9)
+	stepNano := float64(step.Nanoseconds())
+	return time.Unix(0, int64(math.Floor((float64(t.UnixNano())+offsetNano)/stepNano)*stepNano-offsetNano)).UTC()
+}
@@ -0,0 +1,784 @@
+package models_test
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/stretchr/testify/require"
+
+	"github.com/grafana/grafana/pkg/promlib/intervalv2"
+	"github.com/grafana/grafana/pkg/promlib/models"
+)
+
+var (
+	now                = time.Now()
+	intervalCalculator = intervalv2.NewCalculator()
+)
+
+func TestParse(t *testing.T) {
+	t.Run("parsing query from unified alerting", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(12 * time.Hour),
+		}
+
+		queryJson := `{
+			"expr": "go_goroutines",
+			"refId": "A",
+			"exemplar": true
+		}`
+
+		q := backend.DataQuery{
+			JSON:      []byte(queryJson),
+			TimeRange: timeRange,
+			RefID:     "A",
+		}
+
+		res, err := models.Parse(q, "15s", intervalCalculator, true, false)
+		require.NoError(t, err)
+		require.Equal(t, false, res.ExemplarQuery)
+	})
+
+	t.Run("parsing query model with step", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(12 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "go_goroutines",
+			"format": "time_series",
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, time.Second*30, res.Step)
+	})
+
+	t.Run("parsing query model without step parameter", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(1 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "go_goroutines",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, time.Second*15, res.Step)
+	})
+
+	t.Run("parsing query model with high intervalFactor", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "go_goroutines",
+			"format": "time_series",
+			"intervalFactor": 10,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, time.Minute*20, res.Step)
+	})
+
+	t.Run("parsing query model with low intervalFactor", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "go_goroutines",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, time.Minute*2, res.Step)
+	})
+
+	t.Run("parsing query model specified scrape-interval in the data source", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "go_goroutines",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "240s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, time.Minute*4, res.Step)
+	})
+
+	t.Run("parsing query model with $__interval variable", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [$__interval]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"intervalMs": 60000,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [2m]})", res.Expr)
+		require.Equal(t, 120*time.Second, res.Step)
+	})
+
+	t.Run("parsing query model with ${__interval} variable", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [${__interval}]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"interval": "1m",
+			"intervalMs": 60000,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [2m]})", res.Expr)
+	})
+
+	t.Run("parsing query model with $__interval_ms variable", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [$__interval_ms]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"intervalMs": 60000,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [120000]})", res.Expr)
+	})
+
+	t.Run("parsing query model with $__interval_ms and $__interval variable", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [$__interval_ms]}) + rate(ALERTS{job=\"test\" [$__interval]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"intervalMs": 60000,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [120000]}) + rate(ALERTS{job=\"test\" [2m]})", res.Expr)
+	})
+
+	t.Run("parsing query model with ${__interval_ms} and ${__interval} variable", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [${__interval_ms}]}) + rate(ALERTS{job=\"test\" [${__interval}]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"intervalMs": 60000,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [120000]}) + rate(ALERTS{job=\"test\" [2m]})", res.Expr)
+	})
+
+	t.Run("parsing query model with $__range variable", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [$__range]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [172800s]})", res.Expr)
+	})
+
+	t.Run("parsing query model with $__range_s variable", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [$__range_s]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [172800]})", res.Expr)
+	})
+
+	t.Run("parsing query model with ${__range_s} variable", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [${__range_s}s]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [172800s]})", res.Expr)
+	})
+
+	t.Run("parsing query model with $__range_s variable below 0.5s", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(40 * time.Millisecond),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [$__range_s]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [0]})", res.Expr)
+	})
+
+	t.Run("parsing query model with $__range_s variable between 1-0.5s", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(800 * time.Millisecond),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [$__range_s]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [1]})", res.Expr)
+	})
+
+	t.Run("parsing query model with $__range_ms variable", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [$__range_ms]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [172800000]})", res.Expr)
+	})
+
+	t.Run("parsing query model with $__range_ms variable below 1s", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(20 * time.Millisecond),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [$__range_ms]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [20]})", res.Expr)
+	})
+
+	t.Run("parsing query model with $__rate_interval variable", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(5 * time.Minute),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [$__rate_interval]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"interval": "5m",
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [20m0s]})", res.Expr)
+	})
+
+	t.Run("parsing query model with $__rate_interval variable in expr and interval", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(5 * time.Minute),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [$__rate_interval]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"interval": "$__rate_interval",
+			"refId": "A"
+		}`, timeRange, 1*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [1m0s]})", res.Expr)
+		require.Equal(t, 1*time.Minute, res.Step)
+	})
+
+	t.Run("parsing query model with $__rate_interval_ms variable", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [$__rate_interval_ms]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, 2*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [135000]})", res.Expr)
+	})
+
+	t.Run("parsing query model with $__rate_interval_ms and $__rate_interval variable", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [$__rate_interval_ms]}) + rate(ALERTS{job=\"test\" [$__rate_interval]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, 2*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [135000]}) + rate(ALERTS{job=\"test\" [2m15s]})", res.Expr)
+	})
+
+	t.Run("parsing query model with ${__rate_interval_ms} and ${__rate_interval} variable", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "rate(ALERTS{job=\"test\" [${__rate_interval_ms}]}) + rate(ALERTS{job=\"test\" [${__rate_interval}]})",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, 2*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "rate(ALERTS{job=\"test\" [135000]}) + rate(ALERTS{job=\"test\" [2m15s]})", res.Expr)
+	})
+
+	t.Run("parsing query model of range query", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "go_goroutines",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A",
+			"range": true
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, true, res.RangeQuery)
+	})
+
+	t.Run("parsing query model of range and instant query", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "go_goroutines",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A",
+			"range": true,
+			"instant": true
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, true, res.RangeQuery)
+		require.Equal(t, true, res.InstantQuery)
+	})
+
+	t.Run("parsing query model of with no query type", func(t *testing.T) {
+		timeRange := backend.TimeRange{
+			From: now,
+			To:   now.Add(48 * time.Hour),
+		}
+
+		q := queryContext(`{
+			"expr": "go_goroutines",
+			"format": "time_series",
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, timeRange, time.Duration(1)*time.Minute)
+
+		res, err := models.Parse(q, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, true, res.RangeQuery)
+	})
+}
+
+func TestRateInterval(t *testing.T) {
+	type args struct {
+		expr             string
+		interval         string
+		intervalMs       int64
+		dsScrapeInterval string
+		timeRange        *backend.TimeRange
+	}
+	tests := []struct {
+		name string
+		args args
+		want *models.Query
+	}{
+		{
+			name: "intervalMs 100s, minStep override 150s and scrape interval 30s",
+			args: args{
+				expr:             "rate(rpc_durations_seconds_count[$__rate_interval])",
+				interval:         "150s",
+				intervalMs:       100000,
+				dsScrapeInterval: "30s",
+			},
+			want: &models.Query{
+				Expr: "rate(rpc_durations_seconds_count[10m0s])",
+				Step: time.Second * 150,
+			},
+		},
+		{
+			name: "intervalMs 120s, minStep override 150s and ds scrape interval 30s",
+			args: args{
+				expr:             "rate(rpc_durations_seconds_count[$__rate_interval])",
+				interval:         "150s",
+				intervalMs:       120000,
+				dsScrapeInterval: "30s",
+			},
+			want: &models.Query{
+				Expr: "rate(rpc_durations_seconds_count[10m0s])",
+				Step: time.Second * 150,
+			},
+		},
+		{
+			name: "intervalMs 120s, minStep auto (interval not overridden) and ds scrape interval 30s",
+			args: args{
+				expr:             "rate(rpc_durations_seconds_count[$__rate_interval])",
+				interval:         "120s",
+				intervalMs:       120000,
+				dsScrapeInterval: "30s",
+			},
+			want: &models.Query{
+				Expr: "rate(rpc_durations_seconds_count[8m0s])",
+				Step: time.Second * 120,
+			},
+		},
+		{
+			name: "interval and minStep are automatically calculated and ds scrape interval 30s and time range 1 hour",
+			args: args{
+				expr:             "rate(rpc_durations_seconds_count[$__rate_interval])",
+				interval:         "30s",
+				intervalMs:       30000,
+				dsScrapeInterval: "30s",
+				timeRange: &backend.TimeRange{
+					From: now,
+					To:   now.Add(1 * time.Hour),
+				},
+			},
+			want: &models.Query{
+				Expr: "rate(rpc_durations_seconds_count[2m0s])",
+				Step: time.Second * 30,
+			},
+		},
+		{
+			name: "minStep is $__rate_interval and ds scrape interval 30s and time range 1 hour",
+			args: args{
+				expr:             "rate(rpc_durations_seconds_count[$__rate_interval])",
+				interval:         "$__rate_interval",
+				intervalMs:       30000,
+				dsScrapeInterval: "30s",
+				timeRange: &backend.TimeRange{
+					From: now,
+					To:   now.Add(1 * time.Hour),
+				},
+			},
+			want: &models.Query{
+				Expr: "rate(rpc_durations_seconds_count[2m0s])",
+				Step: time.Minute * 2,
+			},
+		},
+		{
+			name: "minStep is $__rate_interval and ds scrape interval 30s and time range 2 days",
+			args: args{
+				expr:             "rate(rpc_durations_seconds_count[$__rate_interval])",
+				interval:         "$__rate_interval",
+				intervalMs:       120000,
+				dsScrapeInterval: "30s",
+				timeRange: &backend.TimeRange{
+					From: now,
+					To:   now.Add(2 * 24 * time.Hour),
+				},
+			},
+			want: &models.Query{
+				Expr: "rate(rpc_durations_seconds_count[2m30s])",
+				Step: time.Second * 150,
+			},
+		},
+		{
+			name: "minStep is $__rate_interval and ds scrape interval 15s and time range 2 days",
+			args: args{
+				expr:             "rate(rpc_durations_seconds_count[$__rate_interval])",
+				interval:         "$__interval",
+				intervalMs:       120000,
+				dsScrapeInterval: "15s",
+				timeRange: &backend.TimeRange{
+					From: now,
+					To:   now.Add(2 * 24 * time.Hour),
+				},
+			},
+			want: &models.Query{
+				Expr: "rate(rpc_durations_seconds_count[8m0s])",
+				Step: time.Second * 120,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			q := mockQuery(tt.args.expr, tt.args.interval, tt.args.intervalMs, tt.args.timeRange)
+			q.MaxDataPoints = 12384
+			res, err := models.Parse(q, tt.args.dsScrapeInterval, intervalCalculator, false, false)
+			require.NoError(t, err)
+			require.Equal(t, tt.want.Expr, res.Expr)
+			require.Equal(t, tt.want.Step, res.Step)
+		})
+	}
+
+	t.Run("minStep is auto and ds scrape interval 30s and time range 1 hour", func(t *testing.T) {
+		query := backend.DataQuery{
+			RefID:         "G",
+			QueryType:     "",
+			MaxDataPoints: 1613,
+			Interval:      30 * time.Second,
+			TimeRange: backend.TimeRange{
+				From: now,
+				To:   now.Add(1 * time.Hour),
+			},
+			JSON: []byte(`{
+			"datasource":{"type":"prometheus","uid":"zxS5e5W4k"},
+			"datasourceId":38,
+			"editorMode":"code",
+			"exemplar":false,
+			"expr":"sum(rate(process_cpu_seconds_total[$__rate_interval]))",
+			"instant":false,
+			"interval":"",
+			"intervalMs":30000,
+			"key":"Q-f96b6729-c47a-4ea8-8f71-a79774cf9bd5-0",
+			"legendFormat":"__auto",
+			"maxDataPoints":1613,
+			"range":true,
+			"refId":"G",
+			"requestId":"1G",
+			"utcOffsetSec":3600
+		}`),
+		}
+		res, err := models.Parse(query, "30s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "sum(rate(process_cpu_seconds_total[2m0s]))", res.Expr)
+		require.Equal(t, 30*time.Second, res.Step)
+	})
+
+	t.Run("minStep is auto and ds scrape interval 15s and time range 5 minutes", func(t *testing.T) {
+		query := backend.DataQuery{
+			RefID:         "A",
+			QueryType:     "",
+			MaxDataPoints: 1055,
+			Interval:      15 * time.Second,
+			TimeRange: backend.TimeRange{
+				From: now,
+				To:   now.Add(5 * time.Minute),
+			},
+			JSON: []byte(`{
+			"datasource": {
+		        "type": "prometheus",
+		        "uid": "2z9d6ElGk"
+		    },
+		    "editorMode": "code",
+		    "expr": "sum(rate(cache_requests_total[$__rate_interval]))",
+		    "legendFormat": "__auto",
+		    "range": true,
+		    "refId": "A",
+		    "exemplar": false,
+		    "requestId": "1A",
+		    "utcOffsetSec": 0,
+		    "interval": "",
+		    "datasourceId": 508,
+		    "intervalMs": 15000,
+		    "maxDataPoints": 1055
+		}`),
+		}
+		res, err := models.Parse(query, "15s", intervalCalculator, false, false)
+		require.NoError(t, err)
+		require.Equal(t, "sum(rate(cache_requests_total[1m0s]))", res.Expr)
+		require.Equal(t, 15*time.Second, res.Step)
+	})
+}
+
+func mockQuery(expr string, interval string, intervalMs int64, timeRange *backend.TimeRange) backend.DataQuery {
+	if timeRange == nil {
+		timeRange = &backend.TimeRange{
+			From: now,
+			To:   now.Add(1 * time.Hour),
+		}
+	}
+	return backend.DataQuery{
+		Interval: time.Duration(intervalMs) * time.Millisecond,
+		JSON: []byte(fmt.Sprintf(`{
+			"expr": "%s",
+			"format": "time_series",
+			"interval": "%s",
+			"intervalMs": %v,
+			"intervalFactor": 1,
+			"refId": "A"
+		}`, expr, interval, intervalMs)),
+		TimeRange: *timeRange,
+		RefID:     "A",
+	}
+}
+
+func queryContext(json string, timeRange backend.TimeRange, queryInterval time.Duration) backend.DataQuery {
+	return backend.DataQuery{
+		Interval:  queryInterval,
+		JSON:      []byte(json),
+		TimeRange: timeRange,
+		RefID:     "A",
+	}
+}
+
+// AlignTimeRange aligns query range to step and handles the time offset.
+// It rounds start and end down to a multiple of step.
+// Prometheus caching is dependent on the range being aligned with the step.
+// Rounding to the step can significantly change the start and end of the range for larger steps, i.e. a week.
+// In rounding the range to a 1w step the range will always start on a Thursday.
+func TestAlignTimeRange(t *testing.T) {
+	type args struct {
+		t      time.Time
+		step   time.Duration
+		offset int64
+	}
+
+	var monday int64 = 1704672000
+	var thursday int64 = 1704326400
+	var one_week_min_step = 604800 * time.Second
+
+	tests := []struct {
+		name string
+		args args
+		want time.Time
+	}{
+		{
+			name: "second step",
+			args: args{t: time.Unix(1664816826, 0), step: 10 * time.Second, offset: 0},
+			want: time.Unix(1664816820, 0).UTC(),
+		},
+		{name: "millisecond step", args: args{t: time.Unix(1664816825, 5*int64(time.Millisecond)), step: 10 * time.Millisecond, offset: 0}, want: time.Unix(1664816825, 0).UTC()},
+		{name: "second step with offset", args: args{t: time.Unix(1664816825, 5*int64(time.Millisecond)), step: 2 * time.Second, offset: -3}, want: time.Unix(1664816825, 0).UTC()},
+		// we may not want this functionality in the future but if we change this we break Prometheus caching.
+		{
+			name: "1w step with range date of Monday that changes the range to a Thursday.",
+			args: args{t: time.Unix(monday, 0), step: one_week_min_step, offset: 0},
+			want: time.Unix(thursday, 0).UTC(),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := models.AlignTimeRange(tt.args.t, tt.args.step, tt.args.offset); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("AlignTimeRange() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
@@ -0,0 +1,55 @@
+package models
+
+import (
+	"time"
+
+	"github.com/grafana/grafana-plugin-sdk-go/data"
+)
+
+// +enum
+type ResultType string
+
+const (
+	ResultTypeMatrix   ResultType = "matrix"
+	ResultTypeExemplar ResultType = "exemplar"
+	ResultTypeVector   ResultType = "vector"
+	ResultTypeUnknown  ResultType = ""
+)
+
+func ResultTypeFromFrame(frame *data.Frame) ResultType {
+	if frame.Meta.Custom == nil {
+		return ResultTypeUnknown
+	}
+	custom, ok := frame.Meta.Custom.(map[string]string)
+	if !ok {
+		return ResultTypeUnknown
+	}
+
+	rt, ok := custom["resultType"]
+	if !ok {
+		return ResultTypeUnknown
+	}
+
+	switch rt {
+	case ResultTypeMatrix.String():
+		return ResultTypeMatrix
+	case ResultTypeExemplar.String():
+		return ResultTypeExemplar
+	case ResultTypeVector.String():
+		return ResultTypeVector
+	}
+
+	return ResultTypeUnknown
+}
+
+func (r ResultType) String() string {
+	return string(r)
+}
+
+type Exemplar struct {
+	SeriesLabels map[string]string
+	Fields       []*data.Field
+	RowIdx       int
+	Value        float64
+	Timestamp    time.Time
+}
@@ -0,0 +1,52 @@
+package models
+
+import (
+	"github.com/prometheus/prometheus/model/labels"
+	"github.com/prometheus/prometheus/promql/parser"
+)
+
+func ApplyQueryScope(rawExpr string, matchers []*labels.Matcher) (string, error) {
+	expr, err := parser.ParseExpr(rawExpr)
+	if err != nil {
+		return "", err
+	}
+
+	matcherNamesToIdx := make(map[string]int, len(matchers))
+	for i, matcher := range matchers {
+		if matcher == nil {
+			continue
+		}
+		matcherNamesToIdx[matcher.Name] = i
+	}
+
+	parser.Inspect(expr, func(node parser.Node, nodes []parser.Node) error {
+		switch v := node.(type) {
+		case *parser.VectorSelector:
+			found := make([]bool, len(matchers))
+			for _, matcher := range v.LabelMatchers {
+				if matcher == nil || matcher.Name == "__name__" { // const prob
+					continue
+				}
+				if _, ok := matcherNamesToIdx[matcher.Name]; ok {
+					found[matcherNamesToIdx[matcher.Name]] = true
+					newM := matchers[matcherNamesToIdx[matcher.Name]]
+					matcher.Name = newM.Name
+					matcher.Type = newM.Type
+					matcher.Value = newM.Value
+				}
+			}
+			for i, f := range found {
+				if f {
+					continue
+				}
+				v.LabelMatchers = append(v.LabelMatchers, matchers[i])
+			}
+
+			return nil
+
+		default:
+			return nil
+		}
+	})
+	return expr.String(), nil
+}