Fix lint errors in Sparkline hover implementation

- Remove type assertions (as any) in favor of type guards
- Fix emotion CSS to use object notation instead of template literal
- Rename 'component' to 'view' in test files (testing-library convention)
- Add eslint-disable comments for necessary any types in tests
- Add proper uPlot typing for test mock objects

.github/CODEOWNERS

@@ -185,6 +185,7 @@
 /pkg/services/search/ @grafana/grafana-search-and-storage
 /pkg/services/searchusers/ @grafana/grafana-search-and-storage
 /pkg/services/secrets/ @grafana/grafana-operator-experience-squad
+/pkg/services/setting/ @grafana/grafana-backend-services-squad
 /pkg/services/shorturls/ @grafana/sharing-squad
 /pkg/services/sqlstore/ @grafana/grafana-search-and-storage
 /pkg/services/ssosettings/ @grafana/identity-squad

.gitignore

@@ -71,6 +71,7 @@ public/css/*.min.css
 .vs/
 .cursor/
 .devcontainer/
+.claude/
 
 .eslintcache
 .stylelintcache

docs/sources/administration/migration-guide/cloud-migration-assistant.md

@@ -14,10 +14,10 @@ weight: 400
 The Grafana Cloud Migration Assistant, generally available from Grafana v12.0, automatically migrates resources from your Grafana OSS/Enterprise instance to Grafana Cloud. It provides the following functionality:
 
 - Securely connect your self-managed instance to a Grafana Cloud instance.
-- Seamlessly migrate resources such as dashboards, data sources, and folders to your cloud instance in a few easy steps.
+- Migrate resources such as dashboards, data sources, and folders to your cloud instance in a few easy steps.
 - View the migration status of your resources in real-time.
 
-Some of the benefits of the migration assistant are:
+Some benefits of the migration assistant are:
 
 Ease of use
 : Follow the steps provided by the UI to easily migrate all your resources to Grafana Cloud without using Grafana APIs or scripts.
@@ -44,7 +44,7 @@ The following resources are supported by the migration assistant:
 
 To use the Grafana migration assistant, you need:
 
-- Grafana v11.2 or above with the `onPremToCloudMigrations` feature toggle enabled. In Grafana 11.5, this is enabled by default. For more information on how to enable a feature toggle, refer to [Configure feature toggles](https://grafana.com/docs/grafana/<GRAFANA_VERSION>/setup-grafana/configure-grafana/feature-toggles/#configure-feature-toggles).
+- A self-managed Grafana instance version v11.2 or above with the `onPremToCloudMigrations` feature toggle enabled. In Grafana 11.5, this is enabled by default. For more information on how to enable a feature toggle, refer to [Configure feature toggles](https://grafana.com/docs/grafana/<GRAFANA_VERSION>/setup-grafana/configure-grafana/feature-toggles/#configure-feature-toggles).
 - A [Grafana Cloud Stack](https://grafana.com/docs/grafana-cloud/get-started/) you intend to migrate your resources to.
 - [`Admin`](https://grafana.com/docs/grafana-cloud/account-management/authentication-and-permissions/cloud-roles/) access to the Grafana Cloud Stack. To check your access level, go to `https://grafana.com/orgs/<YOUR-ORG-NAME>/members`.
 - [Grafana server administrator](https://grafana.com/docs/grafana/<GRAFANA_VERSION>/administration/roles-and-permissions/#grafana-server-administrators) access to your existing Grafana OSS/Enterprise instance. To check your access level, go to `https://<GRAFANA-ONPREM-URL>/admin/users`.
@@ -64,7 +64,7 @@ In Grafana Enterprise, the server administrator has access to the migration assi
 
 ### Grant access in Grafana Enterprise
 
-{{< admonition type="important">}}
+{{< admonition type="note" >}}
 You must [configure RBAC](https://grafana.com/docs/grafana/<GRAFANA_VERSION>/administration/roles-and-permissions/access-control/configure-rbac/) before you can grant other administrators access to the Grafana Migration Assistant.
 {{< /admonition >}}
 

docs/sources/setup-grafana/configure-grafana/feature-toggles/index.md

@@ -66,6 +66,7 @@ Most [generally available](https://grafana.com/docs/release-life-cycle/#general-
 | `grafanaAssistantInProfilesDrilldown` | Enables integration with Grafana Assistant in Profiles Drilldown                                                                                              | Yes                |
 | `sharingDashboardImage`               | Enables image sharing functionality for dashboards                                                                                                            | Yes                |
 | `tabularNumbers`                      | Use fixed-width numbers globally in the UI                                                                                                                    |                    |
+| `azureResourcePickerUpdates`          | Enables the updated Azure Monitor resource picker                                                                                                             | Yes                |
 | `tempoSearchBackendMigration`         | Run search queries through the tempo backend                                                                                                                  |                    |
 
 ## Public preview feature toggles
@@ -95,9 +96,9 @@ Most [generally available](https://grafana.com/docs/release-life-cycle/#general-
 | `localeFormatPreference`          | Specifies the locale so the correct format for numbers and dates can be shown                          |
 | `logsPanelControls`               | Enables a control component for the logs panel in Explore                                              |
 | `interactiveLearning`             | Enables the interactive learning app                                                                   |
-| `azureResourcePickerUpdates`      | Enables the updated Azure Monitor resource picker                                                      |
 | `newVizSuggestions`               | Enable new visualization suggestions                                                                   |
 | `preventPanelChromeOverflow`      | Restrict PanelChrome contents with overflow: hidden;                                                   |
+| `newPanelPadding`                 | Increases panel padding globally                                                                       |
 | `transformationsEmptyPlaceholder` | Show transformation quick-start cards in empty transformations state                                   |
 
 ## Development feature toggles

packages/grafana-data/src/panel/PanelPlugin.ts

@@ -381,6 +381,11 @@ export class PanelPlugin<
               const appender = builder.getListAppender<TOptions, TFieldConfigOptions>({
                 pluginId: this.meta.id,
                 name: this.meta.name,
+                options: {},
+                fieldConfig: {
+                  defaults: {},
+                  overrides: [],
+                },
               });
 
               const result = supplier(builder.dataSummary);

packages/grafana-data/src/panel/suggestions/getPanelDataSummary.ts

@@ -1,19 +1,27 @@
 import { PreferredVisualisationType } from '../../types/data';
 import { DataFrame, FieldType } from '../../types/dataFrame';
+import { DataFrameType } from '../../types/dataFrameTypes';
 
-/**
- * @alpha
- */
 export interface PanelDataSummary {
   hasData?: boolean;
   rowCountTotal: number;
+  /** max number of rows in any given dataframe in the panel data */
   rowCountMax: number;
   frameCount: number;
   fieldCount: number;
+  /** max number of fields in any given dataframe in the panel data */
+  fieldCountMax: number;
+  /** given a field type, return the number of fields across all dataframes which match this type */
   fieldCountByType: (type: FieldType) => number;
+  /** returns true if any fields in any frames match the field type */
   hasFieldType: (type: FieldType) => boolean;
-  /** The first frame that set's this value */
-  preferredVisualisationType?: PreferredVisualisationType;
+  /* returns true if any of the frames in this panel data summary have the type */
+  hasDataFrameType: (type: DataFrameType) => boolean;
+  /* returns true if any of the frames in this panel data summary have the type */
+  hasPreferredVisualisationType: (type: PreferredVisualisationType) => boolean;
+
+  /** pass along a reference to the DataFrame array in case it's needed by the plugin */
+  rawFrames?: DataFrame[];
 
   /* --- DEPRECATED FIELDS BELOW --- */
   /** @deprecated use PanelDataSummary.fieldCountByType(FieldType.number) */
@@ -23,60 +31,114 @@ export interface PanelDataSummary {
   /** @deprecated use PanelDataSummary.fieldCountByType(FieldType.string) */
   stringFieldCount: number;
   /** @deprecated use PanelDataSummary.hasFieldType(FieldType.number) */
-  hasNumberField?: boolean;
-  /** @deprecated use PanelDataSummary.hasFieldType(FieldType.time) */
   hasTimeField?: boolean;
+  /** @deprecated use PanelDataSummary.hasFieldType(FieldType.time) */
+  hasNumberField?: boolean;
   /** @deprecated use PanelDataSummary.hasFieldType(FieldType.string) */
   hasStringField?: boolean;
 }
 
+/**
+ * @alpha
+ */
+class PanelDataSummaryImpl implements PanelDataSummary {
+  public rowCountTotal = 0;
+  /** max number of rows in any single dataframe in the panel data */
+  public rowCountMax = 0;
+  public fieldCount = 0;
+  /** max number of fields in any single dataframe in the panel data */
+  public fieldCountMax = 0;
+
+  private countByType: Partial<Record<FieldType, number>> = {};
+  private preferredVisualisationTypes: Set<PreferredVisualisationType> = new Set<PreferredVisualisationType>();
+  private dataFrameTypes: Set<DataFrameType> = new Set<DataFrameType>();
+
+  public get hasData(): boolean {
+    return this.rowCountTotal > 0;
+  }
+
+  public get frameCount(): number {
+    return this.rawFrames?.length ?? 0;
+  }
+
+  constructor(public rawFrames?: DataFrame[]) {
+    this._processFrames();
+  }
+
+  private _processFrames() {
+    for (const frame of this.rawFrames ?? []) {
+      this.rowCountTotal += frame.length;
+
+      if (frame.meta?.preferredVisualisationType) {
+        this.preferredVisualisationTypes.add(frame.meta.preferredVisualisationType);
+      }
+      if (frame.meta?.type) {
+        this.dataFrameTypes.add(frame.meta.type);
+      }
+
+      for (const field of frame.fields) {
+        this.fieldCount++;
+        this.countByType[field.type] = (this.countByType[field.type] || 0) + 1;
+      }
+
+      if (frame.length > this.rowCountMax) {
+        this.rowCountMax = frame.length;
+      }
+      if (frame.fields.length > this.fieldCountMax) {
+        this.fieldCountMax = frame.fields.length;
+      }
+    }
+  }
+
+  public fieldCountByType(type: FieldType): number {
+    return this.countByType[type] ?? 0;
+  }
+
+  public hasFieldType(type: FieldType): boolean {
+    return this.fieldCountByType(type) > 0;
+  }
+
+  public hasPreferredVisualisationType(type: PreferredVisualisationType): boolean {
+    return this.preferredVisualisationTypes.has(type);
+  }
+
+  public hasDataFrameType(type: DataFrameType): boolean {
+    return this.dataFrameTypes.has(type);
+  }
+
+  /**** DEPRECATED ****/
+  /** @deprecated use PanelDataSummary.fieldCountByType(FieldType.number) */
+  public get numberFieldCount(): number {
+    return this.fieldCountByType(FieldType.number);
+  }
+  /** @deprecated use PanelDataSummary.fieldCountByType(FieldType.time) */
+  public get timeFieldCount(): number {
+    return this.fieldCountByType(FieldType.time);
+  }
+  /** @deprecated use PanelDataSummary.fieldCountByType(FieldType.string) */
+  public get stringFieldCount() {
+    return this.fieldCountByType(FieldType.string);
+  }
+  /** @deprecated use PanelDataSummary.hasFieldType(FieldType.number) */
+  public get hasTimeField() {
+    return this.fieldCountByType(FieldType.time) > 0;
+  }
+  /** @deprecated use PanelDataSummary.hasFieldType(FieldType.time) */
+  public get hasNumberField() {
+    return this.fieldCountByType(FieldType.number) > 0;
+  }
+  /** @deprecated use PanelDataSummary.hasFieldType(FieldType.string) */
+  public get hasStringField() {
+    return this.fieldCountByType(FieldType.string) > 0;
+  }
+}
+
 /**
  * @alpha
  * given a list of dataframes, summarize attributes of those frames for features like suggestions.
  * @param frames - dataframes to summarize
  * @returns summary of the dataframes
  */
-export function getPanelDataSummary(frames: DataFrame[] = []): PanelDataSummary {
-  let rowCountTotal = 0;
-  let rowCountMax = 0;
-  let fieldCount = 0;
-  const countByType: Partial<Record<FieldType, number>> = {};
-  let preferredVisualisationType: PreferredVisualisationType | undefined;
-
-  for (const frame of frames) {
-    rowCountTotal += frame.length;
-
-    if (frame.meta?.preferredVisualisationType) {
-      preferredVisualisationType = frame.meta.preferredVisualisationType;
-    }
-
-    for (const field of frame.fields) {
-      fieldCount++;
-      countByType[field.type] = (countByType[field.type] || 0) + 1;
-    }
-
-    if (frame.length > rowCountMax) {
-      rowCountMax = frame.length;
-    }
-  }
-
-  const fieldCountByType = (f: FieldType) => countByType[f] ?? 0;
-
-  return {
-    rowCountTotal,
-    rowCountMax,
-    fieldCount,
-    preferredVisualisationType,
-    frameCount: frames.length,
-    hasData: rowCountTotal > 0,
-    hasFieldType: (f: FieldType) => fieldCountByType(f) > 0,
-    fieldCountByType,
-    // deprecated
-    numberFieldCount: fieldCountByType(FieldType.number),
-    timeFieldCount: fieldCountByType(FieldType.time),
-    stringFieldCount: fieldCountByType(FieldType.string),
-    hasTimeField: fieldCountByType(FieldType.time) > 0,
-    hasNumberField: fieldCountByType(FieldType.number) > 0,
-    hasStringField: fieldCountByType(FieldType.string) > 0,
-  };
+export function getPanelDataSummary(frames?: DataFrame[]): PanelDataSummary {
+  return new PanelDataSummaryImpl(frames);
 }

packages/grafana-data/src/transformations/transformers/calculateField.ts

@@ -72,7 +72,7 @@ interface IndexOptions {
   asPercentile: boolean;
 }
 
-const defaultReduceOptions: ReduceOptions = {
+const defaultNumericVizOptions: ReduceOptions = {
   reducer: ReducerID.sum,
 };
 
@@ -149,10 +149,10 @@ export const calculateFieldTransformer: DataTransformerInfo<CalculateFieldTransf
 
         switch (mode) {
           case CalculateFieldMode.ReduceRow:
-            creator = getReduceRowCreator(defaults(options.reduce, defaultReduceOptions), data);
+            creator = getReduceRowCreator(defaults(options.reduce, defaultNumericVizOptions), data);
             break;
           case CalculateFieldMode.CumulativeFunctions:
-            creator = getCumulativeCreator(defaults(options.cumulative, defaultReduceOptions), data);
+            creator = getCumulativeCreator(defaults(options.cumulative, defaultNumericVizOptions), data);
             break;
           case CalculateFieldMode.WindowFunctions:
             creator = getWindowCreator(defaults(options.window, defaultWindowOptions), data);

packages/grafana-data/src/types/featureToggles.gen.ts

@@ -1091,7 +1091,7 @@ export interface FeatureToggles {
   graphiteBackendMode?: boolean;
   /**
   * Enables the updated Azure Monitor resource picker
-  * @default false
+  * @default true
   */
   azureResourcePickerUpdates?: boolean;
   /**
@@ -1150,7 +1150,7 @@ export interface FeatureToggles {
   pluginStoreServiceLoading?: boolean;
   /**
   * Increases panel padding globally
-  * @default false
+  * @default true
   */
   newPanelPadding?: boolean;
   /**

packages/grafana-data/src/types/suggestions.ts

@@ -75,7 +75,9 @@ export interface VisualizationSuggestion<TOptions extends unknown = {}, TFieldCo
      * mutate the suggestion object which is passed in as the first argument.
      */
     previewModifier?: (suggestion: VisualizationSuggestion<TOptions, TFieldConfig>) => void;
+    /** @deprecated this will no longer be supported in the new Suggestions UI. */
     icon?: string;
+    /** @deprecated this will no longer be supported in the new Suggestions UI. */
     imgSrc?: string;
   };
 }

packages/grafana-schema/src/common/common.gen.ts

@@ -831,9 +831,17 @@ export interface TableBarGaugeCellOptions {
  */
 export interface TableSparklineCellOptions extends GraphFieldConfig {
   hideValue?: boolean;
+  /**
+   * Enable interactive hover to inspect values along the sparkline
+   */
+  interactionEnabled?: boolean;
   type: TableCellDisplayMode.Sparkline;
 }
 
+export const defaultTableSparklineCellOptions: Partial<TableSparklineCellOptions> = {
+  interactionEnabled: true,
+};
+
 /**
  * Colored background cell options
  */

packages/grafana-schema/src/common/table.cue

@@ -63,6 +63,8 @@ TableSparklineCellOptions: {
 	GraphFieldConfig
 	type: TableCellDisplayMode & "sparkline"
   hideValue?: bool
+  // Enable interactive hover to inspect values along the sparkline
+  interactionEnabled?: bool | *true
 } @cuetsy(kind="interface")
 
 // Colored background cell options

packages/grafana-ui/src/components/DateTimePickers/TimeRangePicker.test.tsx

@@ -1,7 +1,7 @@
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 
-import { dateTime, makeTimeRange, TimeRange } from '@grafana/data';
+import { dateTime, makeTimeRange, TimeRange, BootData } from '@grafana/data';
 import { selectors as e2eSelectors } from '@grafana/e2e-selectors';
 
 import { TimeRangeProvider } from './TimeRangeContext';
@@ -152,6 +152,58 @@ it('does not submit wrapping forms', async () => {
   expect(onSubmit).not.toHaveBeenCalled();
 });
 
+it('shows CTRL+Z in zoom out tooltip when feature flag is disabled', async () => {
+  window.grafanaBootData = {
+    settings: {
+      featureToggles: {
+        newTimeRangeZoomShortcuts: false,
+      },
+    },
+  } as BootData;
+
+  render(
+    <TimeRangePicker
+      onChangeTimeZone={() => {}}
+      onChange={(value) => {}}
+      value={value}
+      onMoveBackward={() => {}}
+      onMoveForward={() => {}}
+      onZoom={() => {}}
+    />
+  );
+
+  const zoomButton = screen.getByLabelText('Zoom out time range');
+  await userEvent.hover(zoomButton);
+
+  expect(await screen.findByText(/CTRL\+Z/)).toBeInTheDocument();
+});
+
+it('shows t - in zoom out tooltip when feature flag is enabled', async () => {
+  window.grafanaBootData = {
+    settings: {
+      featureToggles: {
+        newTimeRangeZoomShortcuts: true,
+      },
+    },
+  } as BootData;
+
+  render(
+    <TimeRangePicker
+      onChangeTimeZone={() => {}}
+      onChange={(value) => {}}
+      value={value}
+      onMoveBackward={() => {}}
+      onMoveForward={() => {}}
+      onZoom={() => {}}
+    />
+  );
+
+  const zoomButton = screen.getByLabelText('Zoom out time range');
+  await userEvent.hover(zoomButton);
+
+  expect(await screen.findByText(/t -/)).toBeInTheDocument();
+});
+
 describe('TimePickerTooltip', () => {
   beforeAll(() => {
     const mockIntl = {

packages/grafana-ui/src/components/DateTimePickers/TimeRangePicker.tsx

@@ -19,6 +19,7 @@ import { selectors } from '@grafana/e2e-selectors';
 import { t, Trans } from '@grafana/i18n';
 
 import { useStyles2 } from '../../themes/ThemeContext';
+import { getFeatureToggle } from '../../utils/featureToggle';
 import { ButtonGroup } from '../Button/ButtonGroup';
 import { getModalStyles } from '../Modal/getModalStyles';
 import { getPortalContainer } from '../Portal/Portal';
@@ -243,13 +244,22 @@ export function TimeRangePicker(props: TimeRangePickerProps) {
 
 TimeRangePicker.displayName = 'TimeRangePicker';
 
-const ZoomOutTooltip = () => (
-  <>
-    <Trans i18nKey="time-picker.range-picker.zoom-out-tooltip">
-      Time range zoom out <br /> CTRL+Z
-    </Trans>
-  </>
-);
+const ZoomOutTooltip = () => {
+  const newShortcuts = getFeatureToggle('newTimeRangeZoomShortcuts');
+  return (
+    <>
+      {newShortcuts ? (
+        <Trans i18nKey="time-picker.range-picker.zoom-out-tooltip-new">
+          Time range zoom out <br /> t -
+        </Trans>
+      ) : (
+        <Trans i18nKey="time-picker.range-picker.zoom-out-tooltip">
+          Time range zoom out <br /> CTRL+Z
+        </Trans>
+      )}
+    </>
+  );
+};
 
 export const TimePickerTooltip = ({ timeRange, timeZone }: { timeRange: TimeRange; timeZone?: TimeZone }) => {
   const styles = useStyles2(getLabelStyles);

packages/grafana-ui/src/components/Sparkline/Sparkline.test.tsx

@@ -1,30 +1,264 @@
 import { render } from '@testing-library/react';
+import uPlot from 'uplot';
 
-import { createTheme, FieldSparkline, FieldType } from '@grafana/data';
+import { createTheme, FieldConfig, FieldSparkline, FieldType } from '@grafana/data';
+import { GraphFieldConfig } from '@grafana/schema';
 
 import { Sparkline } from './Sparkline';
 
 describe('Sparkline', () => {
+  const mockSparkline: FieldSparkline = {
+    x: {
+      name: 'x',
+      values: [1679839200000, 1680444000000, 1681048800000, 1681653600000, 1682258400000],
+      type: FieldType.time,
+      config: {},
+    },
+    y: {
+      name: 'y',
+      values: [1, 2, 3, 4, 5],
+      type: FieldType.number,
+      config: {},
+      state: {
+        range: { min: 1, max: 5, delta: 1 },
+      },
+    },
+  };
+
   it('should render without throwing an error', () => {
-    const sparkline: FieldSparkline = {
-      x: {
-        name: 'x',
-        values: [1679839200000, 1680444000000, 1681048800000, 1681653600000, 1682258400000],
-        type: FieldType.time,
-        config: {},
-      },
-      y: {
-        name: 'y',
-        values: [1, 2, 3, 4, 5],
-        type: FieldType.number,
-        config: {},
-        state: {
-          range: { min: 1, max: 5, delta: 1 },
-        },
-      },
-    };
     expect(() =>
-      render(<Sparkline width={800} height={600} theme={createTheme()} sparkline={sparkline} />)
+      render(<Sparkline width={800} height={600} theme={createTheme()} sparkline={mockSparkline} />)
     ).not.toThrow();
   });
+
+  describe('hover interaction', () => {
+    it('should call onHover with value when interaction is enabled and cursor moves', () => {
+      const onHover = jest.fn();
+      const config: FieldConfig<GraphFieldConfig> = {
+        custom: {
+          interactionEnabled: true,
+        } as GraphFieldConfig & { interactionEnabled?: boolean },
+      };
+
+      const view = render(
+        <Sparkline
+          width={800}
+          height={600}
+          theme={createTheme()}
+          sparkline={mockSparkline}
+          config={config}
+          onHover={onHover}
+        />
+      );
+
+      // Get the Sparkline instance to access the config builder
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const instance = (view.container.firstChild as any)?.__reactFiber$?.return?.stateNode;
+      if (instance?.state?.configBuilder) {
+        const builder = instance.state.configBuilder;
+        const hooks = builder.getConfig().hooks;
+
+        // Find and execute the setLegend hook
+        const setLegendHook = hooks?.setLegend?.[0];
+        if (setLegendHook) {
+          // Simulate hover over data point at index 2 (value: 3)
+          const mockUPlot = {
+            cursor: { idxs: [2, 2] },
+            data: [mockSparkline.x!.values, mockSparkline.y.values],
+          } as Partial<uPlot>;
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          setLegendHook(mockUPlot as any);
+
+          expect(onHover).toHaveBeenCalledWith(3, 2);
+        }
+      }
+    });
+
+    it('should call onHover with null when cursor leaves', () => {
+      const onHover = jest.fn();
+      const config: FieldConfig<GraphFieldConfig> = {
+        custom: {
+          interactionEnabled: true,
+        } as GraphFieldConfig & { interactionEnabled?: boolean },
+      };
+
+      const view = render(
+        <Sparkline
+          width={800}
+          height={600}
+          theme={createTheme()}
+          sparkline={mockSparkline}
+          config={config}
+          onHover={onHover}
+        />
+      );
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const instance = (view.container.firstChild as any)?.__reactFiber$?.return?.stateNode;
+      if (instance?.state?.configBuilder) {
+        const builder = instance.state.configBuilder;
+        const hooks = builder.getConfig().hooks;
+
+        const setLegendHook = hooks?.setLegend?.[0];
+        if (setLegendHook) {
+          // Simulate cursor leaving (no valid index)
+          const mockUPlot = {
+            cursor: { idxs: [null, null] },
+            data: [mockSparkline.x!.values, mockSparkline.y.values],
+          };
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          setLegendHook(mockUPlot as any);
+
+          expect(onHover).toHaveBeenCalledWith(null, null);
+        }
+      }
+    });
+
+    it('should not set up hover hooks when interaction is disabled', () => {
+      const onHover = jest.fn();
+      const config: FieldConfig<GraphFieldConfig> = {
+        custom: {
+          interactionEnabled: false,
+        } as GraphFieldConfig & { interactionEnabled?: boolean },
+      };
+
+      const view = render(
+        <Sparkline
+          width={800}
+          height={600}
+          theme={createTheme()}
+          sparkline={mockSparkline}
+          config={config}
+          onHover={onHover}
+        />
+      );
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const instance = (view.container.firstChild as any)?.__reactFiber$?.return?.stateNode;
+      if (instance?.state?.configBuilder) {
+        const builder = instance.state.configBuilder;
+        const hooks = builder.getConfig().hooks;
+
+        // setLegend hook should not be registered
+        expect(hooks?.setLegend).toBeUndefined();
+      }
+    });
+
+    it('should not set up hover hooks when onHover is not provided', () => {
+      const config: FieldConfig<GraphFieldConfig> = {
+        custom: {
+          interactionEnabled: true,
+        } as GraphFieldConfig & { interactionEnabled?: boolean },
+      };
+
+      const view = render(
+        <Sparkline
+          width={800}
+          height={600}
+          theme={createTheme()}
+          sparkline={mockSparkline}
+          config={config}
+        />
+      );
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const instance = (view.container.firstChild as any)?.__reactFiber$?.return?.stateNode;
+      if (instance?.state?.configBuilder) {
+        const builder = instance.state.configBuilder;
+        const hooks = builder.getConfig().hooks;
+
+        // setLegend hook should not be registered when no onHover callback
+        expect(hooks?.setLegend).toBeUndefined();
+      }
+    });
+
+    it('should enable interaction by default when not explicitly configured', () => {
+      const onHover = jest.fn();
+      const config: FieldConfig<GraphFieldConfig> = {
+        custom: {} as GraphFieldConfig & { interactionEnabled?: boolean },
+      };
+
+      const view = render(
+        <Sparkline
+          width={800}
+          height={600}
+          theme={createTheme()}
+          sparkline={mockSparkline}
+          config={config}
+          onHover={onHover}
+        />
+      );
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const instance = (view.container.firstChild as any)?.__reactFiber$?.return?.stateNode;
+      if (instance?.state?.configBuilder) {
+        const builder = instance.state.configBuilder;
+        const hooks = builder.getConfig().hooks;
+
+        // setLegend hook should be registered (interaction enabled by default)
+        expect(hooks?.setLegend).toBeDefined();
+        expect(hooks?.setLegend?.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('should handle non-finite values correctly during hover', () => {
+      const onHover = jest.fn();
+      const config: FieldConfig<GraphFieldConfig> = {
+        custom: {
+          interactionEnabled: true,
+        } as GraphFieldConfig & { interactionEnabled?: boolean },
+      };
+
+      const sparklineWithNaN: FieldSparkline = {
+        ...mockSparkline,
+        y: {
+          ...mockSparkline.y,
+          values: [1, NaN, 3, Infinity, 5],
+        },
+      };
+
+      const view = render(
+        <Sparkline
+          width={800}
+          height={600}
+          theme={createTheme()}
+          sparkline={sparklineWithNaN}
+          config={config}
+          onHover={onHover}
+        />
+      );
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const instance = (view.container.firstChild as any)?.__reactFiber$?.return?.stateNode;
+      if (instance?.state?.configBuilder) {
+        const builder = instance.state.configBuilder;
+        const hooks = builder.getConfig().hooks;
+
+        const setLegendHook = hooks?.setLegend?.[0];
+        if (setLegendHook) {
+          // Hover over NaN value at index 1
+          const mockUPlot1 = {
+            cursor: { idxs: [1, 1] },
+            data: [sparklineWithNaN.x!.values, sparklineWithNaN.y.values],
+          } as Partial<uPlot>;
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          setLegendHook(mockUPlot1 as any);
+          expect(onHover).toHaveBeenCalledWith(null, null);
+
+          onHover.mockClear();
+
+          // Hover over Infinity value at index 3
+          const mockUPlot3 = {
+            cursor: { idxs: [3, 3] },
+            data: [sparklineWithNaN.x!.values, sparklineWithNaN.y.values],
+          } as Partial<uPlot>;
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          setLegendHook(mockUPlot3 as any);
+          expect(onHover).toHaveBeenCalledWith(null, null);
+        }
+      }
+    });
+  });
 });

packages/grafana-ui/src/components/Sparkline/Sparkline.tsx

@@ -1,3 +1,4 @@
+import { css } from '@emotion/css';
 import { isEqual } from 'lodash';
 import { PureComponent } from 'react';
 import { AlignedData, Range } from 'uplot';
@@ -33,6 +34,7 @@ export interface SparklineProps extends Themeable2 {
   height: number;
   config?: FieldConfig<GraphFieldConfig>;
   sparkline: FieldSparkline;
+  onHover?: (value: number | null, index: number | null) => void;
 }
 
 interface State {
@@ -106,14 +108,14 @@ export class Sparkline extends PureComponent<SparklineProps, State> {
   }
 
   prepareConfig(data: DataFrame) {
-    const { theme } = this.props;
+    const { theme, onHover, config } = this.props;
     const builder = new UPlotConfigBuilder();
 
-    builder.setCursor({
-      show: false,
-      x: false, // no crosshairs
-      y: false,
-    });
+    // Check if interaction is enabled (default to true)
+    // interactionEnabled is on TableSparklineCellOptions which extends GraphFieldConfig
+    const customConfig = config?.custom;
+    const interactionEnabled =
+      customConfig && 'interactionEnabled' in customConfig ? customConfig.interactionEnabled : true;
 
     // X is the first field in the alligned frame
     const xField = data.fields[0];
@@ -141,6 +143,9 @@ export class Sparkline extends PureComponent<SparklineProps, State> {
       placement: AxisPlacement.Hidden,
     });
 
+    // Track the series color for cursor point styling
+    let seriesColor: string | undefined;
+
     for (let i = 0; i < data.fields.length; i++) {
       const field = data.fields[i];
       const config: FieldConfig<GraphFieldConfig> = field.config;
@@ -168,7 +173,7 @@ export class Sparkline extends PureComponent<SparklineProps, State> {
       });
 
       const colorMode = getFieldColorModeForField(field);
-      const seriesColor = colorMode.getCalculator(field, theme)(0, 0);
+      seriesColor = colorMode.getCalculator(field, theme)(0, 0);
       const pointsMode =
         customConfig.drawStyle === GraphDrawStyle.Points ? VisibilityMode.Always : customConfig.showPoints;
 
@@ -183,7 +188,7 @@ export class Sparkline extends PureComponent<SparklineProps, State> {
         lineWidth: customConfig.lineWidth,
         lineInterpolation: customConfig.lineInterpolation,
         showPoints: pointsMode,
-        pointSize: customConfig.pointSize,
+        pointSize: customConfig.pointSize || 5, // Ensure minimum size for cursor point calculation
         fillOpacity: customConfig.fillOpacity,
         fillColor: customConfig.fillColor,
         lineStyle: customConfig.lineStyle,
@@ -192,12 +197,72 @@ export class Sparkline extends PureComponent<SparklineProps, State> {
       });
     }
 
+    // Configure cursor after series so we have the series color
+    if (interactionEnabled && onHover) {
+      // Enable cursor with vertical bar indicator for hover interaction
+      // Vertical bar is more visible on small sparklines (25-30px height) than a dot
+      builder.setCursor({
+        show: true,
+        x: true, // show vertical line (bar indicator)
+        y: false, // no horizontal line
+        points: {
+          show: false, // don't show dots - use vertical bar instead
+          // Provide safe functions that don't access this.frames (which is undefined for Sparkline)
+          stroke: () => 'transparent',
+          fill: () => 'transparent',
+          size: () => 0,
+          width: () => 0,
+        },
+        focus: {
+          prox: 30, // proximity in CSS pixels for hover detection
+        },
+      });
+
+      // Track cursor position and call onHover with the value at that position
+      // Using setLegend hook which fires on hover (not just drag-to-select like setSelect)
+      builder.addHook('setLegend', (u: uPlot) => {
+        const dataIdx = u.cursor.idxs?.[1]; // Get the data index from the cursor
+        if (dataIdx != null) {
+          const yData = u.data[1]; // Y-axis data (values)
+          if (yData && dataIdx < yData.length) {
+            const value = yData[dataIdx];
+            if (value != null && isFinite(value)) {
+              onHover(value, dataIdx);
+              return;
+            }
+          }
+        }
+        // Reset on mouse leave or when no valid data point
+        onHover(null, null);
+      });
+    } else {
+      // Default behavior: cursor disabled
+      builder.setCursor({
+        show: false,
+        x: false, // no crosshairs
+        y: false,
+      });
+    }
+
     return builder;
   }
 
   render() {
     const { data, configBuilder } = this.state;
     const { width, height } = this.props;
-    return <UPlotChart data={data} config={configBuilder} width={width} height={height} />;
+
+    // Style the vertical cursor bar to be more visible on small sparklines
+    const cursorStyles = css({
+      '.u-cursor-x': {
+        borderLeft: '2px solid !important',
+        opacity: '1 !important',
+      },
+    });
+
+    return (
+      <div className={cursorStyles}>
+        <UPlotChart data={data} config={configBuilder} width={width} height={height} />
+      </div>
+    );
   }
 }

packages/grafana-ui/src/components/Table/TableNG/Cells/SparklineCell.tsx

@@ -1,5 +1,6 @@
 import { css } from '@emotion/css';
 import * as React from 'react';
+import { useState, useCallback } from 'react';
 
 import { FieldConfig, getMinMaxAndDelta, Field, isDataFrameWithValue } from '@grafana/data';
 import { t } from '@grafana/i18n';
@@ -32,12 +33,20 @@ export const defaultSparklineCellConfig: TableSparklineCellOptions = {
   barAlignment: BarAlignment.Center,
   showPoints: VisibilityMode.Never,
   hideValue: false,
+  interactionEnabled: true,
 };
 
 export const SparklineCell = (props: SparklineCellProps) => {
   const { field, value, theme, timeRange, rowIdx, width } = props;
   const sparkline = prepareSparklineValue(value, field);
 
+  // Hover state management for interactive sparklines
+  const [hoverValue, setHoverValue] = useState<number | null>(null);
+
+  const handleHover = useCallback((value: number | null, index: number | null) => {
+    setHoverValue(value);
+  }, []);
+
   if (!sparkline) {
     return (
       <MaybeWrapWithLink field={field} rowIdx={rowIdx}>
@@ -80,8 +89,10 @@ export const SparklineCell = (props: SparklineCellProps) => {
   let valueWidth = 0;
   let valueElement: React.ReactNode = null;
   if (!hideValue) {
-    const newValue = isDataFrameWithValue(value) ? value.value : null;
-    const displayValue = field.display!(newValue);
+    // Use hover value if hovering, otherwise use the default value
+    const defaultValue = isDataFrameWithValue(value) ? value.value : null;
+    const displayRawValue = hoverValue ?? defaultValue;
+    const displayValue = field.display!(displayRawValue);
     const alignmentFactor = getAlignmentFactor(field, displayValue, rowIdx!);
 
     valueWidth =
@@ -94,7 +105,14 @@ export const SparklineCell = (props: SparklineCellProps) => {
   return (
     <MaybeWrapWithLink field={field} rowIdx={rowIdx}>
       {valueElement}
-      <Sparkline width={width - valueWidth} height={25} sparkline={sparkline} config={config} theme={theme} />
+      <Sparkline
+        width={width - valueWidth}
+        height={25}
+        sparkline={sparkline}
+        config={config}
+        theme={theme}
+        onHover={handleHover}
+      />
     </MaybeWrapWithLink>
   );
 };

packages/grafana-ui/src/components/uPlot/config/UPlotConfigBuilder.ts

@@ -29,7 +29,7 @@ const cursorDefaults: Cursor = {
 type PrepData = (frames: DataFrame[]) => AlignedData | FacetedData;
 type PreDataStacked = (frames: DataFrame[], stackingGroups: StackingGroup[]) => AlignedData | FacetedData;
 
-type PlotState = { isPanning: false } | { isPanning: true; min: number; max: number };
+type PlotState = { isPanning: false } | { isPanning: true; min: number; max: number; isTimeRangePending?: boolean };
 
 export class UPlotConfigBuilder {
   readonly uid = Math.random().toString(36).slice(2);

packages/grafana-ui/src/components/uPlot/plugins/XAxisInteractionAreaPlugin.test.tsx

@@ -137,7 +137,7 @@ describe('XAxisInteractionAreaPlugin', () => {
       expect(mockQueryZoom).not.toHaveBeenCalled();
     });
 
-    it('should set isPanning state during drag and clear on mouseup', () => {
+    it('should set isPanning state during drag and mark isTimeRangePending on mouseup', () => {
       setupXAxisPan(asUPlot(mockUPlot), asConfigBuilder(mockConfigBuilder), mockQueryZoom);
 
       xAxisElement.dispatchEvent(new MouseEvent('mousedown', { clientX: 400, bubbles: true }));
@@ -153,6 +153,20 @@ describe('XAxisInteractionAreaPlugin', () => {
 
       document.dispatchEvent(new MouseEvent('mouseup', { clientX: 350, bubbles: true }));
 
+      expect(mockConfigBuilder.setState).toHaveBeenCalledWith({
+        isPanning: true,
+        min: expectedRange.from,
+        max: expectedRange.to,
+        isTimeRangePending: true,
+      });
+    });
+
+    it('should clear isPanning state immediately for small drags below threshold', () => {
+      setupXAxisPan(asUPlot(mockUPlot), asConfigBuilder(mockConfigBuilder), mockQueryZoom);
+
+      xAxisElement.dispatchEvent(new MouseEvent('mousedown', { clientX: 400, bubbles: true }));
+      document.dispatchEvent(new MouseEvent('mouseup', { clientX: 402, bubbles: true }));
+
       expect(mockConfigBuilder.setState).toHaveBeenCalledWith({ isPanning: false });
     });
   });

packages/grafana-ui/src/components/uPlot/plugins/XAxisInteractionAreaPlugin.tsx

@@ -96,11 +96,14 @@ export const setupXAxisPan = (
 
       xAxisEl.style.cursor = 'grab';
 
-      config.setState({ isPanning: false });
+      const isSignificantDrag = Math.abs(dragPixels) >= MIN_PAN_DIST;
 
-      if (Math.abs(dragPixels) >= MIN_PAN_DIST) {
+      if (isSignificantDrag) {
         const newRange = calculatePanRange(startMin, startMax, dragPixels, u.bbox.width);
+        config.setState({ isPanning: true, min: newRange.from, max: newRange.to, isTimeRangePending: true });
         queryZoom(newRange);
+      } else {
+        config.setState({ isPanning: false });
       }
 
       document.removeEventListener('mousemove', onMove);

pkg/api/datasources.go

@@ -9,6 +9,7 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 
@@ -18,6 +19,7 @@ import (
 	"github.com/grafana/grafana/pkg/apimachinery/identity"
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/infra/metrics/metricutil"
 	contextmodel "github.com/grafana/grafana/pkg/services/contexthandler/model"
 	"github.com/grafana/grafana/pkg/services/datasources"
 	"github.com/grafana/grafana/pkg/setting"
@@ -200,6 +202,11 @@ func (hs *HTTPServer) DeleteDataSourceById(c *contextmodel.ReqContext) response.
 // 404: notFoundError
 // 500: internalServerError
 func (hs *HTTPServer) GetDataSourceByUID(c *contextmodel.ReqContext) response.Response {
+	start := time.Now()
+	defer func() {
+		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())
 
 	if err != nil {
@@ -231,6 +238,11 @@ func (hs *HTTPServer) GetDataSourceByUID(c *contextmodel.ReqContext) response.Re
 // 404: notFoundError
 // 500: internalServerError
 func (hs *HTTPServer) DeleteDataSourceByUID(c *contextmodel.ReqContext) response.Response {
+	start := time.Now()
+	defer func() {
+		metricutil.ObserveWithExemplar(c.Req.Context(), hs.dsConfigHandlerRequestsDuration.WithLabelValues("legacy", "DeleteDataSourceByUID"), time.Since(start).Seconds())
+	}()
+
 	uid := web.Params(c.Req)[":uid"]
 
 	if uid == "" {
@@ -361,6 +373,11 @@ func validateJSONData(jsonData *simplejson.Json, cfg *setting.Cfg) error {
 // 409: conflictError
 // 500: internalServerError
 func (hs *HTTPServer) AddDataSource(c *contextmodel.ReqContext) response.Response {
+	start := time.Now()
+	defer func() {
+		metricutil.ObserveWithExemplar(c.Req.Context(), hs.dsConfigHandlerRequestsDuration.WithLabelValues("legacy", "AddDataSource"), time.Since(start).Seconds())
+	}()
+
 	cmd := datasources.AddDataSourceCommand{}
 	if err := web.Bind(c.Req, &cmd); err != nil {
 		return response.Error(http.StatusBadRequest, "bad request data", err)
@@ -478,6 +495,10 @@ func (hs *HTTPServer) UpdateDataSourceByID(c *contextmodel.ReqContext) response.
 // 409: conflictError
 // 500: internalServerError
 func (hs *HTTPServer) UpdateDataSourceByUID(c *contextmodel.ReqContext) response.Response {
+	start := time.Now()
+	defer func() {
+		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 {
 		return response.Error(http.StatusBadRequest, "bad request data", err)

pkg/api/datasources_test.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/prometheus/client_golang/prometheus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -16,6 +17,7 @@ import (
 	"github.com/grafana/grafana/pkg/api/routing"
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	"github.com/grafana/grafana/pkg/infra/db/dbtest"
+	"github.com/grafana/grafana/pkg/infra/metrics/metricutil"
 	ac "github.com/grafana/grafana/pkg/services/accesscontrol"
 	"github.com/grafana/grafana/pkg/services/accesscontrol/acimpl"
 	"github.com/grafana/grafana/pkg/services/accesscontrol/actest"
@@ -81,6 +83,19 @@ func TestDataSourcesProxy_userLoggedIn(t *testing.T) {
 		}, mockSQLStore)
 }
 
+// setupDsConfigMetrics creates and registers the prometheus metrics needed for HTTPServer tests
+// that call methods using dsConfigHandlerRequestsDuration.
+func setupDsConfigHandlerMetrics() (prometheus.Registerer, *prometheus.HistogramVec) {
+	promRegister := prometheus.NewRegistry()
+	dsConfigHandlerRequestsDuration := metricutil.NewHistogramVec(prometheus.HistogramOpts{
+		Namespace: "grafana",
+		Name:      "ds_config_handler_requests_duration_seconds",
+		Help:      "Duration of requests handled by datasource configuration handlers",
+	}, []string{"code_path", "handler"})
+	promRegister.MustRegister(dsConfigHandlerRequestsDuration)
+	return promRegister, dsConfigHandlerRequestsDuration
+}
+
 // Adding data sources with invalid URLs should lead to an error.
 func TestAddDataSource_InvalidURL(t *testing.T) {
 	sc := setupScenarioContext(t, "/api/datasources")
@@ -88,6 +103,7 @@ func TestAddDataSource_InvalidURL(t *testing.T) {
 		DataSourcesService: &dataSourcesServiceMock{},
 		Cfg:                setting.NewCfg(),
 	}
+	hs.promRegister, hs.dsConfigHandlerRequestsDuration = setupDsConfigHandlerMetrics()
 
 	sc.m.Post(sc.url, routing.Wrap(func(c *contextmodel.ReqContext) response.Response {
 		c.Req.Body = mockRequestBody(datasources.AddDataSourceCommand{
@@ -118,6 +134,7 @@ func TestAddDataSource_URLWithoutProtocol(t *testing.T) {
 		AccessControl:        acimpl.ProvideAccessControl(featuremgmt.WithFeatures()),
 		accesscontrolService: actest.FakeService{},
 	}
+	hs.promRegister, hs.dsConfigHandlerRequestsDuration = setupDsConfigHandlerMetrics()
 
 	sc := setupScenarioContext(t, "/api/datasources")
 
@@ -143,6 +160,7 @@ func TestAddDataSource_InvalidJSONData(t *testing.T) {
 		DataSourcesService: &dataSourcesServiceMock{},
 		Cfg:                setting.NewCfg(),
 	}
+	hs.promRegister, hs.dsConfigHandlerRequestsDuration = setupDsConfigHandlerMetrics()
 
 	sc := setupScenarioContext(t, "/api/datasources")
 
@@ -175,6 +193,7 @@ func TestUpdateDataSource_InvalidURL(t *testing.T) {
 		DataSourcesService: &dataSourcesServiceMock{},
 		Cfg:                setting.NewCfg(),
 	}
+	hs.promRegister, hs.dsConfigHandlerRequestsDuration = setupDsConfigHandlerMetrics()
 	sc := setupScenarioContext(t, "/api/datasources/1234")
 
 	sc.m.Put(sc.url, routing.Wrap(func(c *contextmodel.ReqContext) response.Response {
@@ -199,6 +218,7 @@ func TestUpdateDataSource_InvalidJSONData(t *testing.T) {
 		DataSourcesService: &dataSourcesServiceMock{},
 		Cfg:                setting.NewCfg(),
 	}
+	hs.promRegister, hs.dsConfigHandlerRequestsDuration = setupDsConfigHandlerMetrics()
 	sc := setupScenarioContext(t, "/api/datasources/1234")
 
 	hs.Cfg.AuthProxy.Enabled = true
@@ -236,6 +256,7 @@ func TestAddDataSourceTeamHTTPHeaders(t *testing.T) {
 			ExpectedErr:      nil,
 		},
 	}
+	hs.promRegister, hs.dsConfigHandlerRequestsDuration = setupDsConfigHandlerMetrics()
 	sc := setupScenarioContext(t, fmt.Sprintf("/api/datasources/%s", tenantID))
 	hs.Cfg.AuthProxy.Enabled = true
 
@@ -289,6 +310,7 @@ func TestUpdateDataSource_URLWithoutProtocol(t *testing.T) {
 		AccessControl:        acimpl.ProvideAccessControl(featuremgmt.WithFeatures()),
 		accesscontrolService: actest.FakeService{},
 	}
+	hs.promRegister, hs.dsConfigHandlerRequestsDuration = setupDsConfigHandlerMetrics()
 
 	sc := setupScenarioContext(t, "/api/datasources/1234")
 
@@ -429,6 +451,7 @@ func TestAPI_datasources_AccessControl(t *testing.T) {
 				hs.DataSourcesService = &dataSourcesServiceMock{expectedDatasource: &datasources.DataSource{}}
 				hs.accesscontrolService = actest.FakeService{}
 				hs.Live = newTestLive(t, hs.SQLStore)
+				hs.promRegister, hs.dsConfigHandlerRequestsDuration = setupDsConfigHandlerMetrics()
 			})
 
 			for _, url := range tt.urls {

pkg/api/http_server.go

@@ -203,27 +203,28 @@ type HTTPServer struct {
 	pluginsCDNService            *pluginscdn.Service
 	managedPluginsService        managedplugins.Manager
 
-	userService                 user.Service
-	tempUserService             tempUser.Service
-	loginAttemptService         loginAttempt.Service
-	orgService                  org.Service
-	orgDeletionService          org.DeletionService
-	TeamService                 team.Service
-	accesscontrolService        accesscontrol.Service
-	annotationsRepo             annotations.Repository
-	tagService                  tag.Service
-	oauthTokenService           oauthtoken.OAuthTokenService
-	statsService                stats.Service
-	authnService                authn.Service
-	starApi                     *starApi.API
-	promRegister                prometheus.Registerer
-	promGatherer                prometheus.Gatherer
-	clientConfigProvider        grafanaapiserver.DirectRestConfigProvider
-	namespacer                  request.NamespaceMapper
-	anonService                 anonymous.Service
-	userVerifier                user.Verifier
-	tlsCerts                    TLSCerts
-	htmlHandlerRequestsDuration *prometheus.HistogramVec
+	userService                     user.Service
+	tempUserService                 tempUser.Service
+	loginAttemptService             loginAttempt.Service
+	orgService                      org.Service
+	orgDeletionService              org.DeletionService
+	TeamService                     team.Service
+	accesscontrolService            accesscontrol.Service
+	annotationsRepo                 annotations.Repository
+	tagService                      tag.Service
+	oauthTokenService               oauthtoken.OAuthTokenService
+	statsService                    stats.Service
+	authnService                    authn.Service
+	starApi                         *starApi.API
+	promRegister                    prometheus.Registerer
+	promGatherer                    prometheus.Gatherer
+	clientConfigProvider            grafanaapiserver.DirectRestConfigProvider
+	namespacer                      request.NamespaceMapper
+	anonService                     anonymous.Service
+	userVerifier                    user.Verifier
+	tlsCerts                        TLSCerts
+	htmlHandlerRequestsDuration     *prometheus.HistogramVec
+	dsConfigHandlerRequestsDuration *prometheus.HistogramVec
 }
 
 type TLSCerts struct {
@@ -382,9 +383,15 @@ func ProvideHTTPServer(opts ServerOptions, cfg *setting.Cfg, routeRegister routi
 			Name:      "html_handler_requests_duration_seconds",
 			Help:      "Duration of requests handled by the index.go HTML handler",
 		}, []string{"handler"}),
+		dsConfigHandlerRequestsDuration: metricutil.NewHistogramVec(prometheus.HistogramOpts{
+			Namespace: "grafana",
+			Name:      "ds_config_handler_requests_duration_seconds",
+			Help:      "Duration of requests handled by datasource configuration handlers",
+		}, []string{"code_path", "handler"}),
 	}
 
 	promRegister.MustRegister(hs.htmlHandlerRequestsDuration)
+	promRegister.MustRegister(hs.dsConfigHandlerRequestsDuration)
 
 	if hs.Listener != nil {
 		hs.log.Debug("Using provided listener")

pkg/registry/apis/datasource/legacy_store.go

@@ -3,7 +3,9 @@ package datasource
 import (
 	"context"
 	"fmt"
+	"time"
 
+	"github.com/prometheus/client_golang/prometheus"
 	"k8s.io/apimachinery/pkg/apis/meta/internalversion"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -11,6 +13,7 @@ import (
 
 	"github.com/grafana/grafana/pkg/apimachinery/utils"
 	"github.com/grafana/grafana/pkg/apis/datasource/v0alpha1"
+	"github.com/grafana/grafana/pkg/infra/metrics/metricutil"
 )
 
 var (
@@ -26,8 +29,9 @@ var (
 )
 
 type legacyStorage struct {
-	datasources  PluginDatasourceProvider
-	resourceInfo *utils.ResourceInfo
+	datasources                     PluginDatasourceProvider
+	resourceInfo                    *utils.ResourceInfo
+	dsConfigHandlerRequestsDuration *prometheus.HistogramVec
 }
 
 func (s *legacyStorage) New() runtime.Object {
@@ -57,11 +61,21 @@ func (s *legacyStorage) List(ctx context.Context, options *internalversion.ListO
 }
 
 func (s *legacyStorage) Get(ctx context.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
+	start := time.Now()
+	defer func() {
+		metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("new", "Get"), time.Since(start).Seconds())
+	}()
+
 	return s.datasources.GetDataSource(ctx, name)
 }
 
 // Create implements rest.Creater.
 func (s *legacyStorage) Create(ctx context.Context, obj runtime.Object, createValidation rest.ValidateObjectFunc, options *metav1.CreateOptions) (runtime.Object, error) {
+	start := time.Now()
+	defer func() {
+		metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("new", "Create"), time.Since(start).Seconds())
+	}()
+
 	ds, ok := obj.(*v0alpha1.DataSource)
 	if !ok {
 		return nil, fmt.Errorf("expected a datasource object")
@@ -71,6 +85,11 @@ func (s *legacyStorage) Create(ctx context.Context, obj runtime.Object, createVa
 
 // Update implements rest.Updater.
 func (s *legacyStorage) Update(ctx context.Context, name string, objInfo rest.UpdatedObjectInfo, createValidation rest.ValidateObjectFunc, updateValidation rest.ValidateObjectUpdateFunc, forceAllowCreate bool, options *metav1.UpdateOptions) (runtime.Object, bool, error) {
+	start := time.Now()
+	defer func() {
+		metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("new", "Create"), time.Since(start).Seconds())
+	}()
+
 	old, err := s.Get(ctx, name, &metav1.GetOptions{})
 	if err != nil {
 		return nil, false, err
@@ -107,6 +126,11 @@ func (s *legacyStorage) Update(ctx context.Context, name string, objInfo rest.Up
 
 // Delete implements rest.GracefulDeleter.
 func (s *legacyStorage) Delete(ctx context.Context, name string, deleteValidation rest.ValidateObjectFunc, options *metav1.DeleteOptions) (runtime.Object, bool, error) {
+	start := time.Now()
+	defer func() {
+		metricutil.ObserveWithExemplar(ctx, s.dsConfigHandlerRequestsDuration.WithLabelValues("new", "Create"), time.Since(start).Seconds())
+	}()
+
 	err := s.datasources.DeleteDataSource(ctx, name)
 	return nil, false, err
 }

pkg/registry/apis/datasource/register.go

@@ -20,6 +20,7 @@ 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/metricutil"
 	"github.com/grafana/grafana/pkg/plugins"
 	"github.com/grafana/grafana/pkg/plugins/manager/sources"
 	"github.com/grafana/grafana/pkg/promlib/models"
@@ -218,6 +219,11 @@ func (b *DataSourceAPIBuilder) UpdateAPIGroupInfo(apiGroupInfo *genericapiserver
 		legacyStore := &legacyStorage{
 			datasources:  b.datasources,
 			resourceInfo: &ds,
+			dsConfigHandlerRequestsDuration: metricutil.NewHistogramVec(prometheus.HistogramOpts{
+				Namespace: "grafana",
+				Name:      "ds_config_handler_requests_duration_seconds",
+				Help:      "Duration of requests handled by datasource configuration handlers",
+			}, []string{"code_path", "handler"}),
 		}
 		unified, err := grafanaregistry.NewRegistryStore(opts.Scheme, ds, opts.OptsGetter)
 		if err != nil {

pkg/registry/apis/ofrep/register.go

@@ -64,6 +64,10 @@ func NewAPIBuilder(providerType string, url *url.URL, insecure bool, caFile stri
 }
 
 func RegisterAPIService(apiregistration builder.APIRegistrar, cfg *setting.Cfg) (*APIBuilder, error) {
+	if !cfg.OpenFeature.APIEnabled {
+		return nil, nil
+	}
+
 	var staticEvaluator featuremgmt.StaticFlagEvaluator //  No static evaluator needed for non-static provider
 	var err error
 	if cfg.OpenFeature.ProviderType == setting.StaticProviderType {

pkg/server/wire_gen.go

@@ -668,7 +668,7 @@ func Initialize(ctx context.Context, cfg *setting.Cfg, opts Options, apiOpts api
 	azurePromMigrationService := promtypemigration.ProvideAzurePromMigrationService(service15, inMemory, repoManager, pluginInstaller, cfg)
 	amazonPromMigrationService := promtypemigration.ProvideAmazonPromMigrationService(service15, inMemory, repoManager, pluginInstaller, cfg)
 	promTypeMigrationProviderImpl := promtypemigration.ProvidePromTypeMigrationProvider(serverLockService, featureToggles, azurePromMigrationService, amazonPromMigrationService)
-	provisioningServiceImpl, err := provisioning.ProvideService(accessControl, cfg, sqlStore, pluginstoreService, dBstore, serviceService, notificationService, dashboardProvisioningService, service15, correlationsService, dashboardService, folderimplService, service13, searchService, quotaService, secretsService, orgService, receiverPermissionsService, tracingService, dualwriteService, promTypeMigrationProviderImpl)
+	provisioningServiceImpl, err := provisioning.ProvideService(accessControl, cfg, sqlStore, pluginstoreService, dBstore, serviceService, notificationService, dashboardProvisioningService, service15, correlationsService, dashboardService, folderimplService, service13, searchService, quotaService, secretsService, orgService, receiverPermissionsService, tracingService, dualwriteService, promTypeMigrationProviderImpl, serverLockService)
 	if err != nil {
 		return nil, err
 	}
@@ -1312,7 +1312,7 @@ func InitializeForTest(ctx context.Context, t sqlutil.ITestDB, testingT interfac
 	azurePromMigrationService := promtypemigration.ProvideAzurePromMigrationService(service15, inMemory, repoManager, pluginInstaller, cfg)
 	amazonPromMigrationService := promtypemigration.ProvideAmazonPromMigrationService(service15, inMemory, repoManager, pluginInstaller, cfg)
 	promTypeMigrationProviderImpl := promtypemigration.ProvidePromTypeMigrationProvider(serverLockService, featureToggles, azurePromMigrationService, amazonPromMigrationService)
-	provisioningServiceImpl, err := provisioning.ProvideService(accessControl, cfg, sqlStore, pluginstoreService, dBstore, serviceService, notificationService, dashboardProvisioningService, service15, correlationsService, dashboardService, folderimplService, service13, searchService, quotaService, secretsService, orgService, receiverPermissionsService, tracingService, dualwriteService, promTypeMigrationProviderImpl)
+	provisioningServiceImpl, err := provisioning.ProvideService(accessControl, cfg, sqlStore, pluginstoreService, dBstore, serviceService, notificationService, dashboardProvisioningService, service15, correlationsService, dashboardService, folderimplService, service13, searchService, quotaService, secretsService, orgService, receiverPermissionsService, tracingService, dualwriteService, promTypeMigrationProviderImpl, serverLockService)
 	if err != nil {
 		return nil, err
 	}

pkg/services/apiserver/builder/helper.go

@@ -22,7 +22,6 @@ import (
 	k8srequest "k8s.io/apiserver/pkg/endpoints/request"
 	"k8s.io/apiserver/pkg/registry/generic"
 	genericapiserver "k8s.io/apiserver/pkg/server"
-	serverstorage "k8s.io/apiserver/pkg/server/storage"
 	"k8s.io/apiserver/pkg/util/openapi"
 	k8sscheme "k8s.io/client-go/kubernetes/scheme"
 	k8stracing "k8s.io/component-base/tracing"
@@ -73,36 +72,13 @@ var PathRewriters = []filters.PathRewriter{
 	},
 }
 
-// GetDefaultBuildHandlerChainFuncForAggregator is a replica of GetDefaultBuildHandlerChainFunc except it skips custom routes handling
-func GetDefaultBuildHandlerChainFuncForAggregator() BuildHandlerChainFunc {
-	return func(delegateHandler http.Handler, c *genericapiserver.Config) http.Handler {
-		// filters.WithRequester needs to be after the K8s chain because it depends on the K8s user in context
-		handler := filters.WithRequester(delegateHandler)
-
-		// Call DefaultBuildHandlerChain on the main entrypoint http.Handler
-		// See https://github.com/kubernetes/apiserver/blob/v0.28.0/pkg/server/config.go#L906
-		// DefaultBuildHandlerChain provides many things, notably CORS, HSTS, cache-control, authz and latency tracking
-		handler = genericapiserver.DefaultBuildHandlerChain(handler, c)
-
-		handler = filters.WithAcceptHeader(handler)
-		handler = filters.WithPathRewriters(handler, PathRewriters)
-		handler = k8stracing.WithTracing(handler, c.TracerProvider, "KubernetesAPI")
-		handler = filters.WithExtractJaegerTrace(handler)
-		// Configure filters.WithPanicRecovery to not crash on panic
-		utilruntime.ReallyCrash = false
-
-		return handler
-	}
-}
 func GetDefaultBuildHandlerChainFunc(builders []APIGroupBuilder, reg prometheus.Registerer) BuildHandlerChainFunc {
 	return func(delegateHandler http.Handler, c *genericapiserver.Config) http.Handler {
 		requestHandler, err := GetCustomRoutesHandler(
 			delegateHandler,
 			c.LoopbackClientConfig,
 			builders,
-			reg,
-			c.MergedResourceConfig,
-		)
+			reg)
 		if err != nil {
 			panic(fmt.Sprintf("could not build the request handler for specified API builders: %s", err.Error()))
 		}
@@ -129,8 +105,6 @@ func GetDefaultBuildHandlerChainFunc(builders []APIGroupBuilder, reg prometheus.
 	}
 }
 
-// SetupConfig sets up the server config for the API server
-// specify isAggregator=true, if the chain is being constructed for kube-aggregator
 func SetupConfig(
 	scheme *runtime.Scheme,
 	serverConfig *genericapiserver.RecommendedConfig,
@@ -140,7 +114,6 @@ func SetupConfig(
 	gvs []schema.GroupVersion,
 	additionalOpenAPIDefGetters []common.GetOpenAPIDefinitions,
 	reg prometheus.Registerer,
-	apiResourceConfig *serverstorage.ResourceConfig,
 ) error {
 	serverConfig.AdmissionControl = NewAdmissionFromBuilders(builders)
 	defsGetter := GetOpenAPIDefinitions(builders, additionalOpenAPIDefGetters...)
@@ -153,7 +126,7 @@ func SetupConfig(
 		openapinamer.NewDefinitionNamer(scheme, k8sscheme.Scheme))
 
 	// Add the custom routes to service discovery
-	serverConfig.OpenAPIV3Config.PostProcessSpec = getOpenAPIPostProcessor(buildVersion, builders, gvs, apiResourceConfig)
+	serverConfig.OpenAPIV3Config.PostProcessSpec = getOpenAPIPostProcessor(buildVersion, builders, gvs)
 	serverConfig.OpenAPIV3Config.GetOperationIDAndTagsFromRoute = func(r common.Route) (string, []string, error) {
 		meta := r.Metadata()
 		kind := ""
@@ -314,7 +287,6 @@ func InstallAPIs(
 	features featuremgmt.FeatureToggles,
 	dualWriterMetrics *grafanarest.DualWriterMetrics,
 	builderMetrics *BuilderMetrics,
-	apiResourceConfig *serverstorage.ResourceConfig,
 ) error {
 	// dual writing is only enabled when the storage type is not legacy.
 	// this is needed to support setting a default RESTOptionsGetter for new APIs that don't
@@ -429,9 +401,34 @@ func InstallAPIs(
 	for group, buildersForGroup := range buildersGroupMap {
 		g := genericapiserver.NewDefaultAPIGroupInfo(group, scheme, metav1.ParameterCodec, codecs)
 		for _, b := range buildersForGroup {
-			if err := installAPIGroupsForBuilder(&g, group, b, apiResourceConfig, scheme, optsGetter, dualWrite, reg, optsregister, storageOpts, features); err != nil {
+			if err := b.UpdateAPIGroupInfo(&g, APIGroupOptions{
+				Scheme:              scheme,
+				OptsGetter:          optsGetter,
+				DualWriteBuilder:    dualWrite,
+				MetricsRegister:     reg,
+				StorageOptsRegister: optsregister,
+				StorageOpts:         storageOpts,
+			}); err != nil {
 				return err
 			}
+			if len(g.PrioritizedVersions) < 1 {
+				continue
+			}
+
+			// if grafanaAPIServerWithExperimentalAPIs is not enabled, remove v0alpha1 resources unless explicitly allowed
+			//nolint:staticcheck // not yet migrated to OpenFeature
+			if !features.IsEnabledGlobally(featuremgmt.FlagGrafanaAPIServerWithExperimentalAPIs) {
+				if resources, ok := g.VersionedResourcesStorageMap["v0alpha1"]; ok {
+					for name := range resources {
+						if !allowRegisteringResourceByInfo(b.AllowedV0Alpha1Resources(), name) {
+							delete(resources, name)
+						}
+					}
+					if len(resources) == 0 {
+						delete(g.VersionedResourcesStorageMap, "v0alpha1")
+					}
+				}
+			}
 		}
 
 		// skip installing the group if there are no resources left after filtering
@@ -448,53 +445,6 @@ func InstallAPIs(
 	return nil
 }
 
-func installAPIGroupsForBuilder(g *genericapiserver.APIGroupInfo, group string, b APIGroupBuilder, apiResourceConfig *serverstorage.ResourceConfig, scheme *runtime.Scheme,
-	optsGetter generic.RESTOptionsGetter, dualWrite grafanarest.DualWriteBuilder, reg prometheus.Registerer, optsregister apistore.StorageOptionsRegister,
-	storageOpts *options.StorageOptions, features featuremgmt.FeatureToggles) error {
-	if err := b.UpdateAPIGroupInfo(g, APIGroupOptions{
-		Scheme:              scheme,
-		OptsGetter:          optsGetter,
-		DualWriteBuilder:    dualWrite,
-		MetricsRegister:     reg,
-		StorageOptsRegister: optsregister,
-		StorageOpts:         storageOpts,
-	}); err != nil {
-		return err
-	}
-	if len(g.PrioritizedVersions) < 1 {
-		return nil
-	}
-
-	// filter out api groups that are disabled in APIEnablementOptions
-	for version := range g.VersionedResourcesStorageMap {
-		gvr := schema.GroupVersionResource{
-			Group:   group,
-			Version: version,
-		}
-		if apiResourceConfig != nil && !apiResourceConfig.ResourceEnabled(gvr) {
-			klog.InfoS("Skipping storage for disabled resource", "gvr", gvr.String())
-			delete(g.VersionedResourcesStorageMap, version)
-		}
-	}
-
-	// if grafanaAPIServerWithExperimentalAPIs is not enabled, remove v0alpha1 resources unless explicitly allowed
-	//nolint:staticcheck // not yet migrated to OpenFeature
-	if !features.IsEnabledGlobally(featuremgmt.FlagGrafanaAPIServerWithExperimentalAPIs) {
-		if resources, ok := g.VersionedResourcesStorageMap["v0alpha1"]; ok {
-			for name := range resources {
-				if !allowRegisteringResourceByInfo(b.AllowedV0Alpha1Resources(), name) {
-					delete(resources, name)
-				}
-			}
-			if len(resources) == 0 {
-				delete(g.VersionedResourcesStorageMap, "v0alpha1")
-			}
-		}
-	}
-
-	return nil
-}
-
 // AddPostStartHooks adds post start hooks to a generic API server config
 func AddPostStartHooks(
 	config *genericapiserver.RecommendedConfig,

pkg/services/apiserver/builder/openapi.go

@@ -9,8 +9,6 @@ import (
 
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
 	"k8s.io/apimachinery/pkg/runtime/schema"
-	serverstorage "k8s.io/apiserver/pkg/server/storage"
-	"k8s.io/klog/v2"
 	openapi "k8s.io/kube-openapi/pkg/common"
 	"k8s.io/kube-openapi/pkg/spec3"
 	spec "k8s.io/kube-openapi/pkg/validation/spec"
@@ -78,7 +76,6 @@ func addBuilderRoutes(
 	targetGroupVersion schema.GroupVersion,
 	openAPISpec *spec3.OpenAPI,
 	apiGroupBuilders []APIGroupBuilder,
-	apiResourceConfig *serverstorage.ResourceConfig,
 ) (*spec3.OpenAPI, error) {
 	for _, apiGroupBuilder := range apiGroupBuilders {
 		// Optionally include raw http handlers for all builders
@@ -110,24 +107,12 @@ func addBuilderRoutes(
 			}
 		}
 	}
-
-	// filter out api groups that are disabled in APIEnablementOptions
-	for path := range openAPISpec.Paths.Paths {
-		if strings.HasPrefix(path, "/apis/"+targetGroupVersion.String()+"/") {
-			gv := targetGroupVersion.WithResource("")
-			if apiResourceConfig != nil && !apiResourceConfig.ResourceEnabled(gv) {
-				klog.InfoS("removing openapi routes for disabled resource", "gv", gv.String())
-				delete(openAPISpec.Paths.Paths, path)
-			}
-		}
-	}
-
 	return openAPISpec, nil
 }
 
 // Modify the OpenAPI spec to include the additional routes.
 // nolint:gocyclo
-func getOpenAPIPostProcessor(version string, builders []APIGroupBuilder, gvs []schema.GroupVersion, apiResourceConfig *serverstorage.ResourceConfig) func(*spec3.OpenAPI) (*spec3.OpenAPI, error) {
+func getOpenAPIPostProcessor(version string, builders []APIGroupBuilder, gvs []schema.GroupVersion) func(*spec3.OpenAPI) (*spec3.OpenAPI, error) {
 	return func(s *spec3.OpenAPI) (*spec3.OpenAPI, error) {
 		if s.Paths == nil {
 			return s, nil
@@ -242,7 +227,7 @@ func getOpenAPIPostProcessor(version string, builders []APIGroupBuilder, gvs []s
 						}
 					}
 				}
-				return addBuilderRoutes(gv, &copy, builders, apiResourceConfig)
+				return addBuilderRoutes(gv, &copy, builders)
 			}
 		}
 		return s, nil

pkg/services/apiserver/builder/request_handler.go

@@ -6,9 +6,7 @@ import (
 
 	"github.com/gorilla/mux"
 	"github.com/prometheus/client_golang/prometheus"
-	serverstorage "k8s.io/apiserver/pkg/server/storage"
 	restclient "k8s.io/client-go/rest"
-	klog "k8s.io/klog/v2"
 	"k8s.io/kube-openapi/pkg/spec3"
 )
 
@@ -16,7 +14,7 @@ type requestHandler struct {
 	router *mux.Router
 }
 
-func GetCustomRoutesHandler(delegateHandler http.Handler, restConfig *restclient.Config, builders []APIGroupBuilder, metricsRegistry prometheus.Registerer, apiResourceConfig *serverstorage.ResourceConfig) (http.Handler, error) {
+func GetCustomRoutesHandler(delegateHandler http.Handler, restConfig *restclient.Config, builders []APIGroupBuilder, metricsRegistry prometheus.Registerer) (http.Handler, error) {
 	useful := false // only true if any routes exist anywhere
 	router := mux.NewRouter()
 
@@ -29,12 +27,6 @@ func GetCustomRoutesHandler(delegateHandler http.Handler, restConfig *restclient
 		}
 
 		for _, gv := range GetGroupVersions(builder) {
-			// filter out api groups that are disabled in APIEnablementOptions
-			gvr := gv.WithResource("")
-			if apiResourceConfig != nil && !apiResourceConfig.ResourceEnabled(gvr) {
-				klog.InfoS("Skipping custom route handler for disabled group version", "gv", gv.String())
-				continue
-			}
 			routes := provider.GetAPIRoutes(gv)
 			if routes == nil {
 				continue

pkg/services/apiserver/service.go

@@ -316,11 +316,7 @@ func (s *service) start(ctx context.Context) error {
 		s.cfg.BuildBranch,
 	)
 
-	apiResourceConfig := appinstaller.NewAPIResourceConfig(s.appInstallers)
-	// add the builder group versions to the api resource config
-	apiResourceConfig.EnableVersions(groupVersions...)
-
-	if err := o.APIEnablementOptions.ApplyTo(&serverConfig.Config, apiResourceConfig, s.scheme); err != nil {
+	if err := o.APIEnablementOptions.ApplyTo(&serverConfig.Config, appinstaller.NewAPIResourceConfig(s.appInstallers), s.scheme); err != nil {
 		return err
 	}
 
@@ -363,7 +359,6 @@ func (s *service) start(ctx context.Context) error {
 		groupVersions,
 		defGetters,
 		s.metrics,
-		apiResourceConfig,
 	)
 	if err != nil {
 		return err
@@ -405,7 +400,6 @@ func (s *service) start(ctx context.Context) error {
 		s.features,
 		s.dualWriterMetrics,
 		s.builderMetrics,
-		apiResourceConfig,
 	)
 	if err != nil {
 		return err

pkg/services/featuremgmt/registry.go

@@ -1801,10 +1801,10 @@ var (
 		{
 			Name:         "azureResourcePickerUpdates",
 			Description:  "Enables the updated Azure Monitor resource picker",
-			Stage:        FeatureStagePublicPreview,
+			Stage:        FeatureStageGeneralAvailability,
 			FrontendOnly: true,
 			Owner:        grafanaPartnerPluginsSquad,
-			Expression:   "false",
+			Expression:   "true",
 		},
 		{
 			Name:            "prometheusTypeMigration",
@@ -1895,10 +1895,10 @@ var (
 		{
 			Name:         "newPanelPadding",
 			Description:  "Increases panel padding globally",
-			Stage:        FeatureStageExperimental,
-			FrontendOnly: false,
+			Stage:        FeatureStagePublicPreview,
+			FrontendOnly: true,
 			Owner:        grafanaDashboardsSquad,
-			Expression:   "false",
+			Expression:   "true",
 		},
 		{
 			Name:         "onlyStoreActionSets",

pkg/services/featuremgmt/toggles_gen.csv

@@ -245,7 +245,7 @@ teamFolders,experimental,@grafana/grafana-search-navigate-organise,false,false,f
 interactiveLearning,preview,@grafana/pathfinder,false,false,false
 alertingTriage,experimental,@grafana/alerting-squad,false,false,false
 graphiteBackendMode,privatePreview,@grafana/partner-datasources,false,false,false
-azureResourcePickerUpdates,preview,@grafana/partner-datasources,false,false,true
+azureResourcePickerUpdates,GA,@grafana/partner-datasources,false,false,true
 prometheusTypeMigration,experimental,@grafana/partner-datasources,false,true,false
 pluginContainers,privatePreview,@grafana/plugins-platform-backend,false,true,false
 tempoSearchBackendMigration,GA,@grafana/oss-big-tent,false,true,false
@@ -257,7 +257,7 @@ newVizSuggestions,preview,@grafana/dataviz-squad,false,false,true
 preventPanelChromeOverflow,preview,@grafana/grafana-frontend-platform,false,false,true
 jaegerEnableGrpcEndpoint,experimental,@grafana/oss-big-tent,false,false,false
 pluginStoreServiceLoading,experimental,@grafana/plugins-platform-backend,false,false,false
-newPanelPadding,experimental,@grafana/dashboards-squad,false,false,false
+newPanelPadding,preview,@grafana/dashboards-squad,false,false,true
 onlyStoreActionSets,GA,@grafana/identity-access-team,false,false,false
 panelTimeSettings,experimental,@grafana/dashboards-squad,false,false,false
 kubernetesAnnotations,experimental,@grafana/grafana-backend-services-squad,false,false,false

pkg/services/featuremgmt/toggles_gen.go

@@ -742,10 +742,6 @@ const (
 	// Load plugins on store service startup instead of wire provider, and call RegisterFixedRoles after all plugins are loaded
 	FlagPluginStoreServiceLoading = "pluginStoreServiceLoading"
 
-	// FlagNewPanelPadding
-	// Increases panel padding globally
-	FlagNewPanelPadding = "newPanelPadding"
-
 	// FlagOnlyStoreActionSets
 	// When storing dashboard and folder resource permissions, only store action sets and not the full list of underlying permission
 	FlagOnlyStoreActionSets = "onlyStoreActionSets"

pkg/services/featuremgmt/toggles_gen.json

@@ -551,7 +551,6 @@
         "description": "Enables the UI to use rules backend-side filters 100% compatible with the frontend filters",
         "stage": "experimental",
         "codeowner": "@grafana/alerting-squad",
-        "hideFromAdminPage": true,
         "hideFromDocs": true
       }
     },
@@ -565,7 +564,6 @@
         "description": "Enables the UI to use rules backend-side filters 100% compatible with the frontend filters",
         "stage": "experimental",
         "codeowner": "@grafana/alerting-squad",
-        "hideFromAdminPage": true,
         "hideFromDocs": true
       }
     },
@@ -768,16 +766,19 @@
     {
       "metadata": {
         "name": "azureResourcePickerUpdates",
-        "resourceVersion": "1763734583253",
+        "resourceVersion": "1764153435365",
         "creationTimestamp": "2025-07-31T22:56:50Z",
-        "deletionTimestamp": "2025-08-01T11:30:17Z"
+        "deletionTimestamp": "2025-08-01T11:30:17Z",
+        "annotations": {
+          "grafana.app/updatedTimestamp": "2025-11-26 10:37:15.365919 +0000 UTC"
+        }
       },
       "spec": {
         "description": "Enables the updated Azure Monitor resource picker",
-        "stage": "preview",
+        "stage": "GA",
         "codeowner": "@grafana/partner-datasources",
         "frontend": true,
-        "expression": "false"
+        "expression": "true"
       }
     },
     {
@@ -2361,14 +2362,18 @@
     {
       "metadata": {
         "name": "newPanelPadding",
-        "resourceVersion": "1763734583253",
-        "creationTimestamp": "2025-11-12T15:40:46Z"
+        "resourceVersion": "1764168915089",
+        "creationTimestamp": "2025-11-12T15:40:46Z",
+        "annotations": {
+          "grafana.app/updatedTimestamp": "2025-11-26 14:55:15.089551 +0000 UTC"
+        }
       },
       "spec": {
         "description": "Increases panel padding globally",
-        "stage": "experimental",
+        "stage": "preview",
         "codeowner": "@grafana/dashboards-squad",
-        "expression": "false"
+        "frontend": true,
+        "expression": "true"
       }
     },
     {

pkg/services/ngalert/models/alert_query.go

@@ -165,6 +165,21 @@ func (aq *AlertQuery) setMaxDatapoints() error {
 	return nil
 }
 
+// setRefID sets the model refId if it's missing or invalid
+func (aq *AlertQuery) setRefID() error {
+	if aq.modelProps == nil {
+		err := aq.setModelProps()
+		if err != nil {
+			return err
+		}
+	}
+
+	if refID, ok := aq.modelProps["refId"].(string); !ok || refID != aq.RefID {
+		aq.modelProps["refId"] = aq.RefID
+	}
+	return nil
+}
+
 func (aq *AlertQuery) GetMaxDatapoints() (int64, error) {
 	err := aq.setMaxDatapoints()
 	if err != nil {
@@ -256,6 +271,11 @@ func (aq *AlertQuery) GetModel() ([]byte, error) {
 		return nil, err
 	}
 
+	err = aq.setRefID()
+	if err != nil {
+		return nil, err
+	}
+
 	err = aq.setIntervalMS()
 	if err != nil {
 		return nil, err

pkg/services/provisioning/dashboards/dashboard.go

@@ -2,6 +2,7 @@ package dashboards
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"time"
@@ -9,10 +10,12 @@ import (
 	dashboardV1 "github.com/grafana/grafana/apps/dashboard/pkg/apis/dashboard/v1beta1"
 	folderV1 "github.com/grafana/grafana/apps/folder/pkg/apis/folder/v1beta1"
 	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/infra/serverlock"
 	"github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/folder"
 	"github.com/grafana/grafana/pkg/services/org"
 	"github.com/grafana/grafana/pkg/services/provisioning/utils"
+	"github.com/grafana/grafana/pkg/setting"
 	"github.com/grafana/grafana/pkg/storage/legacysql/dualwrite"
 )
 
@@ -28,7 +31,7 @@ type DashboardProvisioner interface {
 }
 
 // DashboardProvisionerFactory creates DashboardProvisioners based on input
-type DashboardProvisionerFactory func(context.Context, string, dashboards.DashboardProvisioningService, org.Service, utils.DashboardStore, folder.Service, dualwrite.Service) (DashboardProvisioner, error)
+type DashboardProvisionerFactory func(context.Context, string, dashboards.DashboardProvisioningService, *setting.Cfg, org.Service, utils.DashboardStore, folder.Service, dualwrite.Service, *serverlock.ServerLockService) (DashboardProvisioner, error)
 
 // Provisioner is responsible for syncing dashboard from disk to Grafana's database.
 type Provisioner struct {
@@ -38,6 +41,8 @@ type Provisioner struct {
 	duplicateValidator duplicateValidator
 	provisioner        dashboards.DashboardProvisioningService
 	dual               dualwrite.Service
+	serverLock         *serverlock.ServerLockService
+	cfg                *setting.Cfg
 }
 
 func (provider *Provisioner) HasDashboardSources() bool {
@@ -45,7 +50,7 @@ func (provider *Provisioner) HasDashboardSources() bool {
 }
 
 // New returns a new DashboardProvisioner
-func New(ctx context.Context, configDirectory string, provisioner dashboards.DashboardProvisioningService, orgService org.Service, dashboardStore utils.DashboardStore, folderService folder.Service, dual dualwrite.Service) (DashboardProvisioner, error) {
+func New(ctx context.Context, configDirectory string, provisioner dashboards.DashboardProvisioningService, cfg *setting.Cfg, orgService org.Service, dashboardStore utils.DashboardStore, folderService folder.Service, dual dualwrite.Service, serverLockService *serverlock.ServerLockService) (DashboardProvisioner, error) {
 	logger := log.New("provisioning.dashboard")
 	cfgReader := &configReader{path: configDirectory, log: logger, orgExists: utils.NewOrgExistsChecker(orgService)}
 	configs, err := cfgReader.readConfig(ctx)
@@ -78,6 +83,8 @@ func New(ctx context.Context, configDirectory string, provisioner dashboards.Das
 		duplicateValidator: newDuplicateValidator(logger, fileReaders),
 		provisioner:        provisioner,
 		dual:               dual,
+		serverLock:         serverLockService,
+		cfg:                cfg,
 	}
 
 	return d, nil
@@ -95,23 +102,53 @@ func (provider *Provisioner) Provision(ctx context.Context) error {
 		}
 	}
 
-	provider.log.Info("starting to provision dashboards")
+	var errProvisioning error
 
-	for _, reader := range provider.fileReaders {
-		if err := reader.walkDisk(ctx); err != nil {
-			if os.IsNotExist(err) {
-				// don't stop the provisioning service in case the folder is missing. The folder can appear after the startup
-				provider.log.Warn("Failed to provision config", "name", reader.Cfg.Name, "error", err)
-				return nil
-			}
-
-			return fmt.Errorf("failed to provision config %v: %w", reader.Cfg.Name, err)
+	// retry obtaining the lock for 20 attempts
+	retryOpt := func(attempts int) error {
+		if attempts < 20 {
+			return nil
 		}
+		return errors.New("retries exhausted")
 	}
 
-	provider.duplicateValidator.validate()
-	provider.log.Info("finished to provision dashboards")
-	return nil
+	lockTimeConfig := serverlock.LockTimeConfig{
+		// if a replica crashes while holding the lock, other replicas can obtain the
+		// lock after this duration (15s default value, might be configured via config file)
+		MaxInterval: time.Duration(provider.cfg.ClassicProvisioningDashboardsServerLockMaxIntervalSeconds) * time.Second,
+
+		// wait beetween 100ms and 1s before retrying to obtain the lock (default values, might be configured via config file)
+		MinWait: time.Duration(provider.cfg.ClassicProvisioningDashboardsServerLockMinWaitMs) * time.Millisecond,
+		MaxWait: time.Duration(provider.cfg.ClassicProvisioningDashboardsServerLockMaxWaitMs) * time.Millisecond,
+	}
+
+	// this means that if we fail to obtain the lock after ~10 seconds, we return an error
+	lockErr := provider.serverLock.LockExecuteAndReleaseWithRetries(ctx, "provisioning_dashboards", lockTimeConfig, func(ctx context.Context) {
+		provider.log.Info("starting to provision dashboards")
+
+		for _, reader := range provider.fileReaders {
+			if err := reader.walkDisk(ctx); err != nil {
+				if os.IsNotExist(err) {
+					// don't stop the provisioning service in case the folder is missing. The folder can appear after the startup
+					provider.log.Warn("Failed to provision config", "name", reader.Cfg.Name, "error", err)
+					return
+				}
+
+				errProvisioning = fmt.Errorf("failed to provision config %v: %w", reader.Cfg.Name, err)
+				return
+			}
+		}
+
+		provider.duplicateValidator.validate()
+		provider.log.Info("finished to provision dashboards")
+	}, retryOpt)
+
+	if lockErr != nil {
+		provider.log.Error("Failed to obtain dashboard provisioning lock", "error", lockErr)
+		return lockErr
+	}
+
+	return errProvisioning
 }
 
 // CleanUpOrphanedDashboards deletes provisioned dashboards missing a linked reader.

pkg/services/provisioning/provisioning.go

@@ -10,6 +10,7 @@ import (
 	"github.com/grafana/dskit/services"
 	"github.com/grafana/grafana/pkg/infra/db"
 	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/infra/serverlock"
 	"github.com/grafana/grafana/pkg/infra/tracing"
 	"github.com/grafana/grafana/pkg/registry"
 	"github.com/grafana/grafana/pkg/services/accesscontrol"
@@ -64,6 +65,7 @@ func ProvideService(
 	tracer tracing.Tracer,
 	dual dualwrite.Service,
 	promTypeMigrationProvider promtypemigration.PromTypeMigrationProvider,
+	serverLockService *serverlock.ServerLockService,
 ) (*ProvisioningServiceImpl, error) {
 	s := &ProvisioningServiceImpl{
 		Cfg:                          cfg,
@@ -92,6 +94,7 @@ func ProvideService(
 		tracer:                       tracer,
 		migratePrometheusType:        promTypeMigrationProvider.Run,
 		dual:                         dual,
+		serverLock:                   serverLockService,
 	}
 
 	s.NamedService = services.NewBasicService(s.starting, s.running, nil).WithName(ServiceName)
@@ -166,7 +169,7 @@ func (ps *ProvisioningServiceImpl) running(ctx context.Context) error {
 
 func (ps *ProvisioningServiceImpl) setDashboardProvisioner() error {
 	dashboardPath := filepath.Join(ps.Cfg.ProvisioningPath, "dashboards")
-	dashProvisioner, err := ps.newDashboardProvisioner(context.Background(), dashboardPath, ps.dashboardProvisioningService, ps.orgService, ps.dashboardService, ps.folderService, ps.dual)
+	dashProvisioner, err := ps.newDashboardProvisioner(context.Background(), dashboardPath, ps.dashboardProvisioningService, ps.Cfg, ps.orgService, ps.dashboardService, ps.folderService, ps.dual, ps.serverLock)
 	if err != nil {
 		return fmt.Errorf("%v: %w", "Failed to create provisioner", err)
 	}
@@ -242,6 +245,7 @@ type ProvisioningServiceImpl struct {
 	resourcePermissions          accesscontrol.ReceiverPermissionsService
 	tracer                       tracing.Tracer
 	dual                         dualwrite.Service
+	serverLock                   *serverlock.ServerLockService
 	migratePrometheusType        func(context.Context) error
 }
 

pkg/services/provisioning/provisioning_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/grafana/grafana/pkg/infra/serverlock"
 	dashboardstore "github.com/grafana/grafana/pkg/services/dashboards"
 	"github.com/grafana/grafana/pkg/services/folder"
 	"github.com/grafana/grafana/pkg/services/org"
@@ -20,6 +21,7 @@ import (
 	"github.com/grafana/grafana/pkg/services/provisioning/datasources"
 	"github.com/grafana/grafana/pkg/services/provisioning/utils"
 	"github.com/grafana/grafana/pkg/services/searchV2"
+	"github.com/grafana/grafana/pkg/setting"
 	"github.com/grafana/grafana/pkg/storage/legacysql/dualwrite"
 )
 
@@ -160,7 +162,7 @@ func setup(t *testing.T) *serviceTestStruct {
 	searchStub := searchV2.NewStubSearchService()
 
 	service, err := newProvisioningServiceImpl(
-		func(context.Context, string, dashboardstore.DashboardProvisioningService, org.Service, utils.DashboardStore, folder.Service, dualwrite.Service) (dashboards.DashboardProvisioner, error) {
+		func(context.Context, string, dashboardstore.DashboardProvisioningService, *setting.Cfg, org.Service, utils.DashboardStore, folder.Service, dualwrite.Service, *serverlock.ServerLockService) (dashboards.DashboardProvisioner, error) {
 			serviceTest.dashboardProvisionerInstantiations++
 			return serviceTest.mock, nil
 		},

pkg/services/setting/service.go

@@ -0,0 +1,384 @@
+package setting
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/grafana/grafana/pkg/infra/tracing"
+	"github.com/prometheus/client_golang/prometheus"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/trace"
+	"gopkg.in/ini.v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	utilnet "k8s.io/apimachinery/pkg/util/net"
+	"k8s.io/apiserver/pkg/endpoints/request"
+	"k8s.io/client-go/dynamic"
+	clientrest "k8s.io/client-go/rest"
+	"k8s.io/client-go/transport"
+
+	authlib "github.com/grafana/authlib/authn"
+	logging "github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/semconv"
+)
+
+var tracer = otel.Tracer("github.com/grafana/grafana/pkg/services/setting")
+
+const LogPrefix = "setting.service"
+
+const DefaultPageSize = int64(500)
+const DefaultQPS = float32(10)
+const DefaultBurst = 25
+
+const (
+	ApiGroup   = "setting.grafana.app"
+	apiVersion = "v0alpha1"
+	resource   = "settings"
+	kind       = "Setting"
+	listKind   = "SettingList"
+)
+
+var settingGroupVersion = schema.GroupVersionResource{
+	Group:    ApiGroup,
+	Version:  apiVersion,
+	Resource: resource,
+}
+
+var settingGroupListKind = map[schema.GroupVersionResource]string{
+	settingGroupVersion: listKind,
+}
+
+type remoteSettingServiceMetrics struct {
+	listDuration   *prometheus.HistogramVec
+	listResultSize *prometheus.HistogramVec
+}
+
+// Service retrieves configuration settings from a remote settings service.
+//
+// The service uses label selectors to filter settings. Settings are labeled with
+// "section" and "key" labels matching their spec fields.
+//
+// Example - Select all settings:
+//
+//	ctx := request.WithNamespace(context.Background(), "my-namespace")
+//	ini, err := service.ListAsIni(ctx, metav1.LabelSelector{})
+//
+// Example - Select settings from specific sections:
+//
+//	selector := metav1.LabelSelector{
+//	    MatchExpressions: []metav1.LabelSelectorRequirement{
+//	        {
+//	            Key:      "section",
+//	            Operator: metav1.LabelSelectorOpIn,
+//	            Values:   []string{"database", "server"},
+//	        },
+//	    },
+//	}
+//	ini, err := service.ListAsIni(ctx, selector)
+//
+// Example - Select settings from a single section with specific labels:
+//
+//	selector := metav1.LabelSelector{
+//	    MatchLabels: map[string]string{
+//	        "section": "database",
+//	    },
+//	}
+//	settings, err := service.List(ctx, selector)
+type Service interface {
+	prometheus.Collector
+	// ListAsIni retrieves settings filtered by a label selector from the namespace in context
+	// and returns them as an ini.File.
+	//
+	// The namespace must be present in the context, ie: via request.WithNamespace.
+	// An empty selector returns all settings in the namespace.
+	ListAsIni(ctx context.Context, selector metav1.LabelSelector) (*ini.File, error)
+
+	// List retrieves settings filtered by a label selector from the namespace in context
+	// and returns them as a slice of Setting structs.
+	//
+	// The namespace must be present in the context, ie: via request.WithNamespace.
+	// An empty selector returns all settings in the namespace.
+	List(ctx context.Context, selector metav1.LabelSelector) ([]*Setting, error)
+}
+
+type remoteSettingService struct {
+	dynamicClient dynamic.Interface
+	log           logging.Logger
+	pageSize      int64
+	metrics       remoteSettingServiceMetrics
+}
+
+var _ Service = (*remoteSettingService)(nil)
+var _ prometheus.Collector = (*remoteSettingService)(nil)
+
+// Config configures a Service.
+type Config struct {
+	// URL is the base URL for the remote settings service (required).
+	URL string
+	// TokenExchangeClient authenticates requests (required if WrapTransport is not set).
+	TokenExchangeClient *authlib.TokenExchangeClient
+	// WrapTransport wraps the HTTP transport for authentication.
+	// Takes precedence over TokenExchangeClient when both are set.
+	// At least one of WrapTransport or TokenExchangeClient is required.
+	WrapTransport transport.WrapperFunc
+	// TLSClientConfig configures TLS for the client connection.
+	TLSClientConfig clientrest.TLSClientConfig
+	// QPS limits requests per second (defaults to DefaultQPS).
+	QPS float32
+	// Burst allows request bursts above QPS (defaults to DefaultBurst).
+	Burst int
+	// PageSize sets the number of items per API page (defaults to DefaultPageSize).
+	PageSize int64
+}
+
+// Setting represents the parsed spec of a Setting resource.
+type Setting struct {
+	// Setting section
+	Section string `json:"section"`
+	// Setting key
+	Key string `json:"key"`
+	// Setting value
+	Value string `json:"value"`
+}
+
+// New creates a Service from the provided configuration.
+func New(config Config) (Service, error) {
+	log := logging.New(LogPrefix)
+	dynamicClient, err := getDynamicClient(config, log)
+	if err != nil {
+		return nil, err
+	}
+	pageSize := DefaultPageSize
+	if config.PageSize > 0 {
+		pageSize = config.PageSize
+	}
+
+	metrics := initMetrics()
+
+	return &remoteSettingService{
+		dynamicClient: dynamicClient,
+		pageSize:      pageSize,
+		log:           log,
+		metrics:       metrics,
+	}, nil
+}
+
+func (m *remoteSettingService) ListAsIni(ctx context.Context, labelSelector metav1.LabelSelector) (*ini.File, error) {
+	namespace, ok := request.NamespaceFrom(ctx)
+	ns := semconv.GrafanaNamespaceName(namespace)
+	ctx, span := tracer.Start(ctx, "remoteSettingService.ListAsIni",
+		trace.WithAttributes(ns))
+	defer span.End()
+
+	if !ok || namespace == "" {
+		return nil, tracing.Errorf(span, "missing namespace in context")
+	}
+
+	settings, err := m.List(ctx, labelSelector)
+	if err != nil {
+		return nil, err
+	}
+	iniFile, err := m.toIni(settings)
+	if err != nil {
+		return nil, tracing.Error(span, err)
+	}
+	return iniFile, nil
+}
+
+func (m *remoteSettingService) List(ctx context.Context, labelSelector metav1.LabelSelector) ([]*Setting, error) {
+	namespace, ok := request.NamespaceFrom(ctx)
+	ns := semconv.GrafanaNamespaceName(namespace)
+	ctx, span := tracer.Start(ctx, "remoteSettingService.List",
+		trace.WithAttributes(ns))
+	defer span.End()
+	if !ok || namespace == "" {
+		return nil, tracing.Errorf(span, "missing namespace in context")
+	}
+	log := m.log.FromContext(ctx).New(ns.Key, ns.Value, "function", "remoteSettingService.List", "traceId", span.SpanContext().TraceID())
+
+	startTime := time.Now()
+	var status string
+	defer func() {
+		duration := time.Since(startTime).Seconds()
+		m.metrics.listDuration.WithLabelValues(status).Observe(duration)
+	}()
+
+	selector, err := metav1.LabelSelectorAsSelector(&labelSelector)
+	if err != nil {
+		status = "error"
+		return nil, tracing.Error(span, err)
+	}
+	if selector.Empty() {
+		log.Debug("empty selector. Fetching all settings")
+	}
+
+	var allSettings []*Setting
+	var continueToken string
+	hasNext := true
+	totalPages := 0
+	// Using an upper limit to prevent infinite loops
+	for hasNext && totalPages < 1000 {
+		totalPages++
+		opts := metav1.ListOptions{
+			Limit:    m.pageSize,
+			Continue: continueToken,
+		}
+		if !selector.Empty() {
+			opts.LabelSelector = selector.String()
+		}
+
+		settingsList, lErr := m.dynamicClient.Resource(settingGroupVersion).Namespace(namespace).List(ctx, opts)
+		if lErr != nil {
+			status = "error"
+			return nil, tracing.Error(span, lErr)
+		}
+		for i := range settingsList.Items {
+			setting, pErr := parseSettingResource(&settingsList.Items[i])
+			if pErr != nil {
+				status = "error"
+				return nil, tracing.Error(span, pErr)
+			}
+			allSettings = append(allSettings, setting)
+		}
+		continueToken = settingsList.GetContinue()
+		if continueToken == "" {
+			hasNext = false
+		}
+	}
+
+	status = "success"
+	m.metrics.listResultSize.WithLabelValues(status).Observe(float64(len(allSettings)))
+
+	return allSettings, nil
+}
+
+func parseSettingResource(setting *unstructured.Unstructured) (*Setting, error) {
+	spec, found, err := unstructured.NestedMap(setting.Object, "spec")
+	if err != nil {
+		return nil, fmt.Errorf("failed to get spec from setting: %w", err)
+	}
+	if !found {
+		return nil, fmt.Errorf("spec not found in setting %s", setting.GetName())
+	}
+
+	var result Setting
+	if err := runtime.DefaultUnstructuredConverter.FromUnstructured(spec, &result); err != nil {
+		return nil, fmt.Errorf("failed to convert spec to Setting: %w", err)
+	}
+
+	return &result, nil
+}
+
+func (m *remoteSettingService) toIni(settings []*Setting) (*ini.File, error) {
+	conf := ini.Empty()
+	for _, setting := range settings {
+		if !conf.HasSection(setting.Section) {
+			_, _ = conf.NewSection(setting.Section)
+		}
+		_, err := conf.Section(setting.Section).NewKey(setting.Key, setting.Value)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return conf, nil
+}
+
+func getDynamicClient(config Config, log logging.Logger) (dynamic.Interface, error) {
+	if config.URL == "" {
+		return nil, fmt.Errorf("URL cannot be empty")
+	}
+	if config.WrapTransport == nil && config.TokenExchangeClient == nil {
+		return nil, fmt.Errorf("must set either TokenExchangeClient or WrapTransport")
+	}
+
+	wrapTransport := config.WrapTransport
+	if config.WrapTransport == nil {
+		log.Debug("using default wrapTransport with TokenExchangeClient")
+		wrapTransport = func(rt http.RoundTripper) http.RoundTripper {
+			return &authRoundTripper{
+				tokenClient: config.TokenExchangeClient,
+				transport:   rt,
+			}
+		}
+	}
+
+	qps := DefaultQPS
+	if config.QPS > 0 {
+		qps = config.QPS
+	}
+
+	burst := DefaultBurst
+	if config.Burst > 0 {
+		burst = config.Burst
+	}
+
+	return dynamic.NewForConfig(&clientrest.Config{
+		Host:            config.URL,
+		WrapTransport:   wrapTransport,
+		TLSClientConfig: config.TLSClientConfig,
+		QPS:             qps,
+		Burst:           burst,
+	})
+}
+
+// authRoundTripper wraps an HTTP transport with token-based authentication.
+type authRoundTripper struct {
+	tokenClient *authlib.TokenExchangeClient
+	transport   http.RoundTripper
+}
+
+var _ http.RoundTripper = (*authRoundTripper)(nil)
+
+func (a *authRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	token, err := a.tokenClient.Exchange(req.Context(), authlib.TokenExchangeRequest{
+		Audiences: []string{ApiGroup},
+		Namespace: "*",
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to exchange token: %w", err)
+	}
+	req = utilnet.CloneRequest(req)
+
+	req.Header.Set("X-Access-Token", fmt.Sprintf("Bearer %s", token.Token))
+	return a.transport.RoundTrip(req)
+}
+
+func initMetrics() remoteSettingServiceMetrics {
+	metrics := remoteSettingServiceMetrics{
+		listDuration: prometheus.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Namespace:                   "settings",
+				Subsystem:                   "service",
+				Name:                        "list_settings_duration_seconds",
+				Help:                        "Duration of remote settings service List operations",
+				NativeHistogramBucketFactor: 1.1,
+			},
+			[]string{"status"}, // status: "success" or "error"
+		),
+		listResultSize: prometheus.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Namespace:                   "settings",
+				Subsystem:                   "service",
+				Name:                        "list_settings_result_size",
+				Help:                        "Number of settings returned by remote settings service List operations",
+				NativeHistogramBucketFactor: 1.1,
+			},
+			[]string{"status"}, // status: "success" or "error"
+		),
+	}
+	return metrics
+}
+
+func (m *remoteSettingService) Describe(descs chan<- *prometheus.Desc) {
+	m.metrics.listDuration.Describe(descs)
+	m.metrics.listResultSize.Describe(descs)
+}
+
+func (m *remoteSettingService) Collect(metrics chan<- prometheus.Metric) {
+	m.metrics.listDuration.Collect(metrics)
+	m.metrics.listResultSize.Collect(metrics)
+}

pkg/services/setting/service_test.go

@@ -0,0 +1,542 @@
+package setting
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apiserver/pkg/endpoints/request"
+	"k8s.io/client-go/dynamic/fake"
+	k8testing "k8s.io/client-go/testing"
+
+	authlib "github.com/grafana/authlib/authn"
+	"github.com/grafana/grafana/pkg/infra/log"
+)
+
+func TestRemoteSettingService_ListAsIni(t *testing.T) {
+	t.Run("should filter settings by label selector", func(t *testing.T) {
+		// Create multiple settings, only some matching the selector
+		setting1 := newUnstructuredSetting("test-namespace", Setting{Section: "database", Key: "type", Value: "postgres"})
+		setting2 := newUnstructuredSetting("test-namespace", Setting{Section: "server", Key: "port", Value: "3000"})
+		setting3 := newUnstructuredSetting("test-namespace", Setting{Section: "database", Key: "host", Value: "localhost"})
+
+		client := newTestClient(500, setting1, setting2, setting3)
+
+		// Create a selector that should match only database settings
+		selector := metav1.LabelSelector{
+			MatchLabels: map[string]string{
+				"section": "database",
+			},
+		}
+
+		ctx := request.WithNamespace(context.Background(), "test-namespace")
+		result, err := client.ListAsIni(ctx, selector)
+
+		require.NoError(t, err)
+		assert.NotNil(t, result)
+		// Should only have database settings, not server settings
+		assert.True(t, result.HasSection("database"))
+		assert.Equal(t, "postgres", result.Section("database").Key("type").String())
+		assert.Equal(t, "localhost", result.Section("database").Key("host").String())
+		// Should NOT have server settings
+		assert.False(t, result.HasSection("server"))
+	})
+
+	t.Run("should return all settings with empty selector", func(t *testing.T) {
+		// Create multiple settings across different sections
+		setting1 := newUnstructuredSetting("test-namespace", Setting{Section: "server", Key: "port", Value: "3000"})
+		setting2 := newUnstructuredSetting("test-namespace", Setting{Section: "database", Key: "type", Value: "mysql"})
+
+		client := newTestClient(500, setting1, setting2)
+
+		// Empty selector should select everything
+		selector := metav1.LabelSelector{}
+
+		ctx := request.WithNamespace(context.Background(), "test-namespace")
+		result, err := client.ListAsIni(ctx, selector)
+
+		require.NoError(t, err)
+		assert.NotNil(t, result)
+		// Should have all settings from all sections
+		assert.True(t, result.HasSection("server"))
+		assert.Equal(t, "3000", result.Section("server").Key("port").String())
+		assert.True(t, result.HasSection("database"))
+		assert.Equal(t, "mysql", result.Section("database").Key("type").String())
+	})
+}
+
+func TestRemoteSettingService_List(t *testing.T) {
+	t.Run("should handle single page response", func(t *testing.T) {
+		setting := newUnstructuredSetting("test-namespace", Setting{Section: "server", Key: "port", Value: "3000"})
+
+		client := newTestClient(500, setting)
+
+		ctx := request.WithNamespace(context.Background(), "test-namespace")
+		result, err := client.List(ctx, metav1.LabelSelector{})
+
+		require.NoError(t, err)
+		assert.Len(t, result, 1)
+
+		spec := result[0]
+		assert.Equal(t, "server", spec.Section)
+		assert.Equal(t, "port", spec.Key)
+		assert.Equal(t, "3000", spec.Value)
+	})
+
+	t.Run("should handle multiple pages", func(t *testing.T) {
+		totalPages := 3
+		pageSize := 5
+
+		pages := make([][]*unstructured.Unstructured, totalPages)
+		for pageNum := 0; pageNum < totalPages; pageNum++ {
+			for idx := 0; idx < pageSize; idx++ {
+				item := newUnstructuredSetting(
+					"test-namespace",
+					Setting{
+						Section: fmt.Sprintf("section-%d", pageNum),
+						Key:     fmt.Sprintf("key-%d", idx),
+						Value:   fmt.Sprintf("val-%d-%d", pageNum, idx),
+					},
+				)
+				pages[pageNum] = append(pages[pageNum], item)
+			}
+		}
+
+		scheme := runtime.NewScheme()
+		dynamicClient := fake.NewSimpleDynamicClientWithCustomListKinds(scheme, settingGroupListKind)
+		listCallCount := 0
+		dynamicClient.PrependReactor("list", "settings", func(action k8testing.Action) (handled bool, ret runtime.Object, err error) {
+			listCallCount++
+
+			continueToken := fmt.Sprintf("continue-%d", listCallCount)
+			if listCallCount == totalPages {
+				continueToken = ""
+			}
+
+			if listCallCount <= totalPages {
+				list := &unstructured.UnstructuredList{
+					Object: map[string]interface{}{
+						"apiVersion": ApiGroup + "/" + apiVersion,
+						"kind":       listKind,
+					},
+				}
+				list.SetContinue(continueToken)
+				for _, item := range pages[listCallCount-1] {
+					list.Items = append(list.Items, *item)
+				}
+				return true, list, nil
+			}
+
+			return false, nil, nil
+		})
+
+		client := &remoteSettingService{
+			dynamicClient: dynamicClient,
+			pageSize:      int64(pageSize),
+			log:           log.NewNopLogger(),
+			metrics:       initMetrics(),
+		}
+
+		ctx := request.WithNamespace(context.Background(), "test-namespace")
+		result, err := client.List(ctx, metav1.LabelSelector{})
+
+		require.NoError(t, err)
+		assert.Len(t, result, totalPages*pageSize)
+		assert.Equal(t, totalPages, listCallCount)
+	})
+
+	t.Run("should pass label selector when provided", func(t *testing.T) {
+		scheme := runtime.NewScheme()
+		dynamicClient := fake.NewSimpleDynamicClientWithCustomListKinds(scheme, settingGroupListKind)
+		dynamicClient.PrependReactor("list", "settings", func(action k8testing.Action) (handled bool, ret runtime.Object, err error) {
+			listAction := action.(k8testing.ListActionImpl)
+			assert.Equal(t, "app=grafana", listAction.ListOptions.LabelSelector)
+			return true, &unstructured.UnstructuredList{}, nil
+		})
+
+		client := &remoteSettingService{
+			dynamicClient: dynamicClient,
+			pageSize:      500,
+			log:           log.NewNopLogger(),
+			metrics:       initMetrics(),
+		}
+
+		ctx := request.WithNamespace(context.Background(), "test-namespace")
+		_, err := client.List(ctx, metav1.LabelSelector{MatchLabels: map[string]string{"app": "grafana"}})
+
+		require.NoError(t, err)
+	})
+
+	t.Run("should stop pagination at 1000 pages", func(t *testing.T) {
+		scheme := runtime.NewScheme()
+		dynamicClient := fake.NewSimpleDynamicClientWithCustomListKinds(scheme, settingGroupListKind)
+		listCallCount := 0
+		dynamicClient.PrependReactor("list", "settings", func(action k8testing.Action) (handled bool, ret runtime.Object, err error) {
+			listCallCount++
+			// Always return a continue token to simulate infinite pagination
+			list := &unstructured.UnstructuredList{}
+			list.SetContinue("continue-forever")
+			return true, list, nil
+		})
+
+		client := &remoteSettingService{
+			dynamicClient: dynamicClient,
+			pageSize:      10,
+			log:           log.NewNopLogger(),
+			metrics:       initMetrics(),
+		}
+
+		ctx := request.WithNamespace(context.Background(), "test-namespace")
+		_, err := client.List(ctx, metav1.LabelSelector{})
+
+		require.NoError(t, err)
+		assert.Equal(t, 1000, listCallCount, "Should stop at 1000 pages to prevent infinite loops")
+	})
+
+	t.Run("should return error when parsing setting fails", func(t *testing.T) {
+		scheme := runtime.NewScheme()
+		dynamicClient := fake.NewSimpleDynamicClientWithCustomListKinds(scheme, settingGroupListKind)
+		dynamicClient.PrependReactor("list", "settings", func(action k8testing.Action) (handled bool, ret runtime.Object, err error) {
+			// Return a malformed setting without spec
+			list := &unstructured.UnstructuredList{
+				Object: map[string]interface{}{
+					"apiVersion": ApiGroup + "/" + apiVersion,
+					"kind":       listKind,
+				},
+			}
+			malformedSetting := &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": ApiGroup + "/" + apiVersion,
+					"kind":       kind,
+					"metadata": map[string]interface{}{
+						"name":      "malformed",
+						"namespace": "test-namespace",
+					},
+					// Missing spec
+				},
+			}
+			list.Items = append(list.Items, *malformedSetting)
+			return true, list, nil
+		})
+
+		client := &remoteSettingService{
+			dynamicClient: dynamicClient,
+			pageSize:      500,
+			log:           log.NewNopLogger(),
+			metrics:       initMetrics(),
+		}
+
+		ctx := request.WithNamespace(context.Background(), "test-namespace")
+		result, err := client.List(ctx, metav1.LabelSelector{})
+
+		require.Error(t, err)
+		assert.Nil(t, result)
+		assert.Contains(t, err.Error(), "spec not found")
+	})
+}
+
+func TestParseSettingResource(t *testing.T) {
+	t.Run("should parse valid setting resource", func(t *testing.T) {
+		setting := newUnstructuredSetting("test-namespace", Setting{Section: "database", Key: "type", Value: "postgres"})
+
+		result, err := parseSettingResource(setting)
+
+		require.NoError(t, err)
+		assert.NotNil(t, result)
+		assert.Equal(t, "database", result.Section)
+		assert.Equal(t, "type", result.Key)
+		assert.Equal(t, "postgres", result.Value)
+	})
+
+	t.Run("should return error when spec is missing", func(t *testing.T) {
+		setting := &unstructured.Unstructured{
+			Object: map[string]interface{}{
+				"apiVersion": ApiGroup + "/" + apiVersion,
+				"kind":       kind,
+				"metadata": map[string]interface{}{
+					"name":      "test-setting",
+					"namespace": "test-namespace",
+				},
+				// No spec
+			},
+		}
+
+		result, err := parseSettingResource(setting)
+
+		require.Error(t, err)
+		assert.Nil(t, result)
+		assert.Contains(t, err.Error(), "spec not found")
+	})
+}
+
+func TestRemoteSettingService_ToIni(t *testing.T) {
+	t.Run("should convert settings to ini format", func(t *testing.T) {
+		settings := []*Setting{
+			{Section: "database", Key: "type", Value: "postgres"},
+			{Section: "database", Key: "host", Value: "localhost"},
+			{Section: "server", Key: "http_port", Value: "3000"},
+		}
+
+		client := &remoteSettingService{
+			pageSize: 500,
+			log:      log.NewNopLogger(),
+		}
+
+		result, err := client.toIni(settings)
+
+		require.NoError(t, err)
+		assert.NotNil(t, result)
+		assert.True(t, result.HasSection("database"))
+		assert.True(t, result.HasSection("server"))
+		assert.Equal(t, "postgres", result.Section("database").Key("type").String())
+		assert.Equal(t, "localhost", result.Section("database").Key("host").String())
+		assert.Equal(t, "3000", result.Section("server").Key("http_port").String())
+	})
+
+	t.Run("should handle empty settings list", func(t *testing.T) {
+		var settings []*Setting
+
+		client := &remoteSettingService{
+			pageSize: 500,
+			log:      log.NewNopLogger(),
+		}
+
+		result, err := client.toIni(settings)
+
+		require.NoError(t, err)
+		assert.NotNil(t, result)
+		sections := result.Sections()
+		assert.Len(t, sections, 1) // Only default section
+	})
+
+	t.Run("should create section if it does not exist", func(t *testing.T) {
+		settings := []*Setting{
+			{Section: "new_section", Key: "new_key", Value: "new_value"},
+		}
+
+		client := &remoteSettingService{
+			pageSize: 500,
+			log:      log.NewNopLogger(),
+		}
+
+		result, err := client.toIni(settings)
+
+		require.NoError(t, err)
+		assert.True(t, result.HasSection("new_section"))
+		assert.Equal(t, "new_value", result.Section("new_section").Key("new_key").String())
+	})
+
+	t.Run("should handle multiple keys in same section", func(t *testing.T) {
+		settings := []*Setting{
+			{Section: "auth", Key: "disable_login_form", Value: "false"},
+			{Section: "auth", Key: "disable_signout_menu", Value: "true"},
+		}
+
+		client := &remoteSettingService{
+			pageSize: 500,
+			log:      log.NewNopLogger(),
+		}
+
+		result, err := client.toIni(settings)
+
+		require.NoError(t, err)
+		assert.True(t, result.HasSection("auth"))
+		authSection := result.Section("auth")
+		assert.Equal(t, "false", authSection.Key("disable_login_form").String())
+		assert.Equal(t, "true", authSection.Key("disable_signout_menu").String())
+	})
+}
+
+func TestNew(t *testing.T) {
+	t.Run("should create client with default page size", func(t *testing.T) {
+		config := Config{
+			URL:           "https://example.com",
+			WrapTransport: func(rt http.RoundTripper) http.RoundTripper { return rt },
+		}
+
+		client, err := New(config)
+
+		require.NoError(t, err)
+		assert.NotNil(t, client)
+		remoteClient := client.(*remoteSettingService)
+		assert.Equal(t, DefaultPageSize, remoteClient.pageSize)
+	})
+
+	t.Run("should create client with custom page size", func(t *testing.T) {
+		config := Config{
+			URL:           "https://example.com",
+			WrapTransport: func(rt http.RoundTripper) http.RoundTripper { return rt },
+			PageSize:      100,
+		}
+
+		client, err := New(config)
+
+		require.NoError(t, err)
+		assert.NotNil(t, client)
+		remoteClient := client.(*remoteSettingService)
+		assert.Equal(t, int64(100), remoteClient.pageSize)
+	})
+
+	t.Run("should use default page size when zero is provided", func(t *testing.T) {
+		config := Config{
+			URL:           "https://example.com",
+			WrapTransport: func(rt http.RoundTripper) http.RoundTripper { return rt },
+			PageSize:      0,
+		}
+
+		client, err := New(config)
+
+		require.NoError(t, err)
+		assert.NotNil(t, client)
+		remoteClient := client.(*remoteSettingService)
+		assert.Equal(t, DefaultPageSize, remoteClient.pageSize)
+	})
+
+	t.Run("should return error when config is invalid", func(t *testing.T) {
+		config := Config{
+			URL: "", // Invalid: empty URL
+		}
+
+		client, err := New(config)
+
+		require.Error(t, err)
+		assert.Nil(t, client)
+		assert.Contains(t, err.Error(), "URL cannot be empty")
+	})
+}
+
+func TestGetDynamicClient(t *testing.T) {
+	logger := log.NewNopLogger()
+
+	t.Run("should return error when SettingServiceURL is empty", func(t *testing.T) {
+		config := Config{
+			URL:           "",
+			WrapTransport: func(rt http.RoundTripper) http.RoundTripper { return rt },
+		}
+
+		client, err := getDynamicClient(config, logger)
+
+		require.Error(t, err)
+		assert.Nil(t, client)
+		assert.Contains(t, err.Error(), "URL cannot be empty")
+	})
+
+	t.Run("should return error when both TokenExchangeClient and WrapTransport are nil", func(t *testing.T) {
+		config := Config{
+			URL:                 "https://example.com",
+			TokenExchangeClient: nil,
+			WrapTransport:       nil,
+		}
+
+		client, err := getDynamicClient(config, logger)
+
+		require.Error(t, err)
+		assert.Nil(t, client)
+		assert.Contains(t, err.Error(), "must set either TokenExchangeClient or WrapTransport")
+	})
+
+	t.Run("should create client with WrapTransport", func(t *testing.T) {
+		config := Config{
+			URL:           "https://example.com",
+			WrapTransport: func(rt http.RoundTripper) http.RoundTripper { return rt },
+		}
+
+		client, err := getDynamicClient(config, logger)
+
+		require.NoError(t, err)
+		assert.NotNil(t, client)
+	})
+
+	t.Run("should not fail when QPS and Burst are not provided", func(t *testing.T) {
+		config := Config{
+			URL:           "https://example.com",
+			WrapTransport: func(rt http.RoundTripper) http.RoundTripper { return rt },
+		}
+
+		client, err := getDynamicClient(config, logger)
+
+		require.NoError(t, err)
+		assert.NotNil(t, client)
+	})
+
+	t.Run("should not fail when custom QPS and Burst are provided", func(t *testing.T) {
+		config := Config{
+			URL:           "https://example.com",
+			WrapTransport: func(rt http.RoundTripper) http.RoundTripper { return rt },
+			QPS:           10.0,
+			Burst:         20,
+		}
+
+		client, err := getDynamicClient(config, logger)
+
+		require.NoError(t, err)
+		assert.NotNil(t, client)
+	})
+
+	t.Run("should use WrapTransport when both WrapTransport and TokenExchangeClient are provided", func(t *testing.T) {
+		wrapTransportCalled := false
+		tokenExchangeClient := &authlib.TokenExchangeClient{}
+
+		config := Config{
+			URL:                 "https://example.com",
+			TokenExchangeClient: tokenExchangeClient,
+			WrapTransport: func(rt http.RoundTripper) http.RoundTripper {
+				wrapTransportCalled = true
+				return rt
+			},
+		}
+
+		client, err := getDynamicClient(config, logger)
+
+		require.NoError(t, err)
+		assert.NotNil(t, client)
+		assert.True(t, wrapTransportCalled, "WrapTransport should be called and take precedence over TokenExchangeClient")
+	})
+}
+
+// Helper function to create an unstructured Setting object for tests
+func newUnstructuredSetting(namespace string, spec Setting) *unstructured.Unstructured {
+	// Generate resource name in the format {section}--{key}
+	name := fmt.Sprintf("%s--%s", spec.Section, spec.Key)
+
+	obj := &unstructured.Unstructured{
+		Object: map[string]interface{}{
+			"apiVersion": ApiGroup + "/" + apiVersion,
+			"kind":       kind,
+			"metadata": map[string]interface{}{
+				"name":      name,
+				"namespace": namespace,
+			},
+			"spec": map[string]interface{}{
+				"section": spec.Section,
+				"key":     spec.Key,
+				"value":   spec.Value,
+			},
+		},
+	}
+	// Always set section and key labels
+	obj.SetLabels(map[string]string{
+		"section": spec.Section,
+		"key":     spec.Key,
+	})
+	return obj
+}
+
+// Helper function to create a test client with the dynamic fake client
+func newTestClient(pageSize int64, objects ...runtime.Object) *remoteSettingService {
+	scheme := runtime.NewScheme()
+	dynamicClient := fake.NewSimpleDynamicClientWithCustomListKinds(scheme, settingGroupListKind, objects...)
+
+	return &remoteSettingService{
+		dynamicClient: dynamicClient,
+		pageSize:      pageSize,
+		log:           log.NewNopLogger(),
+		metrics:       initMetrics(),
+	}
+}

pkg/setting/setting.go

@@ -150,6 +150,11 @@ type Cfg struct {
 	PluginsPath                     string
 	EnterpriseLicensePath           string
 
+	// Classic Provisioning settings
+	ClassicProvisioningDashboardsServerLockMaxIntervalSeconds int64
+	ClassicProvisioningDashboardsServerLockMinWaitMs          int64
+	ClassicProvisioningDashboardsServerLockMaxWaitMs          int64
+
 	// SMTP email settings
 	Smtp SmtpSettings
 
@@ -1221,6 +1226,8 @@ func (cfg *Cfg) parseINIFile(iniFile *ini.File) error {
 		return err
 	}
 
+	cfg.readClassicProvisioningSettings(iniFile)
+
 	// read dashboard settings
 	dashboards := iniFile.Section("dashboards")
 	cfg.DashboardVersionsToKeep = dashboards.Key("versions_to_keep").MustInt(20)
@@ -2107,6 +2114,12 @@ func (cfg *Cfg) readLiveSettings(iniFile *ini.File) error {
 	return nil
 }
 
+func (cfg *Cfg) readClassicProvisioningSettings(iniFile *ini.File) {
+	cfg.ClassicProvisioningDashboardsServerLockMinWaitMs = iniFile.Section("classic_provisioning").Key("dashboards_server_lock_min_wait_ms").MustInt64(100)
+	cfg.ClassicProvisioningDashboardsServerLockMaxWaitMs = iniFile.Section("classic_provisioning").Key("dashboards_server_lock_max_wait_ms").MustInt64(1000)
+	cfg.ClassicProvisioningDashboardsServerLockMaxIntervalSeconds = iniFile.Section("classic_provisioning").Key("dashboards_server_lock_max_interval_seconds").MustInt64(15)
+}
+
 func (cfg *Cfg) readProvisioningSettings(iniFile *ini.File) error {
 	provisioning := valueAsString(iniFile.Section("paths"), "provisioning", "")
 	cfg.ProvisioningPath = makeAbsolute(provisioning, cfg.HomePath)

pkg/storage/unified/README.md

@@ -202,30 +202,58 @@ then run:
 kubectl --kubeconfig=./grafana.kubeconfig create -f folder-generate.yaml
 ```
 
-### Run as a GRPC service
+### Run as a separate GRPC service
 
-#### Start GRPC storage-server
+It is recommended to use a separate config file for the storage-server. Create a file `conf/storage-server.ini` with the following content:
 
-Make sure you have the gRPC address in the `[grafana-apiserver]` section of your config file:
 ```ini
+app_mode = development
+
+target = storage-server
+
+[database]
+type = mysql
+host = 127.0.0.1:3306
+name = unified-storage
+user = root
+password = rootpass
+skip_migrations = true
+ensure_default_org_and_user = false
+
+[grpc_server]
+network = "tcp"
+address = "127.0.0.1:10000"
+
 [grafana-apiserver]
-; your gRPC server address
-address = localhost:10000
-```
+storage_type = unified
 
-You also need the `[grpc_server_authentication]` section to authenticate incoming requests:
-```ini
 [grpc_server_authentication]
-; http url to Grafana's signing keys to validate incoming id tokens
-signing_keys_url = http://localhost:3000/api/signing-keys/keys
+signing_keys_url = http://localhost:3011/api/signing-keys/keys
 mode = "on-prem"
+
+[feature_toggles]
+kubernetesDashboards = true
+kubernetesFolders = true
+unifiedStorage = true
+unifiedStorageHistoryPruner = true
+unifiedStorageSearch = true
+unifiedStorageSearchPermissionFiltering = false
+unifiedStorageSearchSprinkles = false
+
+[unified_storage]
+enable_search = true
+https_skip_verify = true
 ```
 
-This currently only works with a separate database configuration (see previous section).
+You should also have a MySQL database running. You can create one with our docker blocks by running:
+```bash
+make devenv sources=mysql
+```
+The database credentials in the example above will work with the default mysql docker block. You'll also need to create a database named `unified-storage`.
 
 Start the storage-server with:
 ```sh
-GF_DEFAULT_TARGET=storage-server ./bin/grafana server target
+./bin/grafana server target --config conf/storage-server.ini
 ```
 
 The GRPC service will listen on port 10000

pkg/tests/api/alerting/api_prometheus_test.go

@@ -252,7 +252,7 @@ func TestIntegrationPrometheusRules(t *testing.T) {
 			"rules": [{
 				"state": "inactive",
 				"name": "AlwaysFiring",
-				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"type\":\"math\"}}]",
+				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"refId\":\"A\",\"type\":\"math\"}}]",
 				"duration": 10,
 				"folderUid": "default",
 				"uid": "%s",
@@ -270,7 +270,7 @@ func TestIntegrationPrometheusRules(t *testing.T) {
 			}, {
 				"state": "inactive",
 				"name": "AlwaysFiringButSilenced",
-				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"type\":\"math\"}}]",
+				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"refId\":\"A\",\"type\":\"math\"}}]",
 				"folderUid": "default",
 				"uid": "%s",
 				"health": "ok",
@@ -317,7 +317,7 @@ func TestIntegrationPrometheusRules(t *testing.T) {
 			"rules": [{
 				"state": "inactive",
 				"name": "AlwaysFiring",
-				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"type\":\"math\"}}]",
+				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"refId\":\"A\",\"type\":\"math\"}}]",
 				"duration": 10,
 				"folderUid": "default",
 				"uid": "%s",
@@ -335,7 +335,7 @@ func TestIntegrationPrometheusRules(t *testing.T) {
 			}, {
 				"state": "inactive",
 				"name": "AlwaysFiringButSilenced",
-				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"type\":\"math\"}}]",
+				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"refId\":\"A\",\"type\":\"math\"}}]",
 				"folderUid": "default",
 				"uid": "%s",
 				"health": "ok",
@@ -639,7 +639,7 @@ func TestIntegrationPrometheusRulesFilterByDashboard(t *testing.T) {
 				"name": "AlwaysFiring",
 				"uid": "%s",
 				"folderUid": "default",
-				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"type\":\"math\"}}]",
+				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"refId\":\"A\",\"type\":\"math\"}}]",
 				"duration": 10,
 				"keepFiringFor": 15,
 				"annotations": {
@@ -656,7 +656,7 @@ func TestIntegrationPrometheusRulesFilterByDashboard(t *testing.T) {
 				"name": "AlwaysFiringButSilenced",
 				"uid": "%s",
 				"folderUid": "default",
-				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"type\":\"math\"}}]",
+				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"refId\":\"A\",\"type\":\"math\"}}]",
 				"health": "ok",
 				"isPaused": false,
 				"type": "alerting",
@@ -688,7 +688,7 @@ func TestIntegrationPrometheusRulesFilterByDashboard(t *testing.T) {
 				"name": "AlwaysFiring",
 				"uid": "%s",
 				"folderUid": "default",
-				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"type\":\"math\"}}]",
+				"query": "[{\"refId\":\"A\",\"queryType\":\"\",\"relativeTimeRange\":{\"from\":18000,\"to\":10800},\"datasourceUid\":\"__expr__\",\"model\":{\"expression\":\"2 + 3 \\u003e 1\",\"intervalMs\":1000,\"maxDataPoints\":43200,\"refId\":\"A\",\"type\":\"math\"}}]",
 				"duration": 10,
 				"keepFiringFor": 15,
 				"annotations": {

pkg/tests/api/alerting/api_ruler_test.go

@@ -1166,6 +1166,7 @@ func TestIntegrationRulerRulesFilterByDashboard(t *testing.T) {
 						"expression": "2 + 3 \u003e 1",
 						"intervalMs": 1000,
 						"maxDataPoints": 43200,
+						"refId": "A",
 						"type": "math"
 					}
 				}],
@@ -1209,6 +1210,7 @@ func TestIntegrationRulerRulesFilterByDashboard(t *testing.T) {
 						"expression": "2 + 3 \u003e 1",
 						"intervalMs": 1000,
 						"maxDataPoints": 43200,
+						"refId": "A",
 						"type": "math"
 					}
 				}],
@@ -1264,6 +1266,7 @@ func TestIntegrationRulerRulesFilterByDashboard(t *testing.T) {
 						"expression": "2 + 3 \u003e 1",
 						"intervalMs": 1000,
 						"maxDataPoints": 43200,
+						"refId": "A",
 						"type": "math"
 					}
 				}],
@@ -1610,7 +1613,7 @@ func TestIntegrationRuleCreate(t *testing.T) {
 									To:   apimodels.Duration(15 * time.Minute),
 								},
 								DatasourceUID: expr.DatasourceUID,
-								Model:         json.RawMessage(`{"expression":"1","intervalMs":1000,"maxDataPoints":43200,"type":"math"}`),
+								Model:         json.RawMessage(`{"expression":"1","intervalMs":1000,"maxDataPoints":43200,"refId":"A","type":"math"}`),
 							},
 						},
 						UpdatedBy: &apimodels.UserInfo{
@@ -2681,6 +2684,7 @@ func TestIntegrationQuota(t *testing.T) {
 							   "expression":"2 + 4 \u003E 1",
 							   "intervalMs":1000,
 							   "maxDataPoints":43200,
+							   "refId":"A",
 							   "type":"math"
 							}
 						     }
@@ -2798,6 +2802,7 @@ func TestIntegrationDeleteFolderWithRules(t *testing.T) {
 												"expression": "2 + 3 > 1",
 												"intervalMs": 1000,
 												"maxDataPoints": 43200,
+												"refId": "A",
 												"type": "math"
 											}
 										}
@@ -3285,6 +3290,7 @@ func TestIntegrationAlertRuleCRUD(t *testing.T) {
 								   "expression":"2 + 3 \u003e 1",
 								   "intervalMs":1000,
 								   "maxDataPoints":43200,
+								   "refId":"A",
 								   "type":"math"
 								}
 							 }
@@ -3331,6 +3337,7 @@ func TestIntegrationAlertRuleCRUD(t *testing.T) {
 								   "expression":"2 + 3 \u003e 1",
 								   "intervalMs":1000,
 								   "maxDataPoints":43200,
+								   "refId":"A",
 								   "type":"math"
 								}
 							 }
@@ -3683,6 +3690,7 @@ func TestIntegrationAlertRuleCRUD(t *testing.T) {
 								   "expression":"2 + 3 \u003e 1",
 								   "intervalMs":1000,
 								   "maxDataPoints":43200,
+								   "refId":"A",
 								   "type":"math"
 								}
 							 }
@@ -3729,6 +3737,7 @@ func TestIntegrationAlertRuleCRUD(t *testing.T) {
 								   "expression":"2 + 3 \u003e 1",
 								   "intervalMs":1000,
 								   "maxDataPoints":43200,
+								   "refId":"A",
 								   "type":"math"
 								}
 							 }
@@ -3872,6 +3881,7 @@ func TestIntegrationAlertRuleCRUD(t *testing.T) {
 		                           "expression":"2 + 3 \u003C 1",
 		                           "intervalMs":1000,
 		                           "maxDataPoints":43200,
+								   "refId":"A",
 		                           "type":"math"
 		                        }
 		                     }
@@ -3995,6 +4005,7 @@ func TestIntegrationAlertRuleCRUD(t *testing.T) {
 						   "expression":"2 + 3 \u003C 1",
 						   "intervalMs":1000,
 						   "maxDataPoints":43200,
+						   "refId":"A",
 						   "type":"math"
 						}
 					     }
@@ -4093,6 +4104,7 @@ func TestIntegrationAlertRuleCRUD(t *testing.T) {
 						   "expression":"2 + 3 \u003C 1",
 						   "intervalMs":1000,
 						   "maxDataPoints":43200,
+						   "refId":"A",
 						   "type":"math"
 						}
 					     }

pkg/tests/api/alerting/test-data/rulegroup-1-export.json

@@ -23,6 +23,7 @@
                 "expression": "0 \u003e 0",
                 "intervalMs": 1000,
                 "maxDataPoints": 43200,
+                "refId": "A",
                 "type": "math"
               }
             }
@@ -55,6 +56,7 @@
                 "expression": "0 == 0",
                 "intervalMs": 1000,
                 "maxDataPoints": 43200,
+                "refId": "A",
                 "type": "math"
               }
             }

pkg/tests/api/alerting/test-data/rulegroup-2-export.json

@@ -23,6 +23,7 @@
                 "expression": "0/0",
                 "intervalMs": 1000,
                 "maxDataPoints": 43200,
+                "refId": "A",
                 "type": "math"
               }
             }

pkg/tests/api/alerting/test-data/rulegroup-3-export.json

@@ -23,6 +23,7 @@
                 "expression": "0 \u003e 0",
                 "intervalMs": 1000,
                 "maxDataPoints": 43200,
+                "refId": "A",
                 "type": "math"
               }
             }
@@ -54,6 +55,7 @@
                 "expression": "0 == 0",
                 "intervalMs": 1000,
                 "maxDataPoints": 43200,
+                "refId": "A",
                 "type": "math"
               }
             }

public/app/core/components/TimeSeries/utils.ts

@@ -138,10 +138,26 @@ export const preparePlotConfigBuilder: UPlotConfigPrepFn = ({
       range: () => {
         const state = builder.getState();
         if (state.isPanning) {
+          if (state.isTimeRangePending) {
+            const timeRange = getTimeRange();
+            const propsFrom = timeRange.from.valueOf();
+            const propsTo = timeRange.to.valueOf();
+
+            const MIN_TIMESPAN_MS = 1;
+            const fromMatches = Math.abs(propsFrom - state.min) <= MIN_TIMESPAN_MS;
+            const toMatches = Math.abs(propsTo - state.max) <= MIN_TIMESPAN_MS;
+            const timeRangeHasUpdated = fromMatches && toMatches;
+
+            if (timeRangeHasUpdated) {
+              builder.setState({ isPanning: false });
+              return [propsFrom, propsTo];
+            }
+          }
+
           return [state.min, state.max];
         }
-        const r = getTimeRange();
-        return [r.from.valueOf(), r.to.valueOf()];
+        const timeRange = getTimeRange();
+        return [timeRange.from.valueOf(), timeRange.to.valueOf()];
       },
     });
 

public/app/core/components/TimelineChart/utils.ts

@@ -159,6 +159,24 @@ export const preparePlotConfigBuilder: UPlotConfigPrepFn<UPlotConfigOptions> = (
     range: (u) => {
       const state = builder.getState();
       if (state.isPanning) {
+        if (state.isTimeRangePending) {
+          const propsRange = coreConfig.xRange(u);
+          const propsFrom = propsRange[0];
+          const propsTo = propsRange[1];
+
+          if (propsFrom != null && propsTo != null) {
+            const MIN_TIMESPAN_MS = 1;
+            const fromMatches = Math.abs(propsFrom - state.min) <= MIN_TIMESPAN_MS;
+            const toMatches = Math.abs(propsTo - state.max) <= MIN_TIMESPAN_MS;
+            const timeRangeHasUpdated = fromMatches && toMatches;
+
+            if (timeRangeHasUpdated) {
+              builder.setState({ isPanning: false });
+              return propsRange;
+            }
+          }
+        }
+
         return [state.min, state.max];
       }
       return coreConfig.xRange(u);

public/app/features/commandPalette/actions/scopeActions.test.tsx

@@ -22,7 +22,7 @@ jest.mock('./scopesUtils', () => {
 });
 
 const mockScopeServicesState = {
-  updateNode: jest.fn(),
+  filterNode: jest.fn(),
   selectScope: jest.fn(),
   resetSelection: jest.fn(),
   nodes: {},
@@ -99,12 +99,12 @@ describe('useRegisterScopesActions', () => {
   });
 
   it('should register scope tree actions and return scopesRow when scopes are selected', () => {
-    const mockUpdateNode = jest.fn();
+    const mockFilterNode = jest.fn();
 
     // First run with empty scopes in the scopes service
     (useScopeServicesState as jest.Mock).mockReturnValue({
       ...mockScopeServicesState,
-      updateNode: mockUpdateNode,
+      filterNode: mockFilterNode,
       selectedScopes: [{ scopeId: 'scope1', name: 'Scope 1' }],
     });
 
@@ -112,14 +112,14 @@ describe('useRegisterScopesActions', () => {
       return useRegisterScopesActions('', jest.fn());
     });
 
-    expect(mockUpdateNode).toHaveBeenCalledWith('', true, '');
+    expect(mockFilterNode).toHaveBeenCalledWith('', '');
     expect(useRegisterActions).toHaveBeenLastCalledWith([rootScopeAction], [[rootScopeAction]]);
     expect(result.current.scopesRow).toBeDefined();
 
     // Simulate loading of scopes in the service
     (useScopeServicesState as jest.Mock).mockReturnValue({
       ...mockScopeServicesState,
-      updateNode: mockUpdateNode,
+      filterNode: mockFilterNode,
       selectedScopes: [{ scopeId: 'scope1', name: 'Scope 1' }],
       nodes,
       tree,
@@ -151,12 +151,12 @@ describe('useRegisterScopesActions', () => {
   });
 
   it('should load next level of scopes', () => {
-    const mockUpdateNode = jest.fn();
+    const mockFilterNode = jest.fn();
 
     // First run with empty scopes in the scopes service
     (useScopeServicesState as jest.Mock).mockReturnValue({
       ...mockScopeServicesState,
-      updateNode: mockUpdateNode,
+      filterNode: mockFilterNode,
       nodes,
       tree,
     });
@@ -165,7 +165,7 @@ describe('useRegisterScopesActions', () => {
       return useRegisterScopesActions('', jest.fn(), 'scopes/scope1');
     });
 
-    expect(mockUpdateNode).toHaveBeenCalledWith('scope1', true, '');
+    expect(mockFilterNode).toHaveBeenCalledWith('scope1', '');
   });
 
   it('does not return component if no scopes are selected', () => {
@@ -259,12 +259,12 @@ describe('useRegisterScopesActions', () => {
   });
 
   it('should not use global scope search when searching in some deeper scope category', async () => {
-    const mockUpdateNode = jest.fn();
+    const mockFilterNode = jest.fn();
 
     // First run with empty scopes in the scopes service
     (useScopeServicesState as jest.Mock).mockReturnValue({
       ...mockScopeServicesState,
-      updateNode: mockUpdateNode,
+      filterNode: mockFilterNode,
       nodes,
       tree,
     });
@@ -273,17 +273,17 @@ describe('useRegisterScopesActions', () => {
       return useRegisterScopesActions('something', jest.fn(), 'scopes/scope1');
     });
 
-    expect(mockUpdateNode).toHaveBeenCalledWith('scope1', true, 'something');
+    expect(mockFilterNode).toHaveBeenCalledWith('scope1', 'something');
     expect(mockScopeServicesState.searchAllNodes).not.toHaveBeenCalled();
   });
 
   it('should not use global scope search if feature flag is off', async () => {
     config.featureToggles.scopeSearchAllLevels = false;
-    const mockUpdateNode = jest.fn();
+    const mockFilterNode = jest.fn();
     // First run with empty scopes in the scopes service
     (useScopeServicesState as jest.Mock).mockReturnValue({
       ...mockScopeServicesState,
-      updateNode: mockUpdateNode,
+      filterNode: mockFilterNode,
       nodes,
       tree,
     });
@@ -292,7 +292,7 @@ describe('useRegisterScopesActions', () => {
       return useRegisterScopesActions('something', jest.fn(), '');
     });
 
-    expect(mockUpdateNode).toHaveBeenCalledWith('', true, 'something');
+    expect(mockFilterNode).toHaveBeenCalledWith('', 'something');
     expect(mockScopeServicesState.searchAllNodes).not.toHaveBeenCalled();
   });
 

public/app/features/commandPalette/actions/scopeActions.tsx

@@ -58,22 +58,22 @@ export function useRegisterScopesActions(
  * @param parentId
  */
 function useScopeTreeActions(searchQuery: string, parentId?: string | null) {
-  const { updateNode, selectScope, resetSelection, nodes, tree, selectedScopes } = useScopeServicesState();
+  const { filterNode, selectScope, resetSelection, nodes, tree, selectedScopes } = useScopeServicesState();
 
   // Initialize the scopes the first time this runs and reset the scopes that were selected on unmount.
   useEffect(() => {
-    updateNode('', true, '');
+    filterNode('', '');
     resetSelection();
     return () => {
       resetSelection();
     };
-  }, [updateNode, resetSelection]);
+  }, [filterNode, resetSelection]);
 
   // Load the next level of scopes when the parentId changes.
   useEffect(() => {
     const parentScopeId = !parentId || parentId === 'scopes' ? '' : last(parentId.split('/'))!;
-    updateNode(parentScopeId, true, searchQuery);
-  }, [updateNode, searchQuery, parentId]);
+    filterNode(parentScopeId, searchQuery);
+  }, [filterNode, searchQuery, parentId]);
 
   return useMemo(
     () => mapScopesNodesTreeToActions(nodes, tree!, selectedScopes, selectScope),

public/app/features/commandPalette/actions/scopesUtils.ts

@@ -14,7 +14,7 @@ export function useScopeServicesState() {
   const services = useScopesServices();
   if (!services) {
     return {
-      updateNode: () => {},
+      filterNode: () => Promise.resolve(),
       selectScope: () => {},
       resetSelection: () => {},
       searchAllNodes: () => Promise.resolve([]),
@@ -32,7 +32,7 @@ export function useScopeServicesState() {
       },
     };
   }
-  const { updateNode, filterNode, selectScope, resetSelection, searchAllNodes, deselectScope, apply, getScopeNodes } =
+  const { filterNode, selectScope, resetSelection, searchAllNodes, deselectScope, apply, getScopeNodes } =
     services.scopesSelectorService;
   const selectorServiceState: ScopesSelectorServiceState | undefined = useObservable(
     services.scopesSelectorService.stateObservable ?? new Observable(),
@@ -42,7 +42,6 @@ export function useScopeServicesState() {
   return {
     getScopeNodes,
     filterNode,
-    updateNode,
     selectScope,
     resetSelection,
     searchAllNodes,

public/app/features/geo/utils/location.ts

@@ -68,6 +68,16 @@ const defaultMatchers: LocationFieldMatchers = {
   geo: (frame: DataFrame) => frame.fields.find((f) => f.type === FieldType.geo),
 };
 
+/**
+ * suggestions needs to run sync, and we just want to use the default matchers in that situation.
+ */
+export function getDefaultLocationMatchers(): LocationFieldMatchers {
+  return {
+    ...defaultMatchers,
+    mode: FrameGeometrySourceMode.Auto,
+  };
+}
+
 export async function getLocationMatchers(src?: FrameGeometrySource): Promise<LocationFieldMatchers> {
   const info: LocationFieldMatchers = {
     ...defaultMatchers,

public/app/features/panel/components/PanelDataErrorView.tsx

@@ -2,6 +2,7 @@ import { css } from '@emotion/css';
 
 import {
   CoreApp,
+  FieldType,
   getPanelDataSummary,
   GrafanaTheme2,
   PanelDataSummary,
@@ -134,15 +135,15 @@ function getMessageFor(
     return fieldConfig?.defaults.noValue ?? t('panel.panel-data-error-view.no-value.default', 'No data');
   }
 
-  if (needsStringField && !dataSummary.hasStringField) {
+  if (needsStringField && !dataSummary.hasFieldType(FieldType.string)) {
     return t('panel.panel-data-error-view.missing-value.string', 'Data is missing a string field');
   }
 
-  if (needsNumberField && !dataSummary.hasNumberField) {
+  if (needsNumberField && !dataSummary.hasFieldType(FieldType.number)) {
     return t('panel.panel-data-error-view.missing-value.number', 'Data is missing a number field');
   }
 
-  if (needsTimeField && !dataSummary.hasTimeField) {
+  if (needsTimeField && !dataSummary.hasFieldType(FieldType.time)) {
     return t('panel.panel-data-error-view.missing-value.time', 'Data is missing a time field');
   }
 

public/app/features/panel/suggestions/getAllSuggestions.test.ts

@@ -5,12 +5,18 @@ import {
   LoadingState,
   PanelData,
   PanelPluginMeta,
-  toDataFrame,
   PanelPluginVisualizationSuggestion,
+  toDataFrame,
 } from '@grafana/data';
-import { GraphFieldConfig, ReduceDataOptions } from '@grafana/schema';
+import {
+  BarGaugeDisplayMode,
+  BigValueColorMode,
+  GraphFieldConfig,
+  ReduceDataOptions,
+  StackingMode,
+  VizOrientation,
+} from '@grafana/schema';
 import { config } from 'app/core/config';
-import { SuggestionName } from 'app/types/suggestions';
 
 import { getAllSuggestions, panelsToCheckFirst } from './getAllSuggestions';
 
@@ -21,6 +27,8 @@ for (const pluginId of panelsToCheckFirst) {
   } as PanelPluginMeta;
 }
 
+const SCALAR_PLUGINS = ['gauge', 'stat', 'bargauge', 'piechart', 'radialbar'];
+
 config.panels['text'] = {
   id: 'text',
   name: 'Text',
@@ -69,7 +77,10 @@ scenario('No series', (ctx) => {
   ctx.setData([]);
 
   it('should return correct suggestions', () => {
-    expect(ctx.names()).toEqual([SuggestionName.Table, SuggestionName.TextPanel]);
+    expect(ctx.suggestions).toEqual([
+      expect.objectContaining({ pluginId: 'table' }),
+      expect.objectContaining({ pluginId: 'text' }),
+    ]);
   });
 });
 
@@ -84,7 +95,7 @@ scenario('No rows', (ctx) => {
   ]);
 
   it('should return correct suggestions', () => {
-    expect(ctx.names()).toEqual([SuggestionName.Table]);
+    expect(ctx.suggestions).toEqual([expect.objectContaining({ pluginId: 'table' })]);
   });
 });
 
@@ -100,33 +111,46 @@ scenario('Single frame with time and number field', (ctx) => {
 
   it('should return correct suggestions', () => {
     expect(ctx.suggestions).toEqual([
-      expect.objectContaining({ name: SuggestionName.LineChart }),
-      expect.objectContaining({ name: SuggestionName.LineChartSmooth }),
-      expect.objectContaining({ name: SuggestionName.AreaChart }),
-      expect.objectContaining({ name: SuggestionName.LineChartGradientColorScheme }),
-      expect.objectContaining({ name: SuggestionName.BarChart }),
-      expect.objectContaining({ name: SuggestionName.BarChartGradientColorScheme }),
-      expect.objectContaining({ name: SuggestionName.Gauge }),
-      expect.objectContaining({ name: SuggestionName.GaugeNoThresholds }),
-      expect.objectContaining({ name: SuggestionName.Stat }),
-      expect.objectContaining({ name: SuggestionName.StatColoredBackground }),
-      expect.objectContaining({ name: SuggestionName.BarGaugeBasic }),
-      expect.objectContaining({ name: SuggestionName.BarGaugeLCD }),
-      expect.objectContaining({ name: SuggestionName.Table }),
+      expect.objectContaining({ pluginId: 'timeseries', name: 'Line chart' }),
+      expect.objectContaining({ pluginId: 'timeseries', name: 'Line chart - smooth' }),
+      expect.objectContaining({ pluginId: 'timeseries', name: 'Area chart' }),
+      expect.objectContaining({ pluginId: 'timeseries', name: 'Bar chart' }),
+      expect.objectContaining({ pluginId: 'gauge' }),
+      expect.objectContaining({ pluginId: 'gauge', options: expect.objectContaining({ showThresholdMarkers: false }) }),
+      expect.objectContaining({ pluginId: 'stat' }),
+      expect.objectContaining({
+        pluginId: 'stat',
+        options: expect.objectContaining({ colorMode: BigValueColorMode.Background }),
+      }),
+      expect.objectContaining({
+        pluginId: 'bargauge',
+        options: expect.objectContaining({ displayMode: BarGaugeDisplayMode.Basic }),
+      }),
+      expect.objectContaining({
+        pluginId: 'bargauge',
+        options: expect.objectContaining({ displayMode: BarGaugeDisplayMode.Lcd }),
+      }),
+      expect.objectContaining({ pluginId: 'table' }),
       expect.objectContaining({ pluginId: 'state-timeline' }),
-      expect.objectContaining({ name: SuggestionName.StatusHistory }),
+      expect.objectContaining({ pluginId: 'status-history' }),
+      expect.objectContaining({ pluginId: 'heatmap' }),
+      expect.objectContaining({ pluginId: 'histogram' }),
     ]);
   });
 
   it('Bar chart suggestion should be using timeseries panel', () => {
-    expect(ctx.suggestions.find((x) => x.name === SuggestionName.BarChart)?.pluginId).toBe('timeseries');
+    expect(ctx.suggestions.find((x) => x.name === 'Bar chart')?.pluginId).toBe('timeseries');
   });
 
-  it('Stat panels have reduce values disabled', () => {
-    for (const suggestion of ctx.suggestions) {
-      if (suggestion.options?.reduceOptions?.values) {
-        throw new Error(`Suggestion ${suggestion.name} reduce.values set to true when it should be false`);
-      }
+  it('Scalar panels should use calcs', () => {
+    for (const suggestion of ctx.suggestions.filter((s) => SCALAR_PLUGINS.includes(s.pluginId))) {
+      expect(suggestion).toEqual(
+        expect.objectContaining({
+          options: expect.objectContaining({
+            reduceOptions: expect.objectContaining({ values: false, calcs: ['lastNotNull'] }),
+          }),
+        })
+      );
     }
   });
 });
@@ -144,31 +168,46 @@ scenario('Single frame with time 2 number fields', (ctx) => {
 
   it('should return correct suggestions', () => {
     expect(ctx.suggestions).toEqual([
-      expect.objectContaining({ name: SuggestionName.LineChart }),
-      expect.objectContaining({ name: SuggestionName.LineChartSmooth }),
-      expect.objectContaining({ name: SuggestionName.AreaChartStacked }),
-      expect.objectContaining({ name: SuggestionName.AreaChartStackedPercent }),
-      expect.objectContaining({ name: SuggestionName.BarChartStacked }),
-      expect.objectContaining({ name: SuggestionName.BarChartStackedPercent }),
-      expect.objectContaining({ name: SuggestionName.Gauge }),
-      expect.objectContaining({ name: SuggestionName.GaugeNoThresholds }),
-      expect.objectContaining({ name: SuggestionName.Stat }),
-      expect.objectContaining({ name: SuggestionName.StatColoredBackground }),
-      expect.objectContaining({ name: SuggestionName.PieChart }),
-      expect.objectContaining({ name: SuggestionName.PieChartDonut }),
-      expect.objectContaining({ name: SuggestionName.BarGaugeBasic }),
-      expect.objectContaining({ name: SuggestionName.BarGaugeLCD }),
-      expect.objectContaining({ name: SuggestionName.Table }),
+      expect.objectContaining({ pluginId: 'timeseries', name: 'Line chart' }),
+      expect.objectContaining({ pluginId: 'timeseries', name: 'Line chart - smooth' }),
+      expect.objectContaining({ pluginId: 'timeseries', name: 'Area chart - stacked' }),
+      expect.objectContaining({ pluginId: 'timeseries', name: 'Area chart - stacked by percentage' }),
+      expect.objectContaining({ pluginId: 'timeseries', name: 'Bar chart - stacked' }),
+      expect.objectContaining({ pluginId: 'timeseries', name: 'Bar chart - stacked by percentage' }),
+      expect.objectContaining({ pluginId: 'gauge' }),
+      expect.objectContaining({ pluginId: 'gauge', options: expect.objectContaining({ showThresholdMarkers: false }) }),
+      expect.objectContaining({ pluginId: 'stat' }),
+      expect.objectContaining({
+        pluginId: 'stat',
+        options: expect.objectContaining({ colorMode: BigValueColorMode.Background }),
+      }),
+      expect.objectContaining({ pluginId: 'piechart' }),
+      expect.objectContaining({ pluginId: 'piechart', options: expect.objectContaining({ pieType: 'donut' }) }),
+      expect.objectContaining({
+        pluginId: 'bargauge',
+        options: expect.objectContaining({ displayMode: BarGaugeDisplayMode.Basic }),
+      }),
+      expect.objectContaining({
+        pluginId: 'bargauge',
+        options: expect.objectContaining({ displayMode: BarGaugeDisplayMode.Lcd }),
+      }),
+      expect.objectContaining({ pluginId: 'table' }),
       expect.objectContaining({ pluginId: 'state-timeline' }),
-      expect.objectContaining({ name: SuggestionName.StatusHistory }),
+      expect.objectContaining({ pluginId: 'status-history' }),
+      expect.objectContaining({ pluginId: 'heatmap' }),
+      expect.objectContaining({ pluginId: 'histogram' }),
     ]);
   });
 
-  it('Stat panels have reduceOptions.values disabled', () => {
-    for (const suggestion of ctx.suggestions) {
-      if (suggestion.options?.reduceOptions?.values) {
-        throw new Error(`Suggestion ${suggestion.name} reduce.values set to true when it should be false`);
-      }
+  it('Scalar panels should use calcs', () => {
+    for (const suggestion of ctx.suggestions.filter((s) => SCALAR_PLUGINS.includes(s.pluginId))) {
+      expect(suggestion).toEqual(
+        expect.objectContaining({
+          options: expect.objectContaining({
+            reduceOptions: expect.objectContaining({ values: false, calcs: ['lastNotNull'] }),
+          }),
+        })
+      );
     }
   });
 });
@@ -184,7 +223,7 @@ scenario('Single time series with 100 data points', (ctx) => {
   ]);
 
   it('should not suggest bar chart', () => {
-    expect(ctx.suggestions.find((x) => x.name === SuggestionName.BarChart)).toBe(undefined);
+    expect(ctx.suggestions.find((x) => x.name === 'Bar chart')).toBe(undefined);
   });
 });
 
@@ -235,26 +274,42 @@ scenario('Single frame with string and number field', (ctx) => {
   ]);
 
   it('should return correct suggestions', () => {
-    expect(ctx.names()).toEqual([
-      SuggestionName.BarChart,
-      SuggestionName.BarChartHorizontal,
-      SuggestionName.Gauge,
-      SuggestionName.GaugeNoThresholds,
-      SuggestionName.Stat,
-      SuggestionName.StatColoredBackground,
-      SuggestionName.PieChart,
-      SuggestionName.PieChartDonut,
-      SuggestionName.BarGaugeBasic,
-      SuggestionName.BarGaugeLCD,
-      SuggestionName.Table,
+    expect(ctx.suggestions).toEqual([
+      expect.objectContaining({ pluginId: 'piechart' }),
+      expect.objectContaining({ pluginId: 'piechart', options: expect.objectContaining({ pieType: 'donut' }) }),
+      expect.objectContaining({ pluginId: 'barchart' }),
+      expect.objectContaining({
+        pluginId: 'barchart',
+        options: expect.objectContaining({ orientation: VizOrientation.Horizontal }),
+      }),
+      expect.objectContaining({ pluginId: 'gauge' }),
+      expect.objectContaining({ pluginId: 'gauge', options: expect.objectContaining({ showThresholdMarkers: false }) }),
+      expect.objectContaining({ pluginId: 'stat' }),
+      expect.objectContaining({
+        pluginId: 'stat',
+        options: expect.objectContaining({ colorMode: BigValueColorMode.Background }),
+      }),
+
+      expect.objectContaining({
+        pluginId: 'bargauge',
+        options: expect.objectContaining({ displayMode: BarGaugeDisplayMode.Basic }),
+      }),
+      expect.objectContaining({
+        pluginId: 'bargauge',
+        options: expect.objectContaining({ displayMode: BarGaugeDisplayMode.Lcd }),
+      }),
+      expect.objectContaining({ pluginId: 'table' }),
+      expect.objectContaining({ pluginId: 'histogram' }),
     ]);
   });
 
-  it('Stat/Gauge/BarGauge/PieChart panels to have reduceOptions.values enabled', () => {
-    for (const suggestion of ctx.suggestions) {
-      if (suggestion.options?.reduceOptions && !suggestion.options?.reduceOptions?.values) {
-        throw new Error(`Suggestion ${suggestion.name} reduce.values set to false when it should be true`);
-      }
+  it('Scalar panels should contain raw values', () => {
+    for (const suggestion of ctx.suggestions.filter((s) => SCALAR_PLUGINS.includes(s.pluginId))) {
+      expect(suggestion).toEqual(
+        expect.objectContaining({
+          options: expect.objectContaining({ reduceOptions: expect.objectContaining({ values: true, calcs: [] }) }),
+        })
+      );
     }
   });
 });
@@ -271,22 +326,48 @@ scenario('Single frame with string and 2 number field', (ctx) => {
   ]);
 
   it('should return correct suggestions', () => {
-    expect(ctx.names()).toEqual([
-      SuggestionName.BarChart,
-      SuggestionName.BarChartStacked,
-      SuggestionName.BarChartStackedPercent,
-      SuggestionName.BarChartHorizontal,
-      SuggestionName.BarChartHorizontalStacked,
-      SuggestionName.BarChartHorizontalStackedPercent,
-      SuggestionName.Gauge,
-      SuggestionName.GaugeNoThresholds,
-      SuggestionName.Stat,
-      SuggestionName.StatColoredBackground,
-      SuggestionName.PieChart,
-      SuggestionName.PieChartDonut,
-      SuggestionName.BarGaugeBasic,
-      SuggestionName.BarGaugeLCD,
-      SuggestionName.Table,
+    expect(ctx.suggestions).toEqual([
+      expect.objectContaining({ pluginId: 'barchart' }),
+      expect.objectContaining({
+        pluginId: 'barchart',
+        options: expect.objectContaining({ stacking: StackingMode.Normal }),
+      }),
+      expect.objectContaining({
+        pluginId: 'barchart',
+        options: expect.objectContaining({ stacking: StackingMode.Percent }),
+      }),
+
+      expect.objectContaining({
+        pluginId: 'barchart',
+        options: expect.objectContaining({ orientation: VizOrientation.Horizontal }),
+      }),
+      expect.objectContaining({
+        pluginId: 'barchart',
+        options: expect.objectContaining({ orientation: VizOrientation.Horizontal, stacking: StackingMode.Normal }),
+      }),
+      expect.objectContaining({
+        pluginId: 'barchart',
+        options: expect.objectContaining({ orientation: VizOrientation.Horizontal, stacking: StackingMode.Percent }),
+      }),
+      expect.objectContaining({ pluginId: 'gauge' }),
+      expect.objectContaining({ pluginId: 'gauge', options: expect.objectContaining({ showThresholdMarkers: false }) }),
+      expect.objectContaining({ pluginId: 'stat' }),
+      expect.objectContaining({
+        pluginId: 'stat',
+        options: expect.objectContaining({ colorMode: BigValueColorMode.Background }),
+      }),
+      expect.objectContaining({ pluginId: 'piechart' }),
+      expect.objectContaining({ pluginId: 'piechart', options: expect.objectContaining({ pieType: 'donut' }) }),
+      expect.objectContaining({
+        pluginId: 'bargauge',
+        options: expect.objectContaining({ displayMode: BarGaugeDisplayMode.Basic }),
+      }),
+      expect.objectContaining({
+        pluginId: 'bargauge',
+        options: expect.objectContaining({ displayMode: BarGaugeDisplayMode.Lcd }),
+      }),
+      expect.objectContaining({ pluginId: 'table' }),
+      expect.objectContaining({ pluginId: 'histogram' }),
     ]);
   });
 });
@@ -299,11 +380,14 @@ scenario('Single frame with only string field', (ctx) => {
   ]);
 
   it('should return correct suggestions', () => {
-    expect(ctx.names()).toEqual([SuggestionName.Stat, SuggestionName.Table]);
+    expect(ctx.suggestions).toEqual([
+      expect.objectContaining({ pluginId: 'stat' }),
+      expect.objectContaining({ pluginId: 'table' }),
+    ]);
   });
 
   it('Stat panels have reduceOptions.fields set to show all fields', () => {
-    for (const suggestion of ctx.suggestions) {
+    for (const suggestion of ctx.suggestions.filter((s) => s.pluginId === 'stat')) {
       if (suggestion.options?.reduceOptions) {
         expect(suggestion.options.reduceOptions.fields).toBe('/.*/');
       }
@@ -333,7 +417,10 @@ scenario('Given default loki logs data', (ctx) => {
   ]);
 
   it('should return correct suggestions', () => {
-    expect(ctx.names()).toEqual([SuggestionName.Logs, SuggestionName.Table]);
+    expect(ctx.suggestions).toEqual([
+      expect.objectContaining({ pluginId: 'logs' }),
+      expect.objectContaining({ pluginId: 'table' }),
+    ]);
   });
 });
 
@@ -356,7 +443,7 @@ scenario('Given a preferredVisualisationType', (ctx) => {
   ]);
 
   it('should return the preferred visualization first', () => {
-    expect(ctx.names()[0]).toEqual(SuggestionName.Table);
+    expect(ctx.suggestions[0]).toEqual(expect.objectContaining({ pluginId: 'table' }));
   });
 });
 

public/app/features/panel/suggestions/getAllSuggestions.ts

@@ -4,6 +4,7 @@ import {
   VisualizationSuggestionsBuilder,
   PanelModel,
   VisualizationSuggestionScore,
+  PreferredVisualisationType,
 } from '@grafana/data';
 import { config } from '@grafana/runtime';
 import { importPanelPlugin } from 'app/features/plugins/importPanelPlugin';
@@ -23,8 +24,26 @@ export const panelsToCheckFirst = [
   'flamegraph',
   'traces',
   'nodeGraph',
+  'heatmap',
+  'histogram',
+  'geomap',
 ];
 
+/**
+ * some of the PreferredVisualisationTypes do not match the panel plugin ids, so we have to map them. d'oh.
+ */
+const PLUGIN_ID_TO_PREFERRED_VIZ_TYPE: Record<string, PreferredVisualisationType> = {
+  traces: 'trace',
+  timeseries: 'graph',
+  table: 'table',
+  logs: 'logs',
+  nodeGraph: 'nodeGraph',
+  flamegraph: 'flamegraph',
+};
+const mapPreferredVisualisationTypeToPlugin = (type: string): PreferredVisualisationType | undefined => {
+  return PLUGIN_ID_TO_PREFERRED_VIZ_TYPE[type];
+};
+
 export async function getAllSuggestions(
   data?: PanelData,
   panel?: PanelModel
@@ -61,13 +80,13 @@ export async function getAllSuggestions(
   }
 
   return list.sort((a, b) => {
-    if (builder.dataSummary.preferredVisualisationType) {
-      if (a.pluginId === builder.dataSummary.preferredVisualisationType) {
-        return -1;
-      }
-      if (b.pluginId === builder.dataSummary.preferredVisualisationType) {
-        return 1;
-      }
+    const mappedA = mapPreferredVisualisationTypeToPlugin(a.pluginId);
+    if (mappedA && builder.dataSummary.hasPreferredVisualisationType(mappedA)) {
+      return -1;
+    }
+    const mappedB = mapPreferredVisualisationTypeToPlugin(a.pluginId);
+    if (mappedB && builder.dataSummary.hasPreferredVisualisationType(mappedB)) {
+      return 1;
     }
     return (b.score ?? VisualizationSuggestionScore.OK) - (a.score ?? VisualizationSuggestionScore.OK);
   });

public/app/features/panel/suggestions/utils.ts

@@ -1,4 +1,11 @@
-import { PanelData, PanelDataSummary } from '@grafana/data';
+import {
+  DataFrameType,
+  PanelData,
+  PanelDataSummary,
+  VisualizationSuggestion,
+  VisualizationSuggestionScore,
+} from '@grafana/data';
+import { ReduceDataOptions } from '@grafana/schema';
 
 /**
  * @internal
@@ -10,6 +17,42 @@ export function showDefaultSuggestion(fn: (panelDataSummary: PanelDataSummary) =
   return (panelDataSummary: PanelDataSummary) => (fn(panelDataSummary) ? [{}] : undefined);
 }
 
+/**
+ * @internal
+ * for panel plugins which render "scalar" data (stat, gauge, etc), this helper provides default reduce options
+ * depending on whether deaggregation is likely needed.
+ * @param suggestion the suggestion to modify
+ * @param panelDataSummary the panel data summary to use for scoring
+ * @param shouldUseRawValues if true, reduceOptions will be set to use raw values,
+ *   otherwise a calcs will be used with the default value of `lastNotNull`.
+ */
+export function defaultNumericVizOptions(
+  suggestion: VisualizationSuggestion<{ reduceOptions?: ReduceDataOptions }>,
+  panelDataSummary: PanelDataSummary,
+  shouldUseRawValues: boolean
+): VisualizationSuggestion {
+  suggestion.score =
+    (suggestion.score ??
+    (panelDataSummary.hasDataFrameType(DataFrameType.NumericLong) ||
+      panelDataSummary.hasDataFrameType(DataFrameType.NumericWide) ||
+      panelDataSummary.hasDataFrameType(DataFrameType.NumericMulti)))
+      ? VisualizationSuggestionScore.Good
+      : VisualizationSuggestionScore.OK;
+  suggestion.options = suggestion.options ?? {};
+  suggestion.options.reduceOptions =
+    suggestion.options.reduceOptions ??
+    (shouldUseRawValues
+      ? {
+          values: true,
+          calcs: [],
+        }
+      : {
+          values: false,
+          calcs: ['lastNotNull'],
+        });
+  return suggestion;
+}
+
 /**
  * @internal
  * Checks if the panel has data

public/app/features/provisioning/Repository/RepositoryLink.tsx

@@ -4,7 +4,7 @@ import { Trans } from '@grafana/i18n';
 import { LinkButton, Stack, Text, TextLink } from '@grafana/ui';
 import { useGetRepositoryQuery } from 'app/api/clients/provisioning/v0alpha1';
 
-import { getRepoHref } from '../utils/git';
+import { getRepoHrefForProvider } from '../utils/git';
 
 type RepositoryLinkProps = {
   name?: string;
@@ -19,7 +19,7 @@ export function RepositoryLink({ name, jobType }: RepositoryLinkProps) {
     return null;
   }
 
-  const repoHref = getRepoHref(repo.spec?.github);
+  const repoHref = getRepoHrefForProvider(repo.spec);
 
   if (jobType === 'sync') {
     return (

public/app/features/provisioning/Repository/RepositoryListItem.tsx

@@ -2,12 +2,13 @@ import { ReactNode } from 'react';
 
 import { t, Trans } from '@grafana/i18n';
 import { reportInteraction } from '@grafana/runtime';
-import { Stack, Text, TextLink, Icon, Card, LinkButton, Badge } from '@grafana/ui';
+import { Badge, Card, LinkButton, Stack, Text, TextLink } from '@grafana/ui';
 import { Repository, ResourceCount } from 'app/api/clients/provisioning/v0alpha1';
 
 import { RepoIcon } from '../Shared/RepoIcon';
 import { StatusBadge } from '../Shared/StatusBadge';
 import { PROVISIONING_URL } from '../constants';
+import { getRepoHrefForProvider } from '../utils/git';
 import { getIsReadOnlyWorkflows } from '../utils/repository';
 
 import { SyncRepository } from './SyncRepository';
@@ -16,7 +17,7 @@ interface Props {
   repository: Repository;
 }
 
-export function RepositoryCard({ repository }: Props) {
+export function RepositoryListItem({ repository }: Props) {
   const isReadOnlyRepo = getIsReadOnlyWorkflows(repository.spec?.workflows);
   const { metadata, spec, status } = repository;
   const name = metadata?.name ?? '';
@@ -27,24 +28,13 @@ export function RepositoryCard({ repository }: Props) {
     if (spec?.type === 'github') {
       const { url = '', branch } = spec.github ?? {};
       const branchUrl = branch ? `${url}/tree/${branch}` : url;
+      const href = getRepoHrefForProvider(spec) || branchUrl;
 
       meta.push(
-        <TextLink key="link" external href={branchUrl}>
-          {branchUrl}
+        <TextLink key="link" external href={href}>
+          {href.split('/').slice(3).join('/')}
         </TextLink>
       );
-
-      if (status?.webhook?.id) {
-        const webhookUrl = `${url}/settings/hooks/${status.webhook.id}`;
-        meta.push(
-          <Stack gap={1} direction="row" alignItems="center">
-            <TextLink key="webhook" href={webhookUrl}>
-              <Trans i18nKey="provisioning.repository-card.get-repository-meta.webhook">Webhook</Trans>
-            </TextLink>
-            <Icon name="check" className="text-success" />
-          </Stack>
-        );
-      }
     } else if (spec?.type === 'local') {
       meta.push(
         <Text variant="bodySmall" key="path">

public/app/features/provisioning/Shared/RepositoryList.tsx

@@ -4,7 +4,7 @@ import { t, Trans } from '@grafana/i18n';
 import { Alert, Box, EmptyState, FilterInput, Icon, Stack, TextLink } from '@grafana/ui';
 import { Repository } from 'app/api/clients/provisioning/v0alpha1';
 
-import { RepositoryCard } from '../Repository/RepositoryCard';
+import { RepositoryListItem } from '../Repository/RepositoryListItem';
 import { useResourceStats } from '../Wizard/hooks/useResourceStats';
 import { UPGRADE_URL } from '../constants';
 import { useIsProvisionedInstance } from '../hooks/useIsProvisionedInstance';
@@ -89,7 +89,7 @@ export function RepositoryList({ items }: Props) {
         )}
         <Stack direction={'column'} gap={2}>
           {filteredItems.length ? (
-            filteredItems.map((item) => <RepositoryCard key={item.metadata?.name} repository={item} />)
+            filteredItems.map((item) => <RepositoryListItem key={item.metadata?.name} repository={item} />)
           ) : (
             <EmptyState
               variant="not-found"

public/app/features/provisioning/components/Shared/PreviewBannerViewPR.tsx

@@ -107,9 +107,14 @@ export function PreviewBannerViewPR({ prParam, isNewPr, behindBranch, repoUrl, b
       {/* when repo type is not local, we show branch information */}
       {showBranchInfo(repoType, branchInfo) && (
         <Box marginTop={1}>
-          <Trans i18nKey="provisioned-resource-preview-banner.preview-banner.branch-text">branch: </Trans>
-          <TextLink href={getBranchUrl(repoBaseUrl!, targetBranch!, repoType)}>{targetBranch}</TextLink> {'\u2192'}{' '}
-          <TextLink href={getBranchUrl(repoBaseUrl!, configuredBranch!, repoType)}>{configuredBranch}</TextLink>
+          <Trans i18nKey="provisioned-resource-preview-banner.preview-banner.branch-text">branch:</Trans>{' '}
+          <TextLink href={getBranchUrl(repoBaseUrl!, targetBranch!, repoType)} external>
+            {targetBranch}
+          </TextLink>{' '}
+          {'\u2192'}{' '}
+          <TextLink href={getBranchUrl(repoBaseUrl!, configuredBranch!, repoType)} external>
+            {configuredBranch}
+          </TextLink>
         </Box>
       )}
     </Alert>

public/app/features/provisioning/hooks/usePullRequestParam.ts

@@ -9,9 +9,9 @@ export const usePullRequestParam = () => {
   const repoType = params.get('repo_type');
 
   return {
-    prURL: prParam ? textUtil.sanitizeUrl(prParam) : undefined,
-    newPrURL: newPrParam ? textUtil.sanitizeUrl(newPrParam) : undefined,
-    repoURL: repoUrl ? textUtil.sanitizeUrl(repoUrl) : undefined,
-    repoType: repoType ? textUtil.sanitizeUrl(repoType) : undefined,
+    prURL: prParam ? textUtil.sanitizeUrl(decodeURIComponent(prParam)) : undefined,
+    newPrURL: newPrParam ? textUtil.sanitizeUrl(decodeURIComponent(newPrParam)) : undefined,
+    repoURL: repoUrl ? textUtil.sanitizeUrl(decodeURIComponent(repoUrl)) : undefined,
+    repoType: repoType ? textUtil.sanitizeUrl(decodeURIComponent(repoType)) : undefined,
   };
 };

public/app/features/provisioning/utils/git.ts

@@ -27,41 +27,81 @@ export const getRepoHref = (github?: RepositorySpec['github']) => {
   return `${github.url}/tree/${github.branch}`;
 };
 
+// Remove leading and trailing slashes from a string.
+const stripSlashes = (s: string) => s.replace(/^\/+|\/+$/g, '');
+
+// Split a path into segments and URL-encode each segment.
+// Ensures the final URL remains valid for all providers (GitHub, GitLab, etc.).
+const splitAndEncode = (s: string) => stripSlashes(s).split('/').map(encodeURIComponent);
+
+type BuildRepoUrlParams = {
+  baseUrl?: string;
+  branch?: string | null;
+  providerSegments: string[];
+  path?: string | null;
+};
+
+const buildRepoUrl = ({ baseUrl, branch, providerSegments, path }: BuildRepoUrlParams) => {
+  if (!baseUrl) {
+    return undefined;
+  }
+
+  // Normalize base URL: trim whitespace + remove trailing slashes.
+  const cleanBase = stripSlashes(baseUrl.trim());
+  const cleanBranch = branch?.trim() || undefined;
+
+  // Start composing URL parts:
+  // base URL + provider-specific segments (e.g., "tree", "blob", etc.)
+  const parts = [cleanBase, ...providerSegments];
+
+  // Append the branch name if present.
+  if (cleanBranch) {
+    parts.push(cleanBranch);
+  }
+
+  // Append encoded path segments if provided.
+  // This ensures nested files like "src/utils/index.ts" produce safe URLs.
+  if (path) {
+    parts.push(...splitAndEncode(path.trim()));
+  }
+
+  return parts.join('/');
+};
+
 export const getRepoHrefForProvider = (spec?: RepositorySpec) => {
   if (!spec || !spec.type) {
     return undefined;
   }
 
   switch (spec.type) {
-    case 'github': {
-      const url = spec.github?.url;
-      const branch = spec.github?.branch;
-      if (!url) {
-        return undefined;
-      }
-      return branch ? `${url}/tree/${branch}` : url;
-    }
-
-    case 'gitlab': {
-      const url = spec.gitlab?.url;
-      const branch = spec.gitlab?.branch;
-      if (!url) {
-        return undefined;
-      }
-      return branch ? `${url}/-/tree/${branch}` : url;
-    }
-    case 'bitbucket': {
-      const url = spec.bitbucket?.url;
-      const branch = spec.bitbucket?.branch;
-      if (!url) {
-        return undefined;
-      }
-      return branch ? `${url}/src/${branch}` : url;
-    }
-    case 'git': {
-      // Return a generic URL for pure git repositories
-      return spec.git?.url;
-    }
+    case 'github':
+      return buildRepoUrl({
+        baseUrl: spec.github?.url,
+        branch: spec.github?.branch,
+        providerSegments: ['tree'],
+        path: spec.github?.path,
+      });
+    case 'gitlab':
+      return buildRepoUrl({
+        baseUrl: spec.gitlab?.url,
+        branch: spec.gitlab?.branch,
+        providerSegments: ['-', 'tree'],
+        path: spec.gitlab?.path,
+      });
+    case 'bitbucket':
+      return buildRepoUrl({
+        baseUrl: spec.bitbucket?.url,
+        branch: spec.bitbucket?.branch,
+        providerSegments: ['src'],
+        path: spec.bitbucket?.path,
+      });
+    case 'git':
+      return buildRepoUrl({
+        baseUrl: spec.git?.url,
+        branch: spec.git?.branch,
+        providerSegments: ['tree'],
+        path: spec.git?.path,
+      });
     default:
       return undefined;
   }

public/app/features/scopes/selector/ScopesSelectorService.test.ts

@@ -107,162 +107,9 @@ describe('ScopesSelectorService', () => {
     service = new ScopesSelectorService(apiClient, dashboardsService, store);
   });
 
-  describe('updateNode', () => {
-    it('should update node and fetch children when expanded', async () => {
-      await service.updateNode('', true, '');
-      expect(service.state.nodes['test-scope-node']).toEqual(mockNode);
-      expect(service.state.tree).toMatchObject({
-        children: { 'test-scope-node': { expanded: false, scopeNodeId: 'test-scope-node' } },
-        expanded: true,
-        query: '',
-        scopeNodeId: '',
-      });
-      expect(apiClient.fetchNodes).toHaveBeenCalledWith({ parent: '', query: '' });
-    });
-
-    it.skip('should update node query and fetch children when query changes', async () => {
-      await service.updateNode('', true, ''); // Expand first
-      // Simulate a change in the query
-      await service.updateNode('', true, 'new-qu');
-      await service.updateNode('', true, 'new-query');
-      expect(service.state.tree).toMatchObject({
-        children: {},
-        expanded: true,
-        query: 'new-query',
-        scopeNodeId: '',
-      });
-      expect(apiClient.fetchNodes).toHaveBeenCalledWith({ parent: '', query: 'new-query' });
-    });
-
-    it('should not fetch children when node is collapsed and query is unchanged', async () => {
-      // First expand the node
-      await service.updateNode('', true, '');
-      // Then collapse it
-      await service.updateNode('', false, '');
-      // Only the first expansion should trigger fetchNodes
-      expect(apiClient.fetchNodes).toHaveBeenCalledTimes(1);
-    });
-
-    it.skip('should clear query on first expansion but keep it when filtering within populated node', async () => {
-      const mockChildNode: ScopeNode = {
-        metadata: { name: 'child-node' },
-        spec: { linkId: 'child-scope', linkType: 'scope', parentName: '', nodeType: 'leaf', title: 'child-node' },
-      };
-
-      apiClient.fetchNodes.mockResolvedValue([mockChildNode]);
-
-      // Scenario 1: First expansion (no children yet) - clear query for unfiltered view
-      await service.updateNode('', true, 'search-query');
-      expect(apiClient.fetchNodes).toHaveBeenCalledWith({ parent: '', query: undefined });
-
-      // Parent query should be cleared and child nodes should have no query (first expansion)
-      expect(service.state.tree?.query).toBe('');
-      let childTreeNode = service.state.tree?.children?.['child-node'];
-      expect(childTreeNode?.query).toBe('');
-
-      // Scenario 2: Filtering within node that already has children
-      await service.updateNode('', true, 'new-search');
-      expect(apiClient.fetchNodes).toHaveBeenCalledWith({ parent: '', query: 'new-search' });
-
-      // Parent and child nodes should have the filter query (filtering within existing children)
-      expect(service.state.tree?.query).toBe('new-search');
-      childTreeNode = service.state.tree?.children?.['child-node'];
-      expect(childTreeNode?.query).toBe('new-search');
-
-      expect(apiClient.fetchNodes).toHaveBeenCalledTimes(2);
-    });
-
-    it.skip('should always reset query on any expansion', async () => {
-      const mockChildNode: ScopeNode = {
-        metadata: { name: 'child-node' },
-        spec: { linkId: 'child-scope', linkType: 'scope', parentName: '', nodeType: 'leaf', title: 'child-node' },
-      };
-
-      apiClient.fetchNodes.mockResolvedValue([mockChildNode]);
-
-      // First expansion with any query should reset parent query and not pass query to API
-      await service.updateNode('', true, 'some-search-query');
-
-      // Verify query is reset and API called without query for first expansion
-      expect(service.state.tree?.query).toBe('');
-      expect(apiClient.fetchNodes).toHaveBeenCalledWith({ parent: '', query: undefined });
-      expect(service.state.tree?.children?.['child-node']?.query).toBe('');
-    });
-
-    it.skip('should handle query reset correctly for nested levels beyond root', async () => {
-      // Set up mock nodes for multi-level hierarchy
-      const mockParentNode: ScopeNode = {
-        metadata: { name: 'parent-container' },
-        spec: { linkId: '', linkType: 'scope', parentName: '', nodeType: 'container', title: 'Parent Container' },
-      };
-
-      const mockChildNode: ScopeNode = {
-        metadata: { name: 'child-container' },
-        spec: {
-          linkId: '',
-          linkType: 'scope',
-          parentName: 'parent-container',
-          nodeType: 'container',
-          title: 'Child Container',
-        },
-      };
-
-      const mockGrandchildNode: ScopeNode = {
-        metadata: { name: 'grandchild-leaf' },
-        spec: {
-          linkId: 'leaf-scope',
-          linkType: 'scope',
-          parentName: 'child-container',
-          nodeType: 'leaf',
-          title: 'Grandchild Leaf',
-        },
-      };
-
-      // Mock different responses for different parent nodes
-      apiClient.fetchNodes.mockImplementation((options: { parent?: string; query?: string; limit?: number }) => {
-        if (options.parent === '') {
-          return Promise.resolve([mockParentNode]);
-        } else if (options.parent === 'parent-container') {
-          return Promise.resolve([mockChildNode]);
-        } else if (options.parent === 'child-container') {
-          return Promise.resolve([mockGrandchildNode]);
-        }
-        return Promise.resolve([]);
-      });
-
-      // Step 1: Expand root node with search query
-      await service.updateNode('', true, 'search-query');
-
-      // Root should have query reset, API called without query
-      expect(service.state.tree?.query).toBe('');
-      expect(apiClient.fetchNodes).toHaveBeenCalledWith({ parent: '', query: undefined });
-      expect(service.state.tree?.children?.['parent-container']?.query).toBe('');
-
-      // Step 2: Expand first-level child with search query
-      await service.updateNode('parent-container', true, 'open-search-query');
-
-      // First-level child should have query reset, API called without query
-      const parentContainer = service.state.tree?.children?.['parent-container'];
-      expect(parentContainer?.query).toBe('');
-      expect(apiClient.fetchNodes).toHaveBeenCalledWith({ parent: 'parent-container', query: undefined });
-      expect(parentContainer?.children?.['child-container']?.query).toBe('');
-
-      // Step 3: Now filter within the first-level child (second call to same node)
-      await service.updateNode('parent-container', true, 'filter-search');
-
-      // Now both parent and children should show the filter query since we're filtering within existing children
-      const newParentContainer = service.state.tree?.children?.['parent-container'];
-      expect(newParentContainer?.query).toBe('filter-search');
-      expect(apiClient.fetchNodes).toHaveBeenCalledWith({ parent: 'parent-container', query: 'filter-search' });
-      expect(newParentContainer?.children?.['child-container']?.query).toBe('filter-search');
-
-      expect(apiClient.fetchNodes).toHaveBeenCalledTimes(3);
-    });
-  });
-
   describe('selectScope and deselectScope', () => {
     beforeEach(async () => {
-      await service.updateNode('', true, '');
+      await service.filterNode('', '');
     });
 
     it('should select a scope', async () => {
@@ -311,7 +158,7 @@ describe('ScopesSelectorService', () => {
 
     it('should set parent node for recent scopes', async () => {
       // Load mock node
-      await service.updateNode('', true, '');
+      await service.filterNode('', '');
 
       await service.changeScopes(['test-scope'], 'test-scope-node');
       expect(service.state.appliedScopes).toEqual([{ scopeId: 'test-scope', parentNodeId: 'test-scope-node' }]);
@@ -363,7 +210,7 @@ describe('ScopesSelectorService', () => {
 
   describe('closeAndApply', () => {
     it('should close the selector and apply the selected scopes', async () => {
-      await service.updateNode('', true, '');
+      await service.filterNode('', '');
       await service.selectScope('test-scope-node');
       await service.closeAndApply();
       expect(service.state.opened).toBe(false);
@@ -373,6 +220,7 @@ describe('ScopesSelectorService', () => {
 
   describe('apply', () => {
     it('should apply the selected scopes without closing the selector', async () => {
+      await service.filterNode('', '');
       await service.open();
       await service.selectScope('test-scope-node');
       await service.apply();
@@ -391,7 +239,7 @@ describe('ScopesSelectorService', () => {
 
   describe('removeAllScopes', () => {
     it('should remove all selected and applied scopes', async () => {
-      await service.updateNode('', true, '');
+      await service.filterNode('', '');
       await service.selectScope('test-scope-node');
       await service.apply();
       await service.removeAllScopes();
@@ -399,7 +247,7 @@ describe('ScopesSelectorService', () => {
     });
 
     it('should clear navigation scope when removing all scopes', async () => {
-      await service.updateNode('', true, '');
+      await service.filterNode('', '');
       await service.selectScope('test-scope-node');
       await service.apply();
       await service.removeAllScopes();
@@ -429,7 +277,7 @@ describe('ScopesSelectorService', () => {
 
   describe('getRecentScopes', () => {
     it('should parse and filter scopes', async () => {
-      await service.updateNode('', true, '');
+      await service.filterNode('', '');
       await service.selectScope('test-scope-node');
       await service.apply();
       storeValue[RECENT_SCOPES_KEY] = JSON.stringify([[mockScope2], [mockScope]]);
@@ -439,7 +287,7 @@ describe('ScopesSelectorService', () => {
     });
 
     it('should work with old version', async () => {
-      await service.updateNode('', true, '');
+      await service.filterNode('', '');
       await service.selectScope('test-scope-node');
       await service.apply();
       storeValue[RECENT_SCOPES_KEY] = JSON.stringify([
@@ -615,9 +463,347 @@ describe('ScopesSelectorService', () => {
     });
   });
 
+  describe('toggleExpandedNode', () => {
+    const expandableNode: ScopeNode = {
+      metadata: { name: 'expandable-node' },
+      spec: {
+        linkId: '',
+        linkType: undefined,
+        parentName: '',
+        nodeType: 'container',
+        title: 'Expandable Node',
+      },
+    };
+
+    const childNode: ScopeNode = {
+      metadata: { name: 'child-node' },
+      spec: {
+        linkId: 'child-scope',
+        linkType: 'scope',
+        parentName: 'expandable-node',
+        nodeType: 'leaf',
+        title: 'Child Node',
+      },
+    };
+
+    const leafNode: ScopeNode = {
+      metadata: { name: 'leaf-node' },
+      spec: {
+        linkId: 'leaf-scope',
+        linkType: 'scope',
+        parentName: '',
+        nodeType: 'leaf',
+        title: 'Leaf Node',
+      },
+    };
+
+    beforeEach(async () => {
+      // Mock fetchNodes to return different nodes based on parent
+      apiClient.fetchNodes = jest
+        .fn()
+        .mockImplementation((options: { parent?: string; query?: string; limit?: number }) => {
+          if (options.parent === '') {
+            return [expandableNode, leafNode];
+          } else if (options.parent === 'expandable-node') {
+            return [childNode];
+          }
+          return [];
+        });
+
+      // Load root nodes
+      await service.filterNode('', '');
+    });
+
+    it('should expand a collapsed node and load its children', async () => {
+      // Node should start collapsed
+      expect(service.state.tree?.children?.['expandable-node']?.expanded).toBe(false);
+
+      // Expand the node
+      await service.toggleExpandedNode('expandable-node');
+
+      // Node should now be expanded
+      expect(service.state.tree?.children?.['expandable-node']?.expanded).toBe(true);
+      // Children should be loaded
+      expect(service.state.tree?.children?.['expandable-node']?.children).toBeDefined();
+      expect(service.state.tree?.children?.['expandable-node']?.children?.['child-node']).toBeDefined();
+    });
+
+    it('should collapse an expanded node', async () => {
+      // First expand the node
+      await service.toggleExpandedNode('expandable-node');
+      expect(service.state.tree?.children?.['expandable-node']?.expanded).toBe(true);
+
+      // Now collapse it
+      await service.toggleExpandedNode('expandable-node');
+      expect(service.state.tree?.children?.['expandable-node']?.expanded).toBe(false);
+    });
+
+    it('should reset query to empty string when toggling', async () => {
+      // First filter with a query
+      await service.filterNode('expandable-node', 'test-query');
+      expect(service.state.tree?.children?.['expandable-node']?.query).toBe('test-query');
+
+      // Toggle the node
+      await service.toggleExpandedNode('expandable-node');
+
+      // Query should be reset
+      expect(service.state.tree?.children?.['expandable-node']?.query).toBe('');
+    });
+
+    it('should throw error when node not found in tree', async () => {
+      await expect(service.toggleExpandedNode('non-existent-node')).rejects.toThrow(
+        'Node non-existent-node not found in tree'
+      );
+    });
+
+    it('should throw error when trying to toggle a non-expandable node', async () => {
+      await expect(service.toggleExpandedNode('leaf-node')).rejects.toThrow(
+        'Trying to expand node at id leaf-node that is not expandable'
+      );
+    });
+
+    it('should reload parent children when collapsing', async () => {
+      const fetchNodesSpy = jest.spyOn(apiClient, 'fetchNodes');
+
+      // Expand then collapse
+      await service.toggleExpandedNode('expandable-node');
+      fetchNodesSpy.mockClear();
+
+      await service.toggleExpandedNode('expandable-node');
+
+      // Should reload parent's (root) children
+      expect(fetchNodesSpy).toHaveBeenCalledWith({ parent: '', query: '' });
+    });
+
+    it('should reload parent children with parent query when collapsing', async () => {
+      // First filter the root with a query
+      await service.filterNode('', 'parent-query');
+
+      // Expand a node
+      await service.toggleExpandedNode('expandable-node');
+
+      const fetchNodesSpy = jest.spyOn(apiClient, 'fetchNodes');
+
+      // Collapse the node
+      await service.toggleExpandedNode('expandable-node');
+
+      // Should reload parent's children with parent's query
+      expect(fetchNodesSpy).toHaveBeenCalledWith({ parent: '', query: 'parent-query' });
+    });
+  });
+
+  describe('filterNode', () => {
+    const containerNode: ScopeNode = {
+      metadata: { name: 'container-node' },
+      spec: {
+        linkId: '',
+        linkType: undefined,
+        parentName: '',
+        nodeType: 'container',
+        title: 'Container Node',
+      },
+    };
+
+    const filteredChild: ScopeNode = {
+      metadata: { name: 'filtered-child' },
+      spec: {
+        linkId: 'filtered-scope',
+        linkType: 'scope',
+        parentName: 'container-node',
+        nodeType: 'leaf',
+        title: 'Filtered Child',
+      },
+    };
+
+    const leafNode: ScopeNode = {
+      metadata: { name: 'leaf-node-2' },
+      spec: {
+        linkId: 'leaf-scope-2',
+        linkType: 'scope',
+        parentName: '',
+        nodeType: 'leaf',
+        title: 'Leaf Node 2',
+      },
+    };
+
+    beforeEach(async () => {
+      // Mock fetchNodes to return different nodes based on query
+      apiClient.fetchNodes = jest
+        .fn()
+        .mockImplementation((options: { parent?: string; query?: string; limit?: number }) => {
+          if (options.parent === '' && !options.query) {
+            return [containerNode, leafNode];
+          } else if (options.parent === 'container-node' && options.query === 'test-filter') {
+            return [filteredChild];
+          } else if (options.parent === 'container-node' && !options.query) {
+            return [filteredChild];
+          }
+          return [];
+        });
+
+      // Load root nodes
+      await service.filterNode('', '');
+    });
+
+    it('should filter node with non-empty query', async () => {
+      await service.filterNode('container-node', 'test-filter');
+
+      // Node should be expanded
+      expect(service.state.tree?.children?.['container-node']?.expanded).toBe(true);
+      // Query should be set
+      expect(service.state.tree?.children?.['container-node']?.query).toBe('test-filter');
+    });
+
+    it('should load children with the query parameter', async () => {
+      const fetchNodesSpy = jest.spyOn(apiClient, 'fetchNodes');
+
+      await service.filterNode('container-node', 'my-query');
+
+      expect(fetchNodesSpy).toHaveBeenCalledWith({ parent: 'container-node', query: 'my-query' });
+    });
+
+    it('should set expanded to true when filtering', async () => {
+      // Node starts collapsed
+      expect(service.state.tree?.children?.['container-node']?.expanded).toBe(false);
+
+      await service.filterNode('container-node', 'test-filter');
+
+      // Should be expanded after filtering
+      expect(service.state.tree?.children?.['container-node']?.expanded).toBe(true);
+    });
+
+    it('should throw error when node not found', async () => {
+      await expect(service.filterNode('non-existent-node', 'query')).rejects.toThrow(
+        'Trying to filter node at path or id non-existent-node not found'
+      );
+    });
+
+    it('should throw error when trying to filter a non-expandable node', async () => {
+      await expect(service.filterNode('leaf-node-2', 'query')).rejects.toThrow(
+        'Trying to filter node at id leaf-node-2 that is not expandable'
+      );
+    });
+
+    it('should handle multiple calls with different queries', async () => {
+      // First filter
+      await service.filterNode('container-node', 'first-query');
+      expect(service.state.tree?.children?.['container-node']?.query).toBe('first-query');
+
+      // Second filter with different query
+      await service.filterNode('container-node', 'second-query');
+      expect(service.state.tree?.children?.['container-node']?.query).toBe('second-query');
+
+      // Third filter with empty query
+      await service.filterNode('container-node', '');
+      expect(service.state.tree?.children?.['container-node']?.query).toBe('');
+    });
+
+    it('should start profiler interaction', async () => {
+      const profiler = {
+        startInteraction: jest.fn(),
+        stopInteraction: jest.fn(),
+      };
+
+      // Create new service with profiler
+      const serviceWithProfiler = new ScopesSelectorService(apiClient, dashboardsService, store, profiler as never);
+
+      await serviceWithProfiler.filterNode('', '');
+
+      expect(profiler.startInteraction).toHaveBeenCalledWith('scopeNodeFilter');
+      expect(profiler.stopInteraction).toHaveBeenCalled();
+    });
+
+    it('should stop profiler even when error is thrown', async () => {
+      const profiler = {
+        startInteraction: jest.fn(),
+        stopInteraction: jest.fn(),
+      };
+
+      const serviceWithProfiler = new ScopesSelectorService(apiClient, dashboardsService, store, profiler as never);
+
+      // Load initial nodes
+      await serviceWithProfiler.filterNode('', '');
+
+      // Try to filter a non-existent node
+      await expect(serviceWithProfiler.filterNode('non-existent', 'query')).rejects.toThrow();
+
+      // Profiler should still be stopped
+      expect(profiler.stopInteraction).toHaveBeenCalled();
+    });
+  });
+
+  describe('interaction between toggleExpandedNode and filterNode', () => {
+    const expandableNode: ScopeNode = {
+      metadata: { name: 'interaction-node' },
+      spec: {
+        linkId: '',
+        linkType: undefined,
+        parentName: '',
+        nodeType: 'container',
+        title: 'Interaction Node',
+      },
+    };
+
+    const childNode: ScopeNode = {
+      metadata: { name: 'interaction-child' },
+      spec: {
+        linkId: 'child-scope',
+        linkType: 'scope',
+        parentName: 'interaction-node',
+        nodeType: 'leaf',
+        title: 'Child Node',
+      },
+    };
+
+    beforeEach(async () => {
+      apiClient.fetchNodes = jest
+        .fn()
+        .mockImplementation((options: { parent?: string; query?: string; limit?: number }) => {
+          if (options.parent === '') {
+            return [expandableNode];
+          } else if (options.parent === 'interaction-node') {
+            return [childNode];
+          }
+          return [];
+        });
+
+      await service.filterNode('', '');
+    });
+
+    it('should clear query when toggleExpandedNode is called after filterNode', async () => {
+      // Filter with a query
+      await service.filterNode('interaction-node', 'test-query');
+      expect(service.state.tree?.children?.['interaction-node']?.query).toBe('test-query');
+
+      // Toggle should clear the query
+      await service.toggleExpandedNode('interaction-node');
+      expect(service.state.tree?.children?.['interaction-node']?.query).toBe('');
+    });
+
+    it('should set query when filterNode is called after toggleExpandedNode', async () => {
+      // First toggle (expand)
+      await service.toggleExpandedNode('interaction-node');
+      expect(service.state.tree?.children?.['interaction-node']?.query).toBe('');
+
+      // Filter should set the query
+      await service.filterNode('interaction-node', 'new-query');
+      expect(service.state.tree?.children?.['interaction-node']?.query).toBe('new-query');
+    });
+
+    it('should maintain expanded state when filtering an already expanded node', async () => {
+      // Expand the node
+      await service.toggleExpandedNode('interaction-node');
+      expect(service.state.tree?.children?.['interaction-node']?.expanded).toBe(true);
+
+      // Filter should keep it expanded
+      await service.filterNode('interaction-node', 'query');
+      expect(service.state.tree?.children?.['interaction-node']?.expanded).toBe(true);
+    });
+  });
+
   describe('redirect on scope selection', () => {
     it('should redirect to the first scopeNavigation with /d/ URL when current URL is not a scopeNavigation', async () => {
-      const mockNavigations: ScopeNavigation[] = [
+      dashboardsService.state.scopeNavigations = [
         {
           spec: {
             scope: 'test-scope',
@@ -632,8 +818,6 @@ describe('ScopesSelectorService', () => {
           },
         },
       ];
-
-      dashboardsService.state.scopeNavigations = mockNavigations;
       (locationService.getLocation as jest.Mock).mockReturnValue({ pathname: '/some-other-page' });
 
       await service.changeScopes(['test-scope']);
@@ -642,7 +826,7 @@ describe('ScopesSelectorService', () => {
     });
 
     it('should NOT redirect when the first scopeNavigation does not contain /d/ (e.g., logs drilldown)', async () => {
-      const mockNavigations: ScopeNavigation[] = [
+      dashboardsService.state.scopeNavigations = [
         {
           spec: {
             scope: 'test-scope',
@@ -657,8 +841,6 @@ describe('ScopesSelectorService', () => {
           },
         },
       ];
-
-      dashboardsService.state.scopeNavigations = mockNavigations;
       (locationService.getLocation as jest.Mock).mockReturnValue({ pathname: '/some-other-page' });
 
       await service.changeScopes(['test-scope']);
@@ -667,7 +849,7 @@ describe('ScopesSelectorService', () => {
     });
 
     it('should NOT redirect when current URL matches a scopeNavigation', async () => {
-      const mockNavigations: ScopeNavigation[] = [
+      dashboardsService.state.scopeNavigations = [
         {
           spec: {
             scope: 'test-scope',
@@ -682,8 +864,6 @@ describe('ScopesSelectorService', () => {
           },
         },
       ];
-
-      dashboardsService.state.scopeNavigations = mockNavigations;
       (locationService.getLocation as jest.Mock).mockReturnValue({ pathname: '/d/dashboard1' });
 
       await service.changeScopes(['test-scope']);
@@ -701,7 +881,7 @@ describe('ScopesSelectorService', () => {
     });
 
     it('should NOT redirect when scopeNavigation does not have a url property', async () => {
-      const mockNavigations = [
+      dashboardsService.state.scopeNavigations = [
         {
           spec: {
             scope: 'test-scope',
@@ -716,8 +896,6 @@ describe('ScopesSelectorService', () => {
           },
         },
       ] as unknown as ScopeNavigation[];
-
-      dashboardsService.state.scopeNavigations = mockNavigations;
       (locationService.getLocation as jest.Mock).mockReturnValue({ pathname: '/some-other-page' });
 
       await service.changeScopes(['test-scope']);
@@ -726,7 +904,7 @@ describe('ScopesSelectorService', () => {
     });
 
     it('should handle multiple scopeNavigations and redirect to the first dashboard one', async () => {
-      const mockNavigations: ScopeNavigation[] = [
+      dashboardsService.state.scopeNavigations = [
         {
           spec: {
             scope: 'test-scope',
@@ -754,8 +932,6 @@ describe('ScopesSelectorService', () => {
           },
         },
       ];
-
-      dashboardsService.state.scopeNavigations = mockNavigations;
       (locationService.getLocation as jest.Mock).mockReturnValue({ pathname: '/some-other-page' });
 
       await service.changeScopes(['test-scope']);
@@ -790,7 +966,7 @@ describe('ScopesSelectorService', () => {
         });
 
       // First update the node to populate the service state
-      await service.updateNode('', true, '');
+      await service.filterNode('', '');
 
       // Then select the scope to set scopeNodeId in selectedScopes
       await service.selectScope('test-scope-node');
@@ -837,7 +1013,7 @@ describe('ScopesSelectorService', () => {
       (locationService.getLocation as jest.Mock).mockReturnValue({ pathname: '/some-other-page' });
 
       // First update the node to populate the service state
-      await service.updateNode('', true, '');
+      await service.filterNode('', '');
 
       // Then select the scope to set scopeNodeId in selectedScopes
       await service.selectScope('test-scope-node');
@@ -851,16 +1027,14 @@ describe('ScopesSelectorService', () => {
     });
 
     it('should fall back to scope navigation when scope node is undefined', async () => {
-      const mockNavigations: ScopeNavigation[] = [
+      // Don't add the node to the service state, so it will be undefined
+      dashboardsService.state.scopeNavigations = [
         {
           spec: { scope: 'test-scope', url: '/d/dashboard1' },
           status: { title: 'Dashboard 1', groups: [] },
           metadata: { name: 'dashboard1' },
         },
       ];
-
-      // Don't add the node to the service state, so it will be undefined
-      dashboardsService.state.scopeNavigations = mockNavigations;
       (locationService.getLocation as jest.Mock).mockReturnValue({ pathname: '/some-other-page' });
 
       await service.changeScopes(['test-scope']);

public/app/features/scopes/selector/ScopesSelectorService.ts

@@ -129,81 +129,38 @@ export class ScopesSelectorService extends ScopesServiceBase<ScopesSelectorServi
 
   // Resets query and toggles expanded state of a node
   public toggleExpandedNode = async (scopeNodeId: string) => {
-    const path = getPathOfNode(scopeNodeId, this.state.nodes);
-    const nodeToToggle = treeNodeAtPath(this.state.tree!, path);
-
-    if (!nodeToToggle) {
-      throw new Error(`Node ${scopeNodeId} not found in tree`);
-    }
-
-    if (nodeToToggle.scopeNodeId !== '' && !isNodeExpandable(this.state.nodes[nodeToToggle.scopeNodeId])) {
-      throw new Error(`Trying to expand node at id ${scopeNodeId} that is not expandable`);
-    }
-
-    const newTree = modifyTreeNodeAtPath(this.state.tree!, path, (treeNode) => {
-      treeNode.expanded = !nodeToToggle.expanded;
-      treeNode.query = '';
-    });
-
-    this.updateState({ tree: newTree });
-    // If we are collapsing, we need to make sure that all the parent's children are avilable
-    if (nodeToToggle.expanded === true) {
-      const parentPath = path.slice(0, -1);
-      const parentNode = treeNodeAtPath(this.state.tree!, parentPath);
-      if (parentNode) {
-        await this.loadNodeChildren(parentPath, parentNode, parentNode.query);
-      }
-    } else {
-      await this.loadNodeChildren(path, nodeToToggle);
-    }
-  };
-
-  public filterNode = async (scopeNodeId: string, query: string) => {
-    const path = getPathOfNode(scopeNodeId, this.state.nodes);
-    const nodeToFilter = treeNodeAtPath(this.state.tree!, path);
-
-    if (!nodeToFilter) {
-      throw new Error(`Trying to filter node at path or id ${scopeNodeId} not found`);
-    }
-
-    if (nodeToFilter.scopeNodeId !== '' && !isNodeExpandable(this.state.nodes[nodeToFilter.scopeNodeId])) {
-      throw new Error(`Trying to filter node at id ${scopeNodeId} that is not expandable`);
-    }
-
-    const newTree = modifyTreeNodeAtPath(this.state.tree!, path, (treeNode) => {
-      treeNode.expanded = true;
-      treeNode.query = query;
-    });
-    this.updateState({ tree: newTree });
-
-    await this.loadNodeChildren(path, nodeToFilter, query);
-  };
-
-  private expandOrFilterNode = async (scopeNodeId: string, query?: string) => {
-    this.interactionProfiler?.startInteraction('scopeNodeDiscovery');
-
-    const path = getPathOfNode(scopeNodeId, this.state.nodes);
-
-    const nodeToExpand = treeNodeAtPath(this.state.tree!, path);
+    this.interactionProfiler?.startInteraction('scopeToggleExpandedNode');
 
     try {
-      if (!nodeToExpand) {
+      const path = getPathOfNode(scopeNodeId, this.state.nodes);
+      const nodeToToggle = treeNodeAtPath(this.state.tree!, path);
+
+      if (!nodeToToggle) {
         throw new Error(`Node ${scopeNodeId} not found in tree`);
       }
 
-      if (nodeToExpand.scopeNodeId !== '' && !isNodeExpandable(this.state.nodes[nodeToExpand.scopeNodeId])) {
+      if (nodeToToggle.scopeNodeId !== '' && !isNodeExpandable(this.state.nodes[nodeToToggle.scopeNodeId])) {
         throw new Error(`Trying to expand node at id ${scopeNodeId} that is not expandable`);
       }
 
-      if (!nodeToExpand.expanded || nodeToExpand.query !== query) {
-        const newTree = modifyTreeNodeAtPath(this.state.tree!, path, (treeNode) => {
-          treeNode.expanded = true;
-          treeNode.query = query || '';
-        });
-        this.updateState({ tree: newTree });
+      const newTree = modifyTreeNodeAtPath(this.state.tree!, path, (treeNode) => {
+        treeNode.expanded = !nodeToToggle.expanded;
+        treeNode.query = '';
+      });
 
-        await this.loadNodeChildren(path, nodeToExpand, query);
+      this.updateState({ tree: newTree });
+      // If we are collapsing, we need to make sure that all the parent's children are available
+      if (nodeToToggle.expanded) {
+        const parentPath = path.slice(0, -1);
+        const parentNode = treeNodeAtPath(this.state.tree!, parentPath);
+        if (parentNode) {
+          await this.loadNodeChildren(parentPath, parentNode, parentNode.query);
+        }
+      } else {
+        await this.loadNodeChildren(path, nodeToToggle);
       }
+      // Catch and throw error so we can ensure the profiler is stopped
+      // todo: leverage component-level
     } catch (error) {
       throw error;
     } finally {
@@ -211,20 +168,34 @@ export class ScopesSelectorService extends ScopesServiceBase<ScopesSelectorServi
     }
   };
 
-  private collapseNode = async (scopeNodeId: string) => {
-    const path = getPathOfNode(scopeNodeId, this.state.nodes);
+  public filterNode = async (scopeNodeId: string, query: string) => {
+    this.interactionProfiler?.startInteraction('scopeNodeFilter');
 
-    const nodeToCollapse = treeNodeAtPath(this.state.tree!, path);
+    try {
+      const path = getPathOfNode(scopeNodeId, this.state.nodes);
+      const nodeToFilter = treeNodeAtPath(this.state.tree!, path);
 
-    if (!nodeToCollapse) {
-      throw new Error(`Trying to collapse node at path or id ${scopeNodeId} not found`);
+      if (!nodeToFilter) {
+        throw new Error(`Trying to filter node at path or id ${scopeNodeId} not found`);
+      }
+
+      if (nodeToFilter.scopeNodeId !== '' && !isNodeExpandable(this.state.nodes[nodeToFilter.scopeNodeId])) {
+        throw new Error(`Trying to filter node at id ${scopeNodeId} that is not expandable`);
+      }
+
+      const newTree = modifyTreeNodeAtPath(this.state.tree!, path, (treeNode) => {
+        treeNode.expanded = true;
+        treeNode.query = query;
+      });
+      this.updateState({ tree: newTree });
+
+      await this.loadNodeChildren(path, nodeToFilter, query);
+      // Catch and throw error so we can ensure the profiler is stopped
+    } catch (error) {
+      throw error;
+    } finally {
+      this.interactionProfiler?.stopInteraction();
     }
-
-    const newTree = modifyTreeNodeAtPath(this.state.tree!, path, (treeNode) => {
-      treeNode.expanded = false;
-      treeNode.query = '';
-    });
-    this.updateState({ tree: newTree });
   };
 
   private loadNodeChildren = async (path: string[], treeNode: TreeNode, query?: string) => {
@@ -332,15 +303,6 @@ export class ScopesSelectorService extends ScopesServiceBase<ScopesSelectorServi
     this.updateState({ selectedScopes: newSelectedScopes });
   };
 
-  // TODO: Replace all usage of this function with expandNode and filterNode.
-  // @deprecated
-  public updateNode = async (scopeNodeId: string, expanded: boolean, query: string) => {
-    if (expanded) {
-      return this.expandOrFilterNode(scopeNodeId, query);
-    }
-    return this.collapseNode(scopeNodeId);
-  };
-
   changeScopes = (scopeNames: string[], parentNodeId?: string, scopeNodeId?: string, redirectOnApply?: boolean) => {
     return this.applyScopes(
       scopeNames.map((id, index) => ({
@@ -494,7 +456,7 @@ export class ScopesSelectorService extends ScopesServiceBase<ScopesSelectorServi
    */
   public open = async () => {
     if (!this.state.tree?.children || Object.keys(this.state.tree?.children).length === 0) {
-      await this.expandOrFilterNode('');
+      await this.filterNode('', '');
     }
 
     // First close all nodes

public/app/plugins/panel/barchart/module.tsx

@@ -18,7 +18,7 @@ import { BarChartPanel } from './BarChartPanel';
 import { TickSpacingEditor } from './TickSpacingEditor';
 import { changeToBarChartPanelMigrationHandler } from './migrations';
 import { FieldConfig, Options, defaultFieldConfig, defaultOptions } from './panelcfg.gen';
-import { BarChartSuggestionsSupplier } from './suggestions';
+import { barchartSuggestionsSupplier } from './suggestions';
 
 export const plugin = new PanelPlugin<Options, FieldConfig>(BarChartPanel)
   .setPanelChangeHandler(changeToBarChartPanelMigrationHandler)
@@ -257,7 +257,7 @@ export const plugin = new PanelPlugin<Options, FieldConfig>(BarChartPanel)
     commonOptionsBuilder.addLegendOptions(builder);
     commonOptionsBuilder.addTextSizeOptions(builder, { withValue: true });
   })
-  .setSuggestionsSupplier(new BarChartSuggestionsSupplier());
+  .setSuggestionsSupplier(barchartSuggestionsSupplier);
 
 function countNumberFields(data?: DataFrame[]): number {
   let count = 0;

public/app/plugins/panel/barchart/suggestions.ts

@@ -1,99 +1,112 @@
-import { VisualizationSuggestionsBuilder, VizOrientation } from '@grafana/data';
+import { defaultsDeep } from 'lodash';
+
+import { FieldType, VisualizationSuggestion, VisualizationSuggestionsSupplierFn, VizOrientation } from '@grafana/data';
+import { t } from '@grafana/i18n';
 import { LegendDisplayMode, StackingMode, VisibilityMode } from '@grafana/schema';
-import { SuggestionName } from 'app/types/suggestions';
 
 import { FieldConfig, Options } from './panelcfg.gen';
 
-export class BarChartSuggestionsSupplier {
-  getListWithDefaults(builder: VisualizationSuggestionsBuilder) {
-    return builder.getListAppender<Options, FieldConfig>({
-      name: SuggestionName.BarChart,
-      pluginId: 'barchart',
-      options: {
-        showValue: VisibilityMode.Never,
-        legend: {
-          calcs: [],
-          displayMode: LegendDisplayMode.List,
-          showLegend: true,
-          placement: 'right',
-        },
+const withDefaults = (suggestion: VisualizationSuggestion<Options, FieldConfig>) =>
+  defaultsDeep(suggestion, {
+    options: {
+      showValue: VisibilityMode.Never,
+      legend: {
+        calcs: [],
+        displayMode: LegendDisplayMode.List,
+        showLegend: true,
+        placement: 'right',
       },
-      fieldConfig: {
-        defaults: {
-          unit: 'short',
-          custom: {},
-        },
-        overrides: [],
+    },
+    fieldConfig: {
+      defaults: {
+        unit: 'short',
+        custom: {},
       },
-      cardOptions: {
-        previewModifier: (s) => {
-          s.options!.barWidth = 0.8;
-        },
+      overrides: [],
+    },
+    cardOptions: {
+      previewModifier: (s) => {
+        s.options!.barWidth = 0.8;
+        s.fieldConfig!.defaults!.custom!.hideFrom = { tooltip: false, legend: true, viz: false }; // hide legend in preview
       },
-    });
+    },
+  } satisfies VisualizationSuggestion<Options, FieldConfig>);
+
+export const barchartSuggestionsSupplier: VisualizationSuggestionsSupplierFn<Options, FieldConfig> = (dataSummary) => {
+  if (dataSummary.frameCount !== 1) {
+    return;
   }
 
-  getSuggestionsForData(builder: VisualizationSuggestionsBuilder) {
-    const list = this.getListWithDefaults(builder);
-    const { dataSummary } = builder;
+  if (!dataSummary.hasFieldType(FieldType.number) || !dataSummary.hasFieldType(FieldType.string)) {
+    return;
+  }
 
-    if (dataSummary.frameCount !== 1) {
-      return;
-    }
+  // if you have this many rows barchart might not be a good fit
+  if (dataSummary.rowCountTotal > 50) {
+    return;
+  }
 
-    if (!dataSummary.hasNumberField || !dataSummary.hasStringField) {
-      return;
-    }
+  const result: Array<VisualizationSuggestion<Options, FieldConfig>> = [
+    {
+      name: t('barchart.suggestions.vertical', 'Bar chart'),
+    },
+  ];
 
-    // if you have this many rows barchart might not be a good fit
-    if (dataSummary.rowCountTotal > 50) {
-      return;
-    }
-
-    // Vertical bars
-    list.append({
-      name: SuggestionName.BarChart,
-    });
-
-    if (dataSummary.numberFieldCount > 1) {
-      list.append({
-        name: SuggestionName.BarChartStacked,
+  if (dataSummary.fieldCountByType(FieldType.number) > 1) {
+    result.push(
+      {
+        name: t('barchart.suggestions.vert-stacked', 'Bar chart - stacked'),
         options: {
           stacking: StackingMode.Normal,
         },
-      });
-      list.append({
-        name: SuggestionName.BarChartStackedPercent,
+      },
+      {
+        name: t('barchart.suggestions.vert-stacked-percent', 'Bar chart - stacked by percentage'),
         options: {
           stacking: StackingMode.Percent,
         },
-      });
-    }
-
-    // horizontal bars
-    list.append({
-      name: SuggestionName.BarChartHorizontal,
-      options: {
-        orientation: VizOrientation.Horizontal,
-      },
-    });
-
-    if (dataSummary.numberFieldCount > 1) {
-      list.append({
-        name: SuggestionName.BarChartHorizontalStacked,
-        options: {
-          stacking: StackingMode.Normal,
-          orientation: VizOrientation.Horizontal,
+        fieldConfig: {
+          overrides: [],
+          defaults: {
+            unit: 'percentunit',
+          },
         },
-      });
+      }
+    );
+  }
 
-      list.append({
-        name: SuggestionName.BarChartHorizontalStackedPercent,
+  // horizontal bars
+  result.push({
+    name: t('barchart.suggestions.horizontal', 'Horizontal bar chart'),
+    options: {
+      orientation: VizOrientation.Horizontal,
+    },
+  });
+
+  if (dataSummary.fieldCountByType(FieldType.number) > 1) {
+    result.push(
+      {
+        name: t('barchart.suggestions.hz-stacked', 'Horizontal bar chart - stacked'),
+        options: {
+          orientation: VizOrientation.Horizontal,
+          stacking: StackingMode.Normal,
+        },
+      },
+      {
+        name: t('barchart.suggestions.hz-stacked-percent', 'Horizontal bar chart - stacked by percentage'),
         options: {
           orientation: VizOrientation.Horizontal,
           stacking: StackingMode.Percent,
         },
-      });
-    }
+        fieldConfig: {
+          overrides: [],
+          defaults: {
+            unit: 'percentunit',
+          },
+        },
+      }
+    );
   }
-}
+
+  return result.map(withDefaults);
+};

public/app/plugins/panel/bargauge/module.tsx

@@ -8,7 +8,7 @@ import { addOrientationOption, addStandardDataReduceOptions } from '../stat/comm
 import { barGaugePanelMigrationHandler } from './BarGaugeMigrations';
 import { BarGaugePanel } from './BarGaugePanel';
 import { Options, defaultOptions } from './panelcfg.gen';
-import { BarGaugeSuggestionsSupplier } from './suggestions';
+import { barGaugeSugggestionsSupplier } from './suggestions';
 
 export const plugin = new PanelPlugin<Options>(BarGaugePanel)
   .useFieldConfig()
@@ -151,4 +151,4 @@ export const plugin = new PanelPlugin<Options>(BarGaugePanel)
   })
   .setPanelChangeHandler(sharedSingleStatPanelChangedHandler)
   .setMigrationHandler(barGaugePanelMigrationHandler)
-  .setSuggestionsSupplier(new BarGaugeSuggestionsSupplier());
+  .setSuggestionsSupplier(barGaugeSugggestionsSupplier);

public/app/plugins/panel/bargauge/suggestions.ts

@@ -1,115 +1,60 @@
-import { FieldColorModeId, VisualizationSuggestionsBuilder, VizOrientation } from '@grafana/data';
+import { defaultsDeep } from 'lodash';
+
+import {
+  FieldColorModeId,
+  FieldType,
+  VisualizationSuggestion,
+  VisualizationSuggestionsSupplierFn,
+  VizOrientation,
+} from '@grafana/data';
+import { t } from '@grafana/i18n';
 import { BarGaugeDisplayMode } from '@grafana/ui';
-import { SuggestionName } from 'app/types/suggestions';
+import { defaultNumericVizOptions } from 'app/features/panel/suggestions/utils';
 
 import { Options } from './panelcfg.gen';
 
-export class BarGaugeSuggestionsSupplier {
-  getSuggestionsForData(builder: VisualizationSuggestionsBuilder) {
-    const { dataSummary } = builder;
-
-    if (!dataSummary.hasData || !dataSummary.hasNumberField) {
-      return;
-    }
-
-    const list = builder.getListAppender<Options, {}>({
-      name: '',
-      pluginId: 'bargauge',
-      options: {},
-      fieldConfig: {
-        defaults: {
-          custom: {},
+const withDefaults = (suggestion: VisualizationSuggestion<Options>): VisualizationSuggestion<Options> =>
+  defaultsDeep(suggestion, {
+    options: {
+      displayMode: BarGaugeDisplayMode.Basic,
+      orientation: VizOrientation.Horizontal,
+    },
+    fieldConfig: {
+      defaults: {
+        color: {
+          mode: FieldColorModeId.ContinuousGrYlRd,
         },
-        overrides: [],
       },
-    });
+      overrides: [],
+    },
+  });
 
-    // This is probably not a good option for many numeric fields
-    if (dataSummary.numberFieldCount > 50) {
-      return;
-    }
+const BAR_LIMIT = 30;
 
-    // To use show individual row values we also need a string field to give each value a name
-    if (dataSummary.hasStringField && dataSummary.frameCount === 1 && dataSummary.rowCountTotal < 30) {
-      list.append({
-        name: SuggestionName.BarGaugeBasic,
-        options: {
-          reduceOptions: {
-            values: true,
-            calcs: [],
-          },
-          displayMode: BarGaugeDisplayMode.Basic,
-          orientation: VizOrientation.Horizontal,
-        },
-        fieldConfig: {
-          defaults: {
-            color: {
-              mode: FieldColorModeId.ContinuousGrYlRd,
-            },
-          },
-          overrides: [],
-        },
-      });
-
-      list.append({
-        name: SuggestionName.BarGaugeLCD,
-        options: {
-          reduceOptions: {
-            values: true,
-            calcs: [],
-          },
-          displayMode: BarGaugeDisplayMode.Lcd,
-          orientation: VizOrientation.Horizontal,
-        },
-        fieldConfig: {
-          defaults: {
-            color: {
-              mode: FieldColorModeId.ContinuousGrYlRd,
-            },
-          },
-          overrides: [],
-        },
-      });
-    } else {
-      list.append({
-        name: SuggestionName.BarGaugeBasic,
-        options: {
-          displayMode: BarGaugeDisplayMode.Basic,
-          orientation: VizOrientation.Horizontal,
-          reduceOptions: {
-            values: false,
-            calcs: ['lastNotNull'],
-          },
-        },
-        fieldConfig: {
-          defaults: {
-            color: {
-              mode: FieldColorModeId.ContinuousGrYlRd,
-            },
-          },
-          overrides: [],
-        },
-      });
-
-      list.append({
-        name: SuggestionName.BarGaugeLCD,
-        options: {
-          displayMode: BarGaugeDisplayMode.Lcd,
-          orientation: VizOrientation.Horizontal,
-          reduceOptions: {
-            values: false,
-            calcs: ['lastNotNull'],
-          },
-        },
-        fieldConfig: {
-          defaults: {
-            color: {
-              mode: FieldColorModeId.ContinuousGrYlRd,
-            },
-          },
-          overrides: [],
-        },
-      });
-    }
+export const barGaugeSugggestionsSupplier: VisualizationSuggestionsSupplierFn<Options> = (dataSummary) => {
+  if (!dataSummary.hasData || !dataSummary.hasFieldType(FieldType.number)) {
+    return;
   }
-}
+
+  // This is probably not a good option for many numeric fields
+  if (dataSummary.fieldCountByType(FieldType.number) > BAR_LIMIT) {
+    return;
+  }
+
+  const suggestions: Array<VisualizationSuggestion<Options>> = [
+    { name: t('bargauge.suggestions.basic', 'Bar gauge') },
+    {
+      name: t('bargauge.suggestions.lcd', 'Bar gauge - LCD'),
+      options: {
+        displayMode: BarGaugeDisplayMode.Lcd,
+      },
+    },
+  ];
+
+  const shouldUseRawValues =
+    dataSummary.hasFieldType(FieldType.string) &&
+    dataSummary.frameCount === 1 &&
+    dataSummary.rowCountTotal <= BAR_LIMIT;
+
+  return suggestions.map((s) => defaultNumericVizOptions(withDefaults(s), dataSummary, shouldUseRawValues));
+};

public/app/plugins/panel/candlestick/module.tsx

@@ -8,7 +8,7 @@ import { defaultGraphConfig, getGraphFieldConfig } from '../timeseries/config';
 
 import { CandlestickPanel } from './CandlestickPanel';
 import { CandlestickData, getCandlestickFieldsInfo, FieldPickerInfo, prepareCandlestickFields } from './fields';
-import { CandlestickSuggestionsSupplier } from './suggestions';
+import { candlestickSuggestionSupplier } from './suggestions';
 import { defaultCandlestickColors, defaultOptions, Options, VizDisplayMode, ColorStrategy, CandleStyle } from './types';
 
 const numericFieldFilter = (f: Field) => f.type === FieldType.number;
@@ -147,4 +147,4 @@ export const plugin = new PanelPlugin<Options, GraphFieldConfig>(CandlestickPane
     commonOptionsBuilder.addLegendOptions(builder);
   })
   .setDataSupport({ annotations: true, alertStates: true })
-  .setSuggestionsSupplier(new CandlestickSuggestionsSupplier());
+  .setSuggestionsSupplier(candlestickSuggestionSupplier);

public/app/plugins/panel/candlestick/suggestions.ts

@@ -1,54 +1,29 @@
-import { VisualizationSuggestionsBuilder, VisualizationSuggestionScore } from '@grafana/data';
+import { FieldType, VisualizationSuggestionScore, VisualizationSuggestionsSupplierFn } from '@grafana/data';
 import { config } from '@grafana/runtime';
-import { SuggestionName } from 'app/types/suggestions';
 
 import { prepareCandlestickFields } from './fields';
 import { defaultOptions, Options } from './types';
 
-export class CandlestickSuggestionsSupplier {
-  getSuggestionsForData(builder: VisualizationSuggestionsBuilder) {
-    const { dataSummary } = builder;
-
-    if (
-      !builder.data?.series ||
-      !dataSummary.hasData ||
-      dataSummary.timeFieldCount < 1 ||
-      dataSummary.numberFieldCount < 2 ||
-      dataSummary.numberFieldCount > 10
-    ) {
-      return;
-    }
-
-    const info = prepareCandlestickFields(builder.data.series, defaultOptions, config.theme2);
-    if (!info) {
-      return;
-    }
-
-    // Regular timeseries
-    if (info.open === info.high && info.open === info.low) {
-      return;
-    }
-
-    const list = builder.getListAppender<Options, {}>({
-      name: '',
-      pluginId: 'candlestick',
-      options: {},
-      fieldConfig: {
-        defaults: {
-          custom: {},
-        },
-        overrides: [],
-      },
-    });
-
-    list.append({
-      name: SuggestionName.Candlestick,
-      options: defaultOptions,
-      fieldConfig: {
-        defaults: {},
-        overrides: [],
-      },
-      score: info.autoOpenClose ? VisualizationSuggestionScore.Good : VisualizationSuggestionScore.Best,
-    });
+export const candlestickSuggestionSupplier: VisualizationSuggestionsSupplierFn<Options> = (dataSummary) => {
+  if (
+    !dataSummary.rawFrames ||
+    !dataSummary.hasData ||
+    dataSummary.fieldCountByType(FieldType.time) < 1 ||
+    dataSummary.fieldCountByType(FieldType.number) < 2 ||
+    dataSummary.fieldCountByType(FieldType.number) > 10
+  ) {
+    return;
   }
-}
+
+  const info = prepareCandlestickFields(dataSummary.rawFrames, defaultOptions, config.theme2);
+  if (!info) {
+    return;
+  }
+
+  // Regular timeseries
+  if (info.open === info.high && info.open === info.low) {
+    return;
+  }
+
+  return [{ score: info.autoOpenClose ? VisualizationSuggestionScore.Good : VisualizationSuggestionScore.Best }];
+};

public/app/plugins/panel/flamegraph/FlameGraphPanel.tsx

@@ -2,6 +2,8 @@ import { CoreApp, PanelProps } from '@grafana/data';
 import { FlameGraph, checkFields, getMessageCheckFieldsResult } from '@grafana/flamegraph';
 import { PanelDataErrorView, reportInteraction, config } from '@grafana/runtime';
 
+import { Options } from './types';
+
 function interaction(name: string, context: Record<string, string | number> = {}) {
   reportInteraction(`grafana_flamegraph_${name}`, {
     app: CoreApp.Unknown,
@@ -10,7 +12,7 @@ function interaction(name: string, context: Record<string, string | number> = {}
   });
 }
 
-export const FlameGraphPanel = (props: PanelProps) => {
+export const FlameGraphPanel = (props: PanelProps<Options>) => {
   const wrongFields = checkFields(props.data.series[0]);
   if (wrongFields) {
     return (

public/app/plugins/panel/flamegraph/module.tsx

@@ -1,12 +1,29 @@
 import { FieldConfigProperty, PanelPlugin } from '@grafana/data';
+import { checkFields } from '@grafana/flamegraph';
 
 import { FlameGraphPanel } from './FlameGraphPanel';
-import { FlameGraphSuggestionsSupplier } from './suggestions';
+import { Options } from './types';
 
 const flamegraphConfigOptions = [FieldConfigProperty.Unit, FieldConfigProperty.Decimals];
 
-export const plugin = new PanelPlugin(FlameGraphPanel)
-  .setSuggestionsSupplier(new FlameGraphSuggestionsSupplier())
+export const plugin = new PanelPlugin<Options>(FlameGraphPanel)
+  // check that the first frame of the data has the required fields for a flamegraph
+  .setSuggestionsSupplier((ds) => {
+    if (!ds.rawFrames?.some((frame) => checkFields(frame) === undefined)) {
+      return;
+    }
+
+    return [
+      {
+        cardOptions: {
+          previewModifier: (s) => {
+            s.options = s.options || {};
+            s.options.showFlameGraphOnly = true;
+          },
+        },
+      },
+    ];
+  })
   .useFieldConfig({
     disableStandardOptions: Object.values(FieldConfigProperty).filter((v) => !flamegraphConfigOptions.includes(v)),
   });

public/app/plugins/panel/flamegraph/suggestions.ts

@@ -1,31 +0,0 @@
-import { VisualizationSuggestionsBuilder } from '@grafana/data';
-import { checkFields } from '@grafana/flamegraph';
-import { SuggestionName } from 'app/types/suggestions';
-
-export class FlameGraphSuggestionsSupplier {
-  getListWithDefaults(builder: VisualizationSuggestionsBuilder) {
-    return builder.getListAppender<{}, {}>({
-      name: SuggestionName.FlameGraph,
-      pluginId: 'flamegraph',
-    });
-  }
-
-  getSuggestionsForData(builder: VisualizationSuggestionsBuilder) {
-    if (!builder.data) {
-      return;
-    }
-
-    const dataFrame = builder.data.series[0];
-    if (!dataFrame) {
-      return;
-    }
-    const wrongFields = checkFields(dataFrame);
-    if (wrongFields) {
-      return;
-    }
-
-    this.getListWithDefaults(builder).append({
-      name: SuggestionName.FlameGraph,
-    });
-  }
-}

public/app/plugins/panel/flamegraph/types.ts

@@ -0,0 +1,3 @@
+export interface Options {
+  showFlameGraphOnly?: boolean;
+}

public/app/plugins/panel/gauge/module.tsx

@@ -8,7 +8,7 @@ import { addOrientationOption, addStandardDataReduceOptions } from '../stat/comm
 import { gaugePanelMigrationHandler, gaugePanelChangedHandler } from './GaugeMigrations';
 import { GaugePanel } from './GaugePanel';
 import { Options, defaultOptions } from './panelcfg.gen';
-import { GaugeSuggestionsSupplier } from './suggestions';
+import { gaugeSuggestionsSupplier } from './suggestions';
 
 export const plugin = new PanelPlugin<Options>(GaugePanel)
   .useFieldConfig({
@@ -88,5 +88,5 @@ export const plugin = new PanelPlugin<Options>(GaugePanel)
     commonOptionsBuilder.addTextSizeOptions(builder, { withTitle: true, withValue: true });
   })
   .setPanelChangeHandler(gaugePanelChangedHandler)
-  .setSuggestionsSupplier(new GaugeSuggestionsSupplier())
+  .setSuggestionsSupplier(gaugeSuggestionsSupplier)
   .setMigrationHandler(gaugePanelMigrationHandler);

public/app/plugins/panel/gauge/suggestions.ts

@@ -1,89 +1,63 @@
-import { ThresholdsMode, VisualizationSuggestionsBuilder } from '@grafana/data';
-import { GraphFieldConfig } from '@grafana/ui';
-import { SuggestionName } from 'app/types/suggestions';
+import { defaultsDeep } from 'lodash';
+
+import { ThresholdsMode, FieldType, VisualizationSuggestion, VisualizationSuggestionsSupplierFn } from '@grafana/data';
+import { t } from '@grafana/i18n';
+import { defaultNumericVizOptions } from 'app/features/panel/suggestions/utils';
 
 import { Options } from './panelcfg.gen';
 
-export class GaugeSuggestionsSupplier {
-  getSuggestionsForData(builder: VisualizationSuggestionsBuilder) {
-    const { dataSummary } = builder;
-
-    if (!dataSummary.hasData || !dataSummary.hasNumberField) {
-      return;
-    }
-
-    // for many fields / series this is probably not a good fit
-    if (dataSummary.numberFieldCount >= 50) {
-      return;
-    }
-
-    const list = builder.getListAppender<Options, GraphFieldConfig>({
-      name: SuggestionName.Gauge,
-      pluginId: 'gauge',
-      options: {},
-      fieldConfig: {
-        defaults: {
-          thresholds: {
-            steps: [
-              { value: -Infinity, color: 'green' },
-              { value: 70, color: 'orange' },
-              { value: 85, color: 'red' },
-            ],
-            mode: ThresholdsMode.Percentage,
-          },
-          custom: {},
+const withDefaults = (suggestion: VisualizationSuggestion<Options>): VisualizationSuggestion<Options> =>
+  defaultsDeep(suggestion, {
+    fieldConfig: {
+      defaults: {
+        thresholds: {
+          steps: [
+            { value: -Infinity, color: 'green' },
+            { value: 70, color: 'orange' },
+            { value: 85, color: 'red' },
+          ],
+          mode: ThresholdsMode.Percentage,
         },
-        overrides: [],
+        custom: {},
       },
-      cardOptions: {
-        previewModifier: (s) => {
-          if (s.options?.reduceOptions?.values) {
-            s.options.reduceOptions.limit = 2;
-          }
-        },
+      overrides: [],
+    },
+    cardOptions: {
+      previewModifier: (s) => {
+        if (s.options?.reduceOptions?.values) {
+          s.options.reduceOptions.limit = 2;
+        }
       },
-    });
+    },
+  } satisfies VisualizationSuggestion<Options>);
 
-    if (dataSummary.hasStringField && dataSummary.frameCount === 1 && dataSummary.rowCountTotal < 10) {
-      list.append({
-        name: SuggestionName.Gauge,
-        options: {
-          reduceOptions: {
-            values: true,
-            calcs: [],
-          },
-        },
-      });
-      list.append({
-        name: SuggestionName.GaugeNoThresholds,
-        options: {
-          reduceOptions: {
-            values: true,
-            calcs: [],
-          },
-          showThresholdMarkers: false,
-        },
-      });
-    } else {
-      list.append({
-        name: SuggestionName.Gauge,
-        options: {
-          reduceOptions: {
-            values: false,
-            calcs: ['lastNotNull'],
-          },
-        },
-      });
-      list.append({
-        name: SuggestionName.GaugeNoThresholds,
-        options: {
-          reduceOptions: {
-            values: false,
-            calcs: ['lastNotNull'],
-          },
-          showThresholdMarkers: false,
-        },
-      });
-    }
+const GAUGE_LIMIT = 10;
+
+export const gaugeSuggestionsSupplier: VisualizationSuggestionsSupplierFn<Options> = (dataSummary) => {
+  if (!dataSummary.hasData || !dataSummary.hasFieldType(FieldType.number)) {
+    return;
   }
-}
+
+  // for many fields / series this is probably not a good fit
+  if (dataSummary.fieldCountByType(FieldType.number) > GAUGE_LIMIT) {
+    return;
+  }
+
+  const suggestions: Array<VisualizationSuggestion<Options>> = [
+    { name: t('gauge.suggestions.arc', 'Gauge') },
+    {
+      name: t('gauge.suggestions.no-thresholds', 'Gauge - no thresholds'),
+      options: {
+        showThresholdMarkers: false,
+      },
+    },
+  ];
+
+  // sometimes, we want to de-aggregate the data for the gauge suggestion
+  const shouldUseRawValues =
+    dataSummary.hasFieldType(FieldType.string) &&
+    dataSummary.frameCount === 1 &&
+    dataSummary.rowCountTotal <= GAUGE_LIMIT;
+
+  return suggestions.map((s) => defaultNumericVizOptions(withDefaults(s), dataSummary, shouldUseRawValues));
+};

public/app/plugins/panel/geomap/module.tsx

@@ -8,6 +8,7 @@ import { LayersEditor } from './editor/LayersEditor';
 import { MapViewEditor } from './editor/MapViewEditor';
 import { getLayerEditor } from './editor/layerEditor';
 import { mapPanelChangedHandler, mapMigrationHandler } from './migrations';
+import { geomapSuggestionsSupplier } from './suggestions';
 import { defaultMapViewConfig, Options, TooltipMode, GeomapInstanceState } from './types';
 
 export const plugin = new PanelPlugin<Options>(GeomapPanel)
@@ -171,4 +172,5 @@ export const plugin = new PanelPlugin<Options>(GeomapPanel)
           ],
         },
       });
-  });
+  })
+  .setSuggestionsSupplier(geomapSuggestionsSupplier);

public/app/plugins/panel/geomap/suggestions.ts

@@ -0,0 +1,46 @@
+import { VisualizationSuggestionScore, VisualizationSuggestionsSupplierFn } from '@grafana/data';
+import { GraphFieldConfig } from '@grafana/ui';
+import { getGeometryField, getDefaultLocationMatchers } from 'app/features/geo/utils/location';
+
+import { Options } from './panelcfg.gen';
+
+export const geomapSuggestionsSupplier: VisualizationSuggestionsSupplierFn<Options, GraphFieldConfig> = (
+  dataSummary
+) => {
+  if (!dataSummary.hasData || !dataSummary.rawFrames) {
+    return;
+  }
+
+  // use getGeometryField to see if any frames have geolocation info
+  const location = getDefaultLocationMatchers();
+  if (!dataSummary.rawFrames.some((frame) => !getGeometryField(frame, location).warning)) {
+    return;
+  }
+
+  return [
+    {
+      score: VisualizationSuggestionScore.Best,
+      fieldConfig: {
+        defaults: {
+          custom: {},
+        },
+        overrides: [],
+      },
+      cardOptions: {
+        previewModifier: (s) => {
+          s.options!.controls = {
+            showZoom: false,
+            showScale: false,
+            showAttribution: false,
+            showMeasure: false,
+          };
+          // FIXME: this doesn't work. I want to disable legends in the preview.
+          s.options?.layers?.forEach((layer) => {
+            layer.config = layer.config || {};
+            layer.config.showLegend = false;
+          });
+        },
+      },
+    },
+  ];
+};

public/app/plugins/panel/geomap/utils/layers.test.ts

@@ -0,0 +1,123 @@
+jest.mock('ol-mapbox-style', () => ({}));
+jest.mock('geotiff', () => ({}));
+
+import BaseLayer from 'ol/layer/Base';
+
+import {
+  DataFrame,
+  DataQueryRequest,
+  FieldType,
+  LoadingState,
+  MapLayerHandler,
+  MapLayerOptions,
+  PanelData,
+  TimeRange,
+} from '@grafana/data';
+
+import { applyLayerFilter } from './layers';
+
+describe('applyLayerFilter', () => {
+  const createDataFrame = (refId: string): DataFrame => ({
+    refId,
+    fields: [{ name: 'value', type: FieldType.number, values: [1, 2, 3], config: {} }],
+    length: 3,
+  });
+
+  it('should apply filter when query exists and is visible', () => {
+    const update = jest.fn();
+    const handler: MapLayerHandler = {
+      init: () => ({}) as BaseLayer,
+      update,
+    };
+    const options: MapLayerOptions = {
+      name: 'Test',
+      type: 'markers',
+      filterData: { id: 'byRefId', options: 'A' },
+    };
+    const panelData: PanelData = {
+      series: [createDataFrame('A'), createDataFrame('B')],
+      state: LoadingState.Done,
+      timeRange: {} as TimeRange,
+      request: { targets: [{ refId: 'A' }, { refId: 'B' }] } as DataQueryRequest,
+    };
+
+    applyLayerFilter(handler, options, panelData);
+
+    expect(update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        series: [createDataFrame('A')],
+      })
+    );
+  });
+
+  it('should return empty series when query exists but is hidden', () => {
+    const update = jest.fn();
+    const handler: MapLayerHandler = {
+      init: () => ({}) as BaseLayer,
+      update,
+    };
+    const options: MapLayerOptions = {
+      name: 'Test',
+      type: 'markers',
+      filterData: { id: 'byRefId', options: 'A' },
+    };
+    const panelData: PanelData = {
+      series: [createDataFrame('B')],
+      state: LoadingState.Done,
+      timeRange: {} as TimeRange,
+      request: { targets: [{ refId: 'A', hide: true }, { refId: 'B' }] } as DataQueryRequest,
+    };
+
+    applyLayerFilter(handler, options, panelData);
+
+    expect(update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        series: [],
+      })
+    );
+  });
+
+  it('should not apply filter when query does not exist', () => {
+    const update = jest.fn();
+    const handler: MapLayerHandler = {
+      init: () => ({}) as BaseLayer,
+      update,
+    };
+    const options: MapLayerOptions = {
+      name: 'Test',
+      type: 'markers',
+      filterData: { id: 'byRefId', options: 'C' },
+    };
+    const panelData: PanelData = {
+      series: [createDataFrame('A'), createDataFrame('B')],
+      state: LoadingState.Done,
+      timeRange: {} as TimeRange,
+      request: { targets: [{ refId: 'A' }, { refId: 'B' }] } as DataQueryRequest,
+    };
+
+    applyLayerFilter(handler, options, panelData);
+
+    expect(update).toHaveBeenCalledWith(panelData);
+  });
+
+  it('should pass through all data when no filter is configured', () => {
+    const update = jest.fn();
+    const handler: MapLayerHandler = {
+      init: () => ({}) as BaseLayer,
+      update,
+    };
+    const options: MapLayerOptions = {
+      name: 'Test',
+      type: 'markers',
+    };
+    const panelData: PanelData = {
+      series: [createDataFrame('A'), createDataFrame('B')],
+      state: LoadingState.Done,
+      timeRange: {} as TimeRange,
+    };
+
+    applyLayerFilter(handler, options, panelData);
+
+    expect(update).toHaveBeenCalledWith(panelData);
+  });
+});

public/app/plugins/panel/geomap/utils/layers.ts

@@ -26,7 +26,13 @@ export const applyLayerFilter = (
     let panelData = panelDataProps;
     if (options.filterData) {
       const matcherFunc = getFrameMatchers(options.filterData);
-      if (panelData.series.some(matcherFunc)) {
+
+      const queryExists = panelData.request?.targets.some((target) => {
+        return target.refId === options.filterData?.options;
+      });
+
+      // Only apply filter if the target query exists
+      if (queryExists) {
         panelData = {
           ...panelData,
           series: panelData.series.filter(matcherFunc),

public/app/plugins/panel/heatmap/module.tsx

@@ -18,7 +18,7 @@ import { HeatmapPanel } from './HeatmapPanel';
 import { prepareHeatmapData } from './fields';
 import { heatmapChangedHandler, heatmapMigrationHandler } from './migrations';
 import { colorSchemes, quantizeScheme } from './palettes';
-import { HeatmapSuggestionsSupplier } from './suggestions';
+import { heatmapSuggestionsSupplier } from './suggestions';
 import { Options, defaultOptions, HeatmapColorMode, HeatmapColorScale } from './types';
 
 export const plugin = new PanelPlugin<Options, GraphFieldConfig>(HeatmapPanel)
@@ -472,5 +472,5 @@ export const plugin = new PanelPlugin<Options, GraphFieldConfig>(HeatmapPanel)
         annotations?.some((df) => df.meta?.custom?.resultType === 'exemplar'),
     });
   })
-  .setSuggestionsSupplier(new HeatmapSuggestionsSupplier())
+  .setSuggestionsSupplier(heatmapSuggestionsSupplier)
   .setDataSupport({ annotations: true });

public/app/plugins/panel/heatmap/suggestions.test.ts

@@ -0,0 +1,226 @@
+import {
+  createDataFrame,
+  DataFrameType,
+  FieldType,
+  getPanelDataSummary,
+  VisualizationSuggestionScore,
+} from '@grafana/data';
+
+import { heatmapSuggestionsSupplier } from './suggestions';
+
+describe('heatmap suggestions', () => {
+  describe('applicability', () => {
+    it('should not suggest for data without time field', () => {
+      const dataSummary = getPanelDataSummary([
+        createDataFrame({
+          fields: [
+            { name: 'value1', type: FieldType.number, values: [1, 2, 3] },
+            { name: 'value2', type: FieldType.number, values: [4, 5, 6] },
+          ],
+        }),
+      ]);
+
+      const suggestions = heatmapSuggestionsSupplier(dataSummary);
+      expect(suggestions).toBeUndefined();
+    });
+
+    it('should suggest for data with time and number fields', () => {
+      const dataSummary = getPanelDataSummary([
+        createDataFrame({
+          fields: [
+            { name: 'time', type: FieldType.time, values: [1609459200000, 1609462800000, 1609466400000] },
+            { name: 'value1', type: FieldType.number, values: [1, 2, 3] },
+            { name: 'value2', type: FieldType.number, values: [4, 5, 6] },
+          ],
+        }),
+      ]);
+
+      const suggestions = heatmapSuggestionsSupplier(dataSummary);
+      expect(suggestions).toHaveLength(1);
+    });
+  });
+
+  describe('scoring', () => {
+    it('should score this as "OK" if the data is not particularly heatmap-y', () => {
+      const dataSummary = getPanelDataSummary([
+        createDataFrame({
+          fields: [
+            { name: 'time', type: FieldType.time, values: [1609459200000, 1609462800000, 1609466400000] },
+            { name: 'value1', type: FieldType.number, values: [1, 2, 3] },
+            { name: 'value2', type: FieldType.number, values: [4, 5, 6] },
+          ],
+        }),
+      ]);
+
+      const suggestions = heatmapSuggestionsSupplier(dataSummary);
+      expect(suggestions).toEqual([expect.objectContaining({ score: VisualizationSuggestionScore.OK })]);
+    });
+
+    it.each([DataFrameType.HeatmapRows, DataFrameType.HeatmapCells])(
+      'should score this as "Best" if the data explicitly has %s frame type',
+      (frameType: DataFrameType) => {
+        const dataSummary = getPanelDataSummary([
+          createDataFrame({
+            meta: { type: frameType },
+            fields: [
+              {
+                name: 'time',
+                type: FieldType.time,
+                values: [1609459200000, 1609462800000, 1609466400000],
+                display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+              },
+              {
+                name: 'value1',
+                type: FieldType.number,
+                values: [1, 2, 3],
+                display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+              },
+              {
+                name: 'value2',
+                type: FieldType.number,
+                values: [4, 5, 6],
+                display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+              },
+              {
+                name: 'value3',
+                type: FieldType.number,
+                values: [7, 8, 9],
+                display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+              },
+            ],
+          }),
+        ]);
+
+        const suggestions = heatmapSuggestionsSupplier(dataSummary);
+        expect(suggestions).toEqual([expect.objectContaining({ score: VisualizationSuggestionScore.Best })]);
+      }
+    );
+
+    it('should score this as "Best" if the data has "ge" labels', () => {
+      const dataSummary = getPanelDataSummary([
+        createDataFrame({
+          fields: [
+            {
+              name: 'time',
+              type: FieldType.time,
+              values: [1609459200000, 1609462800000, 1609466400000],
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+            {
+              name: 'value1',
+              type: FieldType.number,
+              values: [1, 2, 3],
+              labels: { ge: '-Inf' },
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+            {
+              name: 'value2',
+              type: FieldType.number,
+              values: [4, 5, 6],
+              labels: { ge: '0' },
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+            {
+              name: 'value3',
+              type: FieldType.number,
+              values: [7, 8, 9],
+              labels: { ge: '10' },
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+          ],
+        }),
+      ]);
+
+      const suggestions = heatmapSuggestionsSupplier(dataSummary);
+      expect(suggestions).toEqual([expect.objectContaining({ score: VisualizationSuggestionScore.Best })]);
+    });
+
+    it('should score this as "Best" if the data has "le" labels', () => {
+      const dataSummary = getPanelDataSummary([
+        createDataFrame({
+          fields: [
+            {
+              name: 'time',
+              type: FieldType.time,
+              values: [1609459200000, 1609462800000, 1609466400000],
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+            {
+              name: 'value1',
+              type: FieldType.number,
+              values: [1, 2, 3],
+              labels: { le: '1' },
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+            {
+              name: 'value2',
+              type: FieldType.number,
+              values: [4, 5, 6],
+              labels: { le: '2' },
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+            {
+              name: 'value2',
+              type: FieldType.number,
+              values: [6, 2, 6],
+              labels: { le: '4' },
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+            {
+              name: 'value3',
+              type: FieldType.number,
+              values: [7, 8, 9],
+              labels: { le: 'Inf' },
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+          ],
+        }),
+      ]);
+
+      const suggestions = heatmapSuggestionsSupplier(dataSummary);
+      expect(suggestions).toEqual([expect.objectContaining({ score: VisualizationSuggestionScore.Best })]);
+    });
+
+    it('should score this as "Best" if the field names are numeric in a way that makes sense', () => {
+      const dataSummary = getPanelDataSummary([
+        createDataFrame({
+          fields: [
+            {
+              name: 'time',
+              type: FieldType.time,
+              values: [1609459200000, 1609462800000, 1609466400000],
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+            {
+              name: '0',
+              type: FieldType.number,
+              values: [1, 2, 3],
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+            {
+              name: '10',
+              type: FieldType.number,
+              values: [4, 5, 6],
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+            {
+              name: '20',
+              type: FieldType.number,
+              values: [7, 8, 9],
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+            {
+              name: 'Inf',
+              type: FieldType.number,
+              values: [10, 9, 8],
+              display: jest.fn((v) => ({ text: '' + v, numeric: Number(v) })),
+            },
+          ],
+        }),
+      ]);
+
+      const suggestions = heatmapSuggestionsSupplier(dataSummary);
+      expect(suggestions).toEqual([expect.objectContaining({ score: VisualizationSuggestionScore.Best })]);
+    });
+  });
+});

public/app/plugins/panel/heatmap/suggestions.ts

@@ -1,45 +1,73 @@
-import { VisualizationSuggestionsBuilder } from '@grafana/data';
+import {
+  DataFrameType,
+  FieldType,
+  PanelDataSummary,
+  VisualizationSuggestionScore,
+  VisualizationSuggestionsSupplierFn,
+} from '@grafana/data';
 import { config } from '@grafana/runtime';
+import { GraphFieldConfig } from '@grafana/schema';
 
 import { prepareHeatmapData } from './fields';
 import { quantizeScheme } from './palettes';
 import { Options, defaultOptions } from './types';
 
-export class HeatmapSuggestionsSupplier {
-  getSuggestionsForData(builder: VisualizationSuggestionsBuilder) {
-    const { dataSummary } = builder;
-
-    if (
-      !builder.data?.series ||
-      !dataSummary.hasData ||
-      dataSummary.timeFieldCount < 1 ||
-      dataSummary.numberFieldCount < 2 ||
-      dataSummary.numberFieldCount > 10
-    ) {
-      return;
-    }
-
-    const palette = quantizeScheme(defaultOptions.color, config.theme2);
-    const info = prepareHeatmapData({
-      frames: builder.data.series,
-      options: defaultOptions,
-      palette,
-      theme: config.theme2,
-    });
-    if (!info || info.warning) {
-      return;
-    }
-
-    builder.getListAppender<Options, {}>({
-      name: '',
-      pluginId: 'heatmap',
-      options: {},
-      fieldConfig: {
-        defaults: {
-          custom: {},
-        },
-        overrides: [],
-      },
-    });
+function determineScore(dataSummary: PanelDataSummary): VisualizationSuggestionScore {
+  // look to see if the data has an explicity marker for heatmap data on it.
+  if ([DataFrameType.HeatmapRows, DataFrameType.HeatmapCells].some((t) => dataSummary.hasDataFrameType(t))) {
+    return VisualizationSuggestionScore.Best;
   }
+
+  // we'll also look more closely at frames which return between 3 and 10 numeric fields.
+  if (dataSummary.fieldCountByType(FieldType.number) > 2 || dataSummary.fieldCountByType(FieldType.number) <= 10) {
+    // look through the names of the panels
+    const hasPotentialHeatmapSeries = dataSummary.rawFrames!.some((frame) => {
+      for (const field of frame.fields) {
+        if (field.type === FieldType.number) {
+          // if the field name, or "ge" or "le" label on the field, are numeric, then it's very possibly part of a heatmap.
+          if ([field.name, field.labels?.ge, field.labels?.le].some((v) => !isNaN(Number(v)))) {
+            return true;
+          }
+        }
+      }
+      return false;
+    });
+
+    // if at least all but 1 of the numeric fields in the frame have numeric names, then this is probably a heatmap.
+    // (the out-of-place one would be "Inf" or "-Inf")
+    if (hasPotentialHeatmapSeries) {
+      return VisualizationSuggestionScore.Best;
+    }
+  }
+
+  return VisualizationSuggestionScore.OK;
 }
+
+export const heatmapSuggestionsSupplier: VisualizationSuggestionsSupplierFn<Options, GraphFieldConfig> = (
+  dataSummary: PanelDataSummary
+) => {
+  if (
+    !dataSummary.rawFrames ||
+    !dataSummary.hasData ||
+    !dataSummary.hasFieldType(FieldType.time) ||
+    !dataSummary.hasFieldType(FieldType.number)
+  ) {
+    return;
+  }
+
+  // parse the frame into a heatmap structure to see if it's possible.
+  const palette = quantizeScheme(defaultOptions.color, config.theme2);
+  const info = prepareHeatmapData({
+    frames: dataSummary.rawFrames,
+    options: defaultOptions,
+    palette,
+    theme: config.theme2,
+  });
+
+  // if we can't parse the data into a heatmap, then bail out and prevent showing suggestions.
+  if (!info || info.warning) {
+    return;
+  }
+
+  return [{ score: determineScore(dataSummary) }];
+};

public/app/plugins/panel/histogram/module.tsx

@@ -5,6 +5,9 @@ import {
   identityOverrideProcessor,
   PanelPlugin,
   histogramFieldInfo,
+  buildHistogram,
+  VisualizationSuggestionScore,
+  DataFrameType,
 } from '@grafana/data';
 import { t } from '@grafana/i18n';
 import { commonOptionsBuilder, getGraphFieldOptions } from '@grafana/ui';
@@ -149,4 +152,16 @@ export const plugin = new PanelPlugin<Options, FieldConfig>(HistogramPanel)
 
       commonOptionsBuilder.addHideFrom(builder);
     },
+  })
+  .setSuggestionsSupplier((ds) => {
+    if (ds.rawFrames && ds.hasData && buildHistogram(ds.rawFrames)) {
+      return [
+        {
+          score: ds.hasDataFrameType(DataFrameType.Histogram)
+            ? VisualizationSuggestionScore.Best
+            : VisualizationSuggestionScore.OK,
+        },
+      ];
+    }
+    return;
   });

public/app/plugins/panel/logs/module.tsx

@@ -1,10 +1,10 @@
-import { PanelPlugin, LogsSortOrder, LogsDedupStrategy, LogsDedupDescription } from '@grafana/data';
+import { PanelPlugin, LogsSortOrder, LogsDedupStrategy, LogsDedupDescription, FieldType } from '@grafana/data';
 import { t } from '@grafana/i18n';
 import { config } from '@grafana/runtime';
+import { showDefaultSuggestion } from 'app/features/panel/suggestions/utils';
 
 import { LogsPanel } from './LogsPanel';
 import { Options } from './panelcfg.gen';
-import { LogsPanelSuggestionsSupplier } from './suggestions';
 
 export const plugin = new PanelPlugin<Options>(LogsPanel)
   .setPanelOptions((builder, context) => {
@@ -207,4 +207,6 @@ export const plugin = new PanelPlugin<Options>(LogsPanel)
         defaultValue: LogsSortOrder.Descending,
       });
   })
-  .setSuggestionsSupplier(new LogsPanelSuggestionsSupplier());
+  .setSuggestionsSupplier(
+    showDefaultSuggestion((ds) => ds.hasData && ds.hasFieldType(FieldType.time) && ds.hasFieldType(FieldType.string))
+  );

public/app/plugins/panel/logs/suggestions.ts

@@ -1,33 +0,0 @@
-import { VisualizationSuggestionsBuilder, VisualizationSuggestionScore } from '@grafana/data';
-import { SuggestionName } from 'app/types/suggestions';
-
-import { Options } from './panelcfg.gen';
-
-export class LogsPanelSuggestionsSupplier {
-  getSuggestionsForData(builder: VisualizationSuggestionsBuilder) {
-    const list = builder.getListAppender<Options, {}>({
-      name: '',
-      pluginId: 'logs',
-      options: {},
-      fieldConfig: {
-        defaults: {
-          custom: {},
-        },
-        overrides: [],
-      },
-    });
-
-    const { dataSummary: ds } = builder;
-
-    // Require a string & time field
-    if (!ds.hasData || !ds.hasTimeField || !ds.hasStringField) {
-      return;
-    }
-
-    if (ds.preferredVisualisationType === 'logs') {
-      list.append({ name: SuggestionName.Logs, score: VisualizationSuggestionScore.Best });
-    } else {
-      list.append({ name: SuggestionName.Logs });
-    }
-  }
-}

public/app/plugins/panel/nodeGraph/module.tsx

@@ -4,7 +4,7 @@ import { t } from '@grafana/i18n';
 import { NodeGraphPanel } from './NodeGraphPanel';
 import { ArcOptionsEditor } from './editor/ArcOptionsEditor';
 import { LayoutAlgorithm, Options as NodeGraphOptions } from './panelcfg.gen';
-import { NodeGraphSuggestionsSupplier } from './suggestions';
+import { nodeGraphSuggestionsSupplier } from './suggestions';
 
 export const plugin = new PanelPlugin<NodeGraphOptions>(NodeGraphPanel)
   .useFieldConfig({
@@ -92,4 +92,4 @@ export const plugin = new PanelPlugin<NodeGraphOptions>(NodeGraphPanel)
       },
     });
   })
-  .setSuggestionsSupplier(new NodeGraphSuggestionsSupplier());
+  .setSuggestionsSupplier(nodeGraphSuggestionsSupplier);

public/app/plugins/panel/nodeGraph/suggestions.ts

@@ -1,71 +1,60 @@
-import { DataFrame, FieldType, VisualizationSuggestionsBuilder, VisualizationSuggestionScore } from '@grafana/data';
-import { SuggestionName } from 'app/types/suggestions';
+import { DataFrame, FieldType, VisualizationSuggestionScore, VisualizationSuggestionsSupplierFn } from '@grafana/data';
 
-export class NodeGraphSuggestionsSupplier {
-  getListWithDefaults(builder: VisualizationSuggestionsBuilder) {
-    return builder.getListAppender<{}, {}>({
-      name: SuggestionName.NodeGraph,
-      pluginId: 'nodeGraph',
-    });
-  }
+import { Options } from './panelcfg.gen';
 
-  hasCorrectFields(frames: DataFrame[]): boolean {
-    let hasNodesFrame = false;
-    let hasEdgesFrame = false;
+function checkFields(fields: Array<[string, FieldType]>, frame: DataFrame): boolean {
+  let hasCorrectFields = true;
 
-    const nodeFields: Array<[string, FieldType]> = [
-      ['id', FieldType.string],
-      ['title', FieldType.string],
-      ['mainstat', FieldType.number],
-    ];
-    const edgeFields: Array<[string, FieldType]> = [
-      ['id', FieldType.string],
-      ['source', FieldType.string],
-      ['target', FieldType.string],
-    ];
-
-    for (const frame of frames) {
-      if (this.checkFields(nodeFields, frame)) {
-        hasNodesFrame = true;
-      }
-      if (this.checkFields(edgeFields, frame)) {
-        hasEdgesFrame = true;
-      }
-    }
-
-    return hasNodesFrame && hasEdgesFrame;
-  }
-
-  checkFields(fields: Array<[string, FieldType]>, frame: DataFrame): boolean {
-    let hasCorrectFields = true;
-
-    for (const field of fields) {
-      const [name, type] = field;
-      const frameField = frame.fields.find((f) => f.name === name);
-      if (!frameField || type !== frameField.type) {
-        hasCorrectFields = false;
-        break;
-      }
-    }
-
-    return hasCorrectFields;
-  }
-
-  getSuggestionsForData(builder: VisualizationSuggestionsBuilder) {
-    if (!builder.data) {
-      return;
-    }
-
-    const hasCorrectFields = this.hasCorrectFields(builder.data.series);
-    const nodeGraphFrames = builder.data.series.filter(
-      (df) => df.meta && df.meta.preferredVisualisationType === 'nodeGraph'
-    );
-
-    if (hasCorrectFields || nodeGraphFrames.length === 2) {
-      this.getListWithDefaults(builder).append({
-        name: SuggestionName.NodeGraph,
-        score: VisualizationSuggestionScore.Best,
-      });
+  for (const field of fields) {
+    const [name, type] = field;
+    const frameField = frame.fields.find((f) => f.name === name);
+    if (!frameField || type !== frameField.type) {
+      hasCorrectFields = false;
+      break;
     }
   }
+
+  return hasCorrectFields;
 }
+
+function frameHasCorrectFields(frames: DataFrame[]): boolean {
+  let hasNodesFrame = false;
+  let hasEdgesFrame = false;
+
+  const nodeFields: Array<[string, FieldType]> = [
+    ['id', FieldType.string],
+    ['title', FieldType.string],
+    ['mainstat', FieldType.number],
+  ];
+  const edgeFields: Array<[string, FieldType]> = [
+    ['id', FieldType.string],
+    ['source', FieldType.string],
+    ['target', FieldType.string],
+  ];
+
+  for (const frame of frames) {
+    if (checkFields(nodeFields, frame)) {
+      hasNodesFrame = true;
+    }
+    if (checkFields(edgeFields, frame)) {
+      hasEdgesFrame = true;
+    }
+  }
+
+  return hasNodesFrame && hasEdgesFrame;
+}
+
+export const nodeGraphSuggestionsSupplier: VisualizationSuggestionsSupplierFn<Options> = (dataSummary) => {
+  if (!dataSummary.rawFrames) {
+    return;
+  }
+
+  const hasCorrectFields = frameHasCorrectFields(dataSummary.rawFrames);
+  const nodeGraphFrames = dataSummary.hasPreferredVisualisationType('nodeGraph');
+
+  if (!hasCorrectFields && !nodeGraphFrames) {
+    return;
+  }
+
+  return [{ score: VisualizationSuggestionScore.Best }];
+};

public/app/plugins/panel/piechart/module.tsx

@@ -9,7 +9,7 @@ import { addStandardDataReduceOptions } from '../stat/common';
 import { PieChartPanel } from './PieChartPanel';
 import { PieChartPanelChangedHandler } from './migrations';
 import { Options, FieldConfig, PieChartType, PieChartLabels, PieChartLegendValues } from './panelcfg.gen';
-import { PieChartSuggestionsSupplier } from './suggestions';
+import { piechartSuggestionsSupplier } from './suggestions';
 
 export const plugin = new PanelPlugin<Options, FieldConfig>(PieChartPanel)
   .setPanelChangeHandler(PieChartPanelChangedHandler)
@@ -92,4 +92,4 @@ export const plugin = new PanelPlugin<Options, FieldConfig>(PieChartPanel)
       showIf: (c) => c.legend.showLegend !== false,
     });
   })
-  .setSuggestionsSupplier(new PieChartSuggestionsSupplier());
+  .setSuggestionsSupplier(piechartSuggestionsSupplier);

public/app/plugins/panel/piechart/suggestions.ts

@@ -1,79 +1,78 @@
-import { VisualizationSuggestionsBuilder } from '@grafana/data';
+import { defaultsDeep } from 'lodash';
+
+import {
+  FieldType,
+  VisualizationSuggestion,
+  VisualizationSuggestionScore,
+  VisualizationSuggestionsSupplierFn,
+} from '@grafana/data';
+import { t } from '@grafana/i18n';
 import { LegendDisplayMode } from '@grafana/schema';
-import { SuggestionName } from 'app/types/suggestions';
+import { defaultNumericVizOptions } from 'app/features/panel/suggestions/utils';
 
 import { PieChartLabels, Options, PieChartType } from './panelcfg.gen';
 
-export class PieChartSuggestionsSupplier {
-  getSuggestionsForData(builder: VisualizationSuggestionsBuilder) {
-    const list = builder.getListAppender<Options, {}>({
-      name: SuggestionName.PieChart,
-      pluginId: 'piechart',
-      options: {
-        reduceOptions: {
-          values: false,
-          calcs: ['lastNotNull'],
-        },
-        displayLabels: [PieChartLabels.Percent],
-        legend: {
-          calcs: [],
-          displayMode: LegendDisplayMode.Hidden,
-          placement: 'right',
-          values: [],
-          showLegend: false,
-        },
+const withDefaults = (suggestion: VisualizationSuggestion<Options>): VisualizationSuggestion<Options> =>
+  defaultsDeep(suggestion, {
+    options: {
+      displayLabels: [PieChartLabels.Percent],
+      legend: {
+        calcs: [],
+        displayMode: LegendDisplayMode.Hidden,
+        placement: 'right',
+        values: [],
+        showLegend: false,
       },
-    });
+    },
+  } satisfies VisualizationSuggestion<Options>);
 
-    const { dataSummary } = builder;
+const SLICE_MAX = 30;
+const SLICE_MIN = 2;
 
-    if (!dataSummary.hasNumberField) {
-      return;
-    }
+export const piechartSuggestionsSupplier: VisualizationSuggestionsSupplierFn<Options> = (dataSummary) => {
+  if (!dataSummary.hasFieldType(FieldType.number)) {
+    return;
+  }
 
-    if (dataSummary.hasStringField && dataSummary.frameCount === 1) {
-      // if many values this or single value PieChart is not a good option
-      if (dataSummary.rowCountTotal > 30 || dataSummary.rowCountTotal < 2) {
-        return;
-      }
-
-      list.append({
-        name: SuggestionName.PieChart,
-        options: {
-          reduceOptions: {
-            values: true,
-            calcs: [],
-          },
-        },
-      });
-
-      list.append({
-        name: SuggestionName.PieChartDonut,
-        options: {
-          reduceOptions: {
-            values: true,
-            calcs: [],
-          },
-          pieType: PieChartType.Donut,
-        },
-      });
-
-      return;
-    }
-
-    if (dataSummary.numberFieldCount > 30 || dataSummary.numberFieldCount < 2) {
-      return;
-    }
-
-    list.append({
-      name: SuggestionName.PieChart,
-    });
-
-    list.append({
-      name: SuggestionName.PieChartDonut,
+  const suggestions: Array<VisualizationSuggestion<Options>> = [
+    {
+      name: t('piechart.suggestions.pie', 'Pie chart'),
+    },
+    {
+      name: t('piechart.suggestions.donut', 'Donut chart'),
       options: {
         pieType: PieChartType.Donut,
       },
-    });
+    },
+  ];
+
+  let shouldUseRawValues = false;
+
+  // we're filtering out data which has more than 30 slices or less than 2, and we're also
+  // determining whether the reduce options should be set based on the data summary.
+  if (dataSummary.hasFieldType(FieldType.string) && dataSummary.frameCount === 1) {
+    if (dataSummary.rowCountTotal > SLICE_MAX && dataSummary.rowCountTotal < SLICE_MIN) {
+      return;
+    }
+
+    shouldUseRawValues = true;
+  } else if (
+    dataSummary.fieldCountByType(FieldType.number) > SLICE_MAX ||
+    dataSummary.fieldCountByType(FieldType.number) < SLICE_MIN
+  ) {
+    return;
   }
-}
+
+  return suggestions.map((s) => {
+    const result = defaultNumericVizOptions(withDefaults(s), dataSummary, shouldUseRawValues);
+    // bump the score up to best if we have exactly one numeric and one string field
+    if (
+      dataSummary.fieldCount === 2 &&
+      dataSummary.fieldCountByType(FieldType.string) === 1 &&
+      dataSummary.fieldCountByType(FieldType.number) === 1
+    ) {
+      result.score = VisualizationSuggestionScore.Best;
+    }
+    return result;
+  });
+};

public/app/plugins/panel/radialbar/module.tsx

@@ -8,7 +8,7 @@ import { EffectsEditor } from './EffectsEditor';
 import { gaugePanelChangedHandler, gaugePanelMigrationHandler, shouldMigrateGauge } from './GaugeMigrations';
 import { RadialBarPanel } from './RadialBarPanel';
 import { defaultGaugePanelEffects, defaultOptions, Options } from './panelcfg.gen';
-import { radialBarSuggestionsHandler } from './suggestions';
+import { radialBarSuggestionsSupplier } from './suggestions';
 
 export const plugin = new PanelPlugin<Options>(RadialBarPanel)
   .useFieldConfig({})
@@ -112,6 +112,6 @@ export const plugin = new PanelPlugin<Options>(RadialBarPanel)
       defaultValue: defaultGaugePanelEffects,
     });
   })
-  .setSuggestionsSupplier(radialBarSuggestionsHandler)
+  .setSuggestionsSupplier(radialBarSuggestionsSupplier)
   .setMigrationHandler(gaugePanelMigrationHandler, shouldMigrateGauge)
   .setPanelChangeHandler(gaugePanelChangedHandler);

public/app/plugins/panel/radialbar/suggestions.test.ts

@@ -1,13 +1,13 @@
 import { createDataFrame, Field, FieldType, getPanelDataSummary } from '@grafana/data';
 
-import { radialBarSuggestionsHandler } from './suggestions';
+import { radialBarSuggestionsSupplier } from './suggestions';
 
 describe('RadialBarPanel Suggestions', () => {
   it('does not suggest gauge if no data is present', () => {
-    expect(radialBarSuggestionsHandler(getPanelDataSummary([]))).toBeFalsy();
-    expect(radialBarSuggestionsHandler(getPanelDataSummary(undefined))).toBeFalsy();
+    expect(radialBarSuggestionsSupplier(getPanelDataSummary([]))).toBeFalsy();
+    expect(radialBarSuggestionsSupplier(getPanelDataSummary(undefined))).toBeFalsy();
     expect(
-      radialBarSuggestionsHandler(
+      radialBarSuggestionsSupplier(
         getPanelDataSummary([
           createDataFrame({
             fields: [
@@ -27,7 +27,7 @@ describe('RadialBarPanel Suggestions', () => {
         { name: 'status', type: FieldType.string },
       ],
     });
-    expect(radialBarSuggestionsHandler(getPanelDataSummary([df]))).toBeFalsy();
+    expect(radialBarSuggestionsSupplier(getPanelDataSummary([df]))).toBeFalsy();
   });
 
   it('does not suggest gauge if there are too many numeric fields', () => {
@@ -35,12 +35,12 @@ describe('RadialBarPanel Suggestions', () => {
     for (let i = 0; i < 20; i++) {
       fields.push({ name: `numeric-${i}`, type: FieldType.number, values: [0, 100, 200, 300, 400, 500], config: {} });
     }
-    expect(radialBarSuggestionsHandler(getPanelDataSummary([createDataFrame({ fields })]))).toBeFalsy();
+    expect(radialBarSuggestionsSupplier(getPanelDataSummary([createDataFrame({ fields })]))).toBeFalsy();
   });
 
   it('suggests gauge for a single numeric field', () => {
     expect(
-      radialBarSuggestionsHandler(
+      radialBarSuggestionsSupplier(
         getPanelDataSummary([
           createDataFrame({
             fields: [
@@ -58,7 +58,7 @@ describe('RadialBarPanel Suggestions', () => {
 
   it('suggests gauge for a few numeric fields, with other fields mixed in', () => {
     expect(
-      radialBarSuggestionsHandler(
+      radialBarSuggestionsSupplier(
         getPanelDataSummary([
           createDataFrame({
             fields: [
@@ -136,7 +136,7 @@ describe('RadialBarPanel Suggestions', () => {
         ],
       },
     ])('$description suggests aggregated=$aggregated', ({ dataframes, aggregated }) => {
-      const suggestions = radialBarSuggestionsHandler(getPanelDataSummary(dataframes));
+      const suggestions = radialBarSuggestionsSupplier(getPanelDataSummary(dataframes));
       const expected = aggregated ? { values: false, calcs: ['lastNotNull'] } : { values: true, calcs: [] };
       if (Array.isArray(suggestions)) {
         for (const suggestion of suggestions) {

public/app/plugins/panel/radialbar/suggestions.ts

@@ -8,10 +8,39 @@ import {
 } from '@grafana/data';
 import { t } from '@grafana/i18n';
 import { GraphFieldConfig } from '@grafana/ui';
+import { defaultNumericVizOptions } from 'app/features/panel/suggestions/utils';
 
 import { Options } from './panelcfg.gen';
 
-export const radialBarSuggestionsHandler: VisualizationSuggestionsSupplierFn<Options, GraphFieldConfig> = (
+const withDefaults = (
+  suggestion: VisualizationSuggestion<Options, GraphFieldConfig>
+): VisualizationSuggestion<Options, GraphFieldConfig> =>
+  defaultsDeep(suggestion, {
+    cardOptions: {
+      previewModifier: (s) => {
+        if (s.options?.reduceOptions) {
+          s.options.reduceOptions.limit = 4;
+        }
+      },
+    },
+    // styles: [{
+    //   name: t('gauge.suggestions.style.circular', 'Glowing'),
+    //   options: {
+    //     effects: {
+    //       rounded: true,
+    //       barGlow: true,
+    //       centerGlow: true,
+    //       spotlight: true,
+    //     },
+    //   },
+    // }, {
+    //   name: t('gauge.suggestions.style.simple', 'Simple'),
+    // }]
+  } satisfies VisualizationSuggestion<Options, GraphFieldConfig>);
+
+const MAX_GAUGES = 10;
+
+export const radialBarSuggestionsSupplier: VisualizationSuggestionsSupplierFn<Options, GraphFieldConfig> = (
   dataSummary
 ) => {
   if (!dataSummary.hasData || !dataSummary.hasFieldType(FieldType.number)) {
@@ -19,69 +48,40 @@ export const radialBarSuggestionsHandler: VisualizationSuggestionsSupplierFn<Opt
   }
 
   // for many fields / series this is probably not a good fit
-  if (dataSummary.fieldCountByType(FieldType.number) >= 10) {
+  if (dataSummary.fieldCountByType(FieldType.number) > MAX_GAUGES) {
     return;
   }
 
-  const withDefaults = (
-    suggestion: VisualizationSuggestion<Options, GraphFieldConfig>
-  ): VisualizationSuggestion<Options, GraphFieldConfig> => {
-    // if there is a string field and there are few enough rows, we assume it's tabular data and not numeric series data,
-    // and the de-aggregated version of the viz probably makes more sense
-    const isTabularData =
-      dataSummary.hasFieldType(FieldType.string) && dataSummary.frameCount === 1 && dataSummary.rowCountTotal < 10;
-    return defaultsDeep(suggestion, {
-      options: {
-        reduceOptions: isTabularData
-          ? {
-              values: true,
-              calcs: [],
-            }
-          : {
-              values: false,
-              calcs: ['lastNotNull'],
-            },
-      },
-      fieldConfig: {
-        defaults: isTabularData
-          ? {
-              color: { mode: FieldColorModeId.PaletteClassic },
-            }
-          : {},
-        overrides: [],
-      },
-      cardOptions: {
-        previewModifier: (s) => {
-          if (s.options?.reduceOptions) {
-            s.options.reduceOptions.limit = 4;
-          }
-        },
-      },
-      // styles: [{
-      //   name: t('gauge.suggestions.style.circular', 'Glowing'),
-      //   options: {
-      //     effects: {
-      //       rounded: true,
-      //       barGlow: true,
-      //       centerGlow: true,
-      //       spotlight: true,
-      //     },
-      //   },
-      // }, {
-      //   name: t('gauge.suggestions.style.simple', 'Simple'),
-      // }]
-    } satisfies VisualizationSuggestion<Options, GraphFieldConfig>);
-  };
-
-  return [
-    withDefaults({ name: t('gauge.suggestions.arc', 'Gauge') }),
-    withDefaults({
+  const suggestions: Array<VisualizationSuggestion<Options, GraphFieldConfig>> = [
+    { name: t('gauge.suggestions.arc', 'Gauge') },
+    {
       name: t('gauge.suggestions.circular', 'Circular gauge'),
       options: {
         shape: 'circle',
         showThresholdMarkers: false,
         barWidthFactor: 0.3,
       },
-    }),
+    },
   ];
+
+  const shouldUseRawValues =
+    dataSummary.hasFieldType(FieldType.string) &&
+    dataSummary.frameCount === 1 &&
+    dataSummary.rowCountTotal <= MAX_GAUGES;
+
+  return suggestions.map((s) => {
+    const suggestion = defaultNumericVizOptions(withDefaults(s), dataSummary, shouldUseRawValues);
+
+    if (shouldUseRawValues) {
+      suggestion.fieldConfig = suggestion.fieldConfig ?? {
+        defaults: {},
+        overrides: [],
+      };
+      suggestion.fieldConfig.defaults.color = suggestion.fieldConfig.defaults.color ?? {
+        mode: FieldColorModeId.PaletteClassic,
+      };
+    }
+
+    return suggestion;
+  });
 };

public/app/plugins/panel/stat/module.tsx

@@ -13,7 +13,7 @@ import { statPanelChangedHandler } from './StatMigrations';
 import { StatPanel } from './StatPanel';
 import { addStandardDataReduceOptions, addOrientationOption } from './common';
 import { defaultOptions, Options } from './panelcfg.gen';
-import { StatSuggestionsSupplier } from './suggestions';
+import { statSuggestionsSupplier } from './suggestions';
 
 export const plugin = new PanelPlugin<Options>(StatPanel)
   .useFieldConfig()
@@ -137,5 +137,5 @@ export const plugin = new PanelPlugin<Options>(StatPanel)
   })
   .setNoPadding()
   .setPanelChangeHandler(statPanelChangedHandler)
-  .setSuggestionsSupplier(new StatSuggestionsSupplier())
+  .setSuggestionsSupplier(statSuggestionsSupplier)
   .setMigrationHandler(sharedSingleStatMigrationHandler);

public/app/plugins/panel/stat/suggestions.ts

@@ -1,41 +1,46 @@
-import { VisualizationSuggestionsBuilder } from '@grafana/data';
-import { BigValueColorMode, BigValueGraphMode, GraphFieldConfig } from '@grafana/schema';
-import { SuggestionName } from 'app/types/suggestions';
+import { defaultsDeep } from 'lodash';
+
+import { FieldType, VisualizationSuggestion, VisualizationSuggestionsSupplierFn } from '@grafana/data';
+import { t } from '@grafana/i18n';
+import { BigValueColorMode, BigValueGraphMode } from '@grafana/schema';
 
 import { Options } from './panelcfg.gen';
 
-export class StatSuggestionsSupplier {
-  getSuggestionsForData(builder: VisualizationSuggestionsBuilder) {
-    const { dataSummary: ds } = builder;
-
-    if (!ds.hasData) {
-      return;
-    }
-
-    const list = builder.getListAppender<Options, GraphFieldConfig>({
-      name: SuggestionName.Stat,
-      pluginId: 'stat',
-      options: {},
-      fieldConfig: {
-        defaults: {
-          unit: 'short',
-          custom: {},
-        },
-        overrides: [],
+const withDefaults = (s: VisualizationSuggestion<Options>): VisualizationSuggestion<Options> =>
+  defaultsDeep(s, {
+    fieldConfig: {
+      defaults: {
+        unit: 'short',
+        custom: {},
       },
-      cardOptions: {
-        previewModifier: (s) => {
-          if (s.options?.reduceOptions?.values) {
-            s.options.reduceOptions.limit = 1;
-          }
-        },
+      overrides: [],
+    },
+    cardOptions: {
+      previewModifier: (s) => {
+        if (s.options?.reduceOptions?.values) {
+          s.options.reduceOptions.limit = 1;
+        }
       },
-    });
+    },
+  } satisfies VisualizationSuggestion<Options>);
 
-    // String and number field with low row count show individual rows
-    if (ds.hasStringField && ds.hasNumberField && ds.frameCount === 1 && ds.rowCountTotal < 10) {
-      list.append({
-        name: SuggestionName.Stat,
+export const statSuggestionsSupplier: VisualizationSuggestionsSupplierFn<Options> = (ds) => {
+  if (!ds.hasData) {
+    return;
+  }
+
+  const suggestions: Array<VisualizationSuggestion<Options>> = [];
+
+  // String and number field with low row count show individual rows
+  if (
+    ds.hasFieldType(FieldType.string) &&
+    ds.hasFieldType(FieldType.number) &&
+    ds.frameCount === 1 &&
+    ds.rowCountTotal < 10
+  ) {
+    suggestions.push(
+      {
+        name: t('stat.suggestions.stat-discrete-values', 'Stat - discrete values'),
         options: {
           reduceOptions: {
             values: true,
@@ -43,9 +48,9 @@ export class StatSuggestionsSupplier {
             fields: '/.*/',
           },
         },
-      });
-      list.append({
-        name: SuggestionName.StatColoredBackground,
+      },
+      {
+        name: t('stat.suggestions.stat-discrete-values-color-background', 'Stat - discrete values - color background'),
         options: {
           reduceOptions: {
             values: true,
@@ -54,36 +59,38 @@ export class StatSuggestionsSupplier {
           },
           colorMode: BigValueColorMode.Background,
         },
-      });
-    }
+      }
+    );
+  }
 
-    // Just a single string field
-    if (ds.stringFieldCount === 1 && ds.frameCount === 1 && ds.rowCountTotal < 10 && ds.fieldCount === 1) {
-      list.append({
-        name: SuggestionName.Stat,
-        options: {
-          reduceOptions: {
-            values: true,
-            calcs: [],
-            fields: '/.*/',
-          },
-          colorMode: BigValueColorMode.None,
+  // just a single string field
+  if (ds.fieldCount === 1 && ds.hasFieldType(FieldType.string)) {
+    suggestions.push({
+      name: t('stat.suggestions.stat-single-string', 'Stat - single string'),
+      options: {
+        reduceOptions: {
+          values: true,
+          calcs: [],
+          fields: '/.*/',
         },
-      });
-    }
+        colorMode: BigValueColorMode.None,
+      },
+    });
+  }
 
-    if (ds.hasNumberField && ds.hasTimeField) {
-      list.append({
+  // aggregated suggestions for number fields
+  if (ds.hasFieldType(FieldType.number) && ds.hasFieldType(FieldType.time)) {
+    suggestions.push(
+      {
         options: {
           reduceOptions: {
             values: false,
             calcs: ['lastNotNull'],
           },
         },
-      });
-
-      list.append({
-        name: SuggestionName.StatColoredBackground,
+      },
+      {
+        name: t('stat.suggestions.stat-color-background', 'Stat - color background'),
         options: {
           reduceOptions: {
             values: false,
@@ -92,7 +99,9 @@ export class StatSuggestionsSupplier {
           graphMode: BigValueGraphMode.None,
           colorMode: BigValueColorMode.Background,
         },
-      });
-    }
+      }
+    );
   }
-}
+
+  return suggestions.map(withDefaults);
+};

public/app/plugins/panel/state-timeline/module.tsx

@@ -177,7 +177,7 @@ export const plugin = new PanelPlugin<Options, FieldConfig>(StateTimelinePanel)
       }
 
       // Probably better ways to filter out this by inspecting the types of string values so view this as temporary
-      if (ds.preferredVisualisationType === 'logs') {
+      if (ds.hasPreferredVisualisationType('logs')) {
         return;
       }
 

public/app/plugins/panel/status-history/module.tsx

@@ -1,11 +1,10 @@
-import { FieldColorModeId, FieldConfigProperty, PanelPlugin } from '@grafana/data';
+import { FieldColorModeId, FieldConfigProperty, FieldType, PanelPlugin } from '@grafana/data';
 import { t } from '@grafana/i18n';
 import { AxisPlacement, VisibilityMode } from '@grafana/schema';
 import { commonOptionsBuilder } from '@grafana/ui';
 
 import { StatusHistoryPanel } from './StatusHistoryPanel';
 import { Options, FieldConfig, defaultFieldConfig } from './panelcfg.gen';
-import { StatusHistorySuggestionsSupplier } from './suggestions';
 
 export const plugin = new PanelPlugin<Options, FieldConfig>(StatusHistoryPanel)
   .useFieldConfig({
@@ -113,5 +112,42 @@ export const plugin = new PanelPlugin<Options, FieldConfig>(StatusHistoryPanel)
     commonOptionsBuilder.addLegendOptions(builder, false);
     commonOptionsBuilder.addTooltipOptions(builder);
   })
-  .setSuggestionsSupplier(new StatusHistorySuggestionsSupplier())
+  .setSuggestionsSupplier((ds) => {
+    if (!ds.hasData) {
+      return;
+    }
+
+    // This panel needs a time field and a string or number field
+    if (
+      !ds.hasFieldType(FieldType.time) ||
+      (!ds.hasFieldType(FieldType.string) && !ds.hasFieldType(FieldType.number))
+    ) {
+      return;
+    }
+
+    // If there are many series then they won't fit on y-axis so this panel is not good fit
+    if (ds.fieldCountByType(FieldType.number) >= 30) {
+      return;
+    }
+
+    // if there a lot of data points for each series then this is not a good match
+    if (ds.rowCountMax > 100) {
+      return;
+    }
+
+    // Probably better ways to filter out this by inspecting the types of string values so view this as temporary
+    if (ds.hasPreferredVisualisationType('logs')) {
+      return;
+    }
+
+    return [
+      {
+        cardOptions: {
+          previewModifier: (s) => {
+            s.options!.colWidth = 0.7;
+          },
+        },
+      },
+    ];
+  })
   .setDataSupport({ annotations: true });

public/app/plugins/panel/status-history/suggestions.ts

@@ -1,56 +0,0 @@
-import { FieldColorModeId, VisualizationSuggestionsBuilder } from '@grafana/data';
-import { SuggestionName } from 'app/types/suggestions';
-
-import { Options, FieldConfig } from './panelcfg.gen';
-
-export class StatusHistorySuggestionsSupplier {
-  getSuggestionsForData(builder: VisualizationSuggestionsBuilder) {
-    const { dataSummary: ds } = builder;
-
-    if (!ds.hasData) {
-      return;
-    }
-
-    // This panel needs a time field and a string or number field
-    if (!ds.hasTimeField || (!ds.hasStringField && !ds.hasNumberField)) {
-      return;
-    }
-
-    // If there are many series then they won't fit on y-axis so this panel is not good fit
-    if (ds.numberFieldCount >= 30) {
-      return;
-    }
-
-    // if there a lot of data points for each series then this is not a good match
-    if (ds.rowCountMax > 100) {
-      return;
-    }
-
-    // Probably better ways to filter out this by inspecting the types of string values so view this as temporary
-    if (ds.preferredVisualisationType === 'logs') {
-      return;
-    }
-
-    const list = builder.getListAppender<Options, FieldConfig>({
-      name: '',
-      pluginId: 'status-history',
-      options: {},
-      fieldConfig: {
-        defaults: {
-          color: {
-            mode: FieldColorModeId.ContinuousGrYlRd,
-          },
-          custom: {},
-        },
-        overrides: [],
-      },
-      cardOptions: {
-        previewModifier: (s) => {
-          s.options!.colWidth = 0.7;
-        },
-      },
-    });
-
-    list.append({ name: SuggestionName.StatusHistory });
-  }
-}

public/app/plugins/panel/table/cells/SparklineCellOptionsEditor.tsx

@@ -12,6 +12,7 @@ import { TableCellEditorProps } from '../TableCellOptionEditor';
 type OptionKey = keyof TableSparklineCellOptions;
 
 const optionIds: Array<keyof TableSparklineCellOptions> = [
+  'interactionEnabled',
   'hideValue',
   'drawStyle',
   'lineInterpolation',
@@ -31,6 +32,12 @@ function getChartCellConfig(cfg: GraphFieldConfig): SetFieldConfigOptionsArgs<Gr
     ...graphFieldConfig,
     useCustomConfig: (builder) => {
       graphFieldConfig.useCustomConfig?.(builder);
+      builder.addBooleanSwitch({
+        path: 'interactionEnabled',
+        name: 'Enable hover interaction',
+        description: 'Allow users to hover over the sparkline to inspect values',
+        defaultValue: true,
+      });
       builder.addBooleanSwitch({
         path: 'hideValue',
         name: 'Hide value',