Implement batch operation support in KV storage

- Introduced a new Batch method to execute multiple operations atomically within a single transaction.
- Defined BatchOp types for various operations: put, create, update, and delete, with specific semantics for each.
- Updated the KV interface and implementation to support batch operations, ensuring rollback on failure.
- Enhanced testing suite to cover various batch scenarios, including success, failure, and edge cases, ensuring robust functionality.

.github/workflows/go-lint.yml

@@ -57,7 +57,7 @@ jobs:
   lint-go:
     needs: detect-changes
     if: needs.detect-changes.outputs.changed == 'true'
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-x64-large-io
     steps:
       - uses: actions/checkout@v5
         with:

apps/alerting/historian/kinds/manifest.cue

@@ -1,34 +1,20 @@
 package kinds
 
+import (
+	"github.com/grafana/grafana/apps/alerting/historian/kinds/v0alpha1"
+)
+
 manifest: {
 	appName:       "alerting-historian"
 	groupOverride: "historian.alerting.grafana.app"
 	versions: {
-		"v0alpha1": v0alpha1
+		"v0alpha1": {
+			kinds: [dummyv0alpha1]
+			routes: v0alpha1.routes
+		}
 	}
 }
 
-v0alpha1: {
-    kinds: [dummyv0alpha1]
-
-    routes: {
-        namespaced: {
-            // This endpoint is an exact copy of the existing /history endpoint,
-            // with the exception that error responses will be Kubernetes-style,
-            // not Grafana-style. It will be replaced in the future with a better
-            // more schema-friendly API.
-            "/alertstate/history": {
-                "GET": {
-                    response: {
-                      body: [string]: _
-                    }
-                    responseMetadata: typeMeta: false
-                }
-            }
-        }
-    }
-}
-
 dummyv0alpha1: {
     kind: "Dummy"
     schema: {
@@ -37,4 +23,4 @@ dummyv0alpha1: {
             dummyField: int
         }
     }
-}
+}

apps/alerting/historian/kinds/v0alpha1/matcher.cue

@@ -0,0 +1,9 @@
+package v0alpha1
+
+#Matcher: {
+	type:  "=" | "!=" | "=~" | "!~" @cuetsy(kind="enum",memberNames="Equal|NotEqual|EqualRegex|NotEqualRegex")
+	label: string
+	value: string
+}
+
+#Matchers: [...#Matcher]

apps/alerting/historian/kinds/v0alpha1/notification.cue

@@ -0,0 +1,65 @@
+package v0alpha1
+
+import (
+    "time"
+)
+
+#NotificationStatus: "firing" | "resolved" @cog(kind="enum",memberNames="Firing|Resolved")
+
+#NotificationOutcome: "success" | "error" @cog(kind="enum",memberNames="Success|Error")
+
+#NotificationQuery: {
+    // From is the starting timestamp for the query.
+    from?: time.Time
+    // To is the starting timestamp for the query.
+    to?: time.Time
+    // Limit is the maximum number of entries to return.
+    limit?: int64    
+    // Receiver optionally filters the entries by receiver title (contact point).
+    receiver?: string
+    // Status optionally filters the entries to only either firing or resolved.
+    status?: #NotificationStatus
+    // Outcome optionally filters the entries to only either successful or failed attempts.
+    outcome?: #NotificationOutcome
+    // RuleUID optionally filters the entries to a specific alert rule.
+    ruleUID?: string
+    // GroupLabels optionally filters the entries by matching group labels.
+    groupLabels?: #Matchers
+}
+
+#NotificationQueryResult: {
+    entries: [...#NotificationEntry]
+}
+
+#NotificationEntry: {
+    // Timestamp is the time at which the notification attempt completed.
+    timestamp: time.Time
+    // Receiver is the receiver (contact point) title.
+    receiver: string
+    // Status indicates if the notification contains one or more firing alerts.
+    status: #NotificationStatus
+    // Outcome indicaes if the notificaion attempt was successful or if it failed.
+    outcome: #NotificationOutcome
+    // GroupLabels are the labels uniquely identifying the alert group within a route.
+    groupLabels: [string]: string
+    // Alerts are the alerts grouped into the notification.
+    alerts: [...#NotificationEntryAlert]
+    // Retry indicates if the attempt was a retried attempt.
+    retry: bool
+    // Error is the message returned by the contact point if delivery failed.
+    error?: string
+    // Duration is the length of time the notification attempt took in nanoseconds.
+    duration: int
+    // PipelineTime is the time at which the flush began.
+    pipelineTime: time.Time
+    // GroupKey uniquely idenifies the dispatcher alert group.
+    groupKey: string
+}
+
+#NotificationEntryAlert: {
+    status: string
+    labels: [string]: string
+    annotations: [string]: string
+    startsAt: time.Time
+    endsAt: time.Time
+}

apps/alerting/historian/kinds/v0alpha1/routes.cue

@@ -0,0 +1,29 @@
+package v0alpha1
+
+routes: {
+	namespaced: {
+		// This endpoint is an exact copy of the existing /history endpoint,
+		// with the exception that error responses will be Kubernetes-style,
+		// not Grafana-style. It will be replaced in the future with a better
+		// more schema-friendly API.
+		"/alertstate/history": {
+			"GET": {
+				response: {
+					body: [string]: _
+				}
+				responseMetadata: typeMeta: false
+			}
+		}
+
+		// Query notification history.
+		"/notification/query": {
+			"POST": {
+				request: {
+					body: #NotificationQuery
+				}
+				response: #NotificationQueryResult
+				responseMetadata: typeMeta: false				
+			}
+		}
+	}
+}

apps/alerting/historian/pkg/apis/alertinghistorian/v0alpha1/createnotificationquery_request_body_types_gen.go

@@ -0,0 +1,67 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package v0alpha1
+
+import (
+	time "time"
+)
+
+type CreateNotificationqueryRequestNotificationStatus string
+
+const (
+	CreateNotificationqueryRequestNotificationStatusFiring   CreateNotificationqueryRequestNotificationStatus = "firing"
+	CreateNotificationqueryRequestNotificationStatusResolved CreateNotificationqueryRequestNotificationStatus = "resolved"
+)
+
+type CreateNotificationqueryRequestNotificationOutcome string
+
+const (
+	CreateNotificationqueryRequestNotificationOutcomeSuccess CreateNotificationqueryRequestNotificationOutcome = "success"
+	CreateNotificationqueryRequestNotificationOutcomeError   CreateNotificationqueryRequestNotificationOutcome = "error"
+)
+
+type CreateNotificationqueryRequestMatchers []CreateNotificationqueryRequestMatcher
+
+type CreateNotificationqueryRequestMatcher struct {
+	Type  CreateNotificationqueryRequestMatcherType `json:"type"`
+	Label string                                    `json:"label"`
+	Value string                                    `json:"value"`
+}
+
+// NewCreateNotificationqueryRequestMatcher creates a new CreateNotificationqueryRequestMatcher object.
+func NewCreateNotificationqueryRequestMatcher() *CreateNotificationqueryRequestMatcher {
+	return &CreateNotificationqueryRequestMatcher{}
+}
+
+type CreateNotificationqueryRequestBody struct {
+	// From is the starting timestamp for the query.
+	From *time.Time `json:"from,omitempty"`
+	// To is the starting timestamp for the query.
+	To *time.Time `json:"to,omitempty"`
+	// Limit is the maximum number of entries to return.
+	Limit *int64 `json:"limit,omitempty"`
+	// Receiver optionally filters the entries by receiver title (contact point).
+	Receiver *string `json:"receiver,omitempty"`
+	// Status optionally filters the entries to only either firing or resolved.
+	Status *CreateNotificationqueryRequestNotificationStatus `json:"status,omitempty"`
+	// Outcome optionally filters the entries to only either successful or failed attempts.
+	Outcome *CreateNotificationqueryRequestNotificationOutcome `json:"outcome,omitempty"`
+	// RuleUID optionally filters the entries to a specific alert rule.
+	RuleUID *string `json:"ruleUID,omitempty"`
+	// GroupLabels optionally filters the entries by matching group labels.
+	GroupLabels *CreateNotificationqueryRequestMatchers `json:"groupLabels,omitempty"`
+}
+
+// NewCreateNotificationqueryRequestBody creates a new CreateNotificationqueryRequestBody object.
+func NewCreateNotificationqueryRequestBody() *CreateNotificationqueryRequestBody {
+	return &CreateNotificationqueryRequestBody{}
+}
+
+type CreateNotificationqueryRequestMatcherType string
+
+const (
+	CreateNotificationqueryRequestMatcherTypeEqual         CreateNotificationqueryRequestMatcherType = "="
+	CreateNotificationqueryRequestMatcherTypeNotEqual      CreateNotificationqueryRequestMatcherType = "!="
+	CreateNotificationqueryRequestMatcherTypeEqualRegex    CreateNotificationqueryRequestMatcherType = "=~"
+	CreateNotificationqueryRequestMatcherTypeNotEqualRegex CreateNotificationqueryRequestMatcherType = "!~"
+)

apps/alerting/historian/pkg/apis/alertinghistorian/v0alpha1/createnotificationquery_response_types_gen.go

@@ -0,0 +1,86 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package v0alpha1
+
+import (
+	time "time"
+)
+
+// +k8s:openapi-gen=true
+type NotificationEntry struct {
+	// Timestamp is the time at which the notification attempt completed.
+	Timestamp time.Time `json:"timestamp"`
+	// Receiver is the receiver (contact point) title.
+	Receiver string `json:"receiver"`
+	// Status indicates if the notification contains one or more firing alerts.
+	Status NotificationStatus `json:"status"`
+	// Outcome indicaes if the notificaion attempt was successful or if it failed.
+	Outcome NotificationOutcome `json:"outcome"`
+	// GroupLabels are the labels uniquely identifying the alert group within a route.
+	GroupLabels map[string]string `json:"groupLabels"`
+	// Alerts are the alerts grouped into the notification.
+	Alerts []NotificationEntryAlert `json:"alerts"`
+	// Retry indicates if the attempt was a retried attempt.
+	Retry bool `json:"retry"`
+	// Error is the message returned by the contact point if delivery failed.
+	Error *string `json:"error,omitempty"`
+	// Duration is the length of time the notification attempt took in nanoseconds.
+	Duration int64 `json:"duration"`
+	// PipelineTime is the time at which the flush began.
+	PipelineTime time.Time `json:"pipelineTime"`
+	// GroupKey uniquely idenifies the dispatcher alert group.
+	GroupKey string `json:"groupKey"`
+}
+
+// NewNotificationEntry creates a new NotificationEntry object.
+func NewNotificationEntry() *NotificationEntry {
+	return &NotificationEntry{
+		GroupLabels: map[string]string{},
+		Alerts:      []NotificationEntryAlert{},
+	}
+}
+
+// +k8s:openapi-gen=true
+type NotificationStatus string
+
+const (
+	NotificationStatusFiring   NotificationStatus = "firing"
+	NotificationStatusResolved NotificationStatus = "resolved"
+)
+
+// +k8s:openapi-gen=true
+type NotificationOutcome string
+
+const (
+	NotificationOutcomeSuccess NotificationOutcome = "success"
+	NotificationOutcomeError   NotificationOutcome = "error"
+)
+
+// +k8s:openapi-gen=true
+type NotificationEntryAlert struct {
+	Status      string            `json:"status"`
+	Labels      map[string]string `json:"labels"`
+	Annotations map[string]string `json:"annotations"`
+	StartsAt    time.Time         `json:"startsAt"`
+	EndsAt      time.Time         `json:"endsAt"`
+}
+
+// NewNotificationEntryAlert creates a new NotificationEntryAlert object.
+func NewNotificationEntryAlert() *NotificationEntryAlert {
+	return &NotificationEntryAlert{
+		Labels:      map[string]string{},
+		Annotations: map[string]string{},
+	}
+}
+
+// +k8s:openapi-gen=true
+type CreateNotificationquery struct {
+	Entries []NotificationEntry `json:"entries"`
+}
+
+// NewCreateNotificationquery creates a new CreateNotificationquery object.
+func NewCreateNotificationquery() *CreateNotificationquery {
+	return &CreateNotificationquery{
+		Entries: []NotificationEntry{},
+	}
+}

apps/alerting/historian/pkg/apis/alertinghistorian_manifest.go

@@ -92,9 +92,321 @@ var appManifestData = app.ManifestData{
 							},
 						},
 					},
+					"/notification/query": {
+						Post: &spec3.Operation{
+							OperationProps: spec3.OperationProps{
+
+								OperationId: "createNotificationquery",
+
+								RequestBody: &spec3.RequestBody{
+									RequestBodyProps: spec3.RequestBodyProps{
+
+										Content: map[string]*spec3.MediaType{
+											"application/json": {
+												MediaTypeProps: spec3.MediaTypeProps{
+													Schema: &spec.Schema{
+														SchemaProps: spec.SchemaProps{
+															Type: []string{"object"},
+															Properties: map[string]spec.Schema{
+																"from": {
+																	SchemaProps: spec.SchemaProps{
+																		Type:        []string{"string"},
+																		Format:      "date-time",
+																		Description: "From is the starting timestamp for the query.",
+																	},
+																},
+																"groupLabels": {
+																	SchemaProps: spec.SchemaProps{
+
+																		Description: "GroupLabels optionally filters the entries by matching group labels.",
+																		Ref:         spec.MustCreateRef("#/components/schemas/createNotificationqueryMatchers"),
+																	},
+																},
+																"limit": {
+																	SchemaProps: spec.SchemaProps{
+																		Type:        []string{"integer"},
+																		Description: "Limit is the maximum number of entries to return.",
+																	},
+																},
+																"outcome": {
+																	SchemaProps: spec.SchemaProps{
+
+																		Description: "Outcome optionally filters the entries to only either successful or failed attempts.",
+																		Ref:         spec.MustCreateRef("#/components/schemas/createNotificationqueryNotificationOutcome"),
+																	},
+																},
+																"receiver": {
+																	SchemaProps: spec.SchemaProps{
+																		Type:        []string{"string"},
+																		Description: "Receiver optionally filters the entries by receiver title (contact point).",
+																	},
+																},
+																"ruleUID": {
+																	SchemaProps: spec.SchemaProps{
+																		Type:        []string{"string"},
+																		Description: "RuleUID optionally filters the entries to a specific alert rule.",
+																	},
+																},
+																"status": {
+																	SchemaProps: spec.SchemaProps{
+
+																		Description: "Status optionally filters the entries to only either firing or resolved.",
+																		Ref:         spec.MustCreateRef("#/components/schemas/createNotificationqueryNotificationStatus"),
+																	},
+																},
+																"to": {
+																	SchemaProps: spec.SchemaProps{
+																		Type:        []string{"string"},
+																		Format:      "date-time",
+																		Description: "To is the starting timestamp for the query.",
+																	},
+																},
+															},
+														}},
+												}},
+										},
+									}},
+								Responses: &spec3.Responses{
+									ResponsesProps: spec3.ResponsesProps{
+										Default: &spec3.Response{
+											ResponseProps: spec3.ResponseProps{
+												Description: "Default OK response",
+												Content: map[string]*spec3.MediaType{
+													"application/json": {
+														MediaTypeProps: spec3.MediaTypeProps{
+															Schema: &spec.Schema{
+																SchemaProps: spec.SchemaProps{
+																	Type: []string{"object"},
+																	Properties: map[string]spec.Schema{
+																		"entries": {
+																			SchemaProps: spec.SchemaProps{
+																				Type: []string{"array"},
+																			},
+																		},
+																	},
+																	Required: []string{
+																		"entries",
+																	},
+																}},
+														}},
+												},
+											},
+										},
+									}},
+							},
+						},
+					},
 				},
 				Cluster: map[string]spec3.PathProps{},
-				Schemas: map[string]spec.Schema{},
+				Schemas: map[string]spec.Schema{
+					"createNotificationqueryMatcher": {
+						SchemaProps: spec.SchemaProps{
+							Type: []string{"object"},
+							Properties: map[string]spec.Schema{
+								"label": {
+									SchemaProps: spec.SchemaProps{
+										Type: []string{"string"},
+									},
+								},
+								"type": {
+									SchemaProps: spec.SchemaProps{
+										Type: []string{"string"},
+										Enum: []interface{}{
+											"=",
+											"!=",
+											"=~",
+											"!~",
+										},
+									},
+								},
+								"value": {
+									SchemaProps: spec.SchemaProps{
+										Type: []string{"string"},
+									},
+								},
+							},
+							Required: []string{
+								"type",
+								"label",
+								"value",
+							},
+						},
+					},
+					"createNotificationqueryMatchers": {
+						SchemaProps: spec.SchemaProps{
+							Type: []string{"array"},
+						},
+					},
+					"createNotificationqueryNotificationEntry": {
+						SchemaProps: spec.SchemaProps{
+							Type: []string{"object"},
+							Properties: map[string]spec.Schema{
+								"alerts": {
+									SchemaProps: spec.SchemaProps{
+										Type:        []string{"array"},
+										Description: "Alerts are the alerts grouped into the notification.",
+									},
+								},
+								"duration": {
+									SchemaProps: spec.SchemaProps{
+										Type:        []string{"integer"},
+										Description: "Duration is the length of time the notification attempt took in nanoseconds.",
+									},
+								},
+								"error": {
+									SchemaProps: spec.SchemaProps{
+										Type:        []string{"string"},
+										Description: "Error is the message returned by the contact point if delivery failed.",
+									},
+								},
+								"groupKey": {
+									SchemaProps: spec.SchemaProps{
+										Type:        []string{"string"},
+										Description: "GroupKey uniquely idenifies the dispatcher alert group.",
+									},
+								},
+								"groupLabels": {
+									SchemaProps: spec.SchemaProps{
+										Type:        []string{"object"},
+										Description: "GroupLabels are the labels uniquely identifying the alert group within a route.",
+										AdditionalProperties: &spec.SchemaOrBool{
+											Schema: &spec.Schema{
+												SchemaProps: spec.SchemaProps{
+													Type: []string{"string"},
+												},
+											},
+										},
+									},
+								},
+								"outcome": {
+									SchemaProps: spec.SchemaProps{
+
+										Description: "Outcome indicaes if the notificaion attempt was successful or if it failed.",
+										Ref:         spec.MustCreateRef("#/components/schemas/createNotificationqueryNotificationOutcome"),
+									},
+								},
+								"pipelineTime": {
+									SchemaProps: spec.SchemaProps{
+										Type:        []string{"string"},
+										Format:      "date-time",
+										Description: "PipelineTime is the time at which the flush began.",
+									},
+								},
+								"receiver": {
+									SchemaProps: spec.SchemaProps{
+										Type:        []string{"string"},
+										Description: "Receiver is the receiver (contact point) title.",
+									},
+								},
+								"retry": {
+									SchemaProps: spec.SchemaProps{
+										Type:        []string{"boolean"},
+										Description: "Retry indicates if the attempt was a retried attempt.",
+									},
+								},
+								"status": {
+									SchemaProps: spec.SchemaProps{
+
+										Description: "Status indicates if the notification contains one or more firing alerts.",
+										Ref:         spec.MustCreateRef("#/components/schemas/createNotificationqueryNotificationStatus"),
+									},
+								},
+								"timestamp": {
+									SchemaProps: spec.SchemaProps{
+										Type:        []string{"string"},
+										Format:      "date-time",
+										Description: "Timestamp is the time at which the notification attempt completed.",
+									},
+								},
+							},
+							Required: []string{
+								"timestamp",
+								"receiver",
+								"status",
+								"outcome",
+								"groupLabels",
+								"alerts",
+								"retry",
+								"duration",
+								"pipelineTime",
+								"groupKey",
+							},
+						},
+					},
+					"createNotificationqueryNotificationEntryAlert": {
+						SchemaProps: spec.SchemaProps{
+							Type: []string{"object"},
+							Properties: map[string]spec.Schema{
+								"annotations": {
+									SchemaProps: spec.SchemaProps{
+										Type: []string{"object"},
+										AdditionalProperties: &spec.SchemaOrBool{
+											Schema: &spec.Schema{
+												SchemaProps: spec.SchemaProps{
+													Type: []string{"string"},
+												},
+											},
+										},
+									},
+								},
+								"endsAt": {
+									SchemaProps: spec.SchemaProps{
+										Type:   []string{"string"},
+										Format: "date-time",
+									},
+								},
+								"labels": {
+									SchemaProps: spec.SchemaProps{
+										Type: []string{"object"},
+										AdditionalProperties: &spec.SchemaOrBool{
+											Schema: &spec.Schema{
+												SchemaProps: spec.SchemaProps{
+													Type: []string{"string"},
+												},
+											},
+										},
+									},
+								},
+								"startsAt": {
+									SchemaProps: spec.SchemaProps{
+										Type:   []string{"string"},
+										Format: "date-time",
+									},
+								},
+								"status": {
+									SchemaProps: spec.SchemaProps{
+										Type: []string{"string"},
+									},
+								},
+							},
+							Required: []string{
+								"status",
+								"labels",
+								"annotations",
+								"startsAt",
+								"endsAt",
+							},
+						},
+					},
+					"createNotificationqueryNotificationOutcome": {
+						SchemaProps: spec.SchemaProps{
+							Type: []string{"string"},
+							Enum: []interface{}{
+								"success",
+								"error",
+							},
+						},
+					},
+					"createNotificationqueryNotificationStatus": {
+						SchemaProps: spec.SchemaProps{
+							Type: []string{"string"},
+							Enum: []interface{}{
+								"firing",
+								"resolved",
+							},
+						},
+					},
+				},
 			},
 		},
 	},
@@ -120,7 +432,8 @@ func ManifestGoTypeAssociator(kind, version string) (goType resource.Kind, exist
 }
 
 var customRouteToGoResponseType = map[string]any{
-	"v0alpha1||<namespace>/alertstate/history|GET": v0alpha1.GetAlertstatehistory{},
+	"v0alpha1||<namespace>/alertstate/history|GET":  v0alpha1.GetAlertstatehistory{},
+	"v0alpha1||<namespace>/notification/query|POST": v0alpha1.CreateNotificationquery{},
 }
 
 // ManifestCustomRouteResponsesAssociator returns the associated response go type for a given kind, version, custom route path, and method, if one exists.
@@ -145,7 +458,9 @@ func ManifestCustomRouteQueryAssociator(kind, version, path, verb string) (goTyp
 	return goType, exists
 }
 
-var customRouteToGoRequestBodyType = map[string]any{}
+var customRouteToGoRequestBodyType = map[string]any{
+	"v0alpha1||<namespace>/notification/query|POST": v0alpha1.CreateNotificationqueryRequestBody{},
+}
 
 func ManifestCustomRouteRequestBodyAssociator(kind, version, path, verb string) (goType any, exists bool) {
 	if len(path) > 0 && path[0] == '/' {

apps/alerting/historian/pkg/app/app.go

@@ -1,8 +1,13 @@
 package app
 
 import (
+	"context"
+	"net/http"
+
 	"github.com/grafana/grafana-app-sdk/app"
 	"github.com/grafana/grafana-app-sdk/simple"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/grafana/grafana/apps/alerting/historian/pkg/apis/alertinghistorian/v0alpha1"
 	"github.com/grafana/grafana/apps/alerting/historian/pkg/app/config"
@@ -21,6 +26,11 @@ func New(cfg app.Config) (app.App, error) {
 					Path:       "/alertstate/history",
 					Method:     "GET",
 				}: runtimeConfig.GetAlertStateHistoryHandler,
+				{
+					Namespaced: true,
+					Path:       "/notification/query",
+					Method:     "POST",
+				}: UnimplementedHandler,
 			},
 		},
 		// TODO: Remove when SDK is fixed.
@@ -43,3 +53,13 @@ func New(cfg app.Config) (app.App, error) {
 
 	return a, nil
 }
+
+func UnimplementedHandler(ctx context.Context, writer app.CustomRouteResponseWriter, request *app.CustomRouteRequest) error {
+	return &apierrors.StatusError{
+		ErrStatus: metav1.Status{
+			Status:  metav1.StatusFailure,
+			Code:    http.StatusUnprocessableEntity,
+			Message: "unimplemented",
+		},
+	}
+}

apps/annotation/kinds/manifest.cue

@@ -10,6 +10,20 @@ manifest: {
 
 v0alpha1: {
     kinds: [annotationv0alpha1]
+    routes: {
+        namespaced: {
+            "/tags": {
+                "GET": {
+                    response: {
+                        tags: [...{
+                            tag: string
+                            count: number
+                        }]
+                    }
+                }
+            }
+        }
+    }
     codegen: {
         ts: {
             enabled: true

apps/annotation/pkg/apis/annotation/v0alpha1/gettags_response_body_types_gen.go

@@ -0,0 +1,26 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package v0alpha1
+
+// +k8s:openapi-gen=true
+type GetTagsBody struct {
+	Tags []V0alpha1GetTagsBodyTags `json:"tags"`
+}
+
+// NewGetTagsBody creates a new GetTagsBody object.
+func NewGetTagsBody() *GetTagsBody {
+	return &GetTagsBody{
+		Tags: []V0alpha1GetTagsBodyTags{},
+	}
+}
+
+// +k8s:openapi-gen=true
+type V0alpha1GetTagsBodyTags struct {
+	Tag   string  `json:"tag"`
+	Count float64 `json:"count"`
+}
+
+// NewV0alpha1GetTagsBodyTags creates a new V0alpha1GetTagsBodyTags object.
+func NewV0alpha1GetTagsBodyTags() *V0alpha1GetTagsBodyTags {
+	return &V0alpha1GetTagsBodyTags{}
+}

apps/annotation/pkg/apis/annotation/v0alpha1/gettags_response_object_types_gen.go

@@ -0,0 +1,37 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package v0alpha1
+
+import (
+	"github.com/grafana/grafana-app-sdk/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+// +k8s:openapi-gen=true
+type GetTags struct {
+	metav1.TypeMeta `json:",inline"`
+	GetTagsBody     `json:",inline"`
+}
+
+func NewGetTags() *GetTags {
+	return &GetTags{}
+}
+
+func (t *GetTagsBody) DeepCopyInto(dst *GetTagsBody) {
+	_ = resource.CopyObjectInto(dst, t)
+}
+
+func (o *GetTags) DeepCopyObject() runtime.Object {
+	dst := NewGetTags()
+	o.DeepCopyInto(dst)
+	return dst
+}
+
+func (o *GetTags) DeepCopyInto(dst *GetTags) {
+	dst.TypeMeta.APIVersion = o.TypeMeta.APIVersion
+	dst.TypeMeta.Kind = o.TypeMeta.Kind
+	o.GetTagsBody.DeepCopyInto(&dst.GetTagsBody)
+}
+
+var _ runtime.Object = NewGetTags()

apps/annotation/pkg/apis/annotation_manifest.go

@@ -43,9 +43,60 @@ var appManifestData = app.ManifestData{
 				},
 			},
 			Routes: app.ManifestVersionRoutes{
-				Namespaced: map[string]spec3.PathProps{},
-				Cluster:    map[string]spec3.PathProps{},
-				Schemas:    map[string]spec.Schema{},
+				Namespaced: map[string]spec3.PathProps{
+					"/tags": {
+						Get: &spec3.Operation{
+							OperationProps: spec3.OperationProps{
+
+								OperationId: "getTags",
+
+								Responses: &spec3.Responses{
+									ResponsesProps: spec3.ResponsesProps{
+										Default: &spec3.Response{
+											ResponseProps: spec3.ResponseProps{
+												Description: "Default OK response",
+												Content: map[string]*spec3.MediaType{
+													"application/json": {
+														MediaTypeProps: spec3.MediaTypeProps{
+															Schema: &spec.Schema{
+																SchemaProps: spec.SchemaProps{
+																	Type: []string{"object"},
+																	Properties: map[string]spec.Schema{
+																		"apiVersion": {
+																			SchemaProps: spec.SchemaProps{
+																				Type:        []string{"string"},
+																				Description: "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources",
+																			},
+																		},
+																		"kind": {
+																			SchemaProps: spec.SchemaProps{
+																				Type:        []string{"string"},
+																				Description: "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds",
+																			},
+																		},
+																		"tags": {
+																			SchemaProps: spec.SchemaProps{
+																				Type: []string{"array"},
+																			},
+																		},
+																	},
+																	Required: []string{
+																		"tags",
+																		"apiVersion",
+																		"kind",
+																	},
+																}},
+														}},
+												},
+											},
+										},
+									}},
+							},
+						},
+					},
+				},
+				Cluster: map[string]spec3.PathProps{},
+				Schemas: map[string]spec.Schema{},
 			},
 		},
 	},
@@ -70,7 +121,9 @@ func ManifestGoTypeAssociator(kind, version string) (goType resource.Kind, exist
 	return goType, exists
 }
 
-var customRouteToGoResponseType = map[string]any{}
+var customRouteToGoResponseType = map[string]any{
+	"v0alpha1||<namespace>/tags|GET": v0alpha1.GetTags{},
+}
 
 // ManifestCustomRouteResponsesAssociator returns the associated response go type for a given kind, version, custom route path, and method, if one exists.
 // kind may be empty for custom routes which are not kind subroutes. Leading slashes are removed from subroute paths.

apps/annotation/pkg/app/app.go

@@ -30,6 +30,23 @@ func New(cfg app.Config) (app.App, error) {
 		},
 	}
 
+	// Add custom route handlers if a TagHandler is provided in SpecificConfig.
+	// The handler is created/owned by the registry layer and passed in via
+	// SpecificConfig to avoid the apps package depending on the registry.
+	if cfg.SpecificConfig != nil {
+		if annotationConfig, ok := cfg.SpecificConfig.(*AnnotationConfig); ok && annotationConfig.TagHandler != nil {
+			simpleConfig.VersionedCustomRoutes = map[string]simple.AppVersionRouteHandlers{
+				"v0alpha1": {
+					{
+						Namespaced: true,
+						Path:       "tags",
+						Method:     "GET",
+					}: annotationConfig.TagHandler,
+				},
+			}
+		}
+	}
+
 	a, err := simple.NewApp(simpleConfig)
 	if err != nil {
 		return nil, err

apps/annotation/pkg/app/config.go

@@ -0,0 +1,16 @@
+package app
+
+import (
+	"context"
+
+	"github.com/grafana/grafana-app-sdk/app"
+)
+
+// AnnotationConfig is the app-specific config for the annotation app. The
+// registry can pass a TagHandler implementation here to wire the /tags
+// resource route into the app without importing registry types.
+type AnnotationConfig struct {
+	// TagHandler is the handler function for the GET /tags custom route.
+	// The function signature matches app.CustomRouteHandler from the app-sdk.
+	TagHandler func(ctx context.Context, writer app.CustomRouteResponseWriter, request *app.CustomRouteRequest) error
+}

apps/dashboard/kinds/v2alpha1/dashboard_spec.cue

@@ -340,7 +340,12 @@ ValueMappingResult: {
 // `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 // `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 // `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+// `continuous-viridis`: Continuous Viridis palette mode
+// `continuous-magma`: Continuous Magma palette mode
+// `continuous-plasma`: Continuous Plasma palette mode
+// `continuous-inferno`: Continuous Inferno palette mode
+// `continuous-cividis`: Continuous Cividis palette mode
+// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 // `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 // `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 // `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -352,7 +357,7 @@ ValueMappingResult: {
 // `continuous-purples`: Continuous Purple palette mode
 // `shades`: Shades of a single color. Specify a single color, useful in an override rule.
 // `fixed`: Fixed color mode. Specify a single color, useful in an override rule.
-FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades"
+FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-viridis" | "continuous-magma" | "continuous-plasma" | "continuous-inferno" | "continuous-cividis" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades"
 
 // Defines how to assign a series color from "by value" color schemes. For example for an aggregated data points like a timeseries, the color can be assigned by the min, max or last value.
 FieldColorSeriesByMode: "min" | "max" | "last"
@@ -377,7 +382,7 @@ FetchOptions: {
 	url: string
 	body?: string
 	// These are 2D arrays of strings, each representing a key-value pair
-	// We are defining them this way because we can't generate a go struct that 
+	// We are defining them this way because we can't generate a go struct that
 	// that would have exactly two strings in each sub-array
 	queryParams?: [...[...string]]
 	headers?: [...[...string]]
@@ -387,7 +392,7 @@ InfinityOptions: FetchOptions & {
 	datasourceUid: string
 }
 
-HttpRequestMethod: "GET" | "PUT" | "POST" | "DELETE" | "PATCH" 
+HttpRequestMethod: "GET" | "PUT" | "POST" | "DELETE" | "PATCH"
 
 // Action variable type
 ActionVariableType: "string"

apps/dashboard/kinds/v2beta1/dashboard_spec.cue

@@ -113,7 +113,7 @@ DashboardLink: {
 	placement?: DashboardLinkPlacement
 }
 
-// Dashboard Link placement. Defines where the link should be displayed. 
+// Dashboard Link placement. Defines where the link should be displayed.
 // - "inControlsMenu" renders the link in bottom part of the dashboard controls dropdown menu
 DashboardLinkPlacement: "inControlsMenu"
 
@@ -342,7 +342,12 @@ ValueMappingResult: {
 // `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 // `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 // `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+// `continuous-viridis`: Continuous Viridis palette mode
+// `continuous-magma`: Continuous Magma palette mode
+// `continuous-plasma`: Continuous Plasma palette mode
+// `continuous-inferno`: Continuous Inferno palette mode
+// `continuous-cividis`: Continuous Cividis palette mode
+// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 // `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 // `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 // `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -354,7 +359,7 @@ ValueMappingResult: {
 // `continuous-purples`: Continuous Purple palette mode
 // `shades`: Shades of a single color. Specify a single color, useful in an override rule.
 // `fixed`: Fixed color mode. Specify a single color, useful in an override rule.
-FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades"
+FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-viridis" | "continuous-magma" | "continuous-plasma" | "continuous-inferno" | "continuous-cividis" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades"
 
 // Defines how to assign a series color from "by value" color schemes. For example for an aggregated data points like a timeseries, the color can be assigned by the min, max or last value.
 FieldColorSeriesByMode: "min" | "max" | "last"
@@ -379,7 +384,7 @@ FetchOptions: {
 	url: string
 	body?: string
 	// These are 2D arrays of strings, each representing a key-value pair
-	// We are defining them this way because we can't generate a go struct that 
+	// We are defining them this way because we can't generate a go struct that
 	// that would have exactly two strings in each sub-array
 	queryParams?: [...[...string]]
 	headers?: [...[...string]]
@@ -389,7 +394,7 @@ InfinityOptions: FetchOptions & {
 	datasourceUid: string
 }
 
-HttpRequestMethod: "GET" | "PUT" | "POST" | "DELETE" | "PATCH" 
+HttpRequestMethod: "GET" | "PUT" | "POST" | "DELETE" | "PATCH"
 
 // Action variable type
 ActionVariableType: "string"

apps/dashboard/pkg/apis/dashboard/v0alpha1/dashboard_kind.cue

@@ -301,8 +301,8 @@ lineage: schemas: [{
 		// Dashboard Link type. Accepted values are dashboards (to refer to another dashboard) and link (to refer to an external resource)
 		#DashboardLinkType: "link" | "dashboards" @cuetsy(kind="type")
 
-		// Dashboard Link placement. Defines where the link should be displayed. 
-		// - "inControlsMenu" renders the link in bottom part of the dashboard controls dropdown menu 
+		// Dashboard Link placement. Defines where the link should be displayed.
+		// - "inControlsMenu" renders the link in bottom part of the dashboard controls dropdown menu
 		#DashboardLinkPlacement: "inControlsMenu" @cuetsy(kind="type")
 
 		// Annotation Query placement. Defines where the annotation query should be displayed.
@@ -318,7 +318,7 @@ lineage: schemas: [{
 			url: string
 			body?: string
 			// These are 2D arrays of strings, each representing a key-value pair
-			// We are defining this way because we can't generate a go struct that 
+			// We are defining this way because we can't generate a go struct that
 			// that would have exactly two strings in each sub-array
 			queryParams?: [...[...string]]
 			headers?: [...[...string]]
@@ -330,7 +330,7 @@ lineage: schemas: [{
 			url: string
 			body?: string
 			// These are 2D arrays of strings, each representing a key-value pair
-			// We are defining them this way because we can't generate a go struct that 
+			// We are defining them this way because we can't generate a go struct that
 			// that would have exactly two strings in each sub-array
 			queryParams?: [...[...string]]
 			headers?: [...[...string]]
@@ -381,7 +381,12 @@ lineage: schemas: [{
 		// `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 		// `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 		// `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-		// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+		// `continuous-viridis`: Continuous Viridis palette mode
+		// `continuous-magma`: Continuous Magma palette mode
+		// `continuous-plasma`: Continuous Plasma palette mode
+		// `continuous-inferno`: Continuous Inferno palette mode
+		// `continuous-cividis`: Continuous Cividis palette mode
+		// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 		// `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 		// `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 		// `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -393,7 +398,7 @@ lineage: schemas: [{
 		// `continuous-purples`: Continuous Purple palette mode
 		// `shades`: Shades of a single color. Specify a single color, useful in an override rule.
 		// `fixed`: Fixed color mode. Specify a single color, useful in an override rule.
-		#FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades" @cuetsy(kind="enum",memberNames="Thresholds|PaletteClassic|PaletteClassicByName|ContinuousGrYlRd|ContinuousRdYlGr|ContinuousBlYlRd|ContinuousYlRd|ContinuousBlPu|ContinuousYlBl|ContinuousBlues|ContinuousReds|ContinuousGreens|ContinuousPurples|Fixed|Shades") @grafanamaturity(NeedsExpertReview)
+		#FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-viridis" | "continuous-magma" | "continuous-plasma" | "continuous-inferno" | "continuous-cividis" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades" @cuetsy(kind="enum",memberNames="Thresholds|PaletteClassic|PaletteClassicByName|ContinuousViridis|ContinuousMagma|ContinuousPlasma|ContinuousInferno|ContinuousCividis|ContinuousGrYlRd|ContinuousRdYlGr|ContinuousBlYlRd|ContinuousYlRd|ContinuousBlPu|ContinuousYlBl|ContinuousBlues|ContinuousReds|ContinuousGreens|ContinuousPurples|Fixed|Shades") @grafanamaturity(NeedsExpertReview)
 
 		// Defines how to assign a series color from "by value" color schemes. For example for an aggregated data points like a timeseries, the color can be assigned by the min, max or last value.
 		#FieldColorSeriesByMode: "min" | "max" | "last" @cuetsy(kind="type")

apps/dashboard/pkg/apis/dashboard/v1beta1/dashboard_kind.cue

@@ -301,8 +301,8 @@ lineage: schemas: [{
 		// Dashboard Link type. Accepted values are dashboards (to refer to another dashboard) and link (to refer to an external resource)
 		#DashboardLinkType: "link" | "dashboards" @cuetsy(kind="type")
 
-		// Dashboard Link placement. Defines where the link should be displayed. 
-		// - "inControlsMenu" renders the link in bottom part of the dashboard controls dropdown menu 
+		// Dashboard Link placement. Defines where the link should be displayed.
+		// - "inControlsMenu" renders the link in bottom part of the dashboard controls dropdown menu
 		#DashboardLinkPlacement: "inControlsMenu" @cuetsy(kind="type")
 
 		// Annotation Query placement. Defines where the annotation query should be displayed.
@@ -318,7 +318,7 @@ lineage: schemas: [{
 			url: string
 			body?: string
 			// These are 2D arrays of strings, each representing a key-value pair
-			// We are defining this way because we can't generate a go struct that 
+			// We are defining this way because we can't generate a go struct that
 			// that would have exactly two strings in each sub-array
 			queryParams?: [...[...string]]
 			headers?: [...[...string]]
@@ -330,7 +330,7 @@ lineage: schemas: [{
 			url: string
 			body?: string
 			// These are 2D arrays of strings, each representing a key-value pair
-			// We are defining them this way because we can't generate a go struct that 
+			// We are defining them this way because we can't generate a go struct that
 			// that would have exactly two strings in each sub-array
 			queryParams?: [...[...string]]
 			headers?: [...[...string]]
@@ -381,7 +381,12 @@ lineage: schemas: [{
 		// `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 		// `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 		// `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-		// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+		// `continuous-viridis`: Continuous Viridis palette mode
+		// `continuous-magma`: Continuous Magma palette mode
+		// `continuous-plasma`: Continuous Plasma palette mode
+		// `continuous-inferno`: Continuous Inferno palette mode
+		// `continuous-cividis`: Continuous Cividis palette mode
+		// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 		// `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 		// `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 		// `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -393,7 +398,7 @@ lineage: schemas: [{
 		// `continuous-purples`: Continuous Purple palette mode
 		// `shades`: Shades of a single color. Specify a single color, useful in an override rule.
 		// `fixed`: Fixed color mode. Specify a single color, useful in an override rule.
-		#FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades" @cuetsy(kind="enum",memberNames="Thresholds|PaletteClassic|PaletteClassicByName|ContinuousGrYlRd|ContinuousRdYlGr|ContinuousBlYlRd|ContinuousYlRd|ContinuousBlPu|ContinuousYlBl|ContinuousBlues|ContinuousReds|ContinuousGreens|ContinuousPurples|Fixed|Shades") @grafanamaturity(NeedsExpertReview)
+		#FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-viridis" | "continuous-magma" | "continuous-plasma" | "continuous-inferno" | "continuous-cividis" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades" @cuetsy(kind="enum",memberNames="Thresholds|PaletteClassic|PaletteClassicByName|ContinuousViridis|ContinuousMagma|ContinuousPlasma|ContinuousInferno|ContinuousCividis|ContinuousGrYlRd|ContinuousRdYlGr|ContinuousBlYlRd|ContinuousYlRd|ContinuousBlPu|ContinuousYlBl|ContinuousBlues|ContinuousReds|ContinuousGreens|ContinuousPurples|Fixed|Shades") @grafanamaturity(NeedsExpertReview)
 
 		// Defines how to assign a series color from "by value" color schemes. For example for an aggregated data points like a timeseries, the color can be assigned by the min, max or last value.
 		#FieldColorSeriesByMode: "min" | "max" | "last" @cuetsy(kind="type")

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

@@ -344,7 +344,12 @@ ValueMappingResult: {
 // `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 // `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 // `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+// `continuous-viridis`: Continuous Viridis palette mode
+// `continuous-magma`: Continuous Magma palette mode
+// `continuous-plasma`: Continuous Plasma palette mode
+// `continuous-inferno`: Continuous Inferno palette mode
+// `continuous-cividis`: Continuous Cividis palette mode
+// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 // `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 // `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 // `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -356,7 +361,7 @@ ValueMappingResult: {
 // `continuous-purples`: Continuous Purple palette mode
 // `shades`: Shades of a single color. Specify a single color, useful in an override rule.
 // `fixed`: Fixed color mode. Specify a single color, useful in an override rule.
-FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades"
+FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-viridis" | "continuous-magma" | "continuous-plasma" | "continuous-inferno" | "continuous-cividis" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades"
 
 // Defines how to assign a series color from "by value" color schemes. For example for an aggregated data points like a timeseries, the color can be assigned by the min, max or last value.
 FieldColorSeriesByMode: "min" | "max" | "last"
@@ -381,7 +386,7 @@ FetchOptions: {
 	url: string
 	body?: string
 	// These are 2D arrays of strings, each representing a key-value pair
-	// We are defining them this way because we can't generate a go struct that 
+	// We are defining them this way because we can't generate a go struct that
 	// that would have exactly two strings in each sub-array
 	queryParams?: [...[...string]]
 	headers?: [...[...string]]
@@ -391,7 +396,7 @@ InfinityOptions: FetchOptions & {
 	datasourceUid: string
 }
 
-HttpRequestMethod: "GET" | "PUT" | "POST" | "DELETE" | "PATCH" 
+HttpRequestMethod: "GET" | "PUT" | "POST" | "DELETE" | "PATCH"
 
 // Action variable type
 ActionVariableType: "string"

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

@@ -583,7 +583,12 @@ func NewDashboardFieldColor() *DashboardFieldColor {
 // `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 // `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 // `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+// `continuous-viridis`: Continuous Viridis palette mode
+// `continuous-magma`: Continuous Magma palette mode
+// `continuous-plasma`: Continuous Plasma palette mode
+// `continuous-inferno`: Continuous Inferno palette mode
+// `continuous-cividis`: Continuous Cividis palette mode
+// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 // `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 // `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 // `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -602,6 +607,11 @@ const (
 	DashboardFieldColorModeIdThresholds           DashboardFieldColorModeId = "thresholds"
 	DashboardFieldColorModeIdPaletteClassic       DashboardFieldColorModeId = "palette-classic"
 	DashboardFieldColorModeIdPaletteClassicByName DashboardFieldColorModeId = "palette-classic-by-name"
+	DashboardFieldColorModeIdContinuousViridis    DashboardFieldColorModeId = "continuous-viridis"
+	DashboardFieldColorModeIdContinuousMagma      DashboardFieldColorModeId = "continuous-magma"
+	DashboardFieldColorModeIdContinuousPlasma     DashboardFieldColorModeId = "continuous-plasma"
+	DashboardFieldColorModeIdContinuousInferno    DashboardFieldColorModeId = "continuous-inferno"
+	DashboardFieldColorModeIdContinuousCividis    DashboardFieldColorModeId = "continuous-cividis"
 	DashboardFieldColorModeIdContinuousGrYlRd     DashboardFieldColorModeId = "continuous-GrYlRd"
 	DashboardFieldColorModeIdContinuousRdYlGr     DashboardFieldColorModeId = "continuous-RdYlGr"
 	DashboardFieldColorModeIdContinuousBlYlRd     DashboardFieldColorModeId = "continuous-BlYlRd"

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

@@ -117,7 +117,7 @@ DashboardLink: {
 	placement?: DashboardLinkPlacement
 }
 
-// Dashboard Link placement. Defines where the link should be displayed. 
+// Dashboard Link placement. Defines where the link should be displayed.
 // - "inControlsMenu" renders the link in bottom part of the dashboard controls dropdown menu
 DashboardLinkPlacement: "inControlsMenu"
 
@@ -346,7 +346,12 @@ ValueMappingResult: {
 // `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 // `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 // `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+// `continuous-viridis`: Continuous Viridis palette mode
+// `continuous-magma`: Continuous Magma palette mode
+// `continuous-plasma`: Continuous Plasma palette mode
+// `continuous-inferno`: Continuous Inferno palette mode
+// `continuous-cividis`: Continuous Cividis palette mode
+// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 // `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 // `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 // `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -358,7 +363,7 @@ ValueMappingResult: {
 // `continuous-purples`: Continuous Purple palette mode
 // `shades`: Shades of a single color. Specify a single color, useful in an override rule.
 // `fixed`: Fixed color mode. Specify a single color, useful in an override rule.
-FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades"
+FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-viridis" | "continuous-magma" | "continuous-plasma" | "continuous-inferno" | "continuous-cividis" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades"
 
 // Defines how to assign a series color from "by value" color schemes. For example for an aggregated data points like a timeseries, the color can be assigned by the min, max or last value.
 FieldColorSeriesByMode: "min" | "max" | "last"
@@ -383,7 +388,7 @@ FetchOptions: {
 	url: string
 	body?: string
 	// These are 2D arrays of strings, each representing a key-value pair
-	// We are defining them this way because we can't generate a go struct that 
+	// We are defining them this way because we can't generate a go struct that
 	// that would have exactly two strings in each sub-array
 	queryParams?: [...[...string]]
 	headers?: [...[...string]]
@@ -393,7 +398,7 @@ InfinityOptions: FetchOptions & {
 	datasourceUid: string
 }
 
-HttpRequestMethod: "GET" | "PUT" | "POST" | "DELETE" | "PATCH" 
+HttpRequestMethod: "GET" | "PUT" | "POST" | "DELETE" | "PATCH"
 
 // Action variable type
 ActionVariableType: "string"

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

@@ -587,7 +587,12 @@ func NewDashboardFieldColor() *DashboardFieldColor {
 // `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 // `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 // `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+// `continuous-viridis`: Continuous Viridis palette mode
+// `continuous-magma`: Continuous Magma palette mode
+// `continuous-plasma`: Continuous Plasma palette mode
+// `continuous-inferno`: Continuous Inferno palette mode
+// `continuous-cividis`: Continuous Cividis palette mode
+// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 // `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 // `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 // `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -606,6 +611,11 @@ const (
 	DashboardFieldColorModeIdThresholds           DashboardFieldColorModeId = "thresholds"
 	DashboardFieldColorModeIdPaletteClassic       DashboardFieldColorModeId = "palette-classic"
 	DashboardFieldColorModeIdPaletteClassicByName DashboardFieldColorModeId = "palette-classic-by-name"
+	DashboardFieldColorModeIdContinuousViridis    DashboardFieldColorModeId = "continuous-viridis"
+	DashboardFieldColorModeIdContinuousMagma      DashboardFieldColorModeId = "continuous-magma"
+	DashboardFieldColorModeIdContinuousPlasma     DashboardFieldColorModeId = "continuous-plasma"
+	DashboardFieldColorModeIdContinuousInferno    DashboardFieldColorModeId = "continuous-inferno"
+	DashboardFieldColorModeIdContinuousCividis    DashboardFieldColorModeId = "continuous-cividis"
 	DashboardFieldColorModeIdContinuousGrYlRd     DashboardFieldColorModeId = "continuous-GrYlRd"
 	DashboardFieldColorModeIdContinuousRdYlGr     DashboardFieldColorModeId = "continuous-RdYlGr"
 	DashboardFieldColorModeIdContinuousBlYlRd     DashboardFieldColorModeId = "continuous-BlYlRd"

apps/plugins/kinds/pluginmeta.cue

@@ -53,6 +53,7 @@ pluginMetaV0Alpha1: {
 	skipDataQuery?: bool
 	state?:         "alpha" | "beta"
 	streaming?:     bool
+	suggestions?:   bool
 	tracing?:       bool
 	iam?:           #IAM
 	// +listType=atomic

apps/plugins/pkg/apis/plugins/v0alpha1/pluginmeta_spec_gen.go

@@ -40,6 +40,7 @@ type PluginMetaJSONData struct {
 	SkipDataQuery *bool                    `json:"skipDataQuery,omitempty"`
 	State         *PluginMetaJSONDataState `json:"state,omitempty"`
 	Streaming     *bool                    `json:"streaming,omitempty"`
+	Suggestions   *bool                    `json:"suggestions,omitempty"`
 	Tracing       *bool                    `json:"tracing,omitempty"`
 	Iam           *PluginMetaIAM           `json:"iam,omitempty"`
 	// +listType=atomic

apps/provisioning/pkg/repository/local/watch.go

@@ -28,6 +28,7 @@ type fileWatcher struct {
 	timers   map[string]*time.Timer
 	watcher  *fsnotify.Watcher
 	logger   logging.Logger
+	closed   bool
 }
 
 // File watcher that buffers events for 100ms before actually firing them
@@ -77,22 +78,21 @@ func NewFileWatcher(path string, accept func(string) bool) (FileWatcher, error)
 
 // Keep watching for changes until the context is done
 func (f *fileWatcher) Watch(ctx context.Context, events chan<- string) {
+	defer f.cleanup(events)
+
 	for {
 		select {
 		case <-ctx.Done():
-			close(events)
 			return
 
 		case _, ok := <-f.watcher.Errors:
 			if !ok { // Channel was closed (i.e. Watcher.Close() was called).
-				close(events)
 				return
 			}
 
 		// Read from Events.
 		case e, ok := <-f.watcher.Events:
 			if !ok { // Channel was closed (i.e. Watcher.Close() was called).
-				close(events)
 				return
 			}
 			name := filepath.Base(e.Name)
@@ -114,6 +114,11 @@ func (f *fileWatcher) Watch(ctx context.Context, events chan<- string) {
 			if !ok {
 				nameCopy := e.Name
 				t = time.AfterFunc(math.MaxInt64, func() {
+					// before sending the event, check if the watcher has been closed
+					if f.closed {
+						return
+					}
+
 					path, _ := strings.CutPrefix(nameCopy, f.prefix)
 					events <- path
 
@@ -128,3 +133,17 @@ func (f *fileWatcher) Watch(ctx context.Context, events chan<- string) {
 		}
 	}
 }
+
+// stop all pending timers and close the event channel
+func (f *fileWatcher) cleanup(events chan<- string) {
+	f.timersMu.Lock()
+	defer f.timersMu.Unlock()
+
+	for _, timer := range f.timers {
+		timer.Stop()
+	}
+	f.timers = make(map[string]*time.Timer)
+
+	close(events)
+	f.closed = true
+}

docs/sources/developers/plugins/plugin.schema.json

@@ -341,6 +341,10 @@
       "type": "boolean",
       "description": "Initialize plugin on startup. By default, the plugin initializes on first use, but when preload is set to true the plugin loads when the Grafana web app loads the first time. Only applicable to app plugins. When setting to `true`, implement [frontend code splitting](https://grafana.com/developers/plugin-tools/get-started/best-practices#app-plugins) to minimise performance implications."
     },
+    "suggestions": {
+      "type": "boolean",
+      "description": "For panel plugins. If set to true, the plugin's suggestions supplier will be invoked and any suggestions returned will be included in the Suggestions pane in the Panel Editor."
+    },
     "queryOptions": {
       "type": "object",
       "description": "For data source plugins. There is a query options section in the plugin's query editor and these options can be turned on if needed.",

docs/sources/visualizations/panels-visualizations/visualizations/node-graph/index.md

@@ -22,7 +22,7 @@ weight: 100
 
 # Node graph
 
-Node graphs are useful when you need to visualize elements that are related to each other. This is done by displaying circles—or _nodes_—for each element you want to visualize, connected by lines—or _edges_. The visualization uses a directed force layout that positions the nodes into a network of connected circles.
+Node graphs are useful when you need to visualize elements that are related to each other. This is done by displaying circles—or _nodes_—for each element you want to visualize, connected by lines—or _edges_. By default, the visualization uses a [layered layout](#layout-algorithm) that positions the nodes into a network of connected circles.
 
 Node graphs display useful information about each node, as well as the relationships between them, allowing you to visualize complex infrastructure maps, hierarchies, or execution diagrams.
 
@@ -123,26 +123,32 @@ You can pan the view by clicking outside any node or edge and dragging your mous
 
 Use the buttons in the lower right corner to zoom in or out. You can also use the mouse wheel or touchpad scroll, together with either Ctrl or Cmd key to do so.
 
+### Switch layouts
+
+Switch quickly between displaying the visualization in graph or grid [layout](#layout-algorithm).
+
+Click a node and select either **Show in Grid layout** or **Show in Graph layout**, depending on the current layout of the visualization:
+
+{{< figure src="/media/docs/grafana/panels-visualizations/screenshot-node-graph-grid-menu.png" max-width="750px" alt="Node graph in grid layout with node menu open" >}}
+
+In grid layout, you can sort nodes by clicking on the stats inside the legend.
+The marker next to the stat name shows which stat is currently used for sorting and the sorting direction:
+
+{{< figure src="/media/docs/grafana/panels-visualizations/screenshot-node-graph-legend-sort.png" max-width="550px" alt="Node graph legend sorting" >}}
+
+Switching between grid and other layouts this way only changes the layout temporarily.
+The visualization maintains the layout algorithm selected in the panel editor, and reverts to it when the dashboard refreshes.
+
+For more information about layouts, refer to [Layout algorithm](#layout-algorithm).
+
+<!-- if you have the panel in grid layout and switch it to graph, is it switching to layered? -->
+
 ### Hidden nodes
 
 The number of nodes shown at a given time is limited to maintain a reasonable visualization performance. Nodes that are not currently visible are hidden behind clickable markers that show an approximate number of hidden nodes that are connected by a particular edge. You can click on the marker to expand the graph around that node.
 
 ![Node graph exploration](/media/docs/grafana/panels-visualizations/node-graph-exploration-8.0-2.png 'Node graph exploration')
 
-### Grid view
-
-You can switch to the grid view to have a better overview of the most interesting nodes in the graph. Grid view shows nodes in a grid without edges and can be sorted by stats shown inside the node or by stats represented by the a colored border of the nodes.
-
-![Node graph grid](/media/docs/grafana/panels-visualizations/screenshot-node-graph-grid-v11.3.png 'Node graph grid')
-
-To sort the nodes, click on the stats inside the legend. The marker next to the stat name shows which stat is currently used for sorting and sorting direction.
-
-![Node graph legend](/media/docs/grafana/panels-visualizations/screenshot-node-graph-legend-v11.3.png 'Node graph legend')
-
-Click on the node and select "Show in Graph layout" option to switch back to graph layout and focus on the selected node, to show it in context of the full graph.
-
-![Node graph grid to default](/media/docs/grafana/panels-visualizations/screenshot-node-graph-view-v11.3.png 'Node graph grid to default')
-
 ## Configuration options
 
 {{< docs/shared lookup="visualizations/config-options-intro.md" source="grafana" version="<GRAFANA_VERSION>" >}}
@@ -155,7 +161,24 @@ Click on the node and select "Show in Graph layout" option to switch back to gra
 
 Use the following options to refine your node graph visualization.
 
-- **Zoom mode** - Choose how the node graph should handle zoom and scroll events.
+#### Zoom mode
+
+Choose how the node graph should handle zoom and scroll events:
+
+- **Cooperative** - Allows you to scroll the visualization normally.
+- **Greedy** - Reacts to all zoom gestures.
+
+#### Layout algorithm
+
+Choose how the visualization layout is generated:
+
+- **Layered** - Default. Creates a predictable and orderly layout, especially useful for service graphs.
+- **Force** - Uses a physics-based force layout algorithm that's useful with a large number of nodes (500+).
+- **Grid** - Arranges nodes into a grid format to provide a better overview of the most interesting nodes in the graph. This layout shows nodes in a grid without edges and can be sorted by the stats shown inside the node or by the ones represented by the a colored border of the nodes.
+
+  {{< figure src="/media/docs/grafana/panels-visualizations/screenshot-node-graph-grid.png" max-width="650px" alt="Node graph in grid layout" >}}
+
+  For more information about using the graph in grid layout, refer to [Switch layouts](#switch-layouts).
 
 ### Nodes options
 
@@ -239,6 +262,6 @@ Optional fields:
 | arc\_\_\*     | number        | Any field prefixed with `arc__` will be used to create the color circle around the node. All values in these fields should add up to 1. You can specify color using `config.color.fixedColor`.                                                                                                                                                                           |
 | detail\_\_\*  | string/number | Any field prefixed with `detail__` will be shown in the header of context menu when clicked on the node. Use `config.displayName` for more human readable label.                                                                                                                                                                                                         |
 | color         | string/number | Can be used to specify a single color instead of using the `arc__` fields to specify color sections. It can be either a string which should then be an acceptable HTML color string or it can be a number in which case the behavior depends on `field.config.color.mode` setting. This can be for example used to create gradient colors controlled by the field value. |
-| icon          | string        | Name of the icon to show inside the node instead of the default stats. Only Grafana [built in icons](https://developers.grafana.com/ui/latest/index.html?path=/story/iconography-icon--icons-overview)) are allowed.                                                                                                                                                     |
+| icon          | string        | Name of the icon to show inside the node instead of the default stats. Only Grafana [built in icons](https://developers.grafana.com/ui/latest/index.html?path=/story/iconography-icon--icons-overview) are allowed.                                                                                                                                                      |
 | nodeRadius    | number        | Radius value in pixels. Used to manage node size.                                                                                                                                                                                                                                                                                                                        |
 | highlighted   | boolean       | Sets whether the node should be highlighted. Useful for example to represent a specific path in the graph by highlighting several nodes and edges. Default: `false`                                                                                                                                                                                                      |

go.work.sum

@@ -870,6 +870,17 @@ github.com/grafana/grafana-app-sdk/logging v0.39.0/go.mod h1:WhDENSnaGHtyVVwZGVn
 github.com/grafana/grafana-app-sdk/logging v0.39.1/go.mod h1:WhDENSnaGHtyVVwZGVnAR7YLvh2xlLDYR3D7E6h7XVk=
 github.com/grafana/grafana-app-sdk/logging v0.40.0/go.mod h1:otUD9XpJD7A5sCLb8mcs9hIXGdeV6lnhzVwe747g4RU=
 github.com/grafana/grafana-app-sdk/logging v0.40.2/go.mod h1:otUD9XpJD7A5sCLb8mcs9hIXGdeV6lnhzVwe747g4RU=
+github.com/grafana/gomemcache v0.0.0-20250228145437-da7b95fd2ac1/go.mod h1:j/s0jkda4UXTemDs7Pgw/vMT06alWc42CHisvYac0qw=
+github.com/grafana/grafana-app-sdk v0.40.1/go.mod h1:4P8h7VB6KcDjX9bAoBQc6IP8iNylxe6bSXLR9gA39gM=
+github.com/grafana/grafana-app-sdk v0.41.0 h1:SYHN3U7B1myRKY3UZZDkFsue9TDmAOap0UrQVTqtYBU=
+github.com/grafana/grafana-app-sdk v0.41.0/go.mod h1:Wg/3vEZfok1hhIWiHaaJm+FwkosfO98o8KbeLFEnZpY=
+github.com/grafana/grafana-app-sdk v0.46.0/go.mod h1:LCTrqR1SwBS13XGVYveBmM7giJDDjzuXK+M9VzPuPWc=
+github.com/grafana/grafana-app-sdk v0.47.0/go.mod h1:kywXmkppq0oReUMzkjTW8Fq2EBzyN7v914jttTWnWxA=
+github.com/grafana/grafana-app-sdk/logging v0.38.0/go.mod h1:Y/bvbDhBiV/tkIle9RW49pgfSPIPSON8Q4qjx3pyqDk=
+github.com/grafana/grafana-app-sdk/logging v0.39.0 h1:3GgN5+dUZYqq74Q+GT9/ET+yo+V54zWQk/Q2/JsJQB4=
+github.com/grafana/grafana-app-sdk/logging v0.39.0/go.mod h1:WhDENSnaGHtyVVwZGVnAR7YLvh2xlLDYR3D7E6h7XVk=
+github.com/grafana/grafana-app-sdk/logging v0.39.1/go.mod h1:WhDENSnaGHtyVVwZGVnAR7YLvh2xlLDYR3D7E6h7XVk=
+github.com/grafana/grafana-app-sdk/logging v0.40.0/go.mod h1:otUD9XpJD7A5sCLb8mcs9hIXGdeV6lnhzVwe747g4RU=
 github.com/grafana/grafana-app-sdk/logging v0.43.0/go.mod h1:0xrjKSGY5z+NLGuGsXQpxiCHR4Smu79i/CbAfdkaB1M=
 github.com/grafana/grafana-app-sdk/logging v0.43.1/go.mod h1:0xrjKSGY5z+NLGuGsXQpxiCHR4Smu79i/CbAfdkaB1M=
 github.com/grafana/grafana-app-sdk/logging v0.43.2/go.mod h1:Gh/nBWnspK3oDNWtiM5qUF/fardHzOIEez+SPI3JeHA=

kinds/dashboard/dashboard_kind.cue

@@ -297,8 +297,8 @@ lineage: schemas: [{
 		// Dashboard Link type. Accepted values are dashboards (to refer to another dashboard) and link (to refer to an external resource)
 		#DashboardLinkType: "link" | "dashboards" @cuetsy(kind="type")
 
-		// Dashboard Link placement. Defines where the link should be displayed. 
-		// - "inControlsMenu" renders the link in bottom part of the dashboard controls dropdown menu 
+		// Dashboard Link placement. Defines where the link should be displayed.
+		// - "inControlsMenu" renders the link in bottom part of the dashboard controls dropdown menu
 		#DashboardLinkPlacement: "inControlsMenu" @cuetsy(kind="type")
 
 		// Annotation Query placement. Defines where the annotation query should be displayed.
@@ -314,7 +314,7 @@ lineage: schemas: [{
 			url: string
 			body?: string
 			// These are 2D arrays of strings, each representing a key-value pair
-			// We are defining this way because we can't generate a go struct that 
+			// We are defining this way because we can't generate a go struct that
 			// that would have exactly two strings in each sub-array
 			queryParams?: [...[...string]]
 			headers?: [...[...string]]
@@ -326,7 +326,7 @@ lineage: schemas: [{
 			url: string
 			body?: string
 			// These are 2D arrays of strings, each representing a key-value pair
-			// We are defining them this way because we can't generate a go struct that 
+			// We are defining them this way because we can't generate a go struct that
 			// that would have exactly two strings in each sub-array
 			queryParams?: [...[...string]]
 			headers?: [...[...string]]
@@ -377,7 +377,12 @@ lineage: schemas: [{
 		// `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 		// `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 		// `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-		// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+		// `continuous-viridis`: Continuous Viridis palette mode
+		// `continuous-magma`: Continuous Magma palette mode
+		// `continuous-plasma`: Continuous Plasma palette mode
+		// `continuous-inferno`: Continuous Inferno palette mode
+		// `continuous-cividis`: Continuous Cividis palette mode
+		// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 		// `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 		// `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 		// `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -389,7 +394,7 @@ lineage: schemas: [{
 		// `continuous-purples`: Continuous Purple palette mode
 		// `shades`: Shades of a single color. Specify a single color, useful in an override rule.
 		// `fixed`: Fixed color mode. Specify a single color, useful in an override rule.
-		#FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades" @cuetsy(kind="enum",memberNames="Thresholds|PaletteClassic|PaletteClassicByName|ContinuousGrYlRd|ContinuousRdYlGr|ContinuousBlYlRd|ContinuousYlRd|ContinuousBlPu|ContinuousYlBl|ContinuousBlues|ContinuousReds|ContinuousGreens|ContinuousPurples|Fixed|Shades") @grafanamaturity(NeedsExpertReview)
+		#FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-viridis" | "continuous-magma" | "continuous-plasma" | "continuous-inferno" | "continuous-cividis" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades" @cuetsy(kind="enum",memberNames="Thresholds|PaletteClassic|PaletteClassicByName|ContinuousViridis|ContinuousMagma|ContinuousPlasma|ContinuousInferno|ContinuousCividis|ContinuousGrYlRd|ContinuousRdYlGr|ContinuousBlYlRd|ContinuousYlRd|ContinuousBlPu|ContinuousYlBl|ContinuousBlues|ContinuousReds|ContinuousGreens|ContinuousPurples|Fixed|Shades") @grafanamaturity(NeedsExpertReview)
 
 		// Defines how to assign a series color from "by value" color schemes. For example for an aggregated data points like a timeseries, the color can be assigned by the min, max or last value.
 		#FieldColorSeriesByMode: "min" | "max" | "last" @cuetsy(kind="type")

packages/grafana-data/package.json

@@ -63,6 +63,7 @@
     "@types/string-hash": "1.1.3",
     "@types/systemjs": "6.15.3",
     "d3-interpolate": "3.0.1",
+    "d3-scale-chromatic": "3.1.0",
     "date-fns": "4.1.0",
     "dompurify": "3.3.0",
     "eventemitter3": "5.0.1",

packages/grafana-data/src/field/fieldColor.ts

@@ -1,4 +1,11 @@
 import { interpolateRgbBasis } from 'd3-interpolate';
+import {
+  interpolateViridis,
+  interpolateMagma,
+  interpolatePlasma,
+  interpolateInferno,
+  interpolateCividis,
+} from 'd3-scale-chromatic';
 import stringHash from 'string-hash';
 import tinycolor from 'tinycolor2';
 
@@ -75,6 +82,41 @@ export const fieldColorModeRegistry = new Registry<FieldColorMode>(() => {
         );
       },
     }),
+    new FieldColorSchemeMode({
+      id: FieldColorModeId.ContinuousViridis,
+      name: 'Viridis',
+      isContinuous: true,
+      isByValue: true,
+      interpolator: interpolateViridis,
+    }),
+    new FieldColorSchemeMode({
+      id: FieldColorModeId.ContinuousMagma,
+      name: 'Magma',
+      isContinuous: true,
+      isByValue: true,
+      interpolator: interpolateMagma,
+    }),
+    new FieldColorSchemeMode({
+      id: FieldColorModeId.ContinuousPlasma,
+      name: 'Plasma',
+      isContinuous: true,
+      isByValue: true,
+      interpolator: interpolatePlasma,
+    }),
+    new FieldColorSchemeMode({
+      id: FieldColorModeId.ContinuousInferno,
+      name: 'Inferno',
+      isContinuous: true,
+      isByValue: true,
+      interpolator: interpolateInferno,
+    }),
+    new FieldColorSchemeMode({
+      id: FieldColorModeId.ContinuousCividis,
+      name: 'Cividis',
+      isContinuous: true,
+      isByValue: true,
+      interpolator: interpolateCividis,
+    }),
     new FieldColorSchemeMode({
       id: FieldColorModeId.ContinuousGrYlRd,
       name: 'Green-Yellow-Red',
@@ -148,16 +190,27 @@ export const fieldColorModeRegistry = new Registry<FieldColorMode>(() => {
   ];
 });
 
-interface FieldColorSchemeModeOptions {
+interface BaseFieldColorSchemeModeOptions {
   id: FieldColorModeId;
   name: string;
   description?: string;
-  getColors: (theme: GrafanaTheme2) => string[];
   isContinuous: boolean;
   isByValue: boolean;
   useSeriesName?: boolean;
 }
 
+interface FieldColorSchemeModeInterpolator extends BaseFieldColorSchemeModeOptions {
+  interpolator: (value: number) => string;
+  getColors?: never;
+}
+
+interface FieldColorSchemeModeGetColors extends BaseFieldColorSchemeModeOptions {
+  getColors: (theme: GrafanaTheme2) => string[];
+  interpolator?: never;
+}
+
+type FieldColorSchemeModeOptions = FieldColorSchemeModeGetColors | FieldColorSchemeModeInterpolator;
+
 export class FieldColorSchemeMode implements FieldColorMode {
   id: FieldColorModeId;
   name: string;
@@ -178,11 +231,15 @@ export class FieldColorSchemeMode implements FieldColorMode {
     this.isContinuous = options.isContinuous;
     this.isByValue = options.isByValue;
     this.useSeriesName = options.useSeriesName;
+    this.interpolator = options.interpolator;
   }
 
   getColors(theme: GrafanaTheme2): string[] {
     if (!this.getNamedColors) {
-      return [];
+      if (!this.interpolator) {
+        return [];
+      }
+      this.getNamedColors = () => new Array(9).fill(0).map((_, i) => this.getInterpolator()(i / 8));
     }
 
     if (this.colorCache && this.colorCacheTheme === theme) {
@@ -231,12 +288,15 @@ export class FieldColorSchemeMode implements FieldColorMode {
 
 /** @beta */
 export function getFieldColorModeForField(field: Field): FieldColorMode {
-  return fieldColorModeRegistry.get(field.config.color?.mode ?? FieldColorModeId.Thresholds);
+  return (
+    fieldColorModeRegistry.getIfExists(field.config.color?.mode) ??
+    fieldColorModeRegistry.get(FieldColorModeId.Thresholds)
+  );
 }
 
 /** @beta */
 export function getFieldColorMode(mode?: FieldColorModeId | string): FieldColorMode {
-  return fieldColorModeRegistry.get(mode ?? FieldColorModeId.Thresholds);
+  return fieldColorModeRegistry.getIfExists(mode) ?? fieldColorModeRegistry.get(FieldColorModeId.Thresholds);
 }
 
 /**

packages/grafana-data/src/index.ts

@@ -715,11 +715,9 @@ export {
 export {
   type VisualizationSuggestion,
   type VisualizationSuggestionsSupplier,
-  type VisualizationSuggestionsSupplierFn,
   type PanelPluginVisualizationSuggestion,
+  type VisualizationSuggestionsBuilder,
   VisualizationSuggestionScore,
-  VisualizationSuggestionsBuilder,
-  VisualizationSuggestionsListAppender,
 } from './types/suggestions';
 export {
   type MatcherConfig,

packages/grafana-data/src/panel/PanelPlugin.test.tsx

@@ -1,14 +1,18 @@
+import { createDataFrame } from '../dataframe/processDataFrame';
 import { identityOverrideProcessor } from '../field/overrides/processors';
 import {
   StandardEditorsRegistryItem,
   standardEditorsRegistry,
   standardFieldConfigEditorRegistry,
 } from '../field/standardFieldConfigEditorRegistry';
+import { FieldType } from '../types/dataFrame';
 import { FieldConfigProperty, FieldConfigPropertyItem } from '../types/fieldOverrides';
 import { PanelMigrationModel } from '../types/panel';
+import { VisualizationSuggestionsBuilder, VisualizationSuggestionScore } from '../types/suggestions';
 import { PanelOptionsEditorBuilder } from '../utils/OptionsUIBuilders';
 
 import { PanelPlugin } from './PanelPlugin';
+import { getPanelDataSummary } from './suggestions/getPanelDataSummary';
 
 describe('PanelPlugin', () => {
   describe('declarative options', () => {
@@ -483,4 +487,107 @@ describe('PanelPlugin', () => {
       });
     });
   });
+
+  describe('suggestions', () => {
+    it('should register a suggestions supplier', () => {
+      const panel = new PanelPlugin(() => <div>Panel</div>);
+      panel.meta = panel.meta || {};
+      panel.meta.id = 'test-panel';
+      panel.meta.name = 'Test Panel';
+
+      panel.setSuggestionsSupplier((ds) => {
+        if (!ds.hasFieldType(FieldType.number)) {
+          return;
+        }
+
+        return [
+          {
+            name: 'Number Panel',
+            score: VisualizationSuggestionScore.Good,
+          },
+        ];
+      });
+
+      const suggestions = panel.getSuggestions(
+        getPanelDataSummary([createDataFrame({ fields: [{ type: FieldType.number, name: 'Value' }] })])
+      );
+      expect(suggestions).toHaveLength(1);
+      expect(suggestions![0].pluginId).toBe(panel.meta.id);
+      expect(suggestions![0].name).toBe('Number Panel');
+
+      expect(
+        panel.getSuggestions(
+          getPanelDataSummary([createDataFrame({ fields: [{ type: FieldType.string, name: 'Value' }] })])
+        )
+      ).toBeUndefined();
+    });
+
+    it('should not throw for the old syntax, but also should not register suggestions', () => {
+      jest.spyOn(console, 'warn').mockImplementation();
+
+      class DeprecatedSuggestionsSupplier {
+        getSuggestionsForData(builder: VisualizationSuggestionsBuilder): void {
+          const appender = builder.getListAppender({
+            name: 'Deprecated Suggestion',
+            pluginId: 'deprecated-plugin',
+            options: {},
+          });
+
+          if (builder.dataSummary.hasNumberField) {
+            appender.append({});
+          }
+        }
+      }
+
+      const panel = new PanelPlugin(() => <div>Panel</div>);
+
+      expect(() => {
+        panel.setSuggestionsSupplier(new DeprecatedSuggestionsSupplier());
+      }).not.toThrow();
+      expect(console.warn).toHaveBeenCalled();
+      expect(
+        panel.getSuggestions(
+          getPanelDataSummary([
+            createDataFrame({
+              fields: [{ type: FieldType.number, name: 'Value', values: [1, 2, 3, 4, 5] }],
+            }),
+          ])
+        )
+      ).toBeUndefined();
+    });
+
+    it('should support the deprecated pattern of getSuggestionsSupplier with builder', () => {
+      jest.spyOn(console, 'warn').mockImplementation();
+
+      const panel = new PanelPlugin(() => <div>Panel</div>).setSuggestionsSupplier((ds) => {
+        if (!ds.hasFieldType(FieldType.number)) {
+          return;
+        }
+
+        return [
+          {
+            name: 'Number Panel',
+            score: VisualizationSuggestionScore.Good,
+          },
+        ];
+      });
+
+      const oldSupplier = panel.getSuggestionsSupplier();
+      const builder1 = new VisualizationSuggestionsBuilder([
+        createDataFrame({ fields: [{ type: FieldType.number, name: 'Value' }] }),
+      ]);
+      oldSupplier.getSuggestionsForData(builder1);
+      const suggestions1 = builder1.getList();
+      expect(suggestions1).toHaveLength(1);
+      expect(suggestions1![0].pluginId).toBe(panel.meta.id);
+      expect(suggestions1![0].name).toBe('Number Panel');
+
+      const builder2 = new VisualizationSuggestionsBuilder([
+        createDataFrame({ fields: [{ type: FieldType.string, name: 'Value' }] }),
+      ]);
+      oldSupplier.getSuggestionsForData(builder2);
+      const suggestions2 = builder2.getList();
+      expect(suggestions2).toHaveLength(0);
+    });
+  });
 });

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

@@ -1,4 +1,4 @@
-import { set } from 'lodash';
+import { defaultsDeep, set } from 'lodash';
 import { ComponentClass, ComponentType } from 'react';
 
 import { FieldConfigOptionsRegistry } from '../field/FieldConfigOptionsRegistry';
@@ -14,11 +14,19 @@ import {
   PanelPluginDataSupport,
 } from '../types/panel';
 import { GrafanaPlugin } from '../types/plugin';
-import { VisualizationSuggestionsSupplierFn, VisualizationSuggestionsSupplier } from '../types/suggestions';
+import {
+  getSuggestionHash,
+  PanelPluginVisualizationSuggestion,
+  VisualizationSuggestion,
+  VisualizationSuggestionsSupplierDeprecated,
+  VisualizationSuggestionsSupplier,
+  VisualizationSuggestionsBuilder,
+} from '../types/suggestions';
 import { FieldConfigEditorBuilder, PanelOptionsEditorBuilder } from '../utils/OptionsUIBuilders';
 import { deprecationWarning } from '../utils/deprecationWarning';
 
 import { createFieldConfigRegistry } from './registryFactories';
+import { PanelDataSummary } from './suggestions/getPanelDataSummary';
 
 /** @beta */
 export type StandardOptionConfig = {
@@ -109,7 +117,7 @@ export class PanelPlugin<
   };
 
   private optionsSupplier?: PanelOptionsSupplier<TOptions>;
-  private suggestionsSupplier?: VisualizationSuggestionsSupplier;
+  private suggestionsSupplier?: VisualizationSuggestionsSupplier<TOptions, TFieldConfigOptions>;
 
   panel: ComponentType<PanelProps<TOptions>> | null;
   editor?: ComponentClass<PanelEditorProps<TOptions>>;
@@ -363,56 +371,84 @@ export class PanelPlugin<
   }
 
   /**
-   * @deprecated use VisualizationSuggestionsSupplierFn
+   * @deprecated use VisualizationSuggestionsSupplier
    */
-  setSuggestionsSupplier(supplier: VisualizationSuggestionsSupplier): this;
+  setSuggestionsSupplier(supplier: VisualizationSuggestionsSupplierDeprecated): this;
   /**
    * @alpha
    * sets function that can return visualization examples and suggestions.
    */
-  setSuggestionsSupplier(supplier: VisualizationSuggestionsSupplierFn<TOptions, TFieldConfigOptions>): this;
+  setSuggestionsSupplier(supplier: VisualizationSuggestionsSupplier<TOptions, TFieldConfigOptions>): this;
   setSuggestionsSupplier(
-    supplier: VisualizationSuggestionsSupplier | VisualizationSuggestionsSupplierFn<TOptions, TFieldConfigOptions>
+    supplier:
+      | VisualizationSuggestionsSupplier<TOptions, TFieldConfigOptions>
+      | VisualizationSuggestionsSupplierDeprecated
   ): this {
-    this.suggestionsSupplier =
-      typeof supplier === 'function'
-        ? {
-            getSuggestionsForData: (builder) => {
-              const appender = builder.getListAppender<TOptions, TFieldConfigOptions>({
-                pluginId: this.meta.id,
-                name: this.meta.name,
-                options: {},
-                fieldConfig: {
-                  defaults: {},
-                  overrides: [],
-                },
-              });
-
-              const result = supplier(builder.dataSummary);
-
-              if (Array.isArray(result)) {
-                appender.appendAll(result);
-              }
-            },
-          }
-        : supplier;
+    if (typeof supplier !== 'function') {
+      deprecationWarning(
+        'PanelPlugin',
+        'plugin.setSuggestionsSupplier(new Supplier())',
+        'plugin.setSuggestionsSupplier(dataSummary => [...])'
+      );
+      return this;
+    }
+    this.suggestionsSupplier = supplier;
     return this;
   }
 
   /**
-   * Returns the suggestions supplier
    * @alpha
+   * get suggestions based on the PanelDataSummary
    */
-  getSuggestionsSupplier(): VisualizationSuggestionsSupplier | undefined {
-    return this.suggestionsSupplier;
+  getSuggestions(
+    panelDataSummary: PanelDataSummary
+  ): Array<PanelPluginVisualizationSuggestion<TOptions, TFieldConfigOptions>> | void {
+    const withDefaults = (
+      suggestion: VisualizationSuggestion<TOptions, TFieldConfigOptions>
+    ): Omit<PanelPluginVisualizationSuggestion<TOptions, TFieldConfigOptions>, 'hash'> =>
+      defaultsDeep(suggestion, {
+        pluginId: this.meta.id,
+        name: this.meta.name,
+        options: {},
+        fieldConfig: {
+          defaults: {},
+          overrides: [],
+        },
+      } satisfies Omit<PanelPluginVisualizationSuggestion<TOptions, TFieldConfigOptions>, 'hash'>);
+    return this.suggestionsSupplier?.(panelDataSummary)?.map(
+      (s): PanelPluginVisualizationSuggestion<TOptions, TFieldConfigOptions> => {
+        const suggestionWithDefaults = withDefaults(s);
+        return Object.assign(suggestionWithDefaults, { hash: getSuggestionHash(suggestionWithDefaults) });
+      }
+    );
   }
 
   /**
-   * @alpha
-   * returns whether the plugin has configured suggestions
+   * @deprecated use getSuggestions
+   * we have to keep this method intact to support cloud-onboarding plugin.
    */
-  hasSuggestions(): boolean {
-    return this.suggestionsSupplier !== undefined;
+  getSuggestionsSupplier() {
+    const withDefaults = (
+      suggestion: VisualizationSuggestion<TOptions, TFieldConfigOptions>
+    ): Omit<PanelPluginVisualizationSuggestion<TOptions, TFieldConfigOptions>, 'hash'> =>
+      defaultsDeep(suggestion, {
+        pluginId: this.meta.id,
+        name: this.meta.name,
+        options: {},
+        fieldConfig: {
+          defaults: {},
+          overrides: [],
+        },
+      } satisfies Omit<PanelPluginVisualizationSuggestion<TOptions, TFieldConfigOptions>, 'hash'>);
+
+    return {
+      getSuggestionsForData: (builder: VisualizationSuggestionsBuilder) => {
+        deprecationWarning('PanelPlugin', 'getSuggestionsSupplier()', 'getSuggestions(panelDataSummary)');
+        this.suggestionsSupplier?.(builder.dataSummary)?.forEach((s) => {
+          builder.getListAppender(withDefaults(s)).append(s);
+        });
+      },
+    };
   }
 
   hasPluginId(pluginId: string) {

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

@@ -1143,6 +1143,11 @@ export interface FeatureToggles {
   */
   newVizSuggestions?: boolean;
   /**
+  * Enable all plugins to supply visualization suggestions (including 3rd party plugins)
+  * @default false
+  */
+  externalVizSuggestions?: boolean;
+  /**
   * Restrict PanelChrome contents with overflow: hidden;
   * @default true
   */

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

@@ -16,6 +16,11 @@ export enum FieldColorModeId {
   ContinuousReds = 'continuous-reds',
   ContinuousGreens = 'continuous-greens',
   ContinuousPurples = 'continuous-purples',
+  ContinuousViridis = 'continuous-viridis',
+  ContinuousMagma = 'continuous-magma',
+  ContinuousPlasma = 'continuous-plasma',
+  ContinuousInferno = 'continuous-inferno',
+  ContinuousCividis = 'continuous-cividis',
   Fixed = 'fixed',
   Shades = 'shades',
 }

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

@@ -20,6 +20,8 @@ export type InterpolateFunction = (value: string, scopedVars?: ScopedVars, forma
 export interface PanelPluginMeta extends PluginMeta {
   /** Indicates that panel does not issue queries */
   skipDataQuery?: boolean;
+  /** Indicates that the panel implements suggestions */
+  suggestions?: boolean;
   /** Indicates that panel should not be available in visualisation picker */
   hideFromList?: boolean;
   /** Sort order */

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

@@ -2,11 +2,10 @@ import { defaultsDeep } from 'lodash';
 
 import { DataTransformerConfig } from '@grafana/schema';
 
-import { PanelDataSummary, getPanelDataSummary } from '../panel/suggestions/getPanelDataSummary';
+import { getPanelDataSummary, PanelDataSummary } from '../panel/suggestions/getPanelDataSummary';
 
-import { PanelModel } from './dashboard';
+import { DataFrame } from './dataFrame';
 import { FieldConfigSource } from './fieldOverrides';
-import { PanelData } from './panel';
 
 /**
  * @internal
@@ -108,35 +107,6 @@ export enum VisualizationSuggestionScore {
   OK = 50,
 }
 
-/**
- * @internal
- * TODO this will move into the grafana app code once suppliers are migrated.
- */
-export class VisualizationSuggestionsBuilder {
-  /** Summary stats for current data */
-  dataSummary: PanelDataSummary;
-  private list: PanelPluginVisualizationSuggestion[] = [];
-
-  constructor(
-    /** Current data */
-    public data?: PanelData,
-    /** Current panel & options */
-    public panel?: PanelModel
-  ) {
-    this.dataSummary = getPanelDataSummary(data?.series);
-  }
-
-  getListAppender<TOptions extends unknown, TFieldConfig extends {} = {}>(
-    defaults: Omit<PanelPluginVisualizationSuggestion<TOptions, TFieldConfig>, 'hash'>
-  ) {
-    return new VisualizationSuggestionsListAppender<TOptions, TFieldConfig>(this.list, defaults);
-  }
-
-  getList() {
-    return this.list;
-  }
-}
-
 /**
  * @alpha
  * TODO: this name is temporary; it will become just "VisualizationSuggestionsSupplier" when the other interface is deleted.
@@ -147,40 +117,48 @@ export class VisualizationSuggestionsBuilder {
  * - returns an array of VisualizationSuggestions
  * - boolean return equates to "show a single suggestion card for this panel plugin with the default options" (true = show, false or void = hide)
  */
-export type VisualizationSuggestionsSupplierFn<TOptions extends unknown, TFieldConfig extends {} = {}> = (
+export type VisualizationSuggestionsSupplier<TOptions extends unknown, TFieldConfig extends {} = {}> = (
   panelDataSummary: PanelDataSummary
 ) => Array<VisualizationSuggestion<TOptions, TFieldConfig>> | void;
 
 /**
- * @deprecated use VisualizationSuggestionsSupplierFn instead.
+ * DEPRECATED - the below exports need to remain in the code base to help make the transition for the Polystat plugin, which implements
+ * suggestions using the old API. These should be removed for Grafana 13.
  */
-export type VisualizationSuggestionsSupplier = {
-  /**
-   * Adds suitable suggestions for the current data
-   */
+/**
+ * @deprecated use VisualizationSuggestionsSupplier
+ */
+export interface VisualizationSuggestionsSupplierDeprecated {
   getSuggestionsForData: (builder: VisualizationSuggestionsBuilder) => void;
-};
+}
 
 /**
- * @internal
- * TODO this will move into the grafana app code once suppliers are migrated.
+ * @deprecated use VisualizationSuggestionsSupplier
  */
-export class VisualizationSuggestionsListAppender<TOptions extends unknown, TFieldConfig extends {} = {}> {
-  constructor(
-    private list: VisualizationSuggestion[],
-    private defaults: Partial<PanelPluginVisualizationSuggestion<TOptions, TFieldConfig>> = {}
-  ) {}
+export class VisualizationSuggestionsBuilder {
+  public dataSummary: PanelDataSummary;
+  public list: PanelPluginVisualizationSuggestion[] = [];
 
-  append(suggestion: VisualizationSuggestion<TOptions, TFieldConfig>) {
-    this.appendAll([suggestion]);
+  constructor(dataFrames: DataFrame[]) {
+    this.dataSummary = getPanelDataSummary(dataFrames);
   }
 
-  appendAll(suggestions: Array<VisualizationSuggestion<TOptions, TFieldConfig>>) {
-    this.list.push(
-      ...suggestions.map((s): PanelPluginVisualizationSuggestion<TOptions, TFieldConfig> => {
-        const suggestionWithDefaults = defaultsDeep(s, this.defaults);
-        return Object.assign(suggestionWithDefaults, { hash: getSuggestionHash(suggestionWithDefaults) });
-      })
-    );
+  getList(): PanelPluginVisualizationSuggestion[] {
+    return this.list;
+  }
+
+  getListAppender(suggestionDefaults: Omit<PanelPluginVisualizationSuggestion, 'hash'>) {
+    const withDefaults = (suggestion: VisualizationSuggestion): PanelPluginVisualizationSuggestion => {
+      const s = defaultsDeep({}, suggestion, suggestionDefaults);
+      return {
+        ...s,
+        hash: getSuggestionHash(s),
+      };
+    };
+    return {
+      append: (suggestion: VisualizationSuggestion) => {
+        this.list.push(withDefaults(suggestion));
+      },
+    };
   }
 }

packages/grafana-plugin-configs/jest/utils.js

@@ -8,6 +8,7 @@ export const grafanaESModules = [
   'd3',
   'd3-color',
   'd3-interpolate',
+  'd3-scale-chromatic',
   'delaunator',
   'get-user-locale',
   'internmap',

packages/grafana-schema/src/raw/dashboard/x/dashboard_types.gen.ts

@@ -475,7 +475,12 @@ export type VariableType = ('query' | 'adhoc' | 'groupby' | 'constant' | 'dataso
  * `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
  * `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
  * `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
- * `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+ * `continuous-viridis`: Continuous Viridis palette mode
+ * `continuous-magma`: Continuous Magma palette mode
+ * `continuous-plasma`: Continuous Plasma palette mode
+ * `continuous-inferno`: Continuous Inferno palette mode
+ * `continuous-cividis`: Continuous Cividis palette mode
+ * `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
  * `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
  * `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
  * `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -492,11 +497,16 @@ export enum FieldColorModeId {
   ContinuousBlPu = 'continuous-BlPu',
   ContinuousBlYlRd = 'continuous-BlYlRd',
   ContinuousBlues = 'continuous-blues',
+  ContinuousCividis = 'continuous-cividis',
   ContinuousGrYlRd = 'continuous-GrYlRd',
   ContinuousGreens = 'continuous-greens',
+  ContinuousInferno = 'continuous-inferno',
+  ContinuousMagma = 'continuous-magma',
+  ContinuousPlasma = 'continuous-plasma',
   ContinuousPurples = 'continuous-purples',
   ContinuousRdYlGr = 'continuous-RdYlGr',
   ContinuousReds = 'continuous-reds',
+  ContinuousViridis = 'continuous-viridis',
   ContinuousYlBl = 'continuous-YlBl',
   ContinuousYlRd = 'continuous-YlRd',
   Fixed = 'fixed',

packages/grafana-schema/src/schema/dashboard/v2alpha0/dashboard.schema.cue

@@ -334,7 +334,12 @@ ValueMappingResult: {
 // `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 // `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 // `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+// `continuous-viridis`: Continuous Viridis palette mode
+// `continuous-magma`: Continuous Magma palette mode
+// `continuous-plasma`: Continuous Plasma palette mode
+// `continuous-inferno`: Continuous Inferno palette mode
+// `continuous-cividis`: Continuous Cividis palette mode
+// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 // `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 // `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 // `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -346,7 +351,7 @@ ValueMappingResult: {
 // `continuous-purples`: Continuous Purple palette mode
 // `shades`: Shades of a single color. Specify a single color, useful in an override rule.
 // `fixed`: Fixed color mode. Specify a single color, useful in an override rule.
-FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades"
+FieldColorModeId: "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-viridis" | "continuous-magma" | "continuous-plasma" | "continuous-inferno" | "continuous-cividis" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades"
 
 // Defines how to assign a series color from "by value" color schemes. For example for an aggregated data points like a timeseries, the color can be assigned by the min, max or last value.
 FieldColorSeriesByMode: "min" | "max" | "last"

packages/grafana-schema/src/schema/dashboard/v2alpha0/types.gen.ts

@@ -327,7 +327,7 @@ export interface FieldConfig {
 	description?: string;
 	// An explicit path to the field in the datasource.  When the frame meta includes a path,
 	// This will default to `${frame.meta.path}/${field.name}
-	// 
+	//
 	// When defined, this value can be used as an identifier within the datasource scope, and
 	// may be used to update the results
 	path?: string;
@@ -529,7 +529,12 @@ export const defaultFieldColor = (): FieldColor => ({
 // `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 // `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 // `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+// `continuous-viridis`: Continuous Viridis palette mode
+// `continuous-magma`: Continuous Magma palette mode
+// `continuous-plasma`: Continuous Plasma palette mode
+// `continuous-inferno`: Continuous Inferno palette mode
+// `continuous-cividis`: Continuous Cividis palette mode
+// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 // `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 // `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 // `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -541,7 +546,7 @@ export const defaultFieldColor = (): FieldColor => ({
 // `continuous-purples`: Continuous Purple palette mode
 // `shades`: Shades of a single color. Specify a single color, useful in an override rule.
 // `fixed`: Fixed color mode. Specify a single color, useful in an override rule.
-export type FieldColorModeId = "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades";
+export type FieldColorModeId = "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-viridis" | "continuous-magma" | "continuous-plasma" | "continuous-inferno" | "continuous-cividis" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades";
 
 export const defaultFieldColorModeId = (): FieldColorModeId => ("thresholds");
 

packages/grafana-schema/src/schema/dashboard/v2alpha1/types.spec.gen.ts

@@ -489,7 +489,12 @@ export const defaultFieldColor = (): FieldColor => ({
 // `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 // `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 // `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+// `continuous-viridis`: Continuous Viridis palette mode
+// `continuous-magma`: Continuous Magma palette mode
+// `continuous-plasma`: Continuous Plasma palette mode
+// `continuous-inferno`: Continuous Inferno palette mode
+// `continuous-cividis`: Continuous Cividis palette mode
+// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 // `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 // `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 // `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -501,7 +506,7 @@ export const defaultFieldColor = (): FieldColor => ({
 // `continuous-purples`: Continuous Purple palette mode
 // `shades`: Shades of a single color. Specify a single color, useful in an override rule.
 // `fixed`: Fixed color mode. Specify a single color, useful in an override rule.
-export type FieldColorModeId = "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades";
+export type FieldColorModeId = "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-viridis" | "continuous-magma" | "continuous-plasma" | "continuous-inferno" | "continuous-cividis" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades";
 
 export const defaultFieldColorModeId = (): FieldColorModeId => ("thresholds");
 

packages/grafana-schema/src/schema/dashboard/v2beta1/types.spec.gen.ts

@@ -496,7 +496,12 @@ export const defaultFieldColor = (): FieldColor => ({
 // `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 // `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 // `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+// `continuous-viridis`: Continuous Viridis palette mode
+// `continuous-magma`: Continuous Magma palette mode
+// `continuous-plasma`: Continuous Plasma palette mode
+// `continuous-inferno`: Continuous Inferno palette mode
+// `continuous-cividis`: Continuous Cividis palette mode
+// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 // `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 // `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 // `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -508,7 +513,7 @@ export const defaultFieldColor = (): FieldColor => ({
 // `continuous-purples`: Continuous Purple palette mode
 // `shades`: Shades of a single color. Specify a single color, useful in an override rule.
 // `fixed`: Fixed color mode. Specify a single color, useful in an override rule.
-export type FieldColorModeId = "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades";
+export type FieldColorModeId = "thresholds" | "palette-classic" | "palette-classic-by-name" | "continuous-viridis" | "continuous-magma" | "continuous-plasma" | "continuous-inferno" | "continuous-cividis" | "continuous-GrYlRd" | "continuous-RdYlGr" | "continuous-BlYlRd" | "continuous-YlRd" | "continuous-BlPu" | "continuous-YlBl" | "continuous-blues" | "continuous-reds" | "continuous-greens" | "continuous-purples" | "fixed" | "shades";
 
 export const defaultFieldColorModeId = (): FieldColorModeId => ("thresholds");
 

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

@@ -518,6 +518,7 @@ const getStyles = (theme: GrafanaTheme2) => {
 
   return {
     container: css({
+      height: '100%',
       position: 'relative',
     }),
     panel: css({

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

@@ -23,13 +23,32 @@ describe('Sidebar', () => {
     // Verify pane is closed
     expect(screen.queryByTestId('sidebar-pane-header-title')).not.toBeInTheDocument();
   });
+
+  it('Can persist docked state', async () => {
+    const { unmount } = render(<TestSetup persistanceKey="test" />);
+
+    act(() => screen.getByLabelText('Settings').click());
+    act(() => screen.getByLabelText('Dock').click());
+
+    unmount();
+
+    render(<TestSetup persistanceKey="test" />);
+
+    act(() => screen.getByLabelText('Settings').click());
+    expect(screen.getByLabelText('Undock')).toBeInTheDocument();
+  });
 });
 
-function TestSetup() {
+interface TestSetupProps {
+  persistanceKey?: string;
+}
+
+function TestSetup({ persistanceKey }: TestSetupProps) {
   const [openPane, setOpenPane] = React.useState('');
   const contextValue = useSidebar({
     position: 'right',
     hasOpenPane: openPane !== '',
+    persistanceKey,
     onClosePane: () => setOpenPane(''),
   });
 

packages/grafana-ui/src/components/Sidebar/useSidebar.tsx

@@ -1,6 +1,8 @@
 import { clamp } from 'lodash';
 import React, { useCallback } from 'react';
 
+import { store } from '@grafana/data';
+
 import { useTheme2 } from '../../themes/ThemeContext';
 
 export type SidebarPosition = 'left' | 'right';
@@ -30,7 +32,10 @@ export interface UseSideBarOptions {
   hasOpenPane?: boolean;
   position?: SidebarPosition;
   tabsMode?: boolean;
-  compactDefault?: boolean;
+  /** Initial state for compact mode */
+  defaultToCompact?: boolean;
+  /** Initial state for docked mode */
+  defaultToDocked?: boolean;
   /** defaults to 2 grid units (16px) */
   bottomMargin?: number;
   /** defaults to 2 grid units (16px) */
@@ -39,6 +44,11 @@ export interface UseSideBarOptions {
   contentMargin?: number;
   /** Called when pane is closed or clicked outside of (in undocked mode) */
   onClosePane?: () => void;
+  /**
+   * Optional key to use for persisting sidebar state (docked / compact / size)
+   * Can only be app name as the final local storag key will be `grafana.ui.sidebar.{persistanceKey}.{docked|compact|size}`
+   */
+  persistanceKey?: string;
 }
 
 export const SIDE_BAR_WIDTH_ICON_ONLY = 5;
@@ -48,21 +58,30 @@ export function useSidebar({
   hasOpenPane,
   position = 'right',
   tabsMode,
-  compactDefault = true,
+  defaultToCompact = true,
+  defaultToDocked = false,
   bottomMargin = 2,
   edgeMargin = 2,
   contentMargin = 2,
+  persistanceKey,
   onClosePane,
 }: UseSideBarOptions): SidebarContextValue {
   const theme = useTheme2();
-  const [isDocked, setIsDocked] = React.useState(false);
-  const [paneWidth, setPaneWidth] = React.useState(280);
-  const [compact, setCompact] = React.useState(compactDefault);
+
+  const [isDocked, setIsDocked] = useSidebarSavedState(persistanceKey, 'docked', defaultToDocked);
+  const [compact, setCompact] = useSidebarSavedState(persistanceKey, 'compact', defaultToCompact);
+  const [paneWidth, setPaneWidth] = useSidebarSavedState(persistanceKey, 'size', 280);
+
   // Used to accumulate drag distance to know when to change compact mode
   const [_, setCompactDrag] = React.useState(0);
 
-  const onToggleDock = useCallback(() => setIsDocked((prev) => !prev), []);
+  const onToggleDock = useCallback(() => {
+    setIsDocked((prev) => {
+      return !prev;
+    });
+  }, [setIsDocked]);
 
+  // Calculate how much space the outer wrapper needs to reserve for the sidebar toolbar + pane (if docked)
   const prop = position === 'right' ? 'paddingRight' : 'paddingLeft';
   const toolbarWidth =
     ((compact ? SIDE_BAR_WIDTH_ICON_ONLY : SIDE_BAR_WIDTH_WITH_TEXT) + edgeMargin + contentMargin) *
@@ -82,10 +101,10 @@ export function useSidebar({
           setCompactDrag((prevDrag) => {
             const newDrag = prevDrag + diff;
             if (newDrag < -20 && !compact) {
-              setCompact(true);
+              setCompact(() => true);
               return 0;
             } else if (newDrag > 20 && compact) {
-              setCompact(false);
+              setCompact(() => false);
               return 0;
             }
 
@@ -98,7 +117,7 @@ export function useSidebar({
         return clamp(prevWidth + diff, 100, 500);
       });
     },
-    [hasOpenPane, compact]
+    [hasOpenPane, setCompact, setPaneWidth, compact]
   );
 
   return {
@@ -117,3 +136,53 @@ export function useSidebar({
     onClosePane,
   };
 }
+
+function useSidebarSavedState<T = number | boolean>(
+  persistanceKey: string | undefined,
+  subKey: string,
+  defaultValue: T
+) {
+  const [state, setState] = React.useState<T>(() => {
+    if (!persistanceKey) {
+      return defaultValue;
+    }
+
+    if (typeof defaultValue === 'boolean') {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return store.getBool(`grafana.ui.sidebar.${persistanceKey}.${subKey}`, defaultValue) as T;
+    }
+
+    if (typeof defaultValue === 'number') {
+      const value = Number.parseInt(store.get(`grafana.ui.sidebar.${persistanceKey}.${subKey}`), 10);
+      if (Number.isNaN(value)) {
+        return defaultValue;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return value as T;
+    }
+
+    return defaultValue;
+  });
+
+  const setPersisted = useCallback(
+    (cb: (prevState: T) => T) => {
+      setState((prevState) => {
+        const newState = cb(prevState);
+
+        if (!persistanceKey) {
+          return newState;
+        }
+
+        if (persistanceKey) {
+          store.set(`grafana.ui.sidebar.${persistanceKey}.${subKey}`, String(newState));
+        }
+
+        return newState;
+      });
+    },
+    [persistanceKey, subKey]
+  );
+
+  return [state, setPersisted] as const;
+}

pkg/api/frontendsettings.go

@@ -164,6 +164,7 @@ func (hs *HTTPServer) getFrontendSettings(c *contextmodel.ReqContext) (*dtos.Fro
 			ModuleHash:      hs.pluginAssets.ModuleHash(c.Req.Context(), panel),
 			BaseURL:         panel.BaseURL,
 			SkipDataQuery:   panel.SkipDataQuery,
+			Suggestions:     panel.Suggestions,
 			HideFromList:    panel.HideFromList,
 			ReleaseState:    string(panel.State),
 			Signature:       string(panel.Signature),

pkg/api/swagger.go

@@ -30,10 +30,8 @@ func (hs *HTTPServer) registerSwaggerUI(r routing.RouteRegister) {
 		}
 
 		data := map[string]any{
-			"Nonce":          c.RequestNonce,
-			"Assets":         assets,
-			"FavIcon":        "public/img/fav32.png",
-			"AppleTouchIcon": "public/img/apple-touch-icon.png",
+			"Nonce":  c.RequestNonce,
+			"Assets": assets,
 		}
 		if hs.Cfg.CSPEnabled {
 			data["CSPEnabled"] = true

pkg/infra/metrics/metrics.go

@@ -222,6 +222,10 @@ var (
 
 	// MStatTotalRepositories is a metric total amount of repositories
 	MStatTotalRepositories prometheus.Gauge
+
+	// MUnifiedStorageMigrationStatus indicates the migration status for unified storage in this instance.
+	// Possible values: 0 (default/undefined), 1 (migration disabled), 2 (migration would run).
+	MUnifiedStorageMigrationStatus prometheus.Gauge
 )
 
 const (
@@ -691,6 +695,12 @@ func init() {
 		Help:      "total amount of repositories",
 		Namespace: ExporterName,
 	})
+
+	MUnifiedStorageMigrationStatus = prometheus.NewGauge(prometheus.GaugeOpts{
+		Name:      "unified_storage_migration_status",
+		Help:      "indicates whether this instance would run unified storage migrations (0=undefined, 1=migration disabled, 2=would run)",
+		Namespace: ExporterName,
+	})
 }
 
 // SetBuildInformation sets the build information for this binary
@@ -829,5 +839,6 @@ func initMetricVars(reg prometheus.Registerer) {
 		MStatTotalRepositories,
 		MFolderIDsAPICount,
 		MFolderIDsServiceCount,
+		MUnifiedStorageMigrationStatus,
 	)
 }

pkg/kinds/dashboard/dashboard_spec_gen.go

@@ -619,7 +619,12 @@ func NewFieldColor() *FieldColor {
 // `thresholds`: From thresholds. Informs Grafana to take the color from the matching threshold
 // `palette-classic`: Classic palette. Grafana will assign color by looking up a color in a palette by series index. Useful for Graphs and pie charts and other categorical data visualizations
 // `palette-classic-by-name`: Classic palette (by name). Grafana will assign color by looking up a color in a palette by series name. Useful for Graphs and pie charts and other categorical data visualizations
-// `continuous-GrYlRd`: ontinuous Green-Yellow-Red palette mode
+// `continuous-viridis`: Continuous Viridis palette mode
+// `continuous-magma`: Continuous Magma palette mode
+// `continuous-plasma`: Continuous Plasma palette mode
+// `continuous-inferno`: Continuous Inferno palette mode
+// `continuous-cividis`: Continuous Cividis palette mode
+// `continuous-GrYlRd`: Continuous Green-Yellow-Red palette mode
 // `continuous-RdYlGr`: Continuous Red-Yellow-Green palette mode
 // `continuous-BlYlRd`: Continuous Blue-Yellow-Red palette mode
 // `continuous-YlRd`: Continuous Yellow-Red palette mode
@@ -637,6 +642,11 @@ const (
 	FieldColorModeIdThresholds           FieldColorModeId = "thresholds"
 	FieldColorModeIdPaletteClassic       FieldColorModeId = "palette-classic"
 	FieldColorModeIdPaletteClassicByName FieldColorModeId = "palette-classic-by-name"
+	FieldColorModeIdContinuousViridis    FieldColorModeId = "continuous-viridis"
+	FieldColorModeIdContinuousMagma      FieldColorModeId = "continuous-magma"
+	FieldColorModeIdContinuousPlasma     FieldColorModeId = "continuous-plasma"
+	FieldColorModeIdContinuousInferno    FieldColorModeId = "continuous-inferno"
+	FieldColorModeIdContinuousCividis    FieldColorModeId = "continuous-cividis"
 	FieldColorModeIdContinuousGrYlRd     FieldColorModeId = "continuous-GrYlRd"
 	FieldColorModeIdContinuousRdYlGr     FieldColorModeId = "continuous-RdYlGr"
 	FieldColorModeIdContinuousBlYlRd     FieldColorModeId = "continuous-BlYlRd"

pkg/plugins/models.go

@@ -319,6 +319,7 @@ type PanelDTO struct {
 	HideFromList    bool              `json:"hideFromList"`
 	Sort            int               `json:"sort"`
 	SkipDataQuery   bool              `json:"skipDataQuery"`
+	Suggestions     bool              `json:"suggestions,omitempty"`
 	ReleaseState    string            `json:"state"`
 	BaseURL         string            `json:"baseUrl"`
 	Signature       string            `json:"signature"`

pkg/plugins/plugins.go

@@ -105,6 +105,7 @@ type JSONData struct {
 
 	// Panel settings
 	SkipDataQuery bool `json:"skipDataQuery"`
+	Suggestions   bool `json:"suggestions,omitempty"`
 
 	// App settings
 	AutoEnabled bool       `json:"autoEnabled"`

pkg/registry/apps/annotation/memory_store.go

@@ -0,0 +1,158 @@
+package annotation
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/google/uuid"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	annotationV0 "github.com/grafana/grafana/apps/annotation/pkg/apis/annotation/v0alpha1"
+)
+
+type memoryStore struct {
+	mu   sync.RWMutex
+	data map[string]*annotationV0.Annotation
+}
+
+func NewMemoryStore() Store {
+	return &memoryStore{
+		data: make(map[string]*annotationV0.Annotation),
+	}
+}
+
+func (m *memoryStore) Get(ctx context.Context, namespace, name string) (*annotationV0.Annotation, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	key := namespace + "/" + name
+	anno, ok := m.data[key]
+	if !ok {
+		return nil, fmt.Errorf("annotation not found")
+	}
+
+	return anno.DeepCopy(), nil
+}
+
+func (m *memoryStore) List(ctx context.Context, namespace string, opts ListOptions) (*AnnotationList, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	//nolint:prealloc
+	var result []annotationV0.Annotation // no, we can't pre-alloc it, we don't know the size yet
+
+	for _, anno := range m.data {
+		if anno.Namespace != namespace {
+			continue
+		}
+
+		if opts.DashboardUID != "" && (anno.Spec.DashboardUID == nil || *anno.Spec.DashboardUID != opts.DashboardUID) {
+			continue
+		}
+
+		if opts.PanelID != 0 && (anno.Spec.PanelID == nil || *anno.Spec.PanelID != opts.PanelID) {
+			continue
+		}
+
+		if opts.From > 0 && anno.Spec.Time < opts.From {
+			continue
+		}
+
+		if opts.To > 0 && anno.Spec.Time > opts.To {
+			continue
+		}
+
+		result = append(result, *anno.DeepCopy())
+
+		if opts.Limit > 0 && int64(len(result)) >= opts.Limit {
+			break
+		}
+	}
+
+	return &AnnotationList{Items: result}, nil
+}
+
+func (m *memoryStore) Create(ctx context.Context, anno *annotationV0.Annotation) (*annotationV0.Annotation, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if anno.Name == "" {
+		anno.Name = uuid.New().String()
+	}
+
+	key := anno.Namespace + "/" + anno.Name
+
+	if _, exists := m.data[key]; exists {
+		return nil, fmt.Errorf("annotation already exists")
+	}
+
+	created := anno.DeepCopy()
+	if created.CreationTimestamp.IsZero() {
+		created.CreationTimestamp = metav1.Now()
+	}
+
+	m.data[key] = created
+
+	return created, nil
+}
+
+func (m *memoryStore) Update(ctx context.Context, anno *annotationV0.Annotation) (*annotationV0.Annotation, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	key := anno.Namespace + "/" + anno.Name
+
+	if _, exists := m.data[key]; !exists {
+		return nil, fmt.Errorf("annotation not found")
+	}
+
+	updated := anno.DeepCopy()
+	m.data[key] = updated
+
+	return updated, nil
+}
+
+func (m *memoryStore) Delete(ctx context.Context, namespace, name string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	key := namespace + "/" + name
+
+	if _, exists := m.data[key]; !exists {
+		return fmt.Errorf("annotation not found")
+	}
+
+	delete(m.data, key)
+	return nil
+}
+
+func (m *memoryStore) ListTags(ctx context.Context, namespace string, opts TagListOptions) ([]Tag, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	tagCounts := make(map[string]int64)
+
+	for _, anno := range m.data {
+		if anno.Namespace != namespace {
+			continue
+		}
+		for _, tag := range anno.Spec.Tags {
+			if opts.Prefix == "" || strings.HasPrefix(tag, opts.Prefix) {
+				tagCounts[tag]++
+			}
+		}
+	}
+
+	tags := make([]Tag, 0, len(tagCounts))
+	for name, count := range tagCounts {
+		tags = append(tags, Tag{Name: name, Count: count})
+	}
+
+	if opts.Limit > 0 && len(tags) > opts.Limit {
+		tags = tags[:opts.Limit]
+	}
+
+	return tags, nil
+}

pkg/registry/apps/annotation/register.go

@@ -12,6 +12,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/selection"
+	"k8s.io/apiserver/pkg/endpoints/request"
 	"k8s.io/apiserver/pkg/registry/rest"
 	restclient "k8s.io/client-go/rest"
 
@@ -21,12 +22,11 @@ import (
 	"github.com/grafana/grafana/apps/annotation/pkg/apis"
 	annotationV0 "github.com/grafana/grafana/apps/annotation/pkg/apis/annotation/v0alpha1"
 	annotationapp "github.com/grafana/grafana/apps/annotation/pkg/app"
-	"github.com/grafana/grafana/pkg/apimachinery/identity"
 	"github.com/grafana/grafana/pkg/apimachinery/utils"
 	apiserverrest "github.com/grafana/grafana/pkg/apiserver/rest"
 	"github.com/grafana/grafana/pkg/services/annotations"
 	"github.com/grafana/grafana/pkg/services/apiserver/appinstaller"
-	"github.com/grafana/grafana/pkg/services/apiserver/endpoints/request"
+	grafrequest "github.com/grafana/grafana/pkg/services/apiserver/endpoints/request"
 	"github.com/grafana/grafana/pkg/services/featuremgmt"
 	"github.com/grafana/grafana/pkg/setting"
 )
@@ -46,15 +46,32 @@ func RegisterAppInstaller(
 	cfg *setting.Cfg,
 	features featuremgmt.FeatureToggles,
 	service annotations.Repository,
+	cleaner annotations.Cleaner,
 ) (*AnnotationAppInstaller, error) {
 	installer := &AnnotationAppInstaller{
 		cfg: cfg,
 	}
+
+	var tagHandler func(context.Context, app.CustomRouteResponseWriter, *app.CustomRouteRequest) error
+	if service != nil {
+		mapper := grafrequest.GetNamespaceMapper(cfg)
+		sqlAdapter := NewSQLAdapter(service, cleaner, mapper, cfg)
+		installer.legacy = &legacyStorage{
+			store:  sqlAdapter,
+			mapper: mapper,
+		}
+		// Create the tags handler using the sqlAdapter as TagProvider
+		tagHandler = newTagsHandler(sqlAdapter)
+	}
+
 	provider := simple.NewAppProvider(apis.LocalManifest(), nil, annotationapp.New)
 
 	appConfig := app.Config{
-		KubeConfig:   restclient.Config{}, // this will be overridden by the installer's InitializeApp method
+		KubeConfig:   restclient.Config{},
 		ManifestData: *apis.LocalManifest().ManifestData,
+		SpecificConfig: &annotationapp.AnnotationConfig{
+			TagHandler: tagHandler,
+		},
 	}
 	i, err := appsdkapiserver.NewDefaultAppInstaller(provider, appConfig, apis.NewGoTypeAssociator())
 	if err != nil {
@@ -62,13 +79,6 @@ func RegisterAppInstaller(
 	}
 	installer.AppInstaller = i
 
-	if service != nil {
-		installer.legacy = &legacyStorage{
-			service:    service,
-			namespacer: request.GetNamespaceMapper(cfg),
-		}
-	}
-
 	return installer, nil
 }
 
@@ -79,9 +89,11 @@ func (a *AnnotationAppInstaller) GetLegacyStorage(requested schema.GroupVersionR
 		Version:  kind.Version(),
 		Resource: kind.Plural(),
 	}
+
 	if requested.String() != gvr.String() {
 		return nil
 	}
+
 	a.legacy.tableConverter = utils.NewTableConverter(
 		gvr.GroupResource(),
 		utils.TableColumns{
@@ -114,8 +126,8 @@ var (
 )
 
 type legacyStorage struct {
-	service        annotations.Repository
-	namespacer     request.NamespaceMapper
+	store          Store
+	mapper         grafrequest.NamespaceMapper
 	tableConverter rest.TableConvertor
 }
 
@@ -142,21 +154,15 @@ func (s *legacyStorage) ConvertToTable(ctx context.Context, object runtime.Objec
 }
 
 func (s *legacyStorage) List(ctx context.Context, options *internalversion.ListOptions) (runtime.Object, error) {
-	orgID, err := request.OrgIDForList(ctx)
-	if err != nil {
-		return nil, err
-	}
-	user, err := identity.GetRequester(ctx)
-	if err != nil {
-		return nil, err
-	}
-	query := &annotations.ItemQuery{OrgID: orgID, SignedInUser: user, AlertID: -1}
+	namespace := request.NamespaceValue(ctx)
+
+	opts := ListOptions{}
 	if options.FieldSelector != nil {
 		for _, r := range options.FieldSelector.Requirements() {
 			switch r.Field {
 			case "spec.dashboardUID":
 				if r.Operator == selection.Equals || r.Operator == selection.DoubleEquals {
-					query.DashboardUID = r.Value
+					opts.DashboardUID = r.Value
 				} else {
 					return nil, fmt.Errorf("unsupported operator %s for spec.dashboardUID (only = supported)", r.Operator)
 				}
@@ -167,7 +173,7 @@ func (s *legacyStorage) List(ctx context.Context, options *internalversion.ListO
 					if err != nil {
 						return nil, fmt.Errorf("invalid panelID value %q: %w", r.Value, err)
 					}
-					query.PanelID = panelID
+					opts.PanelID = panelID
 				} else {
 					return nil, fmt.Errorf("unsupported operator %s for spec.panelID (only = supported)", r.Operator)
 				}
@@ -178,13 +184,13 @@ func (s *legacyStorage) List(ctx context.Context, options *internalversion.ListO
 					if err != nil {
 						return nil, fmt.Errorf("invalid time value %q: %w", r.Value, err)
 					}
-					query.From = from
+					opts.From = from
 				case selection.LessThan:
 					to, err := strconv.ParseInt(r.Value, 10, 64)
 					if err != nil {
 						return nil, fmt.Errorf("invalid time value %q: %w", r.Value, err)
 					}
-					query.To = to
+					opts.To = to
 				default:
 					return nil, fmt.Errorf("unsupported operator %s for spec.time (only >, < supported for ranges)", r.Operator)
 				}
@@ -196,13 +202,13 @@ func (s *legacyStorage) List(ctx context.Context, options *internalversion.ListO
 					if err != nil {
 						return nil, fmt.Errorf("invalid timeEnd value %q: %w", r.Value, err)
 					}
-					query.From = from
+					opts.From = from
 				case selection.LessThan:
 					to, err := strconv.ParseInt(r.Value, 10, 64)
 					if err != nil {
 						return nil, fmt.Errorf("invalid timeEnd value %q: %w", r.Value, err)
 					}
-					query.To = to
+					opts.To = to
 				default:
 					return nil, fmt.Errorf("unsupported operator %s for spec.timeEnd (only >, < supported for ranges)", r.Operator)
 				}
@@ -213,31 +219,22 @@ func (s *legacyStorage) List(ctx context.Context, options *internalversion.ListO
 		}
 	}
 
-	query.Limit = 100
+	opts.Limit = 100
 	if options.Limit > 0 {
-		query.Limit = options.Limit
+		opts.Limit = options.Limit
 	}
-	items, err := s.service.Find(ctx, query)
+
+	result, err := s.store.List(ctx, namespace, opts)
 	if err != nil {
 		return nil, err
 	}
-	list := &annotationV0.AnnotationList{
-		Items: make([]annotationV0.Annotation, len(items)),
-	}
-	for i, item := range items {
-		c, err := toK8sResource(orgID, item, s.namespacer)
-		if err != nil {
-			return nil, err
-		}
-		list.Items[i] = *c
-	}
 
-	// TODO: pagination?
-	return list, nil
+	return &annotationV0.AnnotationList{Items: result.Items}, nil
 }
 
 func (s *legacyStorage) Get(ctx context.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
-	return nil, errors.New("fetching single annotations not supported by legacy storage")
+	namespace := request.NamespaceValue(ctx)
+	return s.store.Get(ctx, namespace, name)
 }
 
 func (s *legacyStorage) Create(ctx context.Context,
@@ -245,22 +242,11 @@ func (s *legacyStorage) Create(ctx context.Context,
 	createValidation rest.ValidateObjectFunc,
 	options *metav1.CreateOptions,
 ) (runtime.Object, error) {
-	return nil, errors.New("not implemented")
-	// resource, ok := obj.(*correlationsV0.Correlation)
-	// if !ok {
-	// 	return nil, fmt.Errorf("expected correlation")
-	// }
-	//
-	// cmd, err := correlations.ToCreateCorrelationCommand(resource)
-	// if err != nil {
-	// 	return nil, err
-	// }
-	//
-	// out, err := s.service.CreateCorrelation(ctx, *cmd)
-	// if err != nil {
-	// 	return nil, err
-	// }
-	// return s.Get(ctx, out.UID, &metav1.GetOptions{})
+	resource, ok := obj.(*annotationV0.Annotation)
+	if !ok {
+		return nil, fmt.Errorf("expected annotation")
+	}
+	return s.store.Create(ctx, resource)
 }
 
 func (s *legacyStorage) Update(ctx context.Context,
@@ -272,73 +258,14 @@ func (s *legacyStorage) Update(ctx context.Context,
 	options *metav1.UpdateOptions,
 ) (runtime.Object, bool, error) {
 	return nil, false, errors.New("not implemented")
-	// before, err := s.Get(ctx, name, &metav1.GetOptions{})
-	// if err != nil {
-	// 	return nil, false, err
-	// }
-	// obj, err := objInfo.UpdatedObject(ctx, before)
-	// if err != nil {
-	// 	return nil, false, err
-	// }
-	//
-	// resource, ok := obj.(*correlationsV0.Correlation)
-	// if !ok {
-	// 	return nil, false, fmt.Errorf("expected correlation")
-	// }
-	//
-	// cmd, err := correlations.ToUpdateCorrelationCommand(resource)
-	// if err != nil {
-	// 	return nil, false, err
-	// }
-	//
-	// out, err := s.service.UpdateCorrelation(ctx, *cmd)
-	// if err != nil {
-	// 	return nil, false, err
-	// }
-	// obj, err = s.Get(ctx, out.UID, &metav1.GetOptions{})
-	// return obj, false, err
 }
 
-// GracefulDeleter
 func (s *legacyStorage) Delete(ctx context.Context, name string, deleteValidation rest.ValidateObjectFunc, options *metav1.DeleteOptions) (runtime.Object, bool, error) {
-	return nil, false, errors.New("not implemented")
-	// orgID, err := request.OrgIDForList(ctx)
-	// if err != nil {
-	// 	return nil, false, err
-	// }
-	// err = s.service.DeleteCorrelation(ctx, correlations.DeleteCorrelationCommand{
-	// 	OrgId: orgID,
-	// 	UID:   name,
-	// })
-	// return nil, (err == nil), err
+	namespace := request.NamespaceValue(ctx)
+	err := s.store.Delete(ctx, namespace, name)
+	return nil, false, err
 }
 
-// CollectionDeleter
 func (s *legacyStorage) DeleteCollection(ctx context.Context, deleteValidation rest.ValidateObjectFunc, options *metav1.DeleteOptions, listOptions *internalversion.ListOptions) (runtime.Object, error) {
-	return nil, fmt.Errorf("DeleteCollection for annotation not implemented")
-}
-
-func toK8sResource(orgID int64, item *annotations.ItemDTO, namespacer request.NamespaceMapper) (*annotationV0.Annotation, error) {
-	annotation := &annotationV0.Annotation{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      fmt.Sprintf("a-%d", item.ID), // FIXME
-			Namespace: namespacer(orgID),
-		},
-		Spec: annotationV0.AnnotationSpec{
-			Text: item.Text,
-			Time: item.Time,
-			Tags: item.Tags,
-		},
-	}
-
-	if item.DashboardUID != nil && *item.DashboardUID != "" {
-		annotation.Spec.DashboardUID = item.DashboardUID
-	}
-	if item.PanelID != 0 {
-		annotation.Spec.PanelID = &item.PanelID
-	}
-	if item.TimeEnd != 0 {
-		annotation.Spec.TimeEnd = &item.TimeEnd
-	}
-	return annotation, nil
+	return nil, fmt.Errorf("DeleteCollection for annotation is not available")
 }

pkg/registry/apps/annotation/sql_adapter.go

@@ -0,0 +1,255 @@
+package annotation
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	claims "github.com/grafana/authlib/types"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	annotationV0 "github.com/grafana/grafana/apps/annotation/pkg/apis/annotation/v0alpha1"
+	"github.com/grafana/grafana/pkg/apimachinery/identity"
+	"github.com/grafana/grafana/pkg/services/annotations"
+	"github.com/grafana/grafana/pkg/services/apiserver/endpoints/request"
+	"github.com/grafana/grafana/pkg/setting"
+)
+
+type sqlAdapter struct {
+	repo     annotations.Repository
+	cleaner  annotations.Cleaner
+	nsMapper request.NamespaceMapper
+	cfg      *setting.Cfg
+}
+
+func NewSQLAdapter(repo annotations.Repository, cleaner annotations.Cleaner, nsMapper request.NamespaceMapper, cfg *setting.Cfg) *sqlAdapter {
+	return &sqlAdapter{
+		repo:     repo,
+		cleaner:  cleaner,
+		nsMapper: nsMapper,
+		cfg:      cfg,
+	}
+}
+
+func (a *sqlAdapter) Get(ctx context.Context, namespace, name string) (*annotationV0.Annotation, error) {
+	id, err := parseAnnotationID(name)
+	if err != nil {
+		return nil, err
+	}
+
+	orgID, err := namespaceToOrgID(ctx, namespace)
+	if err != nil {
+		return nil, err
+	}
+
+	user, err := identity.GetRequester(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	query := &annotations.ItemQuery{
+		SignedInUser: user,
+		OrgID:        orgID,
+		Limit:        1000,
+		AlertID:      -1,
+	}
+
+	items, err := a.repo.Find(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, item := range items {
+		if item.ID == id {
+			return a.toK8sResource(item, namespace), nil
+		}
+	}
+
+	return nil, fmt.Errorf("annotation not found")
+}
+
+func (a *sqlAdapter) List(ctx context.Context, namespace string, opts ListOptions) (*AnnotationList, error) {
+	orgID, err := namespaceToOrgID(ctx, namespace)
+	if err != nil {
+		return nil, err
+	}
+
+	user, err := identity.GetRequester(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	query := &annotations.ItemQuery{
+		SignedInUser: user,
+		OrgID:        orgID,
+		DashboardUID: opts.DashboardUID,
+		PanelID:      opts.PanelID,
+		From:         opts.From,
+		To:           opts.To,
+		Limit:        opts.Limit,
+		AlertID:      -1,
+	}
+
+	items, err := a.repo.Find(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+
+	result := make([]annotationV0.Annotation, 0, len(items))
+	for _, item := range items {
+		result = append(result, *a.toK8sResource(item, namespace))
+	}
+
+	return &AnnotationList{
+		Items:    result,
+		Continue: "",
+	}, nil
+}
+
+func (a *sqlAdapter) Create(ctx context.Context, anno *annotationV0.Annotation) (*annotationV0.Annotation, error) {
+	orgID, err := namespaceToOrgID(ctx, anno.Namespace)
+	if err != nil {
+		return nil, err
+	}
+
+	item := a.fromK8sResource(anno)
+	item.OrgID = orgID
+
+	if err := a.repo.Save(ctx, item); err != nil {
+		return nil, err
+	}
+
+	created := anno.DeepCopy()
+	created.Name = fmt.Sprintf("a-%d", item.ID)
+
+	return created, nil
+}
+
+func (a *sqlAdapter) Update(ctx context.Context, anno *annotationV0.Annotation) (*annotationV0.Annotation, error) {
+	orgID, err := namespaceToOrgID(ctx, anno.Namespace)
+	if err != nil {
+		return nil, err
+	}
+
+	item := a.fromK8sResource(anno)
+	item.OrgID = orgID
+
+	if err := a.repo.Update(ctx, item); err != nil {
+		return nil, err
+	}
+
+	return anno, nil
+}
+
+func (a *sqlAdapter) Delete(ctx context.Context, namespace, name string) error {
+	id, err := parseAnnotationID(name)
+	if err != nil {
+		return err
+	}
+
+	orgID, err := namespaceToOrgID(ctx, namespace)
+	if err != nil {
+		return err
+	}
+
+	return a.repo.Delete(ctx, &annotations.DeleteParams{
+		ID:    id,
+		OrgID: orgID,
+	})
+}
+
+func (a *sqlAdapter) Cleanup(ctx context.Context) (int64, error) {
+	if a.cleaner == nil {
+		return 0, nil
+	}
+	deleted, _, err := a.cleaner.Run(ctx, a.cfg)
+	return deleted, err
+}
+
+func (a *sqlAdapter) ListTags(ctx context.Context, namespace string, opts TagListOptions) ([]Tag, error) {
+	orgID, err := namespaceToOrgID(ctx, namespace)
+	if err != nil {
+		return nil, err
+	}
+
+	query := &annotations.TagsQuery{
+		OrgID: orgID,
+		Limit: int64(opts.Limit),
+		Tag:   opts.Prefix,
+	}
+
+	result, err := a.repo.FindTags(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+
+	tags := make([]Tag, len(result.Tags))
+	for i, t := range result.Tags {
+		tags[i] = Tag{Name: t.Tag, Count: t.Count}
+	}
+	return tags, nil
+}
+
+func (a *sqlAdapter) toK8sResource(item *annotations.ItemDTO, namespace string) *annotationV0.Annotation {
+	anno := &annotationV0.Annotation{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      fmt.Sprintf("a-%d", item.ID),
+			Namespace: namespace,
+		},
+		Spec: annotationV0.AnnotationSpec{
+			Text: item.Text,
+			Time: item.Time,
+			Tags: item.Tags,
+		},
+	}
+
+	if item.DashboardUID != nil && *item.DashboardUID != "" {
+		anno.Spec.DashboardUID = item.DashboardUID
+	}
+	if item.PanelID != 0 {
+		anno.Spec.PanelID = &item.PanelID
+	}
+	if item.TimeEnd != 0 {
+		anno.Spec.TimeEnd = &item.TimeEnd
+	}
+
+	return anno
+}
+
+func (a *sqlAdapter) fromK8sResource(anno *annotationV0.Annotation) *annotations.Item {
+	item := &annotations.Item{
+		Text:  anno.Spec.Text,
+		Epoch: anno.Spec.Time,
+		Tags:  anno.Spec.Tags,
+	}
+
+	if anno.Name != "" {
+		if id, err := parseAnnotationID(anno.Name); err == nil {
+			item.ID = id
+		}
+	}
+
+	if anno.Spec.DashboardUID != nil {
+		item.DashboardUID = *anno.Spec.DashboardUID
+	}
+	if anno.Spec.PanelID != nil {
+		item.PanelID = *anno.Spec.PanelID
+	}
+	if anno.Spec.TimeEnd != nil {
+		item.EpochEnd = *anno.Spec.TimeEnd
+	}
+
+	return item
+}
+
+func parseAnnotationID(name string) (int64, error) {
+	if len(name) < 3 || name[:2] != "a-" {
+		return 0, fmt.Errorf("invalid annotation name format: %s", name)
+	}
+	return strconv.ParseInt(name[2:], 10, 64)
+}
+
+func namespaceToOrgID(ctx context.Context, namespace string) (int64, error) {
+	info, err := claims.ParseNamespace(namespace)
+	return info.OrgID, err
+}

pkg/registry/apps/annotation/storage.go

@@ -0,0 +1,47 @@
+package annotation
+
+import (
+	"context"
+
+	annotationV0 "github.com/grafana/grafana/apps/annotation/pkg/apis/annotation/v0alpha1"
+)
+
+type Store interface {
+	Get(ctx context.Context, namespace, name string) (*annotationV0.Annotation, error)
+	List(ctx context.Context, namespace string, opts ListOptions) (*AnnotationList, error)
+	Create(ctx context.Context, annotation *annotationV0.Annotation) (*annotationV0.Annotation, error)
+	Update(ctx context.Context, annotation *annotationV0.Annotation) (*annotationV0.Annotation, error)
+	Delete(ctx context.Context, namespace, name string) error
+}
+
+type ListOptions struct {
+	DashboardUID string
+	PanelID      int64
+	From         int64
+	To           int64
+	Limit        int64
+	Continue     string
+}
+
+type AnnotationList struct {
+	Items    []annotationV0.Annotation
+	Continue string
+}
+
+type LifecycleManager interface {
+	Cleanup(ctx context.Context) (int64, error)
+}
+
+type TagProvider interface {
+	ListTags(ctx context.Context, namespace string, opts TagListOptions) ([]Tag, error)
+}
+
+type TagListOptions struct {
+	Prefix string
+	Limit  int
+}
+
+type Tag struct {
+	Name  string
+	Count int64
+}

pkg/registry/apps/annotation/tags_handler.go

@@ -0,0 +1,45 @@
+package annotation
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/grafana/grafana-app-sdk/app"
+)
+
+type tagResponse struct {
+	Tags []tagItem `json:"tags"`
+}
+
+type tagItem struct {
+	Tag   string `json:"tag"`
+	Count int64  `json:"count"`
+}
+
+func newTagsHandler(tagProvider TagProvider) func(ctx context.Context, writer app.CustomRouteResponseWriter, request *app.CustomRouteRequest) error {
+	return func(ctx context.Context, writer app.CustomRouteResponseWriter, request *app.CustomRouteRequest) error {
+		fmt.Println("Handling /tags request")
+		namespace := request.ResourceIdentifier.Namespace
+		if namespace == "" {
+			namespace = "default"
+		}
+		tags, err := tagProvider.ListTags(ctx, namespace, TagListOptions{})
+		if err != nil {
+			return err
+		}
+		items := make([]tagItem, len(tags))
+		for i, tag := range tags {
+			items[i] = tagItem{
+				Tag:   tag.Name,
+				Count: tag.Count,
+			}
+		}
+
+		response := tagResponse{
+			Tags: items,
+		}
+
+		return json.NewEncoder(writer).Encode(response)
+	}
+}

pkg/server/wire_gen.go

@@ -813,7 +813,7 @@ func Initialize(ctx context.Context, cfg *setting.Cfg, opts Options, apiOpts api
 	if err != nil {
 		return nil, err
 	}
-	annotationAppInstaller, err := annotation.RegisterAppInstaller(cfg, featureToggles, repositoryImpl)
+	annotationAppInstaller, err := annotation.RegisterAppInstaller(cfg, featureToggles, repositoryImpl, cleanupServiceImpl)
 	if err != nil {
 		return nil, err
 	}
@@ -1467,7 +1467,7 @@ func InitializeForTest(ctx context.Context, t sqlutil.ITestDB, testingT interfac
 	if err != nil {
 		return nil, err
 	}
-	annotationAppInstaller, err := annotation.RegisterAppInstaller(cfg, featureToggles, repositoryImpl)
+	annotationAppInstaller, err := annotation.RegisterAppInstaller(cfg, featureToggles, repositoryImpl, cleanupServiceImpl)
 	if err != nil {
 		return nil, err
 	}

pkg/services/authz/zanzana/server/server_batch_check.go

@@ -5,6 +5,7 @@ import (
 
 	authzv1 "github.com/grafana/authlib/authz/proto/v1"
 	openfgav1 "github.com/openfga/api/proto/openfga/v1"
+	"go.opentelemetry.io/otel/codes"
 
 	authzextv1 "github.com/grafana/grafana/pkg/services/authz/proto/v1"
 	"github.com/grafana/grafana/pkg/services/authz/zanzana/common"
@@ -15,6 +16,8 @@ func (s *Server) BatchCheck(ctx context.Context, r *authzextv1.BatchCheckRequest
 	defer span.End()
 
 	if err := authorize(ctx, r.GetNamespace(), s.cfg); err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
 		return nil, err
 	}
 
@@ -24,11 +27,15 @@ func (s *Server) BatchCheck(ctx context.Context, r *authzextv1.BatchCheckRequest
 
 	store, err := s.getStoreInfo(ctx, r.GetNamespace())
 	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
 		return nil, err
 	}
 
 	contextuals, err := s.getContextuals(r.GetSubject())
 	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
 		return nil, err
 	}
 
@@ -37,6 +44,8 @@ func (s *Server) BatchCheck(ctx context.Context, r *authzextv1.BatchCheckRequest
 	for _, item := range r.GetItems() {
 		res, err := s.batchCheckItem(ctx, r, item, contextuals, store, groupResourceAccess)
 		if err != nil {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, err.Error())
 			return nil, err
 		}
 

pkg/services/authz/zanzana/server/server_check.go

@@ -9,6 +9,7 @@ import (
 	authzv1 "github.com/grafana/authlib/authz/proto/v1"
 	openfgav1 "github.com/openfga/api/proto/openfga/v1"
 	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/codes"
 	"google.golang.org/protobuf/types/known/structpb"
 
 	"github.com/grafana/grafana/pkg/services/authz/zanzana/common"
@@ -25,6 +26,8 @@ func (s *Server) Check(ctx context.Context, r *authzv1.CheckRequest) (*authzv1.C
 
 	res, err := s.check(ctx, r)
 	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
 		s.logger.Error("failed to perform check request", "error", err, "namespace", r.GetNamespace())
 		return nil, errors.New("failed to perform check request")
 	}

pkg/services/authz/zanzana/server/server_list.go

@@ -13,6 +13,7 @@ import (
 	authzv1 "github.com/grafana/authlib/authz/proto/v1"
 	openfgav1 "github.com/openfga/api/proto/openfga/v1"
 	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/codes"
 
 	"github.com/grafana/grafana/pkg/services/authz/zanzana/common"
 )
@@ -28,6 +29,8 @@ func (s *Server) List(ctx context.Context, r *authzv1.ListRequest) (*authzv1.Lis
 
 	res, err := s.list(ctx, r)
 	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
 		s.logger.Error("failed to perform list request", "error", err, "namespace", r.GetNamespace())
 		return nil, errors.New("failed to perform list request")
 	}

pkg/services/authz/zanzana/server/server_mutate.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	authzextv1 "github.com/grafana/grafana/pkg/services/authz/proto/v1"
+	"go.opentelemetry.io/otel/codes"
 )
 
 type OperationGroup string
@@ -30,6 +31,8 @@ func (s *Server) Mutate(ctx context.Context, req *authzextv1.MutateRequest) (*au
 
 	res, err := s.mutate(ctx, req)
 	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
 		s.logger.Error("failed to perform mutate request", "error", err, "namespace", req.GetNamespace())
 		return nil, errors.New("failed to perform mutate request")
 	}

pkg/services/authz/zanzana/server/server_query.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	authzextv1 "github.com/grafana/grafana/pkg/services/authz/proto/v1"
+	"go.opentelemetry.io/otel/codes"
 )
 
 func (s *Server) Query(ctx context.Context, req *authzextv1.QueryRequest) (*authzextv1.QueryResponse, error) {
@@ -20,6 +21,8 @@ func (s *Server) Query(ctx context.Context, req *authzextv1.QueryRequest) (*auth
 
 	res, err := s.query(ctx, req)
 	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
 		s.logger.Error("failed to perform query request", "error", err, "namespace", req.GetNamespace())
 		return nil, errors.New("failed to perform query request")
 	}

pkg/services/authz/zanzana/server/server_read.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	openfgav1 "github.com/openfga/api/proto/openfga/v1"
+	"go.opentelemetry.io/otel/codes"
 
 	authzextv1 "github.com/grafana/grafana/pkg/services/authz/proto/v1"
 	"github.com/grafana/grafana/pkg/services/authz/zanzana/common"
@@ -22,6 +23,8 @@ func (s *Server) Read(ctx context.Context, req *authzextv1.ReadRequest) (*authze
 
 	res, err := s.read(ctx, req)
 	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
 		s.logger.Error("failed to perform read request", "error", err, "namespace", req.GetNamespace())
 		return nil, errors.New("failed to perform read request")
 	}

pkg/services/authz/zanzana/server/server_write.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	openfgav1 "github.com/openfga/api/proto/openfga/v1"
+	"go.opentelemetry.io/otel/codes"
 
 	authzextv1 "github.com/grafana/grafana/pkg/services/authz/proto/v1"
 	"github.com/grafana/grafana/pkg/services/authz/zanzana/common"
@@ -22,6 +23,8 @@ func (s *Server) Write(ctx context.Context, req *authzextv1.WriteRequest) (*auth
 
 	res, err := s.write(ctx, req)
 	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
 		s.logger.Error("failed to perform write request", "error", err, "namespace", req.GetNamespace())
 		return nil, errors.New("failed to perform write request")
 	}

pkg/services/featuremgmt/registry.go

@@ -1884,6 +1884,14 @@ var (
 			Owner:        grafanaDatavizSquad,
 			Expression:   "false",
 		},
+		{
+			Name:         "externalVizSuggestions",
+			Description:  "Enable all plugins to supply visualization suggestions (including 3rd party plugins)",
+			Stage:        FeatureStageExperimental,
+			FrontendOnly: true,
+			Owner:        grafanaDatavizSquad,
+			Expression:   "false",
+		},
 		{
 			Name:         "preventPanelChromeOverflow",
 			Description:  "Restrict PanelChrome contents with overflow: hidden;",

pkg/services/featuremgmt/toggles_gen.csv

@@ -256,6 +256,7 @@ cdnPluginsUrls,experimental,@grafana/plugins-platform-backend,false,false,false
 pluginInstallAPISync,experimental,@grafana/plugins-platform-backend,false,false,false
 newGauge,experimental,@grafana/dataviz-squad,false,false,true
 newVizSuggestions,preview,@grafana/dataviz-squad,false,false,true
+externalVizSuggestions,experimental,@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

pkg/services/featuremgmt/toggles_gen.json

@@ -1383,6 +1383,20 @@
         "codeowner": "@grafana/identity-access-team"
       }
     },
+    {
+      "metadata": {
+        "name": "externalVizSuggestions",
+        "resourceVersion": "1763498528748",
+        "creationTimestamp": "2025-11-18T20:42:08Z"
+      },
+      "spec": {
+        "description": "Enable all plugins to supply visualization suggestions (including 3rd party plugins)",
+        "stage": "experimental",
+        "codeowner": "@grafana/dataviz-squad",
+        "frontend": true,
+        "expression": "false"
+      }
+    },
     {
       "metadata": {
         "name": "extraThemes",

pkg/services/navtree/navtreeimpl/applinks.go

@@ -221,7 +221,7 @@ func (s *ServiceImpl) processAppPlugin(plugin pluginstore.Plugin, c *contextmode
 		// Add Service Center as a standalone nav item under Alerts & IRM
 		if alertsSection := treeRoot.FindById(navtree.NavIDAlertsAndIncidents); alertsSection != nil {
 			serviceLink := &navtree.NavLink{
-				Text:       "Service Center",
+				Text:       "Service center",
 				Id:         "standalone-plugin-page-slo-services",
 				Url:        s.cfg.AppSubURL + "/a/grafana-slo-app/services",
 				SortWeight: 1,

pkg/setting/setting_unified_storage.go

@@ -8,6 +8,7 @@ import (
 	"github.com/grafana/grafana/pkg/util/osutil"
 )
 
+// nolint:unused
 var migratedUnifiedResources = []string{
 	//"playlists.playlist.grafana.app",
 	"folders.folder.grafana.app",
@@ -58,14 +59,16 @@ func (cfg *Cfg) setUnifiedStorageConfig() {
 
 	// Set indexer config for unified storage
 	section := cfg.Raw.Section("unified_storage")
-	// TODO: Re-enable once migrations are ready and disabled on cloud
-	//cfg.DisableDataMigrations = section.Key("disable_data_migrations").MustBool(false)
-	cfg.DisableDataMigrations = true
+	cfg.DisableDataMigrations = section.Key("disable_data_migrations").MustBool(false)
 	if !cfg.DisableDataMigrations && cfg.getUnifiedStorageType() == "unified" {
-		cfg.enforceMigrationToUnifiedConfigs()
+		// Helper log to find instances running migrations in the future
+		cfg.Logger.Info("Unified migration configs not yet enforced")
+		//cfg.enforceMigrationToUnifiedConfigs() // TODO: uncomment when ready for release
 	} else {
-		cfg.EnableSearch = section.Key("enable_search").MustBool(false)
+		// Helper log to find instances disabling migration
+		cfg.Logger.Info("Unified migration configs enforcement disabled", "storage_type", cfg.getUnifiedStorageType(), "disable_data_migrations", cfg.DisableDataMigrations)
 	}
+	cfg.EnableSearch = section.Key("enable_search").MustBool(false)
 	cfg.MaxPageSizeBytes = section.Key("max_page_size_bytes").MustInt(0)
 	cfg.IndexPath = section.Key("index_path").String()
 	cfg.IndexWorkers = section.Key("index_workers").MustInt(10)
@@ -102,6 +105,7 @@ func (cfg *Cfg) setUnifiedStorageConfig() {
 	cfg.MinFileIndexBuildVersion = section.Key("min_file_index_build_version").MustString("")
 }
 
+// nolint:unused
 // enforceMigrationToUnifiedConfigs enforces configurations required to run migrated resources in mode 5
 // All migrated resources in MigratedUnifiedResources are set to mode 5 and unified search is enabled
 func (cfg *Cfg) enforceMigrationToUnifiedConfigs() {

pkg/storage/unified/migrations/service.go

@@ -8,6 +8,7 @@ import (
 	"github.com/grafana/grafana/pkg/infra/db"
 	"github.com/grafana/grafana/pkg/infra/kvstore"
 	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/infra/metrics"
 	sqlstoremigrator "github.com/grafana/grafana/pkg/services/sqlstore/migrator"
 	"github.com/grafana/grafana/pkg/setting"
 	"github.com/grafana/grafana/pkg/storage/unified/migrations/contract"
@@ -55,8 +56,12 @@ func (p *UnifiedStorageMigrationServiceImpl) Run(ctx context.Context) error {
 
 	// skip migrations if disabled in config
 	if p.cfg.DisableDataMigrations {
+		metrics.MUnifiedStorageMigrationStatus.Set(1)
 		logger.Info("Data migrations are disabled, skipping")
 		return nil
+	} else {
+		metrics.MUnifiedStorageMigrationStatus.Set(2)
+		logger.Info("Data migrations not yet enforced, skipping")
 	}
 
 	// TODO: Re-enable once migrations are ready

pkg/storage/unified/resource/kv.go

@@ -35,6 +35,33 @@ type ListOptions struct {
 	Limit    int64     // maximum number of results to return. 0 means no limit.
 }
 
+// BatchOpMode controls the semantics of each operation in a batch
+type BatchOpMode int
+
+const (
+	// BatchOpPut performs an upsert: create or update (never fails on key state)
+	BatchOpPut BatchOpMode = iota
+	// BatchOpCreate creates a new key, fails if the key already exists
+	BatchOpCreate
+	// BatchOpUpdate updates an existing key, fails if the key doesn't exist
+	BatchOpUpdate
+	// BatchOpDelete removes a key, idempotent (never fails on key state)
+	BatchOpDelete
+)
+
+// BatchOp represents a single operation in an atomic batch
+type BatchOp struct {
+	Mode  BatchOpMode
+	Key   string
+	Value []byte // For Put/Create/Update operations, nil for Delete
+}
+
+// Maximum limit for batch operations
+const MaxBatchOps = 20
+
+// ErrKeyAlreadyExists is returned when BatchOpCreate is used on an existing key
+var ErrKeyAlreadyExists = errors.New("key already exists")
+
 type KV interface {
 	// Keys returns all the keys in the store
 	Keys(ctx context.Context, section string, opt ListOptions) iter.Seq2[string, error]
@@ -60,6 +87,17 @@ type KV interface {
 	// UnixTimestamp returns the current time in seconds since Epoch.
 	// This is used to ensure the server and client are not too far apart in time.
 	UnixTimestamp(ctx context.Context) (int64, error)
+
+	// Batch executes all operations atomically within a single transaction.
+	// If any operation fails, all operations are rolled back.
+	// Operations are executed in order; the batch stops on first failure.
+	//
+	// Operation semantics:
+	//   - BatchOpPut: Upsert (create or update), never fails on key state
+	//   - BatchOpCreate: Fail with ErrKeyAlreadyExists if key exists
+	//   - BatchOpUpdate: Fail with ErrNotFound if key doesn't exist
+	//   - BatchOpDelete: Idempotent, never fails on key state
+	Batch(ctx context.Context, section string, ops []BatchOp) error
 }
 
 var _ KV = &badgerKV{}
@@ -360,3 +398,69 @@ func (k *badgerKV) BatchDelete(ctx context.Context, section string, keys []strin
 
 	return txn.Commit()
 }
+
+func (k *badgerKV) Batch(ctx context.Context, section string, ops []BatchOp) error {
+	if k.db.IsClosed() {
+		return fmt.Errorf("database is closed")
+	}
+
+	if section == "" {
+		return fmt.Errorf("section is required")
+	}
+
+	if len(ops) > MaxBatchOps {
+		return fmt.Errorf("too many operations: %d > %d", len(ops), MaxBatchOps)
+	}
+
+	txn := k.db.NewTransaction(true)
+	defer txn.Discard()
+
+	for _, op := range ops {
+		keyWithSection := section + "/" + op.Key
+
+		switch op.Mode {
+		case BatchOpCreate:
+			// Check that key doesn't exist, then set
+			_, err := txn.Get([]byte(keyWithSection))
+			if err == nil {
+				return ErrKeyAlreadyExists
+			}
+			if !errors.Is(err, badger.ErrKeyNotFound) {
+				return err
+			}
+			if err := txn.Set([]byte(keyWithSection), op.Value); err != nil {
+				return err
+			}
+
+		case BatchOpUpdate:
+			// Check that key exists, then set
+			_, err := txn.Get([]byte(keyWithSection))
+			if errors.Is(err, badger.ErrKeyNotFound) {
+				return ErrNotFound
+			}
+			if err != nil {
+				return err
+			}
+			if err := txn.Set([]byte(keyWithSection), op.Value); err != nil {
+				return err
+			}
+
+		case BatchOpPut:
+			// Upsert: create or update
+			if err := txn.Set([]byte(keyWithSection), op.Value); err != nil {
+				return err
+			}
+
+		case BatchOpDelete:
+			// Idempotent delete - don't error if not found
+			if err := txn.Delete([]byte(keyWithSection)); err != nil {
+				return err
+			}
+
+		default:
+			return fmt.Errorf("unknown operation mode: %d", op.Mode)
+		}
+	}
+
+	return txn.Commit()
+}

pkg/storage/unified/testing/kv.go

@@ -28,6 +28,7 @@ const (
 	TestKVUnixTimestamp  = "unix timestamp"
 	TestKVBatchGet       = "batch get operations"
 	TestKVBatchDelete    = "batch delete operations"
+	TestKVBatch          = "batch operations"
 )
 
 // NewKVFunc is a function that creates a new KV instance for testing
@@ -69,6 +70,7 @@ func RunKVTest(t *testing.T, newKV NewKVFunc, opts *KVTestOptions) {
 		{TestKVUnixTimestamp, runTestKVUnixTimestamp},
 		{TestKVBatchGet, runTestKVBatchGet},
 		{TestKVBatchDelete, runTestKVBatchDelete},
+		{TestKVBatch, runTestKVBatch},
 	}
 
 	for _, tc := range cases {
@@ -801,3 +803,259 @@ func saveKVHelper(t *testing.T, kv resource.KV, ctx context.Context, section, ke
 	err = writer.Close()
 	require.NoError(t, err)
 }
+
+func runTestKVBatch(t *testing.T, kv resource.KV, nsPrefix string) {
+	ctx := testutil.NewTestContext(t, time.Now().Add(30*time.Second))
+	section := nsPrefix + "-batch"
+
+	t.Run("batch with empty section", func(t *testing.T) {
+		err := kv.Batch(ctx, "", nil)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "section is required")
+	})
+
+	t.Run("batch with empty ops succeeds", func(t *testing.T) {
+		err := kv.Batch(ctx, section, nil)
+		require.NoError(t, err)
+	})
+
+	t.Run("batch put creates new key", func(t *testing.T) {
+		ops := []resource.BatchOp{
+			{Mode: resource.BatchOpPut, Key: "put-key", Value: []byte("put-value")},
+		}
+
+		err := kv.Batch(ctx, section, ops)
+		require.NoError(t, err)
+
+		// Verify the key was created
+		reader, err := kv.Get(ctx, section, "put-key")
+		require.NoError(t, err)
+		value, err := io.ReadAll(reader)
+		require.NoError(t, err)
+		assert.Equal(t, "put-value", string(value))
+		err = reader.Close()
+		require.NoError(t, err)
+	})
+
+	t.Run("batch put updates existing key", func(t *testing.T) {
+		// First create a key
+		saveKVHelper(t, kv, ctx, section, "put-update-key", strings.NewReader("original-value"))
+
+		ops := []resource.BatchOp{
+			{Mode: resource.BatchOpPut, Key: "put-update-key", Value: []byte("updated-value")},
+		}
+
+		err := kv.Batch(ctx, section, ops)
+		require.NoError(t, err)
+
+		// Verify the key was updated
+		reader, err := kv.Get(ctx, section, "put-update-key")
+		require.NoError(t, err)
+		value, err := io.ReadAll(reader)
+		require.NoError(t, err)
+		assert.Equal(t, "updated-value", string(value))
+		err = reader.Close()
+		require.NoError(t, err)
+	})
+
+	t.Run("batch create succeeds for new key", func(t *testing.T) {
+		ops := []resource.BatchOp{
+			{Mode: resource.BatchOpCreate, Key: "create-new-key", Value: []byte("new-value")},
+		}
+
+		err := kv.Batch(ctx, section, ops)
+		require.NoError(t, err)
+
+		// Verify the key was created
+		reader, err := kv.Get(ctx, section, "create-new-key")
+		require.NoError(t, err)
+		value, err := io.ReadAll(reader)
+		require.NoError(t, err)
+		assert.Equal(t, "new-value", string(value))
+		err = reader.Close()
+		require.NoError(t, err)
+	})
+
+	t.Run("batch create fails for existing key", func(t *testing.T) {
+		// First create a key
+		saveKVHelper(t, kv, ctx, section, "create-exists-key", strings.NewReader("existing-value"))
+
+		ops := []resource.BatchOp{
+			{Mode: resource.BatchOpCreate, Key: "create-exists-key", Value: []byte("new-value")},
+		}
+
+		err := kv.Batch(ctx, section, ops)
+		assert.ErrorIs(t, err, resource.ErrKeyAlreadyExists)
+
+		// Verify the original value is unchanged
+		reader, err := kv.Get(ctx, section, "create-exists-key")
+		require.NoError(t, err)
+		value, err := io.ReadAll(reader)
+		require.NoError(t, err)
+		assert.Equal(t, "existing-value", string(value))
+		err = reader.Close()
+		require.NoError(t, err)
+	})
+
+	t.Run("batch update succeeds for existing key", func(t *testing.T) {
+		// First create a key
+		saveKVHelper(t, kv, ctx, section, "update-exists-key", strings.NewReader("original-value"))
+
+		ops := []resource.BatchOp{
+			{Mode: resource.BatchOpUpdate, Key: "update-exists-key", Value: []byte("updated-value")},
+		}
+
+		err := kv.Batch(ctx, section, ops)
+		require.NoError(t, err)
+
+		// Verify the key was updated
+		reader, err := kv.Get(ctx, section, "update-exists-key")
+		require.NoError(t, err)
+		value, err := io.ReadAll(reader)
+		require.NoError(t, err)
+		assert.Equal(t, "updated-value", string(value))
+		err = reader.Close()
+		require.NoError(t, err)
+	})
+
+	t.Run("batch update fails for non-existent key", func(t *testing.T) {
+		ops := []resource.BatchOp{
+			{Mode: resource.BatchOpUpdate, Key: "update-nonexistent-key", Value: []byte("new-value")},
+		}
+
+		err := kv.Batch(ctx, section, ops)
+		assert.ErrorIs(t, err, resource.ErrNotFound)
+
+		// Verify the key was not created
+		_, err = kv.Get(ctx, section, "update-nonexistent-key")
+		assert.ErrorIs(t, err, resource.ErrNotFound)
+	})
+
+	t.Run("batch delete removes existing key", func(t *testing.T) {
+		// First create a key
+		saveKVHelper(t, kv, ctx, section, "delete-exists-key", strings.NewReader("to-be-deleted"))
+
+		ops := []resource.BatchOp{
+			{Mode: resource.BatchOpDelete, Key: "delete-exists-key"},
+		}
+
+		err := kv.Batch(ctx, section, ops)
+		require.NoError(t, err)
+
+		// Verify the key was deleted
+		_, err = kv.Get(ctx, section, "delete-exists-key")
+		assert.ErrorIs(t, err, resource.ErrNotFound)
+	})
+
+	t.Run("batch delete is idempotent for non-existent key", func(t *testing.T) {
+		ops := []resource.BatchOp{
+			{Mode: resource.BatchOpDelete, Key: "delete-nonexistent-key"},
+		}
+
+		err := kv.Batch(ctx, section, ops)
+		require.NoError(t, err) // Should succeed even though key doesn't exist
+	})
+
+	t.Run("batch multiple operations atomic success", func(t *testing.T) {
+		ops := []resource.BatchOp{
+			{Mode: resource.BatchOpPut, Key: "multi-key1", Value: []byte("value1")},
+			{Mode: resource.BatchOpPut, Key: "multi-key2", Value: []byte("value2")},
+			{Mode: resource.BatchOpPut, Key: "multi-key3", Value: []byte("value3")},
+		}
+
+		err := kv.Batch(ctx, section, ops)
+		require.NoError(t, err)
+
+		// Verify all keys were created
+		for i := 1; i <= 3; i++ {
+			key := fmt.Sprintf("multi-key%d", i)
+			reader, err := kv.Get(ctx, section, key)
+			require.NoError(t, err)
+			value, err := io.ReadAll(reader)
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("value%d", i), string(value))
+			err = reader.Close()
+			require.NoError(t, err)
+		}
+	})
+
+	t.Run("batch multiple operations atomic rollback on failure", func(t *testing.T) {
+		// First create a key that will cause the batch to fail
+		saveKVHelper(t, kv, ctx, section, "rollback-exists", strings.NewReader("existing"))
+
+		ops := []resource.BatchOp{
+			{Mode: resource.BatchOpPut, Key: "rollback-new1", Value: []byte("value1")},
+			{Mode: resource.BatchOpCreate, Key: "rollback-exists", Value: []byte("should-fail")}, // This will fail
+			{Mode: resource.BatchOpPut, Key: "rollback-new2", Value: []byte("value2")},
+		}
+
+		err := kv.Batch(ctx, section, ops)
+		assert.ErrorIs(t, err, resource.ErrKeyAlreadyExists)
+
+		// Verify rollback: the first operation should NOT have persisted
+		_, err = kv.Get(ctx, section, "rollback-new1")
+		assert.ErrorIs(t, err, resource.ErrNotFound)
+
+		// Verify the third operation was not executed
+		_, err = kv.Get(ctx, section, "rollback-new2")
+		assert.ErrorIs(t, err, resource.ErrNotFound)
+	})
+
+	t.Run("batch mixed operations", func(t *testing.T) {
+		// Setup: create a key to update and one to delete
+		saveKVHelper(t, kv, ctx, section, "mixed-update", strings.NewReader("original"))
+		saveKVHelper(t, kv, ctx, section, "mixed-delete", strings.NewReader("to-delete"))
+
+		ops := []resource.BatchOp{
+			{Mode: resource.BatchOpCreate, Key: "mixed-create", Value: []byte("created")},
+			{Mode: resource.BatchOpUpdate, Key: "mixed-update", Value: []byte("updated")},
+			{Mode: resource.BatchOpDelete, Key: "mixed-delete"},
+			{Mode: resource.BatchOpPut, Key: "mixed-put", Value: []byte("put")},
+		}
+
+		err := kv.Batch(ctx, section, ops)
+		require.NoError(t, err)
+
+		// Verify create
+		reader, err := kv.Get(ctx, section, "mixed-create")
+		require.NoError(t, err)
+		value, err := io.ReadAll(reader)
+		require.NoError(t, err)
+		assert.Equal(t, "created", string(value))
+		err = reader.Close()
+		require.NoError(t, err)
+
+		// Verify update
+		reader, err = kv.Get(ctx, section, "mixed-update")
+		require.NoError(t, err)
+		value, err = io.ReadAll(reader)
+		require.NoError(t, err)
+		assert.Equal(t, "updated", string(value))
+		err = reader.Close()
+		require.NoError(t, err)
+
+		// Verify delete
+		_, err = kv.Get(ctx, section, "mixed-delete")
+		assert.ErrorIs(t, err, resource.ErrNotFound)
+
+		// Verify put
+		reader, err = kv.Get(ctx, section, "mixed-put")
+		require.NoError(t, err)
+		value, err = io.ReadAll(reader)
+		require.NoError(t, err)
+		assert.Equal(t, "put", string(value))
+		err = reader.Close()
+		require.NoError(t, err)
+	})
+
+	t.Run("batch too many operations", func(t *testing.T) {
+		ops := make([]resource.BatchOp, resource.MaxBatchOps+1)
+		for i := range ops {
+			ops[i] = resource.BatchOp{Mode: resource.BatchOpPut, Key: fmt.Sprintf("key-%d", i), Value: []byte("value")}
+		}
+
+		err := kv.Batch(ctx, section, ops)
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "too many operations")
+	})
+}

pkg/tests/testinfra/testinfra.go

@@ -107,6 +107,9 @@ func StartGrafanaEnvWithDB(t *testing.T, grafDir, cfgPath string) (string, *serv
 	dbCfg.Key("user").SetValue(testDB.User)
 	dbCfg.Key("password").SetValue(testDB.Password)
 	dbCfg.Key("name").SetValue(testDB.Database)
+	if testDB.Path != "" {
+		dbCfg.Key("path").SetValue(testDB.Path)
+	}
 
 	t.Log("Using test database", "type", testDB.DriverName, "host", testDB.Host, "port", testDB.Port, "user", testDB.User, "name", testDB.Database, "path", testDB.Path)
 

public/app/api/clients/folder/v1beta1/hooks.ts

@@ -103,10 +103,17 @@ const combineFolderResponses = (
 
 export async function getFolderByUidFacade(uid: string): Promise<FolderDTO> {
   const isVirtualFolder = uid && [GENERAL_FOLDER_UID, config.sharedWithMeFolderUID].includes(uid);
-  // We need the legacy API call regardless, for now
-  const legacyApiCall = dispatch(browseDashboardsAPI.endpoints.getFolder.initiate(uid));
-
   const shouldUseAppPlatformAPI = Boolean(config.featureToggles.foldersAppPlatformAPI);
+
+  // We need the legacy API call regardless, for now
+  const legacyApiCall = dispatch(
+    browseDashboardsAPI.endpoints.getFolder.initiate({
+      folderUID: uid,
+      accesscontrol: true,
+      isLegacyCall: shouldUseAppPlatformAPI,
+    })
+  );
+
   if (shouldUseAppPlatformAPI) {
     let virtualFolderResponse;
     if (isVirtualFolder) {
@@ -165,7 +172,9 @@ export function useGetFolderQueryFacade(uid?: string) {
   // This may look weird that we call the legacy folder anyway all the time, but the issue is we don't have good API
   // for the access control metadata yet, and so we still take it from the old api.
   // see https://github.com/grafana/identity-access-team/issues/1103
-  const legacyFolderResult = useGetFolderQueryLegacy(uid || skipToken);
+  const legacyFolderResult = useGetFolderQueryLegacy(
+    uid ? { folderUID: uid, accesscontrol: true, isLegacyCall: true } : skipToken
+  );
   let resultFolder = useGetFolderQuery(shouldUseAppPlatformAPI && !isVirtualFolder ? params : skipToken);
   // We get parents and folders for virtual folders too. Parents should just return empty array but it's easier to
   // stitch the responses this way and access can actually return different response based on the grafana setup.

public/app/features/browse-dashboards/api/browseDashboardsAPI.ts

@@ -94,9 +94,17 @@ export const browseDashboardsAPI = createApi({
     }),
 
     // get folder info (e.g. title, parents) but *not* children
-    getFolder: builder.query<FolderDTO, string>({
-      providesTags: (_result, _error, folderUID) => [{ type: 'getFolder', id: folderUID }],
-      query: (folderUID) => ({ url: `/folders/${folderUID}`, params: { accesscontrol: true } }),
+    getFolder: builder.query<FolderDTO, { folderUID: string; accesscontrol: boolean; isLegacyCall: boolean }>({
+      providesTags: (_result, _error, { folderUID }) => [{ type: 'getFolder', id: folderUID }],
+      query: ({ folderUID, accesscontrol, isLegacyCall }) => ({
+        url: `/folders/${folderUID}`,
+        params: {
+          accesscontrol,
+          // Add additional query param so we can tell when
+          // this was called for app platform compatibility purposes vs. actually needing to use the legacy API
+          isLegacyCall,
+        },
+      }),
     }),
 
     // create a new folder

public/app/features/dashboard-scene/edit-pane/DashboardEditPaneSplitter.tsx

@@ -69,6 +69,7 @@ export function DashboardEditPaneSplitter({ dashboard, isEditing, body, controls
     hasOpenPane: Boolean(openPane),
     contentMargin: 1,
     position: 'right',
+    persistanceKey: 'dashboard',
     onClosePane: () => editPane.closePane(),
   });
 

public/app/features/dashboard-scene/panel-edit/PanelEditor.tsx

@@ -31,7 +31,6 @@ import { UNCONFIGURED_PANEL_PLUGIN_ID } from '../scene/UnconfiguredPanel';
 import { DashboardGridItem } from '../scene/layout-default/DashboardGridItem';
 import { DashboardLayoutItem, isDashboardLayoutItem } from '../scene/types/DashboardLayoutItem';
 import { vizPanelToPanel } from '../serialization/transformSceneToSaveModel';
-import { PanelModelCompatibilityWrapper } from '../utils/PanelModelCompatibilityWrapper';
 import {
   activateSceneObjectAndParentTree,
   getDashboardSceneFor,
@@ -121,8 +120,7 @@ export class PanelEditor extends SceneObjectBase<PanelEditorState> {
       dataObject.subscribeToState(async () => {
         const { data } = dataObject.state;
         if (hasData(data) && panel.state.pluginId === UNCONFIGURED_PANEL_PLUGIN_ID) {
-          const panelModel = new PanelModelCompatibilityWrapper(panel);
-          const suggestions = await getAllSuggestions(data, panelModel);
+          const suggestions = await getAllSuggestions(data);
 
           if (suggestions.length > 0) {
             const defaultFirstSuggestion = suggestions[0];

public/app/features/dashboard-scene/scene/DashboardControls.tsx

@@ -171,7 +171,7 @@ function DashboardControlsRenderer({ model }: SceneComponentProps<DashboardContr
     >
       <div className={cx(styles.rightControls, editPanel && styles.rightControlsWrap)}>
         {!hideTimeControls && (
-          <div className={styles.timeControls}>
+          <div className={styles.fixedControls}>
             <timePicker.Component model={timePicker} />
             <refreshPicker.Component model={refreshPicker} />
           </div>
@@ -181,7 +181,11 @@ function DashboardControlsRenderer({ model }: SceneComponentProps<DashboardContr
             <DashboardControlsButton dashboard={dashboard} />
           </div>
         )}
-        {config.featureToggles.dashboardNewLayouts && <DashboardControlActions dashboard={dashboard} />}
+        {config.featureToggles.dashboardNewLayouts && (
+          <div className={styles.fixedControls}>
+            <DashboardControlActions dashboard={dashboard} />
+          </div>
+        )}
         {!hideLinksControls && !editPanel && <DashboardLinksControls links={links} dashboard={dashboard} />}
       </div>
       {!hideVariableControls && (
@@ -274,12 +278,12 @@ function getStyles(theme: GrafanaTheme2) {
       display: 'flex',
       gap: theme.spacing(1),
       float: 'right',
-      alignItems: 'center',
+      alignItems: 'flex-start',
       flexWrap: 'wrap',
       maxWidth: '100%',
       minWidth: 0,
     }),
-    timeControls: css({
+    fixedControls: css({
       display: 'flex',
       justifyContent: 'flex-end',
       gap: theme.spacing(1),

public/app/features/panel/components/VizTypePicker/VisualizationSuggestions.tsx

@@ -25,7 +25,7 @@ const MIN_COLUMN_SIZE = 260;
 
 export function VisualizationSuggestions({ onChange, data, panel }: Props) {
   const styles = useStyles2(getStyles);
-  const { value: suggestions } = useAsync(() => getAllSuggestions(data, panel), [data, panel]);
+  const { value: suggestions } = useAsync(async () => await getAllSuggestions(data), [data]);
   const [suggestionHash, setSuggestionHash] = useState<string | null>(null);
   const [firstCardRef, { width }] = useMeasure<HTMLDivElement>();
   const [firstCardHash, setFirstCardHash] = useState<string | null>(null);

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

@@ -0,0 +1,19 @@
+export const panelsToCheckFirst = [
+  'timeseries',
+  'barchart',
+  'gauge',
+  'stat',
+  'piechart',
+  'bargauge',
+  'table',
+  'state-timeline',
+  'status-history',
+  'logs',
+  'candlestick',
+  'flamegraph',
+  'traces',
+  'nodeGraph',
+  'heatmap',
+  'histogram',
+  'geomap',
+];

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

@@ -2,11 +2,13 @@ import {
   DataFrame,
   FieldType,
   getDefaultTimeRange,
+  getPanelDataSummary,
   LoadingState,
   PanelData,
-  PanelPluginMeta,
   PanelPluginVisualizationSuggestion,
+  PluginType,
   toDataFrame,
+  VisualizationSuggestionScore,
 } from '@grafana/data';
 import {
   BarGaugeDisplayMode,
@@ -18,26 +20,69 @@ import {
 } from '@grafana/schema';
 import { config } from 'app/core/config';
 
-import { getAllSuggestions, panelsToCheckFirst } from './getAllSuggestions';
+import { panelsToCheckFirst } from './consts';
+import { getAllSuggestions, sortSuggestions } from './getAllSuggestions';
 
+config.featureToggles.externalVizSuggestions = true;
+
+let idx = 0;
 for (const pluginId of panelsToCheckFirst) {
+  if (pluginId === 'geomap') {
+    continue;
+  }
   config.panels[pluginId] = {
-    module: `core:plugin/${pluginId}`,
     id: pluginId,
-  } as PanelPluginMeta;
+    module: `core:plugin/${pluginId}`,
+    sort: idx++,
+    name: pluginId,
+    type: PluginType.panel,
+    baseUrl: 'public/app/plugins/panel',
+    suggestions: true,
+    info: {
+      version: '1.0.0',
+      updated: '2025-01-01',
+      links: [],
+      screenshots: [],
+      author: {
+        name: 'Grafana Labs',
+      },
+      description: pluginId,
+      logos: { small: 'small/logo', large: 'large/logo' },
+    },
+  };
 }
 
-const SCALAR_PLUGINS = ['gauge', 'stat', 'bargauge', 'piechart', 'radialbar'];
-
-config.panels['text'] = {
+config.panels.text = {
   id: 'text',
+  module: 'core:plugin/text',
+  sort: idx++,
   name: 'Text',
+  type: PluginType.panel,
+  baseUrl: 'public/app/plugins/panel',
   skipDataQuery: true,
+  suggestions: false,
   info: {
-    description: 'pretty decent plugin',
+    version: '1.0.0',
+    updated: '2025-01-01',
+    links: [],
+    screenshots: [],
+    author: {
+      name: 'Grafana Labs',
+    },
+    description: 'Text panel',
     logos: { small: 'small/logo', large: 'large/logo' },
   },
-} as PanelPluginMeta;
+};
+
+jest.mock('../state/util', () => {
+  const originalModule = jest.requireActual('../state/util');
+  return {
+    ...originalModule,
+    getAllPanelPluginMeta: jest.fn().mockImplementation(() => [...Object.values(config.panels)]),
+  };
+});
+
+const SCALAR_PLUGINS = ['gauge', 'stat', 'bargauge', 'piechart', 'radialbar'];
 
 class ScenarioContext {
   data: DataFrame[] = [];
@@ -289,10 +334,8 @@ scenario('Single frame with string and number field', (ctx) => {
         pluginId: 'stat',
         options: expect.objectContaining({ colorMode: BigValueColorMode.Background }),
       }),
-
       expect.objectContaining({
         pluginId: 'bargauge',
-        options: expect.objectContaining({ displayMode: BarGaugeDisplayMode.Basic }),
       }),
       expect.objectContaining({
         pluginId: 'bargauge',
@@ -447,6 +490,70 @@ scenario('Given a preferredVisualisationType', (ctx) => {
   });
 });
 
+describe('sortSuggestions', () => {
+  it('should sort suggestions correctly by score', () => {
+    const suggestions = [
+      { pluginId: 'timeseries', name: 'Time series', hash: 'b', score: VisualizationSuggestionScore.OK },
+      { pluginId: 'table', name: 'Table', hash: 'a', score: VisualizationSuggestionScore.OK },
+      { pluginId: 'stat', name: 'Stat', hash: 'c', score: VisualizationSuggestionScore.Good },
+    ] satisfies PanelPluginVisualizationSuggestion[];
+
+    const dataSummary = getPanelDataSummary([
+      toDataFrame({
+        fields: [
+          { name: 'Time', type: FieldType.time, values: [1, 2, 3, 4, 5] },
+          { name: 'ServerA', type: FieldType.number, values: [1, 10, 50, 2, 5] },
+          { name: 'ServerB', type: FieldType.number, values: [1, 10, 50, 2, 5] },
+        ],
+      }),
+    ]);
+
+    sortSuggestions(suggestions, dataSummary);
+
+    expect(suggestions[0].pluginId).toBe('stat');
+    expect(suggestions[1].pluginId).toBe('timeseries');
+    expect(suggestions[2].pluginId).toBe('table');
+  });
+
+  it('should sort suggestions based on core module', () => {
+    const suggestions = [
+      {
+        pluginId: 'fake-external-panel',
+        name: 'Time series',
+        hash: 'b',
+        score: VisualizationSuggestionScore.Good,
+      },
+      {
+        pluginId: 'fake-external-panel',
+        name: 'Time series',
+        hash: 'd',
+        score: VisualizationSuggestionScore.Best,
+      },
+      { pluginId: 'timeseries', name: 'Table', hash: 'a', score: VisualizationSuggestionScore.OK },
+      { pluginId: 'stat', name: 'Stat', hash: 'c', score: VisualizationSuggestionScore.Good },
+    ] satisfies PanelPluginVisualizationSuggestion[];
+
+    const dataSummary = getPanelDataSummary([
+      toDataFrame({
+        fields: [
+          { name: 'Time', type: FieldType.time, values: [1, 2, 3, 4, 5] },
+          { name: 'ServerA', type: FieldType.number, values: [1, 10, 50, 2, 5] },
+          { name: 'ServerB', type: FieldType.number, values: [1, 10, 50, 2, 5] },
+        ],
+      }),
+    ]);
+
+    sortSuggestions(suggestions, dataSummary);
+
+    expect(suggestions[0].pluginId).toBe('stat');
+    expect(suggestions[1].pluginId).toBe('timeseries');
+    expect(suggestions[2].pluginId).toBe('fake-external-panel');
+    expect(suggestions[2].hash).toBe('d');
+    expect(suggestions[3].pluginId).toBe('fake-external-panel');
+    expect(suggestions[3].hash).toBe('b');
+  });
+});
+
 function repeatFrame(count: number, frame: DataFrame): DataFrame[] {
   const frames: DataFrame[] = [];
   for (let i = 0; i < count; i++) {

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

@@ -1,33 +1,52 @@
 import {
+  getPanelDataSummary,
   PanelData,
+  PanelDataSummary,
+  PanelPlugin,
   PanelPluginVisualizationSuggestion,
-  VisualizationSuggestionsBuilder,
-  PanelModel,
-  VisualizationSuggestionScore,
   PreferredVisualisationType,
+  VisualizationSuggestionScore,
 } from '@grafana/data';
 import { config } from '@grafana/runtime';
-import { importPanelPlugin } from 'app/features/plugins/importPanelPlugin';
+import { importPanelPlugin, isBuiltInPlugin } from 'app/features/plugins/importPanelPlugin';
 
-export const panelsToCheckFirst = [
-  'timeseries',
-  'barchart',
-  'gauge',
-  'stat',
-  'piechart',
-  'bargauge',
-  'table',
-  'state-timeline',
-  'status-history',
-  'logs',
-  'candlestick',
-  'flamegraph',
-  'traces',
-  'nodeGraph',
-  'heatmap',
-  'histogram',
-  'geomap',
-];
+import { getAllPanelPluginMeta } from '../state/util';
+
+import { panelsToCheckFirst } from './consts';
+
+/**
+ * gather and cache the plugins which provide visualization suggestions so they can be invoked to build suggestions
+ */
+let _pluginCache: PanelPlugin[] | null = null;
+async function getPanelsWithSuggestions(): Promise<PanelPlugin[]> {
+  if (!_pluginCache) {
+    _pluginCache = [];
+
+    // list of plugins to load is determined by the feature flag
+    const pluginIds: string[] = config.featureToggles.externalVizSuggestions
+      ? getAllPanelPluginMeta()
+          .filter((panel) => panel.suggestions)
+          .map((m) => m.id)
+      : panelsToCheckFirst;
+
+    // import the plugins in parallel using Promise.allSettled
+    const settledPromises = await Promise.allSettled(pluginIds.map((id) => importPanelPlugin(id)));
+    for (let i = 0; i < settledPromises.length; i++) {
+      const settled = settledPromises[i];
+
+      if (settled.status === 'fulfilled') {
+        _pluginCache.push(settled.value);
+      }
+      // TODO: do we want to somehow log if there were errors loading some of the plugins?
+    }
+  }
+
+  if (_pluginCache.length === 0) {
+    throw new Error('No panel plugins with visualization suggestions found');
+  }
+
+  return _pluginCache;
+}
 
 /**
  * some of the PreferredVisualisationTypes do not match the panel plugin ids, so we have to map them. d'oh.
@@ -44,24 +63,54 @@ const mapPreferredVisualisationTypeToPlugin = (type: string): PreferredVisualisa
   return PLUGIN_ID_TO_PREFERRED_VIZ_TYPE[type];
 };
 
-export async function getAllSuggestions(
-  data?: PanelData,
-  panel?: PanelModel
-): Promise<PanelPluginVisualizationSuggestion[]> {
-  const builder = new VisualizationSuggestionsBuilder(data, panel);
+/**
+ * given a list of suggestions, sort them in place based on score and preferred visualisation type
+ */
+export function sortSuggestions(suggestions: PanelPluginVisualizationSuggestion[], dataSummary: PanelDataSummary) {
+  suggestions.sort((a, b) => {
+    // if one of these suggestions is from a built-in panel and the other isn't, prioritize the core panel.
+    const isPluginABuiltIn = isBuiltInPlugin(a.pluginId);
+    const isPluginBBuiltIn = isBuiltInPlugin(b.pluginId);
+    if (isPluginABuiltIn && !isPluginBBuiltIn) {
+      return -1;
+    }
+    if (isPluginBBuiltIn && !isPluginABuiltIn) {
+      return 1;
+    }
 
-  for (const pluginId of panelsToCheckFirst) {
-    const plugin = await importPanelPlugin(pluginId);
-    const supplier = plugin.getSuggestionsSupplier();
+    // if a preferred visualisation type matches the data, prioritize it
+    const mappedA = mapPreferredVisualisationTypeToPlugin(a.pluginId);
+    if (mappedA && dataSummary.hasPreferredVisualisationType(mappedA)) {
+      return -1;
+    }
+    const mappedB = mapPreferredVisualisationTypeToPlugin(a.pluginId);
+    if (mappedB && dataSummary.hasPreferredVisualisationType(mappedB)) {
+      return 1;
+    }
 
-    if (supplier) {
-      supplier.getSuggestionsForData(builder);
+    // compare scores directly if there are no other factors
+    return (b.score ?? VisualizationSuggestionScore.OK) - (a.score ?? VisualizationSuggestionScore.OK);
+  });
+}
+
+/**
+ * given PanelData, return a sorted list of Suggestions from all plugins which support it.
+ * @param {PanelData} data queried and transformed data for the panel
+ * @returns {PanelPluginVisualizationSuggestion[]} sorted list of suggestions
+ */
+export async function getAllSuggestions(data?: PanelData): Promise<PanelPluginVisualizationSuggestion[]> {
+  const dataSummary = getPanelDataSummary(data?.series);
+  const list: PanelPluginVisualizationSuggestion[] = [];
+  const plugins = await getPanelsWithSuggestions();
+
+  for (const plugin of plugins) {
+    const suggestions = plugin.getSuggestions(dataSummary);
+    if (suggestions) {
+      list.push(...suggestions);
     }
   }
 
-  const list = builder.getList();
-
-  if (builder.dataSummary.fieldCount === 0) {
+  if (dataSummary.fieldCount === 0) {
     for (const plugin of Object.values(config.panels)) {
       if (!plugin.skipDataQuery || plugin.hideFromList) {
         continue;
@@ -79,15 +128,7 @@ export async function getAllSuggestions(
     }
   }
 
-  return list.sort((a, b) => {
-    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);
-  });
+  sortSuggestions(list, dataSummary);
+
+  return list;
 }

public/app/features/plugins/built_in_plugins.ts

@@ -115,4 +115,8 @@ const builtInPlugins: Record<string, System.Module | (() => Promise<System.Modul
   'core:plugin/radialbar': radialBar,
 };
 
+export function isBuiltinPluginPath(path: string): path is keyof typeof builtInPlugins {
+  return Boolean(builtInPlugins[path]);
+}
+
 export default builtInPlugins;

public/app/features/plugins/importPanelPlugin.ts

@@ -1,6 +1,7 @@
 import { PanelPlugin, PanelPluginMeta } from '@grafana/data';
 import config from 'app/core/config';
 
+import builtInPlugins, { isBuiltinPluginPath } from './built_in_plugins';
 import { pluginImporter } from './importer/pluginImporter';
 
 const promiseCache: Record<string, Promise<PanelPlugin>> = {};
@@ -25,6 +26,14 @@ export function importPanelPlugin(id: string): Promise<PanelPlugin> {
   return promiseCache[id];
 }
 
+export function isBuiltInPlugin(id?: string): id is keyof typeof builtInPlugins {
+  if (!id) {
+    return false;
+  }
+  const meta = getPanelPluginMeta(id);
+  return Boolean(meta != null && isBuiltinPluginPath(meta.module));
+}
+
 export function hasPanelPlugin(id: string): boolean {
   return !!getPanelPluginMeta(id);
 }

public/app/features/plugins/importer/importPluginModule.ts

@@ -2,7 +2,7 @@ import { DEFAULT_LANGUAGE } from '@grafana/i18n';
 import { getResolvedLanguage } from '@grafana/i18n/internal';
 import { config } from '@grafana/runtime';
 
-import builtInPlugins from '../built_in_plugins';
+import builtInPlugins, { isBuiltinPluginPath } from '../built_in_plugins';
 import { registerPluginInfoInCache } from '../loader/pluginInfoCache';
 import { SystemJS } from '../loader/systemjs';
 import { resolveModulePath } from '../loader/utils';
@@ -35,8 +35,8 @@ export async function importPluginModule({
     });
   }
 
-  const builtIn = builtInPlugins[path];
-  if (builtIn) {
+  if (isBuiltinPluginPath(path)) {
+    const builtIn = builtInPlugins[path];
     // for handling dynamic imports
     if (typeof builtIn === 'function') {
       return await builtIn();

public/app/plugins/panel/barchart/plugin.json

@@ -2,7 +2,7 @@
   "type": "panel",
   "name": "Bar chart",
   "id": "barchart",
-
+  "suggestions": true,
   "info": {
     "description": "Categorical charts with group support",
     "author": {

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

@@ -1,6 +1,6 @@
 import { defaultsDeep } from 'lodash';
 
-import { FieldType, VisualizationSuggestion, VisualizationSuggestionsSupplierFn, VizOrientation } from '@grafana/data';
+import { FieldType, VisualizationSuggestion, VisualizationSuggestionsSupplier, VizOrientation } from '@grafana/data';
 import { t } from '@grafana/i18n';
 import { LegendDisplayMode, StackingMode, VisibilityMode } from '@grafana/schema';
 
@@ -32,7 +32,7 @@ const withDefaults = (suggestion: VisualizationSuggestion<Options, FieldConfig>)
     },
   } satisfies VisualizationSuggestion<Options, FieldConfig>);
 
-export const barchartSuggestionsSupplier: VisualizationSuggestionsSupplierFn<Options, FieldConfig> = (dataSummary) => {
+export const barchartSuggestionsSupplier: VisualizationSuggestionsSupplier<Options, FieldConfig> = (dataSummary) => {
   if (dataSummary.frameCount !== 1) {
     return;
   }

public/app/plugins/panel/bargauge/plugin.json

@@ -2,7 +2,7 @@
   "type": "panel",
   "name": "Bar gauge",
   "id": "bargauge",
-
+  "suggestions": true,
   "info": {
     "description": "Horizontal and vertical gauges",
     "author": {

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

@@ -4,7 +4,7 @@ import {
   FieldColorModeId,
   FieldType,
   VisualizationSuggestion,
-  VisualizationSuggestionsSupplierFn,
+  VisualizationSuggestionsSupplier,
   VizOrientation,
 } from '@grafana/data';
 import { t } from '@grafana/i18n';
@@ -31,7 +31,7 @@ const withDefaults = (suggestion: VisualizationSuggestion<Options>): Visualizati
 
 const BAR_LIMIT = 30;
 
-export const barGaugeSugggestionsSupplier: VisualizationSuggestionsSupplierFn<Options> = (dataSummary) => {
+export const barGaugeSugggestionsSupplier: VisualizationSuggestionsSupplier<Options> = (dataSummary) => {
   if (!dataSummary.hasData || !dataSummary.hasFieldType(FieldType.number)) {
     return;
   }

public/app/plugins/panel/candlestick/plugin.json

@@ -2,7 +2,7 @@
   "type": "panel",
   "name": "Candlestick",
   "id": "candlestick",
-
+  "suggestions": true,
   "info": {
     "description": "Graphical representation of price movements of a security, derivative, or currency.",
     "keywords": ["financial", "price", "currency", "k-line"],

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

@@ -1,10 +1,10 @@
-import { FieldType, VisualizationSuggestionScore, VisualizationSuggestionsSupplierFn } from '@grafana/data';
+import { FieldType, VisualizationSuggestionScore, VisualizationSuggestionsSupplier } from '@grafana/data';
 import { config } from '@grafana/runtime';
 
 import { prepareCandlestickFields } from './fields';
 import { defaultOptions, Options } from './types';
 
-export const candlestickSuggestionSupplier: VisualizationSuggestionsSupplierFn<Options> = (dataSummary) => {
+export const candlestickSuggestionSupplier: VisualizationSuggestionsSupplier<Options> = (dataSummary) => {
   if (
     !dataSummary.rawFrames ||
     !dataSummary.hasData ||

public/app/plugins/panel/flamegraph/plugin.json

@@ -2,7 +2,7 @@
   "type": "panel",
   "name": "Flame Graph",
   "id": "flamegraph",
-
+  "suggestions": true,
   "info": {
     "author": {
       "name": "Grafana Labs",

public/app/plugins/panel/gauge/plugin.json

@@ -2,7 +2,7 @@
   "type": "panel",
   "name": "Gauge",
   "id": "gauge",
-
+  "suggestions": true,
   "info": {
     "description": "Standard gauge visualization",
     "author": {

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

@@ -1,6 +1,6 @@
 import { defaultsDeep } from 'lodash';
 
-import { ThresholdsMode, FieldType, VisualizationSuggestion, VisualizationSuggestionsSupplierFn } from '@grafana/data';
+import { ThresholdsMode, FieldType, VisualizationSuggestion, VisualizationSuggestionsSupplier } from '@grafana/data';
 import { t } from '@grafana/i18n';
 import { defaultNumericVizOptions } from 'app/features/panel/suggestions/utils';
 
@@ -33,7 +33,7 @@ const withDefaults = (suggestion: VisualizationSuggestion<Options>): Visualizati
 
 const GAUGE_LIMIT = 10;
 
-export const gaugeSuggestionsSupplier: VisualizationSuggestionsSupplierFn<Options> = (dataSummary) => {
+export const gaugeSuggestionsSupplier: VisualizationSuggestionsSupplier<Options> = (dataSummary) => {
   if (!dataSummary.hasData || !dataSummary.hasFieldType(FieldType.number)) {
     return;
   }

public/app/plugins/panel/geomap/plugin.json

@@ -2,7 +2,7 @@
   "type": "panel",
   "name": "Geomap",
   "id": "geomap",
-
+  "suggestions": true,
   "info": {
     "description": "Geomap panel",
     "author": {

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

@@ -1,12 +1,10 @@
-import { VisualizationSuggestionScore, VisualizationSuggestionsSupplierFn } from '@grafana/data';
+import { VisualizationSuggestionScore, VisualizationSuggestionsSupplier } 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
-) => {
+export const geomapSuggestionsSupplier: VisualizationSuggestionsSupplier<Options, GraphFieldConfig> = (dataSummary) => {
   if (!dataSummary.hasData || !dataSummary.rawFrames) {
     return;
   }