testing autocomplete

apps/alerting/notifications/pkg/apis/alertingnotifications/v0alpha1/receiver_schema_gen.go

@@ -13,7 +13,7 @@ import (
 // schema is unexported to prevent accidental overwrites
 var (
 	schemaReceiver = resource.NewSimpleSchema("notifications.alerting.grafana.app", "v0alpha1", NewReceiver(), &ReceiverList{}, resource.WithKind("Receiver"),
-		resource.WithPlural("receivers"), resource.WithScope(resource.NamespacedScope), resource.WithSelectableFields([]resource.SelectableField{{
+		resource.WithPlural("receivers"), resource.WithScope(resource.NamespacedScope), resource.WithSelectableFields([]resource.SelectableField{resource.SelectableField{
 			FieldSelector: "spec.title",
 			FieldValueFunc: func(o resource.Object) (string, error) {
 				cast, ok := o.(*Receiver)

apps/dashboard/kinds/v2alpha1/dashboard_spec.cue

@@ -790,6 +790,8 @@ VariableOption: {
 	text: string | [...string]
 	// Value of the option
 	value: string | [...string]
+	// Additional properties for multi-props variables
+	properties?: {[string]: string}
 }
 
 // Query variable specification

apps/dashboard/kinds/v2beta1/dashboard_spec.cue

@@ -794,6 +794,8 @@ VariableOption: {
 	text: string | [...string]
 	// Value of the option
 	value: string | [...string]
+	// Additional properties for multi-props variables
+	properties?: {[string]: string}
 }
 
 // Query variable specification

apps/dashboard/pkg/apis/dashboard/v0alpha1/dashboard_object_gen.go

@@ -301,6 +301,8 @@ var _ resource.ListObject = &DashboardList{}
 
 // Copy methods for all subresource types
 
+
+
 // DeepCopy creates a full deep copy of DashboardStatus
 func (s *DashboardStatus) DeepCopy() *DashboardStatus {
 	cpy := &DashboardStatus{}

apps/dashboard/pkg/apis/dashboard/v1beta1/dashboard_object_gen.go

@@ -301,6 +301,8 @@ var _ resource.ListObject = &DashboardList{}
 
 // Copy methods for all subresource types
 
+
+
 // DeepCopy creates a full deep copy of DashboardStatus
 func (s *DashboardStatus) DeepCopy() *DashboardStatus {
 	cpy := &DashboardStatus{}

apps/dashboard/pkg/apis/dashboard/v2alpha1/dashboard_spec.cue

@@ -794,6 +794,8 @@ VariableOption: {
 	text: string | [...string]
 	// Value of the option
 	value: string | [...string]
+	// Additional properties for multi-props variables
+	properties?: {[string]: string}
 }
 
 // Query variable specification

apps/dashboard/pkg/apis/dashboard/v2alpha1/dashboard_spec_gen.go

@@ -1411,6 +1411,8 @@ type DashboardVariableOption struct {
 	Text DashboardStringOrArrayOfString `json:"text"`
 	// Value of the option
 	Value DashboardStringOrArrayOfString `json:"value"`
+	// Additional properties for multi-props variables
+	Properties map[string]string `json:"properties,omitempty"`
 }
 
 // NewDashboardVariableOption creates a new DashboardVariableOption object.

apps/dashboard/pkg/apis/dashboard/v2beta1/dashboard_spec.cue

@@ -798,6 +798,8 @@ VariableOption: {
 	text: string | [...string]
 	// Value of the option
 	value: string | [...string]
+	// Additional properties for multi-props variables
+	properties?: {[string]: string}
 }
 
 // Query variable specification

apps/dashboard/pkg/apis/dashboard/v2beta1/dashboard_spec_gen.go

@@ -1414,6 +1414,8 @@ type DashboardVariableOption struct {
 	Text DashboardStringOrArrayOfString `json:"text"`
 	// Value of the option
 	Value DashboardStringOrArrayOfString `json:"value"`
+	// Additional properties for multi-props variables
+	Properties map[string]string `json:"properties,omitempty"`
 }
 
 // NewDashboardVariableOption creates a new DashboardVariableOption object.

apps/folder/pkg/apis/manifestdata/folder_manifest.go

@@ -18,6 +18,8 @@ import (
 	v1beta1 "github.com/grafana/grafana/apps/folder/pkg/apis/folder/v1beta1"
 )
 
+var ()
+
 var appManifestData = app.ManifestData{
 	AppName:          "folder",
 	Group:            "folder.grafana.app",

go.mod

@@ -33,14 +33,12 @@ require (
 	github.com/armon/go-radix v1.0.0 // @grafana/grafana-app-platform-squad
 	github.com/aws/aws-sdk-go v1.55.7 // @grafana/aws-datasources
 	github.com/aws/aws-sdk-go-v2 v1.40.0 // @grafana/aws-datasources
-	github.com/aws/aws-sdk-go-v2/credentials v1.18.21 // @grafana/grafana-operator-experience-squad
 	github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.45.3 // @grafana/aws-datasources
 	github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs v1.51.0 // @grafana/aws-datasources
 	github.com/aws/aws-sdk-go-v2/service/ec2 v1.225.2 // @grafana/aws-datasources
 	github.com/aws/aws-sdk-go-v2/service/oam v1.18.3 // @grafana/aws-datasources
 	github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi v1.26.6 // @grafana/aws-datasources
 	github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.40.1 // @grafana/grafana-operator-experience-squad
-	github.com/aws/aws-sdk-go-v2/service/sts v1.39.1 // @grafana/grafana-operator-experience-squad
 	github.com/aws/smithy-go v1.23.2 // @grafana/aws-datasources
 	github.com/beevik/etree v1.4.1 // @grafana/grafana-backend-group
 	github.com/benbjohnson/clock v1.3.5 // @grafana/alerting-backend
@@ -345,6 +343,7 @@ require (
 	github.com/at-wat/mqtt-go v0.19.6 // indirect
 	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.11 // indirect
 	github.com/aws/aws-sdk-go-v2/config v1.31.17 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.18.21 // indirect
 	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.13 // indirect
 	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.84 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.14 // indirect
@@ -359,6 +358,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/s3 v1.84.0 // indirect
 	github.com/aws/aws-sdk-go-v2/service/sso v1.30.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.5 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.39.1 // indirect
 	github.com/axiomhq/hyperloglog v0.0.0-20240507144631-af9851f82b27 // indirect
 	github.com/bahlo/generic-list-go v0.2.0 // indirect
 	github.com/barkimedes/go-deepcopy v0.0.0-20220514131651-17c30cfc62df // indirect

packages/grafana-data/src/datetime/datemath.test.ts

@@ -165,17 +165,9 @@ describe('DateMath', () => {
       expect(date!.valueOf()).toEqual(dateTime([2014, 1, 3]).valueOf());
     });
 
-    it.each([
-      ['-2d-6h', [2014, 1, 5], [2014, 1, 2, 18]],
-      ['-30m-2d', [2014, 1, 5], [2014, 1, 2, 23, 30]],
-      ['-2d-1d', [2014, 1, 5], [2014, 1, 2]],
-      ['-1h-30m', [2014, 1, 5, 12, 0], [2014, 1, 5, 10, 30]],
-      ['-1d-1h-30m', [2014, 1, 5, 12, 0], [2014, 1, 4, 10, 30]],
-      ['+1d-6h', [2014, 1, 5], [2014, 1, 5, 18]],
-      ['-1w-1d', [2014, 1, 14], [2014, 1, 6]],
-    ])('should handle multiple math expressions: %s', (expression, inputDate, expectedDate) => {
-      const date = dateMath.parseDateMath(expression, dateTime(inputDate));
-      expect(date!.valueOf()).toEqual(dateTime(expectedDate).valueOf());
+    it('should handle multiple math expressions', () => {
+      const date = dateMath.parseDateMath('-2d-6h', dateTime([2014, 1, 5]));
+      expect(date!.valueOf()).toEqual(dateTime([2014, 1, 2, 18]).valueOf());
     });
 
     it('should return false when invalid expression', () => {

packages/grafana-sql/src/SQLVariableSupport.tsx

@@ -0,0 +1,174 @@
+import { useEffect, useState } from 'react';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+import {
+  CustomVariableSupport,
+  DataQueryRequest,
+  DataQueryResponse,
+  QueryEditorProps,
+  Field,
+  DataFrame,
+  MetricFindValue,
+} from '@grafana/data';
+import { t } from '@grafana/i18n';
+import { EditorMode, EditorRows, EditorRow, EditorField } from '@grafana/plugin-ui';
+import { Combobox, ComboboxOption } from '@grafana/ui';
+
+import { SqlQueryEditorLazy } from './components/QueryEditorLazy';
+import { SqlDatasource } from './datasource/SqlDatasource';
+import { applyQueryDefaults } from './defaults';
+import { QueryFormat, type SQLQuery, type SQLOptions, type SQLQueryMeta } from './types';
+
+type SQLVariableQuery = { query: string } & SQLQuery;
+
+const refId = 'SQLVariableQueryEditor-VariableQuery';
+
+export class SQLVariableSupport extends CustomVariableSupport<SqlDatasource, SQLQuery> {
+  constructor(readonly datasource: SqlDatasource) {
+    super();
+  }
+  editor = SQLVariablesQueryEditor;
+  query(request: DataQueryRequest<SQLQuery>): Observable<DataQueryResponse> {
+    if (request.targets.length < 1) {
+      throw new Error('no variable query found');
+    }
+    const updatedQuery = migrateVariableQuery(request.targets[0]);
+    return this.datasource.query({ ...request, targets: [updatedQuery] }).pipe(
+      map((d: DataQueryResponse) => {
+        const frames = d.data || [];
+        const metricFindValues = convertDataFramesToMetricFindValues(frames, updatedQuery.meta);
+        return { data: metricFindValues };
+      })
+    );
+  }
+  getDefaultQuery(): Partial<SQLQuery> {
+    return applyQueryDefaults({ refId, editorMode: EditorMode.Builder, format: QueryFormat.Table });
+  }
+}
+
+type SQLVariableQueryEditorProps = QueryEditorProps<SqlDatasource, SQLQuery, SQLOptions>;
+
+const SQLVariablesQueryEditor = (props: SQLVariableQueryEditorProps) => {
+  const query = migrateVariableQuery(props.query);
+  return (
+    <>
+      <SqlQueryEditorLazy {...props} query={query} />
+      <FieldMapping {...props} query={query} />
+    </>
+  );
+};
+
+const FieldMapping = (props: SQLVariableQueryEditorProps) => {
+  const { query, datasource, onChange } = props;
+  const [choices, setChoices] = useState<ComboboxOption[]>([]);
+  useEffect(() => {
+    let isActive = true;
+    // eslint-disable-next-line
+    const subscription = datasource.query({ targets: [query] } as DataQueryRequest<SQLQuery>).subscribe({
+      next: (response) => {
+        if (!isActive) {
+          return;
+        }
+        const fieldNames = (response.data[0] || { fields: [] }).fields.map((f: Field) => f.name);
+        setChoices(fieldNames.map((f: Field) => ({ value: f, label: f })));
+      },
+      error: () => {
+        if (isActive) {
+          setChoices([]);
+        }
+      },
+    });
+    return () => {
+      isActive = false;
+      subscription.unsubscribe();
+    };
+  }, [datasource, query]);
+  const onMetaPropChange = <Key extends keyof SQLQueryMeta, Value extends SQLQueryMeta[Key]>(
+    key: Key,
+    value: Value,
+    meta = query.meta || {}
+  ) => {
+    onChange({ ...query, meta: { ...meta, [key]: value } });
+  };
+  return (
+    <EditorRows>
+      <EditorRow>
+        <EditorField label={t('grafana-sql.components.query-meta.variables.valueField', 'Value Field')}>
+          <Combobox
+            isClearable
+            value={query.meta?.valueField}
+            onChange={(e) => onMetaPropChange('valueField', e?.value)}
+            width={40}
+            options={choices}
+          />
+        </EditorField>
+        <EditorField label={t('grafana-sql.components.query-meta.variables.textField', 'Text Field')}>
+          <Combobox
+            isClearable
+            value={query.meta?.textField}
+            onChange={(e) => onMetaPropChange('textField', e?.value)}
+            width={40}
+            options={choices}
+          />
+        </EditorField>
+      </EditorRow>
+    </EditorRows>
+  );
+};
+
+const migrateVariableQuery = (rawQuery: string | SQLQuery): SQLVariableQuery => {
+  if (typeof rawQuery !== 'string') {
+    return {
+      ...rawQuery,
+      refId: rawQuery.refId || refId,
+      query: rawQuery.rawSql || '',
+    };
+  }
+  return {
+    ...applyQueryDefaults({
+      refId,
+      rawSql: rawQuery,
+      editorMode: rawQuery ? EditorMode.Code : EditorMode.Builder,
+    }),
+    query: rawQuery,
+  };
+};
+
+const convertDataFramesToMetricFindValues = (frames: DataFrame[], meta?: SQLQueryMeta): MetricFindValue[] => {
+  if (!frames.length) {
+    throw new Error('no results found');
+  }
+
+  const frame = frames[0];
+
+  const fields = frame.fields;
+
+  if (fields.length < 1) {
+    throw new Error('no fields found in the response');
+  }
+
+  let textField = fields.find((f) => f.name === '__text');
+  let valueField = fields.find((f) => f.name === '__value');
+  if (meta?.textField) {
+    textField = fields.find((f) => f.name === meta.textField);
+  }
+  if (meta?.valueField) {
+    valueField = fields.find((f) => f.name === meta.valueField);
+  }
+  const resolvedTextField = textField || valueField || fields[0];
+  const resolvedValueField = valueField || textField || fields[0];
+
+  const results: MetricFindValue[] = [];
+  const rowCount = frame.length;
+  for (let i = 0; i < rowCount; i++) {
+    const text = String(resolvedTextField.values[i] ?? '');
+    const value = String(resolvedValueField.values[i] ?? '');
+    const properties: Record<string, string> = {};
+    for (const field of fields) {
+      properties[field.name] = String(field.values[i] ?? '');
+    }
+    results.push({ text, value, properties });
+  }
+  return results;
+};

packages/grafana-sql/src/index.ts

@@ -21,6 +21,7 @@ export { TLSSecretsConfig } from './components/configuration/TLSSecretsConfig';
 export { useMigrateDatabaseFields } from './components/configuration/useMigrateDatabaseFields';
 export { SqlQueryEditorLazy } from './components/QueryEditorLazy';
 export type { QueryHeaderProps } from './components/QueryHeader';
+export { SQLVariableSupport } from './SQLVariableSupport';
 export { createSelectClause, haveColumns } from './utils/sql.utils';
 export { applyQueryDefaults } from './defaults';
 export { makeVariable } from './utils/testHelpers';

packages/grafana-sql/src/locales/en-US/grafana-sql.json

@@ -69,6 +69,12 @@
         "placeholder-select-format": "Select format",
         "run-query": "Run query"
       },
+      "query-meta": {
+        "variables": {
+          "textField": "Text Field",
+          "valueField": "Value Field"
+        }
+      },
       "query-toolbox": {
         "content-hit-ctrlcmdreturn-to-run-query": "Hit CTRL/CMD+Return to run query",
         "tooltip-collapse": "Collapse editor",

packages/grafana-sql/src/types.ts

@@ -50,6 +50,8 @@ export enum QueryFormat {
   Table = 'table',
 }
 
+export type SQLQueryMeta = { valueField?: string; textField?: string };
+
 export interface SQLQuery extends DataQuery {
   alias?: string;
   format?: QueryFormat;
@@ -59,6 +61,7 @@ export interface SQLQuery extends DataQuery {
   sql?: SQLExpression;
   editorMode?: EditorMode;
   rawQuery?: boolean;
+  meta?: SQLQueryMeta;
 }
 
 export interface NameValue {

pkg/api/datasources.go

@@ -204,7 +204,7 @@ func (hs *HTTPServer) DeleteDataSourceById(c *contextmodel.ReqContext) response.
 func (hs *HTTPServer) GetDataSourceByUID(c *contextmodel.ReqContext) response.Response {
 	start := time.Now()
 	defer func() {
-		metricutil.ObserveWithExemplar(c.Req.Context(), hs.dsConfigHandlerRequestsDuration.WithLabelValues("GetDataSourceByUID"), time.Since(start).Seconds())
+		metricutil.ObserveWithExemplar(c.Req.Context(), hs.dsConfigHandlerRequestsDuration.WithLabelValues("legacy", "GetDataSourceByUID"), time.Since(start).Seconds())
 	}()
 
 	ds, err := hs.getRawDataSourceByUID(c.Req.Context(), web.Params(c.Req)[":uid"], c.GetOrgID())
@@ -240,7 +240,7 @@ func (hs *HTTPServer) GetDataSourceByUID(c *contextmodel.ReqContext) response.Re
 func (hs *HTTPServer) DeleteDataSourceByUID(c *contextmodel.ReqContext) response.Response {
 	start := time.Now()
 	defer func() {
-		metricutil.ObserveWithExemplar(c.Req.Context(), hs.dsConfigHandlerRequestsDuration.WithLabelValues("DeleteDataSourceByUID"), time.Since(start).Seconds())
+		metricutil.ObserveWithExemplar(c.Req.Context(), hs.dsConfigHandlerRequestsDuration.WithLabelValues("legacy", "DeleteDataSourceByUID"), time.Since(start).Seconds())
 	}()
 
 	uid := web.Params(c.Req)[":uid"]
@@ -375,7 +375,7 @@ func validateJSONData(jsonData *simplejson.Json, cfg *setting.Cfg) error {
 func (hs *HTTPServer) AddDataSource(c *contextmodel.ReqContext) response.Response {
 	start := time.Now()
 	defer func() {
-		metricutil.ObserveWithExemplar(c.Req.Context(), hs.dsConfigHandlerRequestsDuration.WithLabelValues("AddDataSource"), time.Since(start).Seconds())
+		metricutil.ObserveWithExemplar(c.Req.Context(), hs.dsConfigHandlerRequestsDuration.WithLabelValues("legacy", "AddDataSource"), time.Since(start).Seconds())
 	}()
 
 	cmd := datasources.AddDataSourceCommand{}
@@ -497,7 +497,7 @@ func (hs *HTTPServer) UpdateDataSourceByID(c *contextmodel.ReqContext) response.
 func (hs *HTTPServer) UpdateDataSourceByUID(c *contextmodel.ReqContext) response.Response {
 	start := time.Now()
 	defer func() {
-		metricutil.ObserveWithExemplar(c.Req.Context(), hs.dsConfigHandlerRequestsDuration.WithLabelValues("UpdateDataSourceByUID"), time.Since(start).Seconds())
+		metricutil.ObserveWithExemplar(c.Req.Context(), hs.dsConfigHandlerRequestsDuration.WithLabelValues("legacy", "UpdateDataSourceByUID"), time.Since(start).Seconds())
 	}()
 	cmd := datasources.UpdateDataSourceCommand{}
 	if err := web.Bind(c.Req, &cmd); err != nil {

pkg/api/datasources_test.go

@@ -91,7 +91,7 @@ func setupDsConfigHandlerMetrics() (prometheus.Registerer, *prometheus.Histogram
 		Namespace: "grafana",
 		Name:      "ds_config_handler_requests_duration_seconds",
 		Help:      "Duration of requests handled by datasource configuration handlers",
-	}, []string{"handler"})
+	}, []string{"code_path", "handler"})
 	promRegister.MustRegister(dsConfigHandlerRequestsDuration)
 	return promRegister, dsConfigHandlerRequestsDuration
 }

pkg/api/http_server.go

@@ -387,7 +387,7 @@ func ProvideHTTPServer(opts ServerOptions, cfg *setting.Cfg, routeRegister routi
 			Namespace: "grafana",
 			Name:      "ds_config_handler_requests_duration_seconds",
 			Help:      "Duration of requests handled by datasource configuration handlers",
-		}, []string{"handler"}),
+		}, []string{"code_path", "handler"}),
 	}
 
 	promRegister.MustRegister(hs.htmlHandlerRequestsDuration)

pkg/extensions/enterprise_imports.go

@@ -11,9 +11,6 @@ import (
 	_ "github.com/Azure/azure-sdk-for-go/services/keyvault/v7.1/keyvault"
 	_ "github.com/Azure/go-autorest/autorest"
 	_ "github.com/Azure/go-autorest/autorest/adal"
-	_ "github.com/aws/aws-sdk-go-v2/credentials"
-	_ "github.com/aws/aws-sdk-go-v2/service/secretsmanager"
-	_ "github.com/aws/aws-sdk-go-v2/service/sts"
 	_ "github.com/beevik/etree"
 	_ "github.com/blugelabs/bluge"
 	_ "github.com/blugelabs/bluge_segment_api"
@@ -49,6 +46,7 @@ import (
 	_ "sigs.k8s.io/randfill"
 	_ "xorm.io/builder"
 
+	_ "github.com/aws/aws-sdk-go-v2/service/secretsmanager"
 	_ "github.com/grafana/authlib/authn"
 	_ "github.com/grafana/authlib/authz"
 	_ "github.com/grafana/authlib/cache"

pkg/infra/tracing/tracing.go

@@ -209,7 +209,7 @@ func (ots *TracingService) initSampler() (tracesdk.Sampler, error) {
 	case "rateLimiting":
 		return newRateLimiter(ots.cfg.SamplerParam), nil
 	case "remote":
-		return jaegerremote.New(ots.cfg.ServiceName,
+		return jaegerremote.New("grafana",
 			jaegerremote.WithSamplingServerURL(ots.cfg.SamplerRemoteURL),
 			jaegerremote.WithInitialSampler(tracesdk.TraceIDRatioBased(ots.cfg.SamplerParam)),
 		), nil

pkg/registry/apis/datasource/legacy_store.go

@@ -57,12 +57,6 @@ func (s *legacyStorage) ConvertToTable(ctx context.Context, object runtime.Objec
 }
 
 func (s *legacyStorage) List(ctx context.Context, options *internalversion.ListOptions) (runtime.Object, error) {
-	if s.dsConfigHandlerRequestsDuration != nil {
-		start := time.Now()
-		defer func() {
-			metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("legacyStorage.List"), time.Since(start).Seconds())
-		}()
-	}
 	return s.datasources.ListDataSources(ctx)
 }
 
@@ -70,7 +64,7 @@ func (s *legacyStorage) Get(ctx context.Context, name string, options *metav1.Ge
 	if s.dsConfigHandlerRequestsDuration != nil {
 		start := time.Now()
 		defer func() {
-			metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("legacyStorage.Get"), time.Since(start).Seconds())
+			metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("new", "Get"), time.Since(start).Seconds())
 		}()
 	}
 
@@ -82,7 +76,7 @@ func (s *legacyStorage) Create(ctx context.Context, obj runtime.Object, createVa
 	if s.dsConfigHandlerRequestsDuration != nil {
 		start := time.Now()
 		defer func() {
-			metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("legacyStorage.Create"), time.Since(start).Seconds())
+			metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("new", "Create"), time.Since(start).Seconds())
 		}()
 	}
 
@@ -98,7 +92,7 @@ func (s *legacyStorage) Update(ctx context.Context, name string, objInfo rest.Up
 	if s.dsConfigHandlerRequestsDuration != nil {
 		start := time.Now()
 		defer func() {
-			metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("legacyStorage.Update"), time.Since(start).Seconds())
+			metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("new", "Create"), time.Since(start).Seconds())
 		}()
 	}
 
@@ -141,7 +135,7 @@ func (s *legacyStorage) Delete(ctx context.Context, name string, deleteValidatio
 	if s.dsConfigHandlerRequestsDuration != nil {
 		start := time.Now()
 		defer func() {
-			metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("legacyStorage.Delete"), time.Since(start).Seconds())
+			metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("new", "Create"), time.Since(start).Seconds())
 		}()
 	}
 
@@ -151,13 +145,6 @@ func (s *legacyStorage) Delete(ctx context.Context, name string, deleteValidatio
 
 // DeleteCollection implements rest.CollectionDeleter.
 func (s *legacyStorage) DeleteCollection(ctx context.Context, deleteValidation rest.ValidateObjectFunc, options *metav1.DeleteOptions, listOptions *internalversion.ListOptions) (runtime.Object, error) {
-	if s.dsConfigHandlerRequestsDuration != nil {
-		start := time.Now()
-		defer func() {
-			metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("legacyStorage.DeleteCollection"), time.Since(start).Seconds())
-		}()
-	}
-
 	dss, err := s.datasources.ListDataSources(ctx)
 	if err != nil {
 		return nil, err

pkg/registry/apis/datasource/register.go

@@ -21,7 +21,6 @@ import (
 	datasourceV0 "github.com/grafana/grafana/pkg/apis/datasource/v0alpha1"
 	queryV0 "github.com/grafana/grafana/pkg/apis/query/v0alpha1"
 	grafanaregistry "github.com/grafana/grafana/pkg/apiserver/registry/generic"
-	"github.com/grafana/grafana/pkg/infra/metrics"
 	"github.com/grafana/grafana/pkg/infra/metrics/metricutil"
 	"github.com/grafana/grafana/pkg/plugins"
 	"github.com/grafana/grafana/pkg/plugins/manager/sources"
@@ -70,10 +69,10 @@ func RegisterAPIService(
 
 	dataSourceCRUDMetric := metricutil.NewHistogramVec(prometheus.HistogramOpts{
 		Namespace: "grafana",
-		Name:      "ds_config_handler_apis_requests_duration_seconds",
-		Help:      "Duration of requests handled by new k8s style APIs datasource configuration handlers",
-	}, []string{"handler"})
-	regErr := metrics.ProvideRegisterer().Register(dataSourceCRUDMetric)
+		Name:      "ds_config_handler_requests_duration_seconds",
+		Help:      "Duration of requests handled by datasource configuration handlers",
+	}, []string{"code_path", "handler"})
+	regErr := reg.Register(dataSourceCRUDMetric)
 	if regErr != nil && !errors.As(regErr, &prometheus.AlreadyRegisteredError{}) {
 		return nil, regErr
 	}

pkg/registry/apps/plugins/register.go

@@ -13,7 +13,6 @@ import (
 	"github.com/grafana/grafana/pkg/services/apiserver"
 	"github.com/grafana/grafana/pkg/services/apiserver/appinstaller"
 	grafanaauthorizer "github.com/grafana/grafana/pkg/services/apiserver/auth/authorizer"
-	"github.com/grafana/grafana/pkg/services/featuremgmt"
 	"github.com/grafana/grafana/pkg/services/pluginsintegration/pluginassets"
 	"github.com/grafana/grafana/pkg/services/pluginsintegration/pluginstore"
 )
@@ -37,13 +36,9 @@ func ProvideAppInstaller(
 	pluginStore pluginstore.Store,
 	pluginAssetsService *pluginassets.Service,
 	accessControlService accesscontrol.Service, accessClient authlib.AccessClient,
-	features featuremgmt.FeatureToggles,
 ) (*AppInstaller, error) {
-	//nolint:staticcheck // not yet migrated to OpenFeature
-	if features.IsEnabledGlobally(featuremgmt.FlagPluginStoreServiceLoading) {
-		if err := registerAccessControlRoles(accessControlService); err != nil {
-			return nil, fmt.Errorf("registering access control roles: %w", err)
-		}
+	if err := registerAccessControlRoles(accessControlService); err != nil {
+		return nil, fmt.Errorf("registering access control roles: %w", err)
 	}
 
 	localProvider := meta.NewLocalProvider(pluginStore, pluginAssetsService)

pkg/server/wire_gen.go

@@ -785,7 +785,7 @@ func Initialize(ctx context.Context, cfg *setting.Cfg, opts Options, apiOpts api
 	if err != nil {
 		return nil, err
 	}
-	appInstaller, err := plugins.ProvideAppInstaller(configProvider, eventualRestConfigProvider, pluginstoreService, pluginassetsService, acimplService, accessClient, featureToggles)
+	appInstaller, err := plugins.ProvideAppInstaller(configProvider, eventualRestConfigProvider, pluginstoreService, pluginassetsService, acimplService, accessClient)
 	if err != nil {
 		return nil, err
 	}
@@ -1447,7 +1447,7 @@ func InitializeForTest(ctx context.Context, t sqlutil.ITestDB, testingT interfac
 	if err != nil {
 		return nil, err
 	}
-	appInstaller, err := plugins.ProvideAppInstaller(configProvider, eventualRestConfigProvider, pluginstoreService, pluginassetsService, acimplService, accessClient, featureToggles)
+	appInstaller, err := plugins.ProvideAppInstaller(configProvider, eventualRestConfigProvider, pluginstoreService, pluginassetsService, acimplService, accessClient)
 	if err != nil {
 		return nil, err
 	}

pkg/services/featuremgmt/models.go

@@ -126,63 +126,6 @@ func (s *FeatureFlagStage) UnmarshalJSON(b []byte) error {
 	return nil
 }
 
-type FeatureFlagType int
-
-const (
-	Boolean FeatureFlagType = iota
-	Integer
-	Float
-	String
-	Structure
-)
-
-func (t FeatureFlagType) String() string {
-	switch t {
-	case Boolean:
-		return "boolean"
-	case Integer:
-		return "integer"
-	case Float:
-		return "float"
-	case String:
-		return "string"
-	case Structure:
-		return "structure"
-	}
-
-	return "unknown"
-}
-
-// MarshalJSON marshals the enum as a quoted json string
-func (t FeatureFlagType) MarshalJSON() ([]byte, error) {
-	buffer := bytes.NewBufferString(`"`)
-	buffer.WriteString(t.String())
-	buffer.WriteString(`"`)
-	return buffer.Bytes(), nil
-}
-
-func (t *FeatureFlagType) UnmarshalJSON(b []byte) error {
-	var j string
-	err := json.Unmarshal(b, &j)
-	if err != nil {
-		return err
-	}
-
-	switch j {
-	case "boolean":
-		*t = Boolean
-	case "integer":
-		*t = Integer
-	case "float":
-		*t = Float
-	case "string":
-		*t = String
-	case "structure":
-		*t = Structure
-	}
-	return nil
-}
-
 // These are properties about the feature, but not the current state or value for it
 type FeatureFlag struct {
 	Name        string           `json:"name" yaml:"name"` // Unique name
@@ -192,8 +135,6 @@ type FeatureFlag struct {
 
 	// CEL-GO expression.  Using the value "true" will mean this is on by default
 	Expression string `json:"expression,omitempty"`
-	// Type of the feature flag (boolean, number, string, structure),
-	Type FeatureFlagType `json:"type,omitempty"`
 
 	// Special behavior properties
 	RequiresDevMode bool `json:"requiresDevMode,omitempty"` // can not be enabled in production

pkg/services/featuremgmt/openfeature.go

@@ -26,7 +26,7 @@ type OpenFeatureConfig struct {
 	// HTTPClient is a pre-configured HTTP client (optional, used by features-service + OFREP providers)
 	HTTPClient *http.Client
 	// StaticFlags are the feature flags to use with static provider
-	StaticFlags map[string]setting.FeatureToggle
+	StaticFlags map[string]bool
 	// TargetingKey is used for evaluation context
 	TargetingKey string
 	// ContextAttrs are additional attributes for evaluation context
@@ -100,7 +100,7 @@ func InitOpenFeatureWithCfg(cfg *setting.Cfg) error {
 func createProvider(
 	providerType string,
 	u *url.URL,
-	staticFlags map[string]setting.FeatureToggle,
+	staticFlags map[string]bool,
 	httpClient *http.Client,
 ) (openfeature.FeatureProvider, error) {
 	if providerType == setting.FeaturesServiceProviderType || providerType == setting.OFREPProviderType {
@@ -117,7 +117,7 @@ func createProvider(
 		}
 	}
 
-	return newStaticProvider(staticFlags, standardFeatureFlags)
+	return newStaticProvider(staticFlags)
 }
 
 func createHTTPClient(m *clientauthmiddleware.TokenExchangeMiddleware) (*http.Client, error) {

pkg/services/featuremgmt/service.go

@@ -47,7 +47,7 @@ func ProvideManagerService(cfg *setting.Cfg) (*FeatureManager, error) {
 			}
 			mgmt.warnings[key] = "unknown flag in config"
 		}
-		mgmt.startup[key] = val.Value == true
+		mgmt.startup[key] = val
 	}
 
 	// update the values

pkg/services/featuremgmt/static_evaluator.go

@@ -29,7 +29,7 @@ func CreateStaticEvaluator(cfg *setting.Cfg) (StaticFlagEvaluator, error) {
 		return nil, fmt.Errorf("failed to read feature flags from config: %w", err)
 	}
 
-	staticProvider, err := newStaticProvider(staticFlags, standardFeatureFlags)
+	staticProvider, err := newStaticProvider(staticFlags)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create static provider: %w", err)
 	}

pkg/services/featuremgmt/static_provider.go

@@ -1,11 +1,6 @@
 package featuremgmt
 
 import (
-	"encoding/json"
-	"fmt"
-	"strconv"
-
-	"github.com/grafana/grafana/pkg/setting"
 	"github.com/open-feature/go-sdk/openfeature"
 	"github.com/open-feature/go-sdk/openfeature/memprovider"
 )
@@ -33,76 +28,37 @@ func (p *inMemoryBulkProvider) ListFlags() ([]string, error) {
 	return keys, nil
 }
 
-func newStaticProvider(confFlags map[string]setting.FeatureToggle, standardFlags []FeatureFlag) (openfeature.FeatureProvider, error) {
-	flags := make(map[string]memprovider.InMemoryFlag, len(standardFlags))
-	index := make(map[string]FeatureFlag, len(standardFlags))
-	// Add standard flags
-	for _, flag := range standardFlags {
-		inMemFlag, err := createTypedFlag(flag)
-		if err != nil {
-			return nil, err
-		}
-
-		flags[flag.Name] = inMemFlag
-		index[flag.Name] = flag
-	}
+func newStaticProvider(confFlags map[string]bool) (openfeature.FeatureProvider, error) {
+	flags := make(map[string]memprovider.InMemoryFlag, len(standardFeatureFlags))
 
 	// Add flags from config.ini file
-	for name, flag := range confFlags {
-		standard, exists := index[flag.Name]
+	for name, value := range confFlags {
+		flags[name] = createInMemoryFlag(name, value)
+	}
 
-		// Fail fast if a flag is declared with a mismatched type
-		if exists && standard.Type.String() != string(flag.Type) {
-			return nil, fmt.Errorf("type mismatch for flag '%s' detected", flag.Name)
+	// Add standard flags
+	for _, flag := range standardFeatureFlags {
+		if _, exists := flags[flag.Name]; !exists {
+			enabled := flag.Expression == "true"
+			flags[flag.Name] = createInMemoryFlag(flag.Name, enabled)
 		}
-
-		flags[name] = createInMemoryFlag(flag)
 	}
 
 	return newInMemoryBulkProvider(flags), nil
 }
 
-func createInMemoryFlag(flag setting.FeatureToggle) memprovider.InMemoryFlag {
-	variant := "default"
+func createInMemoryFlag(name string, enabled bool) memprovider.InMemoryFlag {
+	variant := "disabled"
+	if enabled {
+		variant = "enabled"
+	}
 
 	return memprovider.InMemoryFlag{
-		Key:            flag.Name,
+		Key:            name,
 		DefaultVariant: variant,
-		Variants: map[string]any{
-			variant: flag.Value,
+		Variants: map[string]interface{}{
+			"enabled":  true,
+			"disabled": false,
 		},
 	}
 }
-
-func createTypedFlag(flag FeatureFlag) (memprovider.InMemoryFlag, error) {
-	defaultVariant := "default"
-
-	var value any
-	var err error
-	switch flag.Type {
-	case Boolean:
-		value = flag.Expression == "true"
-	case Integer:
-		value, err = strconv.Atoi(flag.Expression)
-	case Float:
-		value, err = strconv.ParseFloat(flag.Expression, 64)
-	case String:
-		value = flag.Expression
-	case Structure:
-		err = json.Unmarshal([]byte(flag.Expression), &value)
-	default:
-		return memprovider.InMemoryFlag{}, fmt.Errorf("unsupported flag type %s", flag.Type)
-	}
-
-	if err != nil {
-		return memprovider.InMemoryFlag{}, err
-	}
-
-	return memprovider.InMemoryFlag{
-		Key:            flag.Name,
-		DefaultVariant: defaultVariant,
-		Variants: map[string]any{
-			defaultVariant: value,
-		},
-	}, nil
-}

pkg/services/featuremgmt/static_provider_test.go

@@ -93,178 +93,3 @@ ABCD = true
 	enabledFeatureManager := mgr.GetEnabled(ctx)
 	assert.Equal(t, openFeatureEnabledFlags, enabledFeatureManager)
 }
-
-func Test_StaticProvider_FailfastOnMismatchedType(t *testing.T) {
-	staticFlags := map[string]setting.FeatureToggle{"oldBooleanFlag": {
-		Type:  setting.Boolean,
-		Name:  "oldBooleanFlag",
-		Value: true,
-	}}
-
-	flag := FeatureFlag{
-		Name:       "oldBooleanFlag",
-		Expression: "1.0",
-		Type:       Float,
-	}
-	_, err := newStaticProvider(staticFlags, []FeatureFlag{flag})
-	assert.EqualError(t, err, "type mismatch for flag 'oldBooleanFlag' detected")
-}
-
-func Test_StaticProvider_TypedFlags(t *testing.T) {
-	tests := []struct {
-		flags         FeatureFlag
-		defaultValue  any
-		expectedValue any
-	}{
-		{
-			flags: FeatureFlag{
-				Name:       "Flag",
-				Expression: "true",
-				Type:       Boolean,
-			},
-			defaultValue:  false,
-			expectedValue: true,
-		},
-		{
-			flags: FeatureFlag{
-				Name:       "Flag",
-				Expression: "1.0",
-				Type:       Float,
-			},
-			defaultValue:  0.0,
-			expectedValue: 1.0,
-		},
-		{
-			flags: FeatureFlag{
-				Name:       "Flag",
-				Expression: "blue",
-				Type:       String,
-			},
-			defaultValue:  "red",
-			expectedValue: "blue",
-		},
-		{
-			flags: FeatureFlag{
-				Name:       "Flag",
-				Expression: "1",
-				Type:       Integer,
-			},
-			defaultValue:  int64(0),
-			expectedValue: int64(1),
-		},
-		{
-			flags: FeatureFlag{
-				Name:       "Flag",
-				Expression: `{ "foo": "bar" }`,
-				Type:       Structure,
-			},
-			defaultValue:  nil,
-			expectedValue: map[string]any{"foo": "bar"},
-		},
-	}
-
-	for _, tt := range tests {
-		provider, err := newStaticProvider(nil, []FeatureFlag{tt.flags})
-		assert.NoError(t, err)
-
-		var result any
-		switch tt.flags.Type {
-		case Boolean:
-			result = provider.BooleanEvaluation(t.Context(), tt.flags.Name, tt.defaultValue.(bool), openfeature.FlattenedContext{}).Value
-		case Float:
-			result = provider.FloatEvaluation(t.Context(), tt.flags.Name, tt.defaultValue.(float64), openfeature.FlattenedContext{}).Value
-		case String:
-			result = provider.StringEvaluation(t.Context(), tt.flags.Name, tt.defaultValue.(string), openfeature.FlattenedContext{}).Value
-		case Integer:
-			result = provider.IntEvaluation(t.Context(), tt.flags.Name, tt.defaultValue.(int64), openfeature.FlattenedContext{}).Value
-		case Structure:
-			result = provider.ObjectEvaluation(t.Context(), tt.flags.Name, tt.defaultValue, openfeature.FlattenedContext{}).Value
-		}
-
-		assert.Equal(t, tt.expectedValue, result)
-	}
-}
-func Test_StaticProvider_ConfigOverride(t *testing.T) {
-	tests := []struct {
-		name          string
-		typ           FeatureFlagType
-		originalValue string
-		configValue   any
-	}{
-		{
-			name:          "bool",
-			typ:           Boolean,
-			originalValue: "false",
-			configValue:   true,
-		},
-		{
-			name:          "int",
-			typ:           Integer,
-			originalValue: "0",
-			configValue:   int64(1),
-		},
-		{
-			name:          "float",
-			typ:           Float,
-			originalValue: "0.0",
-			configValue:   1.0,
-		},
-		{
-			name:          "string",
-			typ:           String,
-			originalValue: "foo",
-			configValue:   "bar",
-		},
-		{
-			name:          "structure",
-			typ:           Structure,
-			originalValue: "{}",
-			configValue:   make(map[string]any),
-		},
-	}
-
-	for _, tt := range tests {
-		configFlags, standardFlags := makeFlags(tt)
-		provider, err := newStaticProvider(configFlags, standardFlags)
-		assert.NoError(t, err)
-
-		var result any
-		switch tt.typ {
-		case Boolean:
-			result = provider.BooleanEvaluation(t.Context(), tt.name, false, openfeature.FlattenedContext{}).Value
-		case Float:
-			result = provider.FloatEvaluation(t.Context(), tt.name, 0.0, openfeature.FlattenedContext{}).Value
-		case String:
-			result = provider.StringEvaluation(t.Context(), tt.name, "foo", openfeature.FlattenedContext{}).Value
-		case Integer:
-			result = provider.IntEvaluation(t.Context(), tt.name, 1, openfeature.FlattenedContext{}).Value
-		case Structure:
-			result = provider.ObjectEvaluation(t.Context(), tt.name, make(map[string]any), openfeature.FlattenedContext{}).Value
-		}
-
-		assert.Equal(t, tt.configValue, result)
-	}
-}
-
-func makeFlags(tt struct {
-	name          string
-	typ           FeatureFlagType
-	originalValue string
-	configValue   any
-}) (map[string]setting.FeatureToggle, []FeatureFlag) {
-	orig := FeatureFlag{
-		Name:       tt.name,
-		Expression: tt.originalValue,
-		Type:       tt.typ,
-	}
-
-	config := map[string]setting.FeatureToggle{
-		tt.name: {
-			Name:  tt.name,
-			Type:  setting.FeatureFlagType(tt.typ.String()),
-			Value: tt.configValue,
-		},
-	}
-
-	return config, []FeatureFlag{orig}
-}

pkg/services/updatemanager/plugins_test.go

@@ -378,8 +378,8 @@ func setupOpenFeatureProvider(t *testing.T, flagValue bool) {
 
 	err := featuremgmt.InitOpenFeature(featuremgmt.OpenFeatureConfig{
 		ProviderType: setting.StaticProviderType,
-		StaticFlags: map[string]setting.FeatureToggle{
-			featuremgmt.FlagPluginsAutoUpdate: {Value: flagValue, Type: setting.Boolean},
+		StaticFlags: map[string]bool{
+			featuremgmt.FlagPluginsAutoUpdate: flagValue,
 		},
 	})
 	require.NoError(t, err)

pkg/setting/setting_feature_toggles.go

@@ -1,8 +1,6 @@
 package setting
 
 import (
-	"encoding/json"
-	"fmt"
 	"strconv"
 
 	"gopkg.in/ini.v1"
@@ -10,22 +8,6 @@ import (
 	"github.com/grafana/grafana/pkg/util"
 )
 
-type FeatureFlagType string
-
-const (
-	Structure FeatureFlagType = "structure"
-	Integer   FeatureFlagType = "integer"
-	Float     FeatureFlagType = "float"
-	Boolean   FeatureFlagType = "boolean"
-	String    FeatureFlagType = "string"
-)
-
-type FeatureToggle struct {
-	Type  FeatureFlagType `json:"type"`
-	Name  string          `json:"name"`
-	Value any             `json:"value"`
-}
-
 // Deprecated: should use `featuremgmt.FeatureToggles`
 func (cfg *Cfg) readFeatureToggles(iniFile *ini.File) error {
 	section := iniFile.Section("feature_toggles")
@@ -33,30 +15,18 @@ func (cfg *Cfg) readFeatureToggles(iniFile *ini.File) error {
 	if err != nil {
 		return err
 	}
-	// TODO IsFeatureToggleEnabled has been deprecated for 2 years now, we should remove this function completely
 	// nolint:staticcheck
-	cfg.IsFeatureToggleEnabled = func(key string) bool {
-		toggle, ok := toggles[key]
-		if !ok {
-			return false
-		}
-
-		return toggle.Type == Boolean && toggle.Value == true
-	}
+	cfg.IsFeatureToggleEnabled = func(key string) bool { return toggles[key] }
 	return nil
 }
 
-func ReadFeatureTogglesFromInitFile(featureTogglesSection *ini.Section) (map[string]FeatureToggle, error) {
-	featureToggles := make(map[string]FeatureToggle, 10)
+func ReadFeatureTogglesFromInitFile(featureTogglesSection *ini.Section) (map[string]bool, error) {
+	featureToggles := make(map[string]bool, 10)
 
 	// parse the comma separated list in `enable`.
 	featuresTogglesStr := valueAsString(featureTogglesSection, "enable", "")
 	for _, feature := range util.SplitString(featuresTogglesStr) {
-		featureToggles[feature] = FeatureToggle{
-			Type:  Boolean,
-			Name:  feature,
-			Value: true,
-		}
+		featureToggles[feature] = true
 	}
 
 	// read all other settings under [feature_toggles]. If a toggle is
@@ -66,36 +36,12 @@ func ReadFeatureTogglesFromInitFile(featureTogglesSection *ini.Section) (map[str
 			continue
 		}
 
-		b, err := ParseFlag(v.Name(), v.Value())
+		b, err := strconv.ParseBool(v.Value())
 		if err != nil {
 			return featureToggles, err
 		}
 
-		flag, exists := featureToggles[v.Name()]
-		if exists && flag.Type != b.Type {
-			return nil, fmt.Errorf("type mismatch during flag declaration '%s': %s, %s", v.Name(), flag.Type, b.Type)
-		}
-
 		featureToggles[v.Name()] = b
 	}
 	return featureToggles, nil
 }
-
-func ParseFlag(name, value string) (FeatureToggle, error) {
-	var structure map[string]any
-
-	if integer, err := strconv.Atoi(value); err == nil {
-		return FeatureToggle{Type: Integer, Name: name, Value: integer}, nil
-	}
-	if float, err := strconv.ParseFloat(value, 64); err == nil {
-		return FeatureToggle{Type: Float, Name: name, Value: float}, nil
-	}
-	if err := json.Unmarshal([]byte(value), &structure); err == nil {
-		return FeatureToggle{Type: Structure, Name: name, Value: structure}, nil
-	}
-	if boolean, err := strconv.ParseBool(value); err == nil {
-		return FeatureToggle{Type: Boolean, Name: name, Value: boolean}, nil
-	}
-
-	return FeatureToggle{Type: String, Name: name, Value: value}, nil
-}

pkg/setting/setting_feature_toggles_test.go

@@ -1,7 +1,7 @@
 package setting
 
 import (
-	"errors"
+	"strconv"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -13,16 +13,16 @@ func TestFeatureToggles(t *testing.T) {
 		name            string
 		conf            map[string]string
 		err             error
-		expectedToggles map[string]FeatureToggle
+		expectedToggles map[string]bool
 	}{
 		{
 			name: "can parse feature toggles passed in the `enable` array",
 			conf: map[string]string{
 				"enable": "feature1,feature2",
 			},
-			expectedToggles: map[string]FeatureToggle{
-				"feature1": {Name: "feature1", Type: Boolean, Value: true},
-				"feature2": {Name: "feature2", Type: Boolean, Value: true},
+			expectedToggles: map[string]bool{
+				"feature1": true,
+				"feature2": true,
 			},
 		},
 		{
@@ -31,10 +31,10 @@ func TestFeatureToggles(t *testing.T) {
 				"enable":   "feature1,feature2",
 				"feature3": "true",
 			},
-			expectedToggles: map[string]FeatureToggle{
-				"feature1": {Name: "feature1", Type: Boolean, Value: true},
-				"feature2": {Name: "feature2", Type: Boolean, Value: true},
-				"feature3": {Name: "feature3", Type: Boolean, Value: true},
+			expectedToggles: map[string]bool{
+				"feature1": true,
+				"feature2": true,
+				"feature3": true,
 			},
 		},
 		{
@@ -43,35 +43,19 @@ func TestFeatureToggles(t *testing.T) {
 				"enable":   "feature1,feature2",
 				"feature2": "false",
 			},
-			expectedToggles: map[string]FeatureToggle{
-				"feature1": {Name: "feature1", Type: Boolean, Value: true},
-				"feature2": {Name: "feature2", Type: Boolean, Value: false},
+			expectedToggles: map[string]bool{
+				"feature1": true,
+				"feature2": false,
 			},
 		},
 		{
-			name: "conflict in type declaration is be detected",
+			name: "invalid boolean value should return syntax error",
 			conf: map[string]string{
 				"enable":   "feature1,feature2",
 				"feature2": "invalid",
 			},
-			expectedToggles: map[string]FeatureToggle{},
-			err:             errors.New("type mismatch during flag declaration 'feature2': boolean, string"),
-		},
-		{
-			name: "type of the feature flag is handled correctly",
-			conf: map[string]string{
-				"feature1": "1", "feature2": "1.0",
-				"feature3": `{"foo":"bar"}`, "feature4": "bar",
-				"feature5": "t", "feature6": "T",
-			},
-			expectedToggles: map[string]FeatureToggle{
-				"feature1": {Name: "feature1", Type: Integer, Value: 1},
-				"feature2": {Name: "feature2", Type: Float, Value: 1.0},
-				"feature3": {Name: "feature3", Type: Structure, Value: map[string]any{"foo": "bar"}},
-				"feature4": {Name: "feature4", Type: String, Value: "bar"},
-				"feature5": {Name: "feature5", Type: Boolean, Value: true},
-				"feature6": {Name: "feature6", Type: Boolean, Value: true},
-			},
+			expectedToggles: map[string]bool{},
+			err:             strconv.ErrSyntax,
 		},
 	}
 
@@ -85,14 +69,11 @@ func TestFeatureToggles(t *testing.T) {
 		}
 
 		featureToggles, err := ReadFeatureTogglesFromInitFile(toggles)
-		if tc.err != nil {
-			require.EqualError(t, err, tc.err.Error())
-		}
+		require.ErrorIs(t, err, tc.err)
 
 		if err == nil {
 			for k, v := range featureToggles {
-				toggle := tc.expectedToggles[k]
-				require.Equal(t, toggle, v, tc.name)
+				require.Equal(t, tc.expectedToggles[k], v, tc.name)
 			}
 		}
 	}

pkg/storage/unified/README.md

@@ -293,15 +293,15 @@ overrides_path = overrides.yaml
 overrides_reload_period = 5s
 ```
 
-To override the default quota for a tenant, add the following to the `overrides.yaml` file:
+To overrides the default quota for a tenant, add the following to the overrides.yaml file:
 ```yaml
 overrides:
   <NAMESPACE>:
     quotas:
-      <GROUP>/<RESOURCE>:
+      <GROUP>.<RESOURCE>:
         limit: 10
 ```
-Unless otherwise set, the `NAMESPACE` when running locally is `default`.
+Unless otherwise set, the NAMESPACE when running locally is `default`.
 
 To access quotas, use the following API endpoint:
 ```
@@ -806,10 +806,8 @@ flowchart TD
 
 #### Setting Dual Writer Mode
 ```ini
-; [unified_storage.{resource}.{group}]
-[unified_storage.dashboards.dashboard.grafana.app]
-; modes {0-5}
-dualWriterMode = 0
+[unified_storage.{resource}.{kind}.{group}]
+dualWriterMode = {0-5}
 ```
 
 #### Background Sync Configuration
@@ -1378,3 +1376,4 @@ disable_data_migrations = false
 ### Documentation
 
 For detailed information about migration architecture, validators, and troubleshooting, refer to [migrations/README.md](./migrations/README.md).
+ 

pkg/storage/unified/resource/data/sqlkv_insert_legacy_resource.sql

@@ -11,7 +11,7 @@ INSERT INTO {{ .Ident "resource" }}
   {{ .Ident "previous_resource_version" }}
 )
 VALUES (
-  (SELECT {{ .Ident "value" }} FROM {{ .Ident "resource_history" }} WHERE {{ .Ident "guid" }} = {{ .Arg .GUID }}),
+  COALESCE({{ .Arg .Value }}, ""),
   {{ .Arg .GUID }},
   {{ .Arg .Group }},
   {{ .Arg .Resource }},
@@ -19,5 +19,13 @@ VALUES (
   {{ .Arg .Name }},
   {{ .Arg .Action }},
   {{ .Arg .Folder }},
-  {{ .Arg .PreviousRV }}
+  CASE WHEN {{ .Arg .Action }} = 1 THEN 0 ELSE (
+    SELECT {{ .Ident "resource_version" }}
+    FROM {{ .Ident "resource" }}
+    WHERE {{ .Ident "group" }} = {{ .Arg .Group }}
+    AND {{ .Ident "resource" }} = {{ .Arg .Resource }}
+    AND {{ .Ident "namespace" }} = {{ .Arg .Namespace }}
+    AND {{ .Ident "name" }} = {{ .Arg .Name }}
+    ORDER BY {{ .Ident "resource_version" }} DESC LIMIT 1
+  ) END
 );

pkg/storage/unified/resource/data/sqlkv_insert_legacy_resource_history.sql

@@ -7,7 +7,9 @@ INSERT INTO {{ .Ident "resource_history" }}
   {{ .Ident "namespace" }},
   {{ .Ident "name" }},
   {{ .Ident "action" }},
-  {{ .Ident "folder" }}
+  {{ .Ident "folder" }},
+  {{ .Ident "previous_resource_version" }},
+  {{ .Ident "generation" }}
 )
 VALUES (
   COALESCE({{ .Arg .Value }}, ""),
@@ -17,5 +19,26 @@ VALUES (
   {{ .Arg .Namespace }},
   {{ .Arg .Name }},
   {{ .Arg .Action }},
-  {{ .Arg .Folder }}
+  {{ .Arg .Folder }},
+  CASE WHEN {{ .Arg .Action }} = 1 THEN 0 ELSE (
+    SELECT {{ .Ident "resource_version" }}
+    FROM {{ .Ident "resource_history" }}
+    WHERE {{ .Ident "group" }} = {{ .Arg .Group }}
+    AND {{ .Ident "resource" }} = {{ .Arg .Resource }}
+    AND {{ .Ident "namespace" }} = {{ .Arg .Namespace }}
+    AND {{ .Ident "name" }} = {{ .Arg .Name }}
+    ORDER BY {{ .Ident "resource_version" }} DESC LIMIT 1
+  ) END,
+  CASE
+    WHEN {{ .Arg .Action }} = 1 THEN 1
+    WHEN {{ .Arg .Action }} = 3 THEN 0
+    ELSE 1 + (
+      SELECT COUNT(1)
+      FROM {{ .Ident "resource_history" }}
+      WHERE {{ .Ident "group" }} = {{ .Arg .Group }}
+      AND {{ .Ident "resource" }} = {{ .Arg .Resource }}
+      AND {{ .Ident "namespace" }} = {{ .Arg .Namespace }}
+      AND {{ .Ident "name" }} = {{ .Arg .Name }}
+    )
+  END
 );

pkg/storage/unified/resource/data/sqlkv_update_legacy_resource.sql

@@ -1,10 +1,8 @@
 UPDATE {{ .Ident "resource" }}
 SET
-  {{ .Ident "guid" }} = {{ .Arg .GUID }},
-  {{ .Ident "value" }} = (SELECT {{ .Ident "value" }} FROM {{ .Ident "resource_history" }} WHERE {{ .Ident "guid" }} = {{ .Arg .GUID }}),
+  {{ .Ident "value" }} = {{ .Arg .Value }},
   {{ .Ident "action" }} = {{ .Arg .Action }},
-  {{ .Ident "folder" }} = {{ .Arg .Folder }},
-  {{ .Ident "previous_resource_version" }} = {{ .Arg .PreviousRV }}
+  {{ .Ident "folder" }} = {{ .Arg .Folder }}
 WHERE {{ .Ident "group" }} = {{ .Arg .Group }}
 AND {{ .Ident "resource" }} = {{ .Arg .Resource }}
 AND {{ .Ident "namespace" }} = {{ .Arg .Namespace }}

pkg/storage/unified/resource/data/sqlkv_update_legacy_resource_history.sql

@@ -1,5 +0,0 @@
-UPDATE {{ .Ident "resource_history" }}
-SET
-  {{ .Ident "previous_resource_version" }} = {{ .Arg .PreviousRV }},
-  {{ .Ident "generation" }} = {{ .Arg .Generation }}
- WHERE {{ .Ident "guid" }} = {{ .Arg .GUID }};

pkg/storage/unified/resource/datastore.go

@@ -12,9 +12,6 @@ import (
 	"time"
 
 	"github.com/grafana/grafana/pkg/apimachinery/validation"
-	"github.com/grafana/grafana/pkg/storage/unified/sql/db"
-	"github.com/grafana/grafana/pkg/storage/unified/sql/dbutil"
-	"github.com/grafana/grafana/pkg/storage/unified/sql/sqltemplate"
 	gocache "github.com/patrickmn/go-cache"
 )
 
@@ -309,6 +306,10 @@ func (d *dataStore) GetResourceKeyAtRevision(ctx context.Context, key GetRequest
 		return DataKey{}, fmt.Errorf("invalid get request key: %w", err)
 	}
 
+	if rv == 0 {
+		rv = math.MaxInt64
+	}
+
 	listKey := ListRequestKey(key)
 
 	iter := d.ListResourceKeysAtRevision(ctx, ListRequestOptions{Key: listKey, ResourceVersion: rv})
@@ -597,7 +598,7 @@ func ParseKey(key string) (DataKey, error) {
 	}, nil
 }
 
-// Temporary while we need to support unified/sql/backend compatibility.
+// Temporary while we need to support unified/sql/backend compatibility
 // Remove once we stop using RvManager in storage_backend.go
 func ParseKeyWithGUID(key string) (DataKey, error) {
 	parts := strings.Split(key, "/")
@@ -814,121 +815,3 @@ func (d *dataStore) getGroupResources(ctx context.Context) ([]GroupResource, err
 
 	return results, nil
 }
-
-// TODO: remove when backwards compatibility is no longer needed.
-var (
-	sqlKVUpdateLegacyResourceHistory = mustTemplate("sqlkv_update_legacy_resource_history.sql")
-	sqlKVInsertLegacyResource        = mustTemplate("sqlkv_insert_legacy_resource.sql")
-	sqlKVUpdateLegacyResource        = mustTemplate("sqlkv_update_legacy_resource.sql")
-)
-
-// TODO: remove when backwards compatibility is no longer needed.
-type sqlKVLegacySaveRequest struct {
-	sqltemplate.SQLTemplate
-	GUID       string
-	Group      string
-	Resource   string
-	Namespace  string
-	Name       string
-	Action     int64
-	Folder     string
-	PreviousRV int64
-}
-
-func (req sqlKVLegacySaveRequest) Validate() error {
-	return nil
-}
-
-// TODO: remove when backwards compatibility is no longer needed.
-type sqlKVLegacyUpdateHistoryRequest struct {
-	sqltemplate.SQLTemplate
-	GUID       string
-	PreviousRV int64
-	Generation int64
-}
-
-func (req sqlKVLegacyUpdateHistoryRequest) Validate() error {
-	return nil
-}
-
-// applyBackwardsCompatibleChanges updates the `resource` and `resource_history` tables
-// to make sure the sqlkv implementation is backwards-compatible with the existing sql backend.
-// Specifically, it will update the `resource_history` table to include the previous resource version
-// and generation, which come from the `WriteEvent`, and also make the corresponding change on the
-// `resource` table, no longer used in the storage backend.
-//
-// TODO: remove when backwards compatibility is no longer needed.
-func (d *dataStore) applyBackwardsCompatibleChanges(ctx context.Context, tx db.Tx, event WriteEvent, key DataKey) error {
-	kv, isSQLKV := d.kv.(*sqlKV)
-	if !isSQLKV {
-		return nil
-	}
-
-	_, err := dbutil.Exec(ctx, tx, sqlKVUpdateLegacyResourceHistory, sqlKVLegacyUpdateHistoryRequest{
-		SQLTemplate: sqltemplate.New(kv.dialect),
-		GUID:        key.GUID,
-		PreviousRV:  event.PreviousRV,
-		Generation:  event.Object.GetGeneration(),
-	})
-
-	if err != nil {
-		return fmt.Errorf("compatibility layer: failed to insert to resource: %w", err)
-	}
-
-	var action int64
-	switch key.Action {
-	case DataActionCreated:
-		action = 1
-	case DataActionUpdated:
-		action = 2
-	case DataActionDeleted:
-		action = 3
-	}
-
-	switch key.Action {
-	case DataActionCreated:
-		_, err := dbutil.Exec(ctx, tx, sqlKVInsertLegacyResource, sqlKVLegacySaveRequest{
-			SQLTemplate: sqltemplate.New(kv.dialect),
-			GUID:        key.GUID,
-			Group:       key.Group,
-			Resource:    key.Resource,
-			Namespace:   key.Namespace,
-			Name:        key.Name,
-			Action:      action,
-			Folder:      key.Folder,
-			PreviousRV:  event.PreviousRV,
-		})
-
-		if err != nil {
-			return fmt.Errorf("compatibility layer: failed to insert to resource: %w", err)
-		}
-	case DataActionUpdated:
-		_, err := dbutil.Exec(ctx, tx, sqlKVUpdateLegacyResource, sqlKVLegacySaveRequest{
-			SQLTemplate: sqltemplate.New(kv.dialect),
-			GUID:        key.GUID,
-			Group:       key.Group,
-			Resource:    key.Resource,
-			Namespace:   key.Namespace,
-			Name:        key.Name,
-			Folder:      key.Folder,
-			PreviousRV:  event.PreviousRV,
-		})
-
-		if err != nil {
-			return fmt.Errorf("compatibility layer: failed to update resource: %w", err)
-		}
-	case DataActionDeleted:
-		_, err := dbutil.Exec(ctx, tx, sqlKVDeleteLegacyResource, sqlKVLegacySaveRequest{
-			SQLTemplate: sqltemplate.New(kv.dialect),
-			Resource:    key.Resource,
-			Namespace:   key.Namespace,
-			Name:        key.Name,
-		})
-
-		if err != nil {
-			return fmt.Errorf("compatibility layer: failed to delete from resource: %w", err)
-		}
-	}
-
-	return nil
-}

pkg/storage/unified/resource/sqlkv.go

@@ -44,6 +44,8 @@ var (
 	sqlKVInsertData                  = mustTemplate("sqlkv_insert_datastore.sql")
 	sqlKVUpdateData                  = mustTemplate("sqlkv_update_datastore.sql")
 	sqlKVInsertLegacyResourceHistory = mustTemplate("sqlkv_insert_legacy_resource_history.sql")
+	sqlKVInsertLegacyResource        = mustTemplate("sqlkv_insert_legacy_resource.sql")
+	sqlKVUpdateLegacyResource        = mustTemplate("sqlkv_update_legacy_resource.sql")
 	sqlKVDeleteLegacyResource        = mustTemplate("sqlkv_delete_legacy_resource.sql")
 	sqlKVDelete                      = mustTemplate("sqlkv_delete.sql")
 	sqlKVBatchDelete                 = mustTemplate("sqlkv_batch_delete.sql")
@@ -155,6 +157,26 @@ func (req sqlKVSaveRequest) Validate() error {
 	return req.sqlKVSectionKey.Validate()
 }
 
+type sqlKVLegacySaveRequest struct {
+	sqltemplate.SQLTemplate
+	Value     []byte
+	GUID      string
+	Group     string
+	Resource  string
+	Namespace string
+	Name      string
+	Action    int64
+	Folder    string
+}
+
+func (req sqlKVLegacySaveRequest) Validate() error {
+	return nil
+}
+
+func (req sqlKVLegacySaveRequest) Results() ([]byte, error) {
+	return req.Value, nil
+}
+
 type sqlKVKeysRequest struct {
 	sqltemplate.SQLTemplate
 	sqlKVSection
@@ -370,7 +392,7 @@ func (w *sqlWriteCloser) Close() error {
 	// used to keep backwards compatibility between sql-based kvstore and unified/sql/backend
 	tx, ok := rvmanager.TxFromCtx(w.ctx)
 	if !ok {
-		// temporary save for dataStore without rvmanager (non backwards-compatible)
+		// temporary save for dataStore without rvmanager
 		// we can use the same template as the event one after we:
 		// - move PK from GUID to key_path
 		// - remove all unnecessary columns (or at least their NOT NULL constraints)
@@ -407,12 +429,11 @@ func (w *sqlWriteCloser) Close() error {
 		return nil
 	}
 
-	// special, temporary backwards-compatible save that includes all the fields in resource_history that are not relevant
-	// for the kvstore, as well as the resource table. This is only called if an RvManager was passed to storage_backend, as that
-	// component will be responsible for populating the resource_version and key_path columns.
-	// For full backwards-compatibility, the `Save` function needs to be called within a callback that updates the resource_history
-	// table with `previous_resource_version` and `generation` and updates the `resource` table accordingly. See the
-	// storage_backend for the full implementation.
+	// special, temporary save that includes all the fields in resource_history that are not relevant for the kvstore,
+	// as well as the resource table. This is only called if an RvManager was passed to storage_backend, as that
+	// component will be responsible for populating the resource_version and key_path columns
+	// note that we are not touching resource_version table, neither the resource_version columns or the key_path column
+	// as the RvManager will be responsible for this
 	dataKey, err := ParseKeyWithGUID(w.sectionKey.Key)
 	if err != nil {
 		return fmt.Errorf("failed to parse key: %w", err)
@@ -427,7 +448,7 @@ func (w *sqlWriteCloser) Close() error {
 	case DataActionDeleted:
 		action = 3
 	default:
-		return fmt.Errorf("failed to parse key: invalid action")
+		return fmt.Errorf("failed to parse key: %w", err)
 	}
 
 	_, err = dbutil.Exec(w.ctx, tx, sqlKVInsertLegacyResourceHistory, sqlKVSaveRequest{
@@ -447,6 +468,52 @@ func (w *sqlWriteCloser) Close() error {
 		return fmt.Errorf("failed to save to resource_history: %w", err)
 	}
 
+	switch dataKey.Action {
+	case DataActionCreated:
+		_, err = dbutil.Exec(w.ctx, tx, sqlKVInsertLegacyResource, sqlKVLegacySaveRequest{
+			SQLTemplate: sqltemplate.New(w.kv.dialect),
+			Value:       w.buf.Bytes(),
+			GUID:        dataKey.GUID,
+			Group:       dataKey.Group,
+			Resource:    dataKey.Resource,
+			Namespace:   dataKey.Namespace,
+			Name:        dataKey.Name,
+			Action:      action,
+			Folder:      dataKey.Folder,
+		})
+
+		if err != nil {
+			return fmt.Errorf("failed to insert to resource: %w", err)
+		}
+	case DataActionUpdated:
+		_, err = dbutil.Exec(w.ctx, tx, sqlKVUpdateLegacyResource, sqlKVLegacySaveRequest{
+			SQLTemplate: sqltemplate.New(w.kv.dialect),
+			Value:       w.buf.Bytes(),
+			Group:       dataKey.Group,
+			Resource:    dataKey.Resource,
+			Namespace:   dataKey.Namespace,
+			Name:        dataKey.Name,
+			Action:      action,
+			Folder:      dataKey.Folder,
+		})
+
+		if err != nil {
+			return fmt.Errorf("failed to update resource: %w", err)
+		}
+	case DataActionDeleted:
+		_, err = dbutil.Exec(w.ctx, tx, sqlKVDeleteLegacyResource, sqlKVLegacySaveRequest{
+			SQLTemplate: sqltemplate.New(w.kv.dialect),
+			Group:       dataKey.Group,
+			Resource:    dataKey.Resource,
+			Namespace:   dataKey.Namespace,
+			Name:        dataKey.Name,
+		})
+
+		if err != nil {
+			return fmt.Errorf("failed to delete from resource: %w", err)
+		}
+	}
+
 	return nil
 }
 

pkg/storage/unified/resource/storage_backend.go

@@ -332,14 +332,11 @@ func (k *kvStorageBackend) WriteEvent(ctx context.Context, event WriteEvent) (in
 		dataKey.GUID = uuid.New().String()
 		var err error
 		rv, err = k.rvManager.ExecWithRV(ctx, event.Key, func(tx db.Tx) (string, error) {
-			if err := k.dataStore.Save(rvmanager.ContextWithTx(ctx, tx), dataKey, bytes.NewReader(event.Value)); err != nil {
+			err := k.dataStore.Save(rvmanager.ContextWithTx(ctx, tx), dataKey, bytes.NewReader(event.Value))
+			if err != nil {
 				return "", fmt.Errorf("failed to write data: %w", err)
 			}
 
-			if err := k.dataStore.applyBackwardsCompatibleChanges(ctx, tx, event, dataKey); err != nil {
-				return "", fmt.Errorf("failed to apply backwards compatible updates: %w", err)
-			}
-
 			return dataKey.GUID, nil
 		})
 		if err != nil {

pkg/tests/apis/features/features_test.go

@@ -44,6 +44,6 @@ func TestIntegrationFeatures(t *testing.T) {
 			"value": true,
 			"key":"`+flag+`",
 			"reason":"static provider evaluation result",
-			"variant":"default"}`, string(rsp.Body))
+			"variant":"enabled"}`, string(rsp.Body))
 	})
 }

pkg/tests/apis/plugins/plugins_test.go

@@ -10,7 +10,6 @@ import (
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 
-	"github.com/grafana/grafana/pkg/services/featuremgmt"
 	"github.com/grafana/grafana/pkg/tests/apis"
 	"github.com/grafana/grafana/pkg/tests/testinfra"
 	"github.com/grafana/grafana/pkg/tests/testsuite"
@@ -178,9 +177,6 @@ func setupHelper(t *testing.T) *apis.K8sTestHelper {
 		AppModeProduction:      true,
 		DisableAnonymous:       true,
 		APIServerRuntimeConfig: "plugins.grafana.app/v0alpha1=true",
-		EnableFeatureToggles: []string{
-			featuremgmt.FlagPluginStoreServiceLoading,
-		},
 	})
 	t.Cleanup(func() { helper.Shutdown() })
 	return helper

public/app/features/alerting/unified/components/silences/utils.ts

@@ -47,7 +47,7 @@ export const getFormFieldsForSilence = (silence: Silence): SilenceFormFields =>
     startsAt: interval.start.toISOString(),
     endsAt: interval.end.toISOString(),
     comment: silence.comment,
-    createdBy: isExpired ? contextSrv.user.name : silence.createdBy,
+    createdBy: silence.createdBy,
     duration: intervalToAbbreviatedDurationString(interval),
     isRegex: false,
     matchers: silence.matchers?.map(matcherToMatcherField) || [],

public/app/features/browse-dashboards/components/RecentlyViewedDashboards.tsx

@@ -39,7 +39,7 @@ export function RecentlyViewedDashboards() {
     retry();
   };
 
-  if (!evaluateBooleanFlag('recentlyViewedDashboards', false) || recentDashboards.length === 0) {
+  if (!evaluateBooleanFlag('recentlyViewedDashboards', false)) {
     return null;
   }
 
@@ -76,6 +76,10 @@ export function RecentlyViewedDashboards() {
         </>
       )}
       {loading && <Spinner />}
+      {/* TODO: Better empty state https://github.com/grafana/grafana/issues/114804 */}
+      {!loading && recentDashboards.length === 0 && (
+        <Text>{t('browse-dashboards.recently-viewed.empty', 'Nothing viewed yet')}</Text>
+      )}
 
       {!loading && recentDashboards.length > 0 && (
         <ul className={styles.list}>

public/app/features/dashboard-scene/scene/panel-timerange/PanelTimeRange.test.tsx

@@ -128,7 +128,7 @@ describe('PanelTimeRange', () => {
     expect(panelTime.state.value.to.format('Z')).toBe('+00:00'); // UTC
   });
 
-  it('should handle invalid time reference in timeShift with relative time range', () => {
+  it('should handle invalid time reference in timeShift', () => {
     const panelTime = new PanelTimeRange({ timeShift: 'now-1d' });
 
     buildAndActivateSceneFor(panelTime);
@@ -139,22 +139,6 @@ describe('PanelTimeRange', () => {
     expect(panelTime.state.to).toBe('now');
   });
 
-  it('should handle invalid time reference in timeShift with absolute time range', () => {
-    const panelTime = new PanelTimeRange({ timeShift: 'now-1d' });
-    const panel = new SceneCanvasText({ text: 'Hello', $timeRange: panelTime });
-    const absoluteFrom = '2019-02-11T10:00:00.000Z';
-    const absoluteTo = '2019-02-11T16:00:00.000Z';
-    const scene = new SceneFlexLayout({
-      $timeRange: new SceneTimeRange({ from: absoluteFrom, to: absoluteTo }),
-      children: [new SceneFlexItem({ body: panel })],
-    });
-    activateFullSceneTree(scene);
-
-    expect(panelTime.state.timeInfo).toBe('invalid timeshift');
-    expect(panelTime.state.from).toBe(absoluteFrom);
-    expect(panelTime.state.to).toBe(absoluteTo);
-  });
-
   it('should handle invalid time reference in timeShift combined with timeFrom', () => {
     const panelTime = new PanelTimeRange({
       timeFrom: 'now-2h',
@@ -169,66 +153,6 @@ describe('PanelTimeRange', () => {
     expect(panelTime.state.to).toBe('now');
   });
 
-  describe('from/to state format for liveNow compatibility', () => {
-    it('should store relative strings in from/to when timeShift is applied to relative time range', () => {
-      const panelTime = new PanelTimeRange({ timeShift: '2h' });
-
-      buildAndActivateSceneFor(panelTime);
-
-      expect(panelTime.state.from).toBe('now-6h-2h');
-      expect(panelTime.state.to).toBe('now-2h');
-      expect(panelTime.state.value.raw.from).toBe('now-6h-2h');
-      expect(panelTime.state.value.raw.to).toBe('now-2h');
-    });
-
-    it('should store relative strings when both timeFrom and timeShift are applied', () => {
-      const panelTime = new PanelTimeRange({ timeFrom: '2h', timeShift: '1h' });
-
-      buildAndActivateSceneFor(panelTime);
-
-      expect(panelTime.state.from).toBe('now-2h-1h');
-      expect(panelTime.state.to).toBe('now-1h');
-    });
-
-    it('should store ISO strings when timeShift is applied to absolute time range', () => {
-      const panelTime = new PanelTimeRange({ timeShift: '1h' });
-      const panel = new SceneCanvasText({ text: 'Hello', $timeRange: panelTime });
-      const absoluteFrom = '2019-02-11T10:00:00.000Z';
-      const absoluteTo = '2019-02-11T16:00:00.000Z';
-      const scene = new SceneFlexLayout({
-        $timeRange: new SceneTimeRange({ from: absoluteFrom, to: absoluteTo }),
-        children: [new SceneFlexItem({ body: panel })],
-      });
-      activateFullSceneTree(scene);
-
-      expect(panelTime.state.from).toBe('2019-02-11T09:00:00.000Z');
-      expect(panelTime.state.to).toBe('2019-02-11T15:00:00.000Z');
-    });
-
-    it('should update from/to when ancestor time range changes', () => {
-      const panelTime = new PanelTimeRange({ timeShift: '1h' });
-      const sceneTimeRange = new SceneTimeRange({ from: 'now-6h', to: 'now' });
-      const panel = new SceneCanvasText({ text: 'Hello', $timeRange: panelTime });
-      const scene = new SceneFlexLayout({
-        $timeRange: sceneTimeRange,
-        children: [new SceneFlexItem({ body: panel })],
-      });
-      activateFullSceneTree(scene);
-
-      expect(panelTime.state.from).toBe('now-6h-1h');
-      expect(panelTime.state.to).toBe('now-1h');
-
-      sceneTimeRange.onTimeRangeChange({
-        from: dateTime('2019-02-11T12:00:00.000Z'),
-        to: dateTime('2019-02-11T18:00:00.000Z'),
-        raw: { from: 'now-12h', to: 'now' },
-      });
-
-      expect(panelTime.state.from).toBe('now-12h-1h');
-      expect(panelTime.state.to).toBe('now-1h');
-    });
-  });
-
   describe('onTimeRangeChange', () => {
     it('should reverse timeShift when updating time range', () => {
       const oneHourShift = '1h';

public/app/features/dashboard-scene/scene/panel-timerange/PanelTimeRange.tsx

@@ -81,19 +81,7 @@ export class PanelTimeRange extends SceneTimeRangeTransformerBase<PanelTimeRange
     }
 
     const overrideResult = this.getTimeOverride(timeRange.value);
-    const { timeRange: overrideTimeRange } = overrideResult;
-    this.setState({
-      value: overrideTimeRange,
-      timeInfo: overrideResult.timeInfo,
-      from:
-        typeof overrideTimeRange.raw.from === 'string'
-          ? overrideTimeRange.raw.from
-          : overrideTimeRange.raw.from.toISOString(),
-      to:
-        typeof overrideTimeRange.raw.to === 'string'
-          ? overrideTimeRange.raw.to
-          : overrideTimeRange.raw.to.toISOString(),
-    });
+    this.setState({ value: overrideResult.timeRange, timeInfo: overrideResult.timeInfo });
   }
 
   // Get a time shifted request to compare with the primary request.
@@ -165,10 +153,10 @@ export class PanelTimeRange extends SceneTimeRangeTransformerBase<PanelTimeRange
 
       // Only evaluate if the timeFrom if parent time is relative
       if (rangeUtil.isRelativeTimeRange(parentTimeRange.raw)) {
-        const timezone = this.getTimeZone();
+        const timeZone = this.getTimeZone();
         newTimeData.timeRange = {
-          from: dateMath.toDateTime(timeFromInfo.from, { timezone })!,
-          to: dateMath.toDateTime(timeFromInfo.to, { timezone })!,
+          from: dateMath.parse(timeFromInfo.from, undefined, timeZone)!,
+          to: dateMath.parse(timeFromInfo.to, undefined, timeZone)!,
           raw: { from: timeFromInfo.from, to: timeFromInfo.to },
         };
         infoBlocks.push(timeFromInfo.display);
@@ -184,39 +172,18 @@ export class PanelTimeRange extends SceneTimeRangeTransformerBase<PanelTimeRange
         return newTimeData;
       }
 
-      const shift = '-' + timeShiftInterpolated;
-      infoBlocks.push('timeshift ' + shift);
+      const timeShift = '-' + timeShiftInterpolated;
+      infoBlocks.push('timeshift ' + timeShift);
 
-      if (rangeUtil.isRelativeTimeRange(newTimeData.timeRange.raw)) {
-        const timezone = this.getTimeZone();
+      const from = dateMath.parseDateMath(timeShift, newTimeData.timeRange.from, false)!;
+      const to = dateMath.parseDateMath(timeShift, newTimeData.timeRange.to, true)!;
 
-        const rawFromShifted = `${newTimeData.timeRange.raw.from}${shift}`;
-        const rawToShifted = `${newTimeData.timeRange.raw.to}${shift}`;
-
-        const from = dateMath.toDateTime(rawFromShifted, { timezone });
-        const to = dateMath.toDateTime(rawToShifted, { timezone });
-
-        if (!from || !to) {
-          newTimeData.timeInfo = 'invalid timeshift';
-          return newTimeData;
-        }
-
-        newTimeData.timeRange = {
-          from,
-          to,
-          raw: { from: rawFromShifted, to: rawToShifted },
-        };
-      } else {
-        const from = dateMath.parseDateMath(shift, newTimeData.timeRange.from, false);
-        const to = dateMath.parseDateMath(shift, newTimeData.timeRange.to, true);
-
-        if (!from || !to) {
-          newTimeData.timeInfo = 'invalid timeshift';
-          return newTimeData;
-        }
-
-        newTimeData.timeRange = { from, to, raw: { from, to } };
+      if (!from || !to) {
+        newTimeData.timeInfo = 'invalid timeshift';
+        return newTimeData;
       }
+
+      newTimeData.timeRange = { from, to, raw: { from, to } };
     }
 
     if (compareWith) {

public/app/features/dashboard-scene/serialization/sceneVariablesSetToVariables.ts

@@ -284,6 +284,7 @@ function variableValueOptionsToVariableOptions(varState: MultiValueVariable['sta
     value: String(o.value),
     text: o.label,
     selected: Array.isArray(varState.value) ? varState.value.includes(o.value) : varState.value === o.value,
+    ...(o.properties && { properties: o.properties }),
   }));
 }
 

public/app/features/panel/panellinks/link_srv.ts

@@ -80,18 +80,18 @@ const buildLabelPath = (label: string) => {
   return label.includes('.') || label.trim().includes(' ') ? `["${label}"]` : `.${label}`;
 };
 
-const getVariableValueProperties = (variable: TypedVariableModel): string[] => {
-  if (!('valuesFormat' in variable) || variable.valuesFormat !== 'json') {
-    return [];
-  }
+const isRecord = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
 
-  function collectFieldPaths(option: Record<string, string>, currentPath: string) {
+const getVariableValueProperties = (variable: TypedVariableModel): string[] => {
+  function collectFieldPaths(option: Record<string, unknown>, currentPath: string): string[] {
     let paths: string[] = [];
     for (const field in option) {
       if (option.hasOwnProperty(field)) {
         const newPath = `${currentPath}.${field}`;
         const value = option[field];
-        if (typeof value === 'object' && value !== null) {
+        if (isRecord(value)) {
           paths = [...paths, ...collectFieldPaths(value, newPath)];
         }
         paths.push(newPath);
@@ -100,11 +100,23 @@ const getVariableValueProperties = (variable: TypedVariableModel): string[] => {
     return paths;
   }
 
-  try {
-    return collectFieldPaths(JSON.parse(variable.query)[0], variable.name);
-  } catch {
-    return [];
+  if ('valuesFormat' in variable && variable.valuesFormat === 'json') {
+    try {
+      return collectFieldPaths(JSON.parse(variable.query)[0], variable.name);
+    } catch {
+      return [];
+    }
   }
+
+  if ('options' in variable && Array.isArray(variable.options) && variable.options.length > 0) {
+    for (const opt of variable.options) {
+      if ('properties' in opt && isRecord(opt.properties) && Object.keys(opt.properties).length > 0) {
+        return collectFieldPaths(opt.properties, variable.name);
+      }
+    }
+  }
+
+  return [];
 };
 
 export const getPanelLinksVariableSuggestions = (): VariableSuggestion[] => [

public/app/plugins/datasource/grafana-postgresql-datasource/datasource.ts

@@ -11,6 +11,7 @@ import {
   SQLQuery,
   SQLSelectableValue,
   SqlDatasource,
+  SQLVariableSupport,
   formatSQL,
 } from '@grafana/sql';
 
@@ -25,6 +26,7 @@ export class PostgresDatasource extends SqlDatasource {
 
   constructor(instanceSettings: DataSourceInstanceSettings<PostgresOptions>) {
     super(instanceSettings);
+    this.variables = new SQLVariableSupport(this);
   }
 
   getQueryModel(target?: SQLQuery, templateSrv?: TemplateSrv, scopedVars?: ScopedVars): PostgresQueryModel {

public/locales/en-US/grafana.json

@@ -3759,6 +3759,7 @@
     },
     "recently-viewed": {
       "clear": "Clear history",
+      "empty": "Nothing viewed yet",
       "error": "Recently viewed dashboards couldn’t be loaded.",
       "retry": "Retry",
       "title": "Recently viewed"