Loki: Implement step editor

pkg/tsdb/loki/parse_query.go

@@ -126,7 +126,10 @@ func parseQuery(queryContext *backend.QueryDataRequest) ([]*lokiQuery, error) {
 		interval := query.Interval
 		timeRange := query.TimeRange.To.Sub(query.TimeRange.From)
 
-		step := calculateStep(interval, timeRange, resolution)
+		step, err := calculateStep(interval, timeRange, resolution, model.Step)
+		if err != nil {
+			return nil, err
+		}
 
 		expr := interpolateVariables(model.Expr, interval, timeRange)
 

pkg/tsdb/loki/step.go

@@ -3,6 +3,8 @@ package loki
 import (
 	"math"
 	"time"
+
+	"github.com/grafana/grafana/pkg/tsdb/intervalv2"
 )
 
 // round the duration to the nearest millisecond larger-or-equal-to the duration
@@ -20,12 +22,19 @@ func durationMax(d1 time.Duration, d2 time.Duration) time.Duration {
 	}
 }
 
-func calculateStep(baseInterval time.Duration, timeRange time.Duration, resolution int64) time.Duration {
-	step := time.Duration(baseInterval.Nanoseconds() * resolution)
-
-	safeStep := timeRange / 11000
+func calculateStep(interval time.Duration, timeRange time.Duration, resolution int64, queryStep *string) (time.Duration, error) {
+	// If we don't have step from query we calculate it from interval, time range and resolution
+	if queryStep == nil || *queryStep == "" {
+		step := time.Duration(interval.Nanoseconds() * resolution)
+		safeStep := timeRange / 11000
+		chosenStep := durationMax(step, safeStep)
+		return ceilMs(chosenStep), nil
+	}
 
-	chosenStep := durationMax(step, safeStep)
+	step, err := intervalv2.ParseIntervalStringToTimeDuration(interpolateVariables(*queryStep, interval, timeRange))
+	if err != nil {
+		return step, err
+	}
 
-	return ceilMs(chosenStep)
+	return time.Duration(step.Nanoseconds() * resolution), nil
 }

pkg/tsdb/loki/step_test.go

@@ -8,50 +8,125 @@ import (
 )
 
 func TestLokiStep(t *testing.T) {
-	t.Run("base case", func(t *testing.T) {
-		require.Equal(t, time.Second*14, calculateStep(time.Second*7, time.Second, 2))
-	})
+	t.Run("with query step", func(t *testing.T) {
+		t.Run("valid step in go duration format", func(t *testing.T) {
+			queryStep := "1m"
+			step, err := calculateStep(time.Second*7, time.Second, 2, &queryStep)
+			require.NoError(t, err)
+			require.Equal(t, time.Minute*2, step)
+		})
 
-	t.Run("step should be at least 1 millisecond", func(t *testing.T) {
-		require.Equal(t, time.Millisecond*1, calculateStep(time.Microsecond*500, time.Second, 1))
-	})
+		t.Run("valid step as number", func(t *testing.T) {
+			queryStep := "30"
+			step, err := calculateStep(time.Second*7, time.Second, 2, &queryStep)
+			require.NoError(t, err)
+			require.Equal(t, time.Minute*1, step)
+		})
 
-	t.Run("safeInterval should happen", func(t *testing.T) {
-		// safeInterval
-		require.Equal(t, time.Second*3, calculateStep(time.Second*2, time.Second*33000, 1))
-	})
+		t.Run("step with range variable", func(t *testing.T) {
+			queryStep := "$__range"
+			step, err := calculateStep(time.Second*7, time.Second, 2, &queryStep)
+			require.NoError(t, err)
+			require.Equal(t, time.Second*2, step)
+		})
 
-	t.Run("step should math.Ceil in milliseconds", func(t *testing.T) {
-		require.Equal(t, time.Millisecond*2, calculateStep(time.Microsecond*1234, time.Second*1, 1))
-	})
+		t.Run("step with interval variable", func(t *testing.T) {
+			queryStep := "$__interval"
+			step, err := calculateStep(time.Second*7, time.Second, 2, &queryStep)
+			require.NoError(t, err)
+			require.Equal(t, time.Second*14, step)
+		})
 
-	t.Run("step should math.Ceil in milliseconds, even if safeInterval happens", func(t *testing.T) {
-		require.Equal(t, time.Millisecond*3001, calculateStep(time.Second*2, time.Second*33001, 1))
-	})
+		// calculateStep parses a duration with support for unit that Grafana uses (e.g 1d)
+		t.Run("step with 1d", func(t *testing.T) {
+			queryStep := "1d"
+			step, err := calculateStep(time.Second*7, time.Second, 2, &queryStep)
+			require.NoError(t, err)
+			require.Equal(t, time.Hour*48, step)
+		})
 
-	t.Run("resolution should happen", func(t *testing.T) {
-		require.Equal(t, time.Second*5, calculateStep(time.Second*1, time.Second*100, 5))
-	})
+		// calculateStep parses a duration with support for unit that Grafana uses (e.g 1w)
+		t.Run("step with 1w", func(t *testing.T) {
+			queryStep := "1w"
+			step, err := calculateStep(time.Second*7, time.Second, 2, &queryStep)
+			require.NoError(t, err)
+			require.Equal(t, time.Hour*336, step)
+		})
 
-	t.Run("safeInterval check should happen after resolution is used", func(t *testing.T) {
-		require.Equal(t, time.Second*4, calculateStep(time.Second*2, time.Second*33000, 2))
+		// Returns error
+		t.Run("invalid step", func(t *testing.T) {
+			queryStep := "invalid"
+			step, err := calculateStep(time.Second*7, time.Second, 2, &queryStep)
+			require.Error(t, err)
+			require.Equal(t, time.Duration(0), step)
+		})
 	})
+	t.Run("with no query step", func(t *testing.T) {
+		t.Run("base case", func(t *testing.T) {
+			step, err := calculateStep(time.Second*7, time.Second, 2, nil)
+			require.NoError(t, err)
+			require.Equal(t, time.Second*14, step)
+		})
 
-	t.Run("survive interval=0", func(t *testing.T) {
-		// interval=0. this should never happen, but we make sure we return something sane
-		// (in this case safeInterval will take care of the problem)
-		require.Equal(t, time.Second*2, calculateStep(time.Second*0, time.Second*22000, 1))
-	})
+		t.Run("step should be at least 1 millisecond", func(t *testing.T) {
+			step, err := calculateStep(time.Microsecond*500, time.Second, 1, nil)
+			require.NoError(t, err)
+			require.Equal(t, time.Millisecond*1, step)
+		})
 
-	t.Run("survive resolution=0", func(t *testing.T) {
-		// resolution=0. this should never happen, but we make sure we return something sane
-		// (in this case safeInterval will take care of the problem)
-		require.Equal(t, time.Second*2, calculateStep(time.Second*1, time.Second*22000, 0))
-	})
+		t.Run("safeInterval should happen", func(t *testing.T) {
+			// safeInterval
+			step, err := calculateStep(time.Second*2, time.Second*33000, 1, nil)
+			require.NoError(t, err)
+			require.Equal(t, time.Second*3, step)
+		})
+
+		t.Run("step should math.Ceil in milliseconds", func(t *testing.T) {
+			step, err := calculateStep(time.Microsecond*1234, time.Second*1, 1, nil)
+			require.NoError(t, err)
+			require.Equal(t, time.Millisecond*2, step)
+		})
+
+		t.Run("step should math.Ceil in milliseconds, even if safeInterval happens", func(t *testing.T) {
+			step, err := calculateStep(time.Second*2, time.Second*33001, 1, nil)
+			require.NoError(t, err)
+			require.Equal(t, time.Millisecond*3001, step)
+		})
+
+		t.Run("resolution should happen", func(t *testing.T) {
+			step, err := calculateStep(time.Second*1, time.Second*100, 5, nil)
+			require.NoError(t, err)
+			require.Equal(t, time.Second*5, step)
+		})
+
+		t.Run("safeInterval check should happen after resolution is used", func(t *testing.T) {
+			step, err := calculateStep(time.Second*2, time.Second*33000, 2, nil)
+			require.NoError(t, err)
+			require.Equal(t, time.Second*4, step)
+		})
+
+		t.Run("survive interval=0", func(t *testing.T) {
+			// interval=0. this should never happen, but we make sure we return something sane
+			// (in this case safeInterval will take care of the problem)
+			step, err := calculateStep(time.Second*0, time.Second*22000, 1, nil)
+			require.NoError(t, err)
+			require.Equal(t, time.Second*2, step)
+		})
+
+		t.Run("survive resolution=0", func(t *testing.T) {
+			// resolution=0. this should never happen, but we make sure we return something sane
+			// (in this case safeInterval will take care of the problem)
+			step, err := calculateStep(time.Second*1, time.Second*22000, 0, nil)
+			require.NoError(t, err)
+			require.Equal(t, time.Second*2, step)
+		})
 
-	t.Run("survive interval=0 and resolution=0", func(t *testing.T) {
-		// resolution=0 and interval=0. this should never happen, but we make sure we return something sane
-		// (in this case safeInterval will take care of the problem)
-		require.Equal(t, time.Second*2, calculateStep(time.Second*0, time.Second*22000, 0))
+		t.Run("survive interval=0 and resolution=0", func(t *testing.T) {
+			// resolution=0 and interval=0. this should never happen, but we make sure we return something sane
+			// (in this case safeInterval will take care of the problem)
+			step, err := calculateStep(time.Second*0, time.Second*22000, 0, nil)
+			require.NoError(t, err)
+			require.Equal(t, time.Second*2, step)
+		})
 	})
 }

public/app/plugins/datasource/loki/querybuilder/components/LokiQueryBuilderOptions.tsx

@@ -61,14 +61,19 @@ export const LokiQueryBuilderOptions = React.memo<Props>(
       }
     }
 
-    let queryType = query.queryType ?? (query.instant ? LokiQueryType.Instant : LokiQueryType.Range);
-    let showMaxLines = isLogsQuery(query.expr);
+    function onStepChange(e: React.SyntheticEvent<HTMLInputElement>) {
+      onChange({ ...query, step: e.currentTarget.value.trimEnd() });
+      onRunQuery();
+    }
+
+    const queryType = query.queryType ?? (query.instant ? LokiQueryType.Instant : LokiQueryType.Range);
+    const isLogQuery = isLogsQuery(query.expr);
 
     return (
       <EditorRow>
         <QueryOptionGroup
           title="Options"
-          collapsedInfo={getCollapsedInfo(query, queryType, showMaxLines, maxLines)}
+          collapsedInfo={getCollapsedInfo(query, queryType, maxLines, isLogQuery)}
           queryStats={queryStats}
         >
           <EditorField
@@ -87,7 +92,7 @@ export const LokiQueryBuilderOptions = React.memo<Props>(
           <EditorField label="Type">
             <RadioButtonGroup options={queryTypeOptions} value={queryType} onChange={onQueryTypeChange} />
           </EditorField>
-          {showMaxLines && (
+          {isLogQuery && (
             <EditorField label="Line limit" tooltip="Upper limit for number of log lines returned by query.">
               <AutoSizeInput
                 className="width-4"
@@ -99,18 +104,34 @@ export const LokiQueryBuilderOptions = React.memo<Props>(
               />
             </EditorField>
           )}
-          <EditorField
-            label="Resolution"
-            tooltip="Sets the step parameter of Loki metrics range queries. With a resolution of 1/1, each pixel corresponds to one data point. 1/10 retrieves one data point per 10 pixels. Lower resolutions perform better."
-          >
-            <Select
-              isSearchable={false}
-              onChange={onResolutionChange}
-              options={RESOLUTION_OPTIONS}
-              value={query.resolution || 1}
-              aria-label="Select resolution"
-            />
-          </EditorField>
+          {!isLogQuery && (
+            <>
+              <EditorField
+                label="Step"
+                tooltip="Use the step parameter when making metric queries to Loki. If not filled, Grafana's calculated interval will be used. Example valid values: 1s, 5m, 10h, 1d."
+              >
+                <AutoSizeInput
+                  className="width-6"
+                  placeholder={'auto'}
+                  type="string"
+                  defaultValue={query.step ?? ''}
+                  onCommitChange={onStepChange}
+                />
+              </EditorField>
+              <EditorField
+                label="Resolution"
+                tooltip="Changes the step parameter of Loki metrics range queries. With a resolution of 1/1, each pixel corresponds to one data point. 1/10 retrieves one data point per 10 pixels. Lower resolutions perform better."
+              >
+                <Select
+                  isSearchable={false}
+                  onChange={onResolutionChange}
+                  options={RESOLUTION_OPTIONS}
+                  value={query.resolution || 1}
+                  aria-label="Select resolution"
+                />
+              </EditorField>
+            </>
+          )}
           {config.featureToggles.lokiQuerySplittingConfig && config.featureToggles.lokiQuerySplitting && (
             <EditorField
               label="Split Duration"
@@ -132,12 +153,7 @@ export const LokiQueryBuilderOptions = React.memo<Props>(
   }
 );
 
-function getCollapsedInfo(
-  query: LokiQuery,
-  queryType: LokiQueryType,
-  showMaxLines: boolean,
-  maxLines: number
-): string[] {
+function getCollapsedInfo(query: LokiQuery, queryType: LokiQueryType, maxLines: number, isLogQuery: boolean): string[] {
   const queryTypeLabel = queryTypeOptions.find((x) => x.value === queryType);
   const resolutionLabel = RESOLUTION_OPTIONS.find((x) => x.value === (query.resolution ?? 1));
 
@@ -153,10 +169,20 @@ function getCollapsedInfo(
 
   items.push(`Type: ${queryTypeLabel?.label}`);
 
-  if (showMaxLines) {
+  if (isLogQuery) {
     items.push(`Line limit: ${query.maxLines ?? maxLines}`);
   }
 
+  if (!isLogQuery) {
+    if (query.step) {
+      items.push(`Step: ${query.step}`);
+    }
+
+    if (query.resolution) {
+      items.push(`Resolution: ${resolutionLabel?.label}`);
+    }
+  }
+
   return items;
 }