Check that variable isnt null when initializing ds reference

Auditing: Move sinkable/logger interfaces and add global default logger implementation (#115743 )
* Auditing: Move sinkable and logger interfaces * Auditing: Add global default logger implementation * Chore: Fix enterprise imports
2025-12-31 09:59:55 +01:00 · 2025-12-30 14:05:23 +01:00 · 2025-12-30 09:54:20 -03:00 · 2025-12-30 08:46:43 -03:00 · 2025-12-30 10:54:00 +01:00 · 2025-12-30 09:47:00 +01:00
135 changed files with 3045 additions and 553 deletions
@@ -0,0 +1,142 @@
+{
+  "kind": "Dashboard",
+  "apiVersion": "dashboard.grafana.app/v1beta1",
+  "metadata": {
+    "name": "bom-in-links-test",
+    "namespace": "org-1",
+    "labels": {
+      "test": "bom-stripping"
+    }
+  },
+  "spec": {
+    "title": "BOM Stripping Test Dashboard",
+    "description": "Testing that BOM characters are stripped from URLs during conversion",
+    "schemaVersion": 42,
+    "tags": ["test", "bom"],
+    "editable": true,
+    "links": [
+      {
+        "title": "Dashboard link with BOM",
+        "type": "link",
+        "url": "http://example.com?var=${datasource}&other=value",
+        "targetBlank": true,
+        "icon": "external link"
+      }
+    ],
+    "panels": [
+      {
+        "id": 1,
+        "type": "table",
+        "title": "Panel with BOM in field config override links",
+        "gridPos": {
+          "h": 8,
+          "w": 12,
+          "x": 0,
+          "y": 0
+        },
+        "fieldConfig": {
+          "defaults": {
+            "custom": {},
+            "mappings": [],
+            "thresholds": {
+              "mode": "absolute",
+              "steps": [
+                {"color": "green"},
+                {"color": "red", "value": 80}
+              ]
+            }
+          },
+          "overrides": [
+            {
+              "matcher": {
+                "id": "byName",
+                "options": "server"
+              },
+              "properties": [
+                {
+                  "id": "links",
+                  "value": [
+                    {
+                      "title": "Override link with BOM",
+                      "url": "http://localhost:3000/d/test?var-datacenter=${__data.fields[datacenter]}&var-server=${__value.raw}"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "links": [
+          {
+            "title": "Panel data link with BOM",
+            "url": "http://example.com/${__data.fields.cluster}&var=value",
+            "targetBlank": true
+          }
+        ],
+        "targets": [
+          {
+            "refId": "A",
+            "datasource": {
+              "type": "prometheus",
+              "uid": "test-ds"
+            }
+          }
+        ]
+      },
+      {
+        "id": 2,
+        "type": "timeseries",
+        "title": "Panel with BOM in options dataLinks",
+        "gridPos": {
+          "h": 8,
+          "w": 12,
+          "x": 12,
+          "y": 0
+        },
+        "options": {
+          "legend": {
+            "showLegend": true,
+            "displayMode": "list",
+            "placement": "bottom"
+          },
+          "dataLinks": [
+            {
+              "title": "Options data link with BOM",
+              "url": "http://example.com?series=${__series.name}&time=${__value.time}",
+              "targetBlank": true
+            }
+          ]
+        },
+        "fieldConfig": {
+          "defaults": {
+            "links": [
+              {
+                "title": "Field config default link with BOM",
+                "url": "http://example.com?field=${__field.name}&value=${__value.raw}",
+                "targetBlank": false
+              }
+            ]
+          },
+          "overrides": []
+        },
+        "targets": [
+          {
+            "refId": "A",
+            "datasource": {
+              "type": "prometheus",
+              "uid": "test-ds"
+            }
+          }
+        ]
+      }
+    ],
+    "time": {
+      "from": "now-6h",
+      "to": "now"
+    },
+    "timepicker": {
+      "refresh_intervals": ["5s", "10s", "30s", "1m", "5m"]
+    }
+  }
+}
+
@@ -120,7 +120,7 @@
                        "value": [
                          {
                            "title": "filter",
-                            "url": "http://localhost:3000/d/-Y-tnEDWk/templating-nested-template-variables?var-datacenter=${__data.fields[datacenter]}\u0026var-server=${__value.raw}"
+                            "url": "http://localhost:3000/d/-Y-tnEDWk/templating-nested-template-variables?var-datacenter=${__data.fields[datacenter]}\u0026var-server=${__value.raw}"
                          }
                        ]
                      }
@@ -124,7 +124,7 @@
                        "value": [
                          {
                            "title": "filter",
-                            "url": "http://localhost:3000/d/-Y-tnEDWk/templating-nested-template-variables?var-datacenter=${__data.fields[datacenter]}\u0026var-server=${__value.raw}"
+                            "url": "http://localhost:3000/d/-Y-tnEDWk/templating-nested-template-variables?var-datacenter=${__data.fields[datacenter]}\u0026var-server=${__value.raw}"
                          }
                        ]
                      }
@@ -2051,4 +2051,4 @@
      "storedVersion": "v0alpha1"
    }
  }
-}
+}
@@ -2691,4 +2691,4 @@
      "storedVersion": "v0alpha1"
    }
  }
-}
+}
@@ -2764,4 +2764,4 @@
      "storedVersion": "v0alpha1"
    }
  }
-}
+}
@@ -1173,4 +1173,4 @@
      "storedVersion": "v0alpha1"
    }
  }
-}
+}
@@ -1618,4 +1618,4 @@
      "storedVersion": "v0alpha1"
    }
  }
-}
+}
@@ -1670,4 +1670,4 @@
      "storedVersion": "v0alpha1"
    }
  }
-}
+}
@@ -0,0 +1,161 @@
+{
+  "kind": "Dashboard",
+  "apiVersion": "dashboard.grafana.app/v0alpha1",
+  "metadata": {
+    "name": "bom-in-links-test",
+    "namespace": "org-1",
+    "labels": {
+      "test": "bom-stripping"
+    }
+  },
+  "spec": {
+    "description": "Testing that BOM characters are stripped from URLs during conversion",
+    "editable": true,
+    "links": [
+      {
+        "icon": "external link",
+        "targetBlank": true,
+        "title": "Dashboard link with BOM",
+        "type": "link",
+        "url": "http://example.com?var=${datasource}\u0026other=value"
+      }
+    ],
+    "panels": [
+      {
+        "fieldConfig": {
+          "defaults": {
+            "custom": {},
+            "mappings": [],
+            "thresholds": {
+              "mode": "absolute",
+              "steps": [
+                {
+                  "color": "green"
+                },
+                {
+                  "color": "red",
+                  "value": 80
+                }
+              ]
+            }
+          },
+          "overrides": [
+            {
+              "matcher": {
+                "id": "byName",
+                "options": "server"
+              },
+              "properties": [
+                {
+                  "id": "links",
+                  "value": [
+                    {
+                      "title": "Override link with BOM",
+                      "url": "http://localhost:3000/d/test?var-datacenter=${__data.fields[datacenter]}\u0026var-server=${__value.raw}"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        "gridPos": {
+          "h": 8,
+          "w": 12,
+          "x": 0,
+          "y": 0
+        },
+        "id": 1,
+        "links": [
+          {
+            "targetBlank": true,
+            "title": "Panel data link with BOM",
+            "url": "http://example.com/${__data.fields.cluster}\u0026var=value"
+          }
+        ],
+        "targets": [
+          {
+            "datasource": {
+              "type": "prometheus",
+              "uid": "test-ds"
+            },
+            "refId": "A"
+          }
+        ],
+        "title": "Panel with BOM in field config override links",
+        "type": "table"
+      },
+      {
+        "fieldConfig": {
+          "defaults": {
+            "links": [
+              {
+                "targetBlank": false,
+                "title": "Field config default link with BOM",
+                "url": "http://example.com?field=${__field.name}\u0026value=${__value.raw}"
+              }
+            ]
+          },
+          "overrides": []
+        },
+        "gridPos": {
+          "h": 8,
+          "w": 12,
+          "x": 12,
+          "y": 0
+        },
+        "id": 2,
+        "options": {
+          "dataLinks": [
+            {
+              "targetBlank": true,
+              "title": "Options data link with BOM",
+              "url": "http://example.com?series=${__series.name}\u0026time=${__value.time}"
+            }
+          ],
+          "legend": {
+            "displayMode": "list",
+            "placement": "bottom",
+            "showLegend": true
+          }
+        },
+        "targets": [
+          {
+            "datasource": {
+              "type": "prometheus",
+              "uid": "test-ds"
+            },
+            "refId": "A"
+          }
+        ],
+        "title": "Panel with BOM in options dataLinks",
+        "type": "timeseries"
+      }
+    ],
+    "schemaVersion": 42,
+    "tags": [
+      "test",
+      "bom"
+    ],
+    "time": {
+      "from": "now-6h",
+      "to": "now"
+    },
+    "timepicker": {
+      "refresh_intervals": [
+        "5s",
+        "10s",
+        "30s",
+        "1m",
+        "5m"
+      ]
+    },
+    "title": "BOM Stripping Test Dashboard"
+  },
+  "status": {
+    "conversion": {
+      "failed": false,
+      "storedVersion": "v1beta1"
+    }
+  }
+}
@@ -0,0 +1,242 @@
+{
+  "kind": "Dashboard",
+  "apiVersion": "dashboard.grafana.app/v2alpha1",
+  "metadata": {
+    "name": "bom-in-links-test",
+    "namespace": "org-1",
+    "labels": {
+      "test": "bom-stripping"
+    }
+  },
+  "spec": {
+    "annotations": [],
+    "cursorSync": "Off",
+    "description": "Testing that BOM characters are stripped from URLs during conversion",
+    "editable": true,
+    "elements": {
+      "panel-1": {
+        "kind": "Panel",
+        "spec": {
+          "id": 1,
+          "title": "Panel with BOM in field config override links",
+          "description": "",
+          "links": [
+            {
+              "title": "Panel data link with BOM",
+              "url": "http://example.com/${__data.fields.cluster}\u0026var=value",
+              "targetBlank": true
+            }
+          ],
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "query": {
+                      "kind": "prometheus",
+                      "spec": {}
+                    },
+                    "datasource": {
+                      "type": "prometheus",
+                      "uid": "test-ds"
+                    },
+                    "refId": "A",
+                    "hidden": false
+                  }
+                }
+              ],
+              "transformations": [],
+              "queryOptions": {}
+            }
+          },
+          "vizConfig": {
+            "kind": "table",
+            "spec": {
+              "pluginVersion": "",
+              "options": {},
+              "fieldConfig": {
+                "defaults": {
+                  "thresholds": {
+                    "mode": "absolute",
+                    "steps": [
+                      {
+                        "value": null,
+                        "color": "green"
+                      },
+                      {
+                        "value": 80,
+                        "color": "red"
+                      }
+                    ]
+                  }
+                },
+                "overrides": [
+                  {
+                    "matcher": {
+                      "id": "byName",
+                      "options": "server"
+                    },
+                    "properties": [
+                      {
+                        "id": "links",
+                        "value": [
+                          {
+                            "title": "Override link with BOM",
+                            "url": "http://localhost:3000/d/test?var-datacenter=${__data.fields[datacenter]}\u0026var-server=${__value.raw}"
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                ]
+              }
+            }
+          }
+        }
+      },
+      "panel-2": {
+        "kind": "Panel",
+        "spec": {
+          "id": 2,
+          "title": "Panel with BOM in options dataLinks",
+          "description": "",
+          "links": [],
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "query": {
+                      "kind": "prometheus",
+                      "spec": {}
+                    },
+                    "datasource": {
+                      "type": "prometheus",
+                      "uid": "test-ds"
+                    },
+                    "refId": "A",
+                    "hidden": false
+                  }
+                }
+              ],
+              "transformations": [],
+              "queryOptions": {}
+            }
+          },
+          "vizConfig": {
+            "kind": "timeseries",
+            "spec": {
+              "pluginVersion": "",
+              "options": {
+                "dataLinks": [
+                  {
+                    "targetBlank": true,
+                    "title": "Options data link with BOM",
+                    "url": "http://example.com?series=${__series.name}\u0026time=${__value.time}"
+                  }
+                ],
+                "legend": {
+                  "displayMode": "list",
+                  "placement": "bottom",
+                  "showLegend": true
+                }
+              },
+              "fieldConfig": {
+                "defaults": {
+                  "links": [
+                    {
+                      "targetBlank": false,
+                      "title": "Field config default link with BOM",
+                      "url": "http://example.com?field=${__field.name}\u0026value=${__value.raw}"
+                    }
+                  ]
+                },
+                "overrides": []
+              }
+            }
+          }
+        }
+      }
+    },
+    "layout": {
+      "kind": "GridLayout",
+      "spec": {
+        "items": [
+          {
+            "kind": "GridLayoutItem",
+            "spec": {
+              "x": 0,
+              "y": 0,
+              "width": 12,
+              "height": 8,
+              "element": {
+                "kind": "ElementReference",
+                "name": "panel-1"
+              }
+            }
+          },
+          {
+            "kind": "GridLayoutItem",
+            "spec": {
+              "x": 12,
+              "y": 0,
+              "width": 12,
+              "height": 8,
+              "element": {
+                "kind": "ElementReference",
+                "name": "panel-2"
+              }
+            }
+          }
+        ]
+      }
+    },
+    "links": [
+      {
+        "title": "Dashboard link with BOM",
+        "type": "link",
+        "icon": "external link",
+        "tooltip": "",
+        "url": "http://example.com?var=${datasource}\u0026other=value",
+        "tags": [],
+        "asDropdown": false,
+        "targetBlank": true,
+        "includeVars": false,
+        "keepTime": false
+      }
+    ],
+    "liveNow": false,
+    "preload": false,
+    "tags": [
+      "test",
+      "bom"
+    ],
+    "timeSettings": {
+      "timezone": "browser",
+      "from": "now-6h",
+      "to": "now",
+      "autoRefresh": "",
+      "autoRefreshIntervals": [
+        "5s",
+        "10s",
+        "30s",
+        "1m",
+        "5m"
+      ],
+      "hideTimepicker": false,
+      "fiscalYearStartMonth": 0
+    },
+    "title": "BOM Stripping Test Dashboard",
+    "variables": []
+  },
+  "status": {
+    "conversion": {
+      "failed": false,
+      "storedVersion": "v1beta1"
+    }
+  }
+}
@@ -0,0 +1,246 @@
+{
+  "kind": "Dashboard",
+  "apiVersion": "dashboard.grafana.app/v2beta1",
+  "metadata": {
+    "name": "bom-in-links-test",
+    "namespace": "org-1",
+    "labels": {
+      "test": "bom-stripping"
+    }
+  },
+  "spec": {
+    "annotations": [],
+    "cursorSync": "Off",
+    "description": "Testing that BOM characters are stripped from URLs during conversion",
+    "editable": true,
+    "elements": {
+      "panel-1": {
+        "kind": "Panel",
+        "spec": {
+          "id": 1,
+          "title": "Panel with BOM in field config override links",
+          "description": "",
+          "links": [
+            {
+              "title": "Panel data link with BOM",
+              "url": "http://example.com/${__data.fields.cluster}\u0026var=value",
+              "targetBlank": true
+            }
+          ],
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "query": {
+                      "kind": "DataQuery",
+                      "group": "prometheus",
+                      "version": "v0",
+                      "datasource": {
+                        "name": "test-ds"
+                      },
+                      "spec": {}
+                    },
+                    "refId": "A",
+                    "hidden": false
+                  }
+                }
+              ],
+              "transformations": [],
+              "queryOptions": {}
+            }
+          },
+          "vizConfig": {
+            "kind": "VizConfig",
+            "group": "table",
+            "version": "",
+            "spec": {
+              "options": {},
+              "fieldConfig": {
+                "defaults": {
+                  "thresholds": {
+                    "mode": "absolute",
+                    "steps": [
+                      {
+                        "value": null,
+                        "color": "green"
+                      },
+                      {
+                        "value": 80,
+                        "color": "red"
+                      }
+                    ]
+                  }
+                },
+                "overrides": [
+                  {
+                    "matcher": {
+                      "id": "byName",
+                      "options": "server"
+                    },
+                    "properties": [
+                      {
+                        "id": "links",
+                        "value": [
+                          {
+                            "title": "Override link with BOM",
+                            "url": "http://localhost:3000/d/test?var-datacenter=${__data.fields[datacenter]}\u0026var-server=${__value.raw}"
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                ]
+              }
+            }
+          }
+        }
+      },
+      "panel-2": {
+        "kind": "Panel",
+        "spec": {
+          "id": 2,
+          "title": "Panel with BOM in options dataLinks",
+          "description": "",
+          "links": [],
+          "data": {
+            "kind": "QueryGroup",
+            "spec": {
+              "queries": [
+                {
+                  "kind": "PanelQuery",
+                  "spec": {
+                    "query": {
+                      "kind": "DataQuery",
+                      "group": "prometheus",
+                      "version": "v0",
+                      "datasource": {
+                        "name": "test-ds"
+                      },
+                      "spec": {}
+                    },
+                    "refId": "A",
+                    "hidden": false
+                  }
+                }
+              ],
+              "transformations": [],
+              "queryOptions": {}
+            }
+          },
+          "vizConfig": {
+            "kind": "VizConfig",
+            "group": "timeseries",
+            "version": "",
+            "spec": {
+              "options": {
+                "dataLinks": [
+                  {
+                    "targetBlank": true,
+                    "title": "Options data link with BOM",
+                    "url": "http://example.com?series=${__series.name}\u0026time=${__value.time}"
+                  }
+                ],
+                "legend": {
+                  "displayMode": "list",
+                  "placement": "bottom",
+                  "showLegend": true
+                }
+              },
+              "fieldConfig": {
+                "defaults": {
+                  "links": [
+                    {
+                      "targetBlank": false,
+                      "title": "Field config default link with BOM",
+                      "url": "http://example.com?field=${__field.name}\u0026value=${__value.raw}"
+                    }
+                  ]
+                },
+                "overrides": []
+              }
+            }
+          }
+        }
+      }
+    },
+    "layout": {
+      "kind": "GridLayout",
+      "spec": {
+        "items": [
+          {
+            "kind": "GridLayoutItem",
+            "spec": {
+              "x": 0,
+              "y": 0,
+              "width": 12,
+              "height": 8,
+              "element": {
+                "kind": "ElementReference",
+                "name": "panel-1"
+              }
+            }
+          },
+          {
+            "kind": "GridLayoutItem",
+            "spec": {
+              "x": 12,
+              "y": 0,
+              "width": 12,
+              "height": 8,
+              "element": {
+                "kind": "ElementReference",
+                "name": "panel-2"
+              }
+            }
+          }
+        ]
+      }
+    },
+    "links": [
+      {
+        "title": "Dashboard link with BOM",
+        "type": "link",
+        "icon": "external link",
+        "tooltip": "",
+        "url": "http://example.com?var=${datasource}\u0026other=value",
+        "tags": [],
+        "asDropdown": false,
+        "targetBlank": true,
+        "includeVars": false,
+        "keepTime": false
+      }
+    ],
+    "liveNow": false,
+    "preload": false,
+    "tags": [
+      "test",
+      "bom"
+    ],
+    "timeSettings": {
+      "timezone": "browser",
+      "from": "now-6h",
+      "to": "now",
+      "autoRefresh": "",
+      "autoRefreshIntervals": [
+        "5s",
+        "10s",
+        "30s",
+        "1m",
+        "5m"
+      ],
+      "hideTimepicker": false,
+      "fiscalYearStartMonth": 0
+    },
+    "title": "BOM Stripping Test Dashboard",
+    "variables": []
+  },
+  "status": {
+    "conversion": {
+      "failed": false,
+      "storedVersion": "v1beta1"
+    }
+  }
+}
@@ -229,6 +229,36 @@ func getBoolField(m map[string]interface{}, key string, defaultValue bool) bool
 	return defaultValue
 }

+// stripBOM removes Byte Order Mark (BOM) characters from a string.
+// BOMs (U+FEFF) can be introduced through copy/paste from certain editors
+// and cause CUE validation errors ("illegal byte order mark").
+func stripBOM(s string) string {
+	return strings.ReplaceAll(s, "\ufeff", "")
+}
+
+// stripBOMFromInterface recursively strips BOM characters from all strings
+// in an interface{} value (map, slice, or string).
+func stripBOMFromInterface(v interface{}) interface{} {
+	switch val := v.(type) {
+	case string:
+		return stripBOM(val)
+	case map[string]interface{}:
+		result := make(map[string]interface{}, len(val))
+		for k, v := range val {
+			result[k] = stripBOMFromInterface(v)
+		}
+		return result
+	case []interface{}:
+		result := make([]interface{}, len(val))
+		for i, item := range val {
+			result[i] = stripBOMFromInterface(item)
+		}
+		return result
+	default:
+		return v
+	}
+}
+
 func getUnionField[T ~string](m map[string]interface{}, key string) *T {
 	if val, ok := m[key]; ok {
 		if str, ok := val.(string); ok && str != "" {
@@ -393,7 +423,8 @@ func transformLinks(dashboard map[string]interface{}) []dashv2alpha1.DashboardDa
 				// Optional field - only set if present
 				if url, exists := linkMap["url"]; exists {
 					if urlStr, ok := url.(string); ok {
-						dashLink.Url = &urlStr
+						cleanUrl := stripBOM(urlStr)
+						dashLink.Url = &cleanUrl
 					}
 				}

@@ -2239,7 +2270,7 @@ func transformDataLinks(panelMap map[string]interface{}) []dashv2alpha1.Dashboar
 		if linkMap, ok := link.(map[string]interface{}); ok {
 			dataLink := dashv2alpha1.DashboardDataLink{
 				Title: schemaversion.GetStringValue(linkMap, "title"),
-				Url:   schemaversion.GetStringValue(linkMap, "url"),
+				Url:   stripBOM(schemaversion.GetStringValue(linkMap, "url")),
 			}
 			if _, exists := linkMap["targetBlank"]; exists {
 				targetBlank := getBoolField(linkMap, "targetBlank", false)
@@ -2331,6 +2362,12 @@ func buildVizConfig(panelMap map[string]interface{}) dashv2alpha1.DashboardVizCo
 		}
 	}

+	// Strip BOMs from options (may contain dataLinks with URLs that have BOMs)
+	cleanedOptions := stripBOMFromInterface(options)
+	if cleanedMap, ok := cleanedOptions.(map[string]interface{}); ok {
+		options = cleanedMap
+	}
+
 	// Build field config by mapping each field individually
 	fieldConfigSource := extractFieldConfigSource(fieldConfig)

@@ -2474,9 +2511,14 @@ func extractFieldConfigDefaults(defaults map[string]interface{}) dashv2alpha1.Da
 		hasDefaults = true
 	}

-	// Extract array field
+	// Extract array field - strip BOMs from link URLs
 	if linksArray, ok := extractArrayField(defaults, "links"); ok {
-		fieldConfigDefaults.Links = linksArray
+		cleanedLinks := stripBOMFromInterface(linksArray)
+		if cleanedArray, ok := cleanedLinks.([]interface{}); ok {
+			fieldConfigDefaults.Links = cleanedArray
+		} else {
+			fieldConfigDefaults.Links = linksArray
+		}
 		hasDefaults = true
 	}

@@ -2762,9 +2804,11 @@ func extractFieldConfigOverrides(fieldConfig map[string]interface{}) []dashv2alp
 				fieldOverride.Properties = make([]dashv2alpha1.DashboardDynamicConfigValue, 0, len(propertiesArray))
 				for _, property := range propertiesArray {
 					if propertyMap, ok := property.(map[string]interface{}); ok {
+						// Strip BOMs from property values (may contain links with URLs)
+						cleanedValue := stripBOMFromInterface(propertyMap["value"])
 						fieldOverride.Properties = append(fieldOverride.Properties, dashv2alpha1.DashboardDynamicConfigValue{
 							Id:    schemaversion.GetStringValue(propertyMap, "id"),
-							Value: propertyMap["value"],
+							Value: cleanedValue,
 						})
 					}
 				}
@@ -0,0 +1,20 @@
+# Plugins App
+
+API documentation is available at http://localhost:3000/swagger?api=plugins.grafana.app-v0alpha1
+
+## Codegen
+
+- Go: `make generate`
+- Frontend: Follow instructions in this [README](../..//packages/grafana-api-clients/README.md)
+
+## Plugin sync
+
+The plugin sync pushes the plugins loaded from disk to the plugins API.
+
+To enable, add these feature toggles in your `custom.ini`:
+
+```ini
+[feature_toggles]
+pluginInstallAPISync = true
+pluginStoreServiceLoading = true
+```
@@ -98,7 +98,7 @@ You can share dashboards in the following ways:
 - [As a report](#schedule-a-report)
 - [As a snapshot](#share-a-snapshot)
 - [As a PDF export](#export-a-dashboard-as-pdf)
- [As a JSON file export](#export-a-dashboard-as-json)
+- [As a JSON file export](#export-a-dashboard-as-code)
 - [As an image export](#export-a-dashboard-as-an-image)

 When you share a dashboard externally as a link or by email, those dashboards are included in a list of your shared dashboards. To view the list and manage these dashboards, navigate to **Dashboards > Shared dashboards**.
@@ -10,7 +10,7 @@ const NUM_NESTED_DASHBOARDS = 60;
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -5,7 +5,7 @@ import testDashboard from '../dashboards/TestDashboard.json';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -7,7 +7,7 @@ test.use({
    scenes: true,
    sharingDashboardImage: true, // Enable the export image feature
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -3,7 +3,7 @@ import { test, expect } from '@grafana/plugin-e2e';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -3,7 +3,7 @@ import { test, expect } from '@grafana/plugin-e2e';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -5,7 +5,7 @@ import testDashboard from '../dashboards/DataLinkWithoutSlugTest.json';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -5,7 +5,7 @@ import testDashboard from '../dashboards/DashboardLiveTest.json';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -3,7 +3,7 @@ import { test, expect } from '@grafana/plugin-e2e';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
    dashboardScene: false, // this test is for the old sharing modal only used when scenes is turned off
  },
 });
@@ -3,7 +3,7 @@ import { test, expect } from '@grafana/plugin-e2e';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
    dashboardScene: false, // this test is for the old sharing modal only used when scenes is turned off
  },
 });
@@ -4,7 +4,7 @@ test.use({
  featureToggles: {
    scenes: true,
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -4,7 +4,7 @@ test.use({
  featureToggles: {
    scenes: true,
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -6,7 +6,7 @@ test.use({
  featureToggles: {
    scenes: true,
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -6,7 +6,7 @@ test.use({
  timezoneId: 'Pacific/Easter',
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -8,7 +8,7 @@ const TIMEZONE_DASHBOARD_UID = 'd41dbaa2-a39e-4536-ab2b-caca52f1a9c8';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -17,7 +17,7 @@ test.use({
  },
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -3,7 +3,7 @@ import { test, expect } from '@grafana/plugin-e2e';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -5,7 +5,7 @@ const PAGE_UNDER_TEST = 'edediimbjhdz4b/a-tall-dashboard';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -5,7 +5,7 @@ import testDashboard from '../dashboards/TestDashboard.json';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -5,7 +5,7 @@ const PAGE_UNDER_TEST = '-Y-tnEDWk/templating-nested-template-variables';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -6,7 +6,7 @@ const DASHBOARD_NAME = 'Test variable output';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -53,7 +53,7 @@ async function assertPreviewValues(
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -6,7 +6,7 @@ const DASHBOARD_NAME = 'Test variable output';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -19,7 +19,7 @@ async function assertPreviewValues(
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -6,7 +6,7 @@ const DASHBOARD_NAME = 'Templating - Nested Template Variables';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -6,7 +6,7 @@ const DASHBOARD_NAME = 'Test variable output';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -5,7 +5,7 @@ const PAGE_UNDER_TEST = 'WVpf2jp7z/repeating-a-panel-horizontally';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -5,7 +5,7 @@ const PAGE_UNDER_TEST = 'OY8Ghjt7k/repeating-a-panel-vertically';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -5,7 +5,7 @@ const PAGE_UNDER_TEST = 'dtpl2Ctnk/repeating-an-empty-row';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -5,7 +5,7 @@ const PAGE_UNDER_TEST = '-Y-tnEDWk/templating-nested-template-variables';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -5,7 +5,7 @@ const DASHBOARD_UID = 'ZqZnVvFZz';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
    dashboardScene: false, // this test is for the old sharing modal only used when scenes is turned off
  },
 });
@@ -5,7 +5,7 @@ const DASHBOARD_UID = 'yBCC3aKGk';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -7,7 +7,7 @@ const PAGE_UNDER_TEST = 'AejrN1AMz';
 test.use({
  featureToggles: {
    kubernetesDashboards: process.env.FORCE_V2_DASHBOARDS_API === 'true',
-    kubernetesDashboardsV2: process.env.FORCE_V2_DASHBOARDS_API === 'true',
+    dashboardNewLayouts: process.env.FORCE_V2_DASHBOARDS_API === 'true',
  },
 });

@@ -2,18 +2,16 @@ import { Locator } from '@playwright/test';

 import { test, expect } from '@grafana/plugin-e2e';

-import { setVisualization } from './vizpicker-utils';
-
 test.use({
  featureToggles: {
    canvasPanelPanZoom: true,
  },
 });
 test.describe('Canvas Panel - Scene Tests', () => {
-  test.beforeEach(async ({ page, gotoDashboardPage, selectors }) => {
+  test.beforeEach(async ({ page, gotoDashboardPage }) => {
    const dashboardPage = await gotoDashboardPage({});
    const panelEditPage = await dashboardPage.addPanel();
-    await setVisualization(panelEditPage, 'Canvas', selectors);
+    await panelEditPage.setVisualization('Canvas');

    // Wait for canvas panel to load
    await page.waitForSelector('[data-testid="canvas-scene-pan-zoom"]', { timeout: 10000 });
@@ -1,24 +0,0 @@
-import { expect, E2ESelectorGroups, PanelEditPage } from '@grafana/plugin-e2e';
-
-// this replaces the panelEditPage.setVisualization method used previously in tests, since it
-// does not know how to use the updated 12.4 viz picker UI to set the visualization
-export const setVisualization = async (panelEditPage: PanelEditPage, vizName: string, selectors: E2ESelectorGroups) => {
-  const vizPicker = panelEditPage.getByGrafanaSelector(selectors.components.PanelEditor.toggleVizPicker);
-  await expect(vizPicker, '"Change" button should be visible').toBeVisible();
-  await vizPicker.click();
-
-  const allVizTabBtn = panelEditPage.getByGrafanaSelector(selectors.components.Tab.title('All visualizations'));
-  await expect(allVizTabBtn, '"All visualiations" button should be visible').toBeVisible();
-  await allVizTabBtn.click();
-
-  const vizItem = panelEditPage.getByGrafanaSelector(selectors.components.PluginVisualization.item(vizName));
-  await expect(vizItem, `"${vizName}" item should be visible`).toBeVisible();
-  await vizItem.scrollIntoViewIfNeeded();
-  await vizItem.click();
-
-  await expect(vizPicker, '"Change" button should be visible again').toBeVisible();
-  await expect(
-    panelEditPage.getByGrafanaSelector(selectors.components.PanelEditor.OptionsPane.header),
-    'Panel header should have the new viz type name'
-  ).toHaveText(vizName);
-};
@@ -1,6 +1,5 @@
 import { expect, test } from '@grafana/plugin-e2e';

-import { setVisualization } from '../../../panels-suite/vizpicker-utils';
 import { formatExpectError } from '../errors';
 import { successfulDataQuery } from '../mocks/queries';

@@ -25,10 +24,10 @@ test.describe(
        ).toContainText(['Field', 'Max', 'Mean', 'Last']);
      });

-      test('table panel data assertions', async ({ panelEditPage, selectors }) => {
+      test('table panel data assertions', async ({ panelEditPage }) => {
        await panelEditPage.mockQueryDataResponse(successfulDataQuery, 200);
        await panelEditPage.datasource.set('gdev-testdata');
-        await setVisualization(panelEditPage, 'Table', selectors);
+        await panelEditPage.setVisualization('Table');
        await panelEditPage.refreshPanel();
        await expect(
          panelEditPage.panel.locator,
@@ -44,10 +43,10 @@ test.describe(
        ).toContainText(['val1', 'val2', 'val3', 'val4']);
      });

-      test('timeseries panel - table view assertions', async ({ panelEditPage, selectors }) => {
+      test('timeseries panel - table view assertions', async ({ panelEditPage }) => {
        await panelEditPage.mockQueryDataResponse(successfulDataQuery, 200);
        await panelEditPage.datasource.set('gdev-testdata');
-        await setVisualization(panelEditPage, 'Time series', selectors);
+        await panelEditPage.setVisualization('Time series');
        await panelEditPage.refreshPanel();
        await panelEditPage.toggleTableView();
        await expect(
@@ -1,6 +1,5 @@
 import { expect, test } from '@grafana/plugin-e2e';

-import { setVisualization } from '../../../panels-suite/vizpicker-utils';
 import { formatExpectError } from '../errors';
 import { successfulDataQuery } from '../mocks/queries';
 import { scenarios } from '../mocks/resources';
@@ -54,10 +53,10 @@ test.describe(
        ).toHaveText(scenarios.map((s) => s.name));
      });

-      test('mocked query data response', async ({ panelEditPage, page, selectors }) => {
+      test('mocked query data response', async ({ panelEditPage, page }) => {
        await panelEditPage.mockQueryDataResponse(successfulDataQuery, 200);
        await panelEditPage.datasource.set('gdev-testdata');
-        await setVisualization(panelEditPage, TABLE_VIZ_NAME, selectors);
+        await panelEditPage.setVisualization(TABLE_VIZ_NAME);
        await panelEditPage.refreshPanel();
        await expect(
          panelEditPage.panel.getErrorIcon(),
@@ -76,7 +75,7 @@ test.describe(
        selectors,
        page,
      }) => {
-        await setVisualization(panelEditPage, TABLE_VIZ_NAME, selectors);
+        await panelEditPage.setVisualization(TABLE_VIZ_NAME);
        await expect(
          panelEditPage.getByGrafanaSelector(selectors.components.PanelEditor.OptionsPane.header),
          formatExpectError('Expected panel visualization to be set to table')
@@ -93,8 +92,8 @@ test.describe(
        ).toBeVisible();
      });

-      test('Select time zone in timezone picker', async ({ panelEditPage, selectors }) => {
-        await setVisualization(panelEditPage, TIME_SERIES_VIZ_NAME, selectors);
+      test('Select time zone in timezone picker', async ({ panelEditPage }) => {
+        await panelEditPage.setVisualization(TIME_SERIES_VIZ_NAME);
        const axisOptions = await panelEditPage.getCustomOptions('Axis');
        const timeZonePicker = axisOptions.getSelect('Time zone');

@@ -102,8 +101,8 @@ test.describe(
        await expect(timeZonePicker).toHaveSelected('Europe/Stockholm');
      });

-      test('select unit in unit picker', async ({ panelEditPage, selectors }) => {
-        await setVisualization(panelEditPage, TIME_SERIES_VIZ_NAME, selectors);
+      test('select unit in unit picker', async ({ panelEditPage }) => {
+        await panelEditPage.setVisualization(TIME_SERIES_VIZ_NAME);
        const standardOptions = panelEditPage.getStandardOptions();
        const unitPicker = standardOptions.getUnitPicker('Unit');

@@ -112,8 +111,8 @@ test.describe(
        await expect(unitPicker).toHaveSelected('Pixels');
      });

-      test('enter value in number input', async ({ panelEditPage, selectors }) => {
-        await setVisualization(panelEditPage, TIME_SERIES_VIZ_NAME, selectors);
+      test('enter value in number input', async ({ panelEditPage }) => {
+        await panelEditPage.setVisualization(TIME_SERIES_VIZ_NAME);
        const axisOptions = panelEditPage.getCustomOptions('Axis');
        const lineWith = axisOptions.getNumberInput('Soft min');

@@ -122,8 +121,8 @@ test.describe(
        await expect(lineWith).toHaveValue('10');
      });

-      test('enter value in slider', async ({ panelEditPage, selectors }) => {
-        await setVisualization(panelEditPage, TIME_SERIES_VIZ_NAME, selectors);
+      test('enter value in slider', async ({ panelEditPage }) => {
+        await panelEditPage.setVisualization(TIME_SERIES_VIZ_NAME);
        const graphOptions = panelEditPage.getCustomOptions('Graph styles');
        const lineWidth = graphOptions.getSliderInput('Line width');

@@ -132,8 +131,8 @@ test.describe(
        await expect(lineWidth).toHaveValue('10');
      });

-      test('select value in single value select', async ({ panelEditPage, selectors }) => {
-        await setVisualization(panelEditPage, TIME_SERIES_VIZ_NAME, selectors);
+      test('select value in single value select', async ({ panelEditPage }) => {
+        await panelEditPage.setVisualization(TIME_SERIES_VIZ_NAME);
        const standardOptions = panelEditPage.getStandardOptions();
        const colorSchemeSelect = standardOptions.getSelect('Color scheme');

@@ -141,8 +140,8 @@ test.describe(
        await expect(colorSchemeSelect).toHaveSelected('Classic palette');
      });

-      test('clear input', async ({ panelEditPage, selectors }) => {
-        await setVisualization(panelEditPage, TIME_SERIES_VIZ_NAME, selectors);
+      test('clear input', async ({ panelEditPage }) => {
+        await panelEditPage.setVisualization(TIME_SERIES_VIZ_NAME);
        const panelOptions = panelEditPage.getPanelOptions();
        const title = panelOptions.getTextInput('Title');

@@ -151,8 +150,8 @@ test.describe(
        await expect(title).toHaveValue('');
      });

-      test('enter value in input', async ({ panelEditPage, selectors }) => {
-        await setVisualization(panelEditPage, TIME_SERIES_VIZ_NAME, selectors);
+      test('enter value in input', async ({ panelEditPage }) => {
+        await panelEditPage.setVisualization(TIME_SERIES_VIZ_NAME);
        const panelOptions = panelEditPage.getPanelOptions();
        const description = panelOptions.getTextInput('Description');

@@ -161,8 +160,8 @@ test.describe(
        await expect(description).toHaveValue('This is a panel');
      });

-      test('unchecking switch', async ({ panelEditPage, selectors }) => {
-        await setVisualization(panelEditPage, TIME_SERIES_VIZ_NAME, selectors);
+      test('unchecking switch', async ({ panelEditPage }) => {
+        await panelEditPage.setVisualization(TIME_SERIES_VIZ_NAME);
        const axisOptions = panelEditPage.getCustomOptions('Axis');
        const showBorder = axisOptions.getSwitch('Show border');

@@ -174,8 +173,8 @@ test.describe(
        await expect(showBorder).toBeChecked({ checked: false });
      });

-      test('checking switch', async ({ panelEditPage, selectors }) => {
-        await setVisualization(panelEditPage, TIME_SERIES_VIZ_NAME, selectors);
+      test('checking switch', async ({ panelEditPage }) => {
+        await panelEditPage.setVisualization(TIME_SERIES_VIZ_NAME);
        const axisOptions = panelEditPage.getCustomOptions('Axis');
        const showBorder = axisOptions.getSwitch('Show border');

@@ -184,8 +183,8 @@ test.describe(
        await expect(showBorder).toBeChecked();
      });

-      test('re-selecting value in radio button group', async ({ panelEditPage, selectors }) => {
-        await setVisualization(panelEditPage, TIME_SERIES_VIZ_NAME, selectors);
+      test('re-selecting value in radio button group', async ({ panelEditPage }) => {
+        await panelEditPage.setVisualization(TIME_SERIES_VIZ_NAME);
        const axisOptions = panelEditPage.getCustomOptions('Axis');
        const placement = axisOptions.getRadioGroup('Placement');

@@ -196,8 +195,8 @@ test.describe(
        await expect(placement).toHaveChecked('Auto');
      });

-      test('selecting value in radio button group', async ({ panelEditPage, selectors }) => {
-        await setVisualization(panelEditPage, TIME_SERIES_VIZ_NAME, selectors);
+      test('selecting value in radio button group', async ({ panelEditPage }) => {
+        await panelEditPage.setVisualization(TIME_SERIES_VIZ_NAME);
        const axisOptions = panelEditPage.getCustomOptions('Axis');
        const placement = axisOptions.getRadioGroup('Placement');

@@ -285,6 +285,10 @@ const injectedRtkApi = api
        query: (queryArg) => ({ url: `/snapshots/delete/${queryArg.deleteKey}`, method: 'DELETE' }),
        invalidatesTags: ['Snapshot'],
      }),
+      getSnapshotSettings: build.query<GetSnapshotSettingsApiResponse, GetSnapshotSettingsApiArg>({
+        query: () => ({ url: `/snapshots/settings` }),
+        providesTags: ['Snapshot'],
+      }),
      getSnapshot: build.query<GetSnapshotApiResponse, GetSnapshotApiArg>({
        query: (queryArg) => ({
          url: `/snapshots/${queryArg.name}`,
@@ -742,6 +746,8 @@ export type DeleteWithKeyApiArg = {
  /** unique key returned in create */
  deleteKey: string;
 };
+export type GetSnapshotSettingsApiResponse = /** status 200 undefined */ any;
+export type GetSnapshotSettingsApiArg = void;
 export type GetSnapshotApiResponse = /** status 200 OK */ Snapshot;
 export type GetSnapshotApiArg = {
  /** name of the Snapshot */
@@ -1273,6 +1279,8 @@ export const {
  useLazyListSnapshotQuery,
  useCreateSnapshotMutation,
  useDeleteWithKeyMutation,
+  useGetSnapshotSettingsQuery,
+  useLazyGetSnapshotSettingsQuery,
  useGetSnapshotQuery,
  useLazyGetSnapshotQuery,
  useDeleteSnapshotMutation,
@@ -356,10 +356,6 @@ export interface FeatureToggles {
  */
  dashboardNewLayouts?: boolean;
  /**
-  * Use the v2 kubernetes API in the frontend for dashboards
-  */
-  kubernetesDashboardsV2?: boolean;
-  /**
  * Enables undo/redo in dynamic dashboards
  */
  dashboardUndoRedo?: boolean;
@@ -421,6 +417,10 @@ export interface FeatureToggles {
  */
  jitterAlertRulesWithinGroups?: boolean;
  /**
+  * Enable audit logging with Kubernetes under app platform
+  */
+  auditLoggingAppPlatform?: boolean;
+  /**
  * Enable the secrets management API and services under app platform
  */
  secretsManagementAppPlatform?: boolean;
@@ -48,7 +48,7 @@ describe('MetricsModal', () => {
      operations: [],
    };

-    setup(query, ['with-labels'], true);
+    setup(query, ['with-labels']);
    await waitFor(() => {
      expect(screen.getByText('with-labels')).toBeInTheDocument();
    });
@@ -220,6 +220,10 @@ function createDatasource(withLabels?: boolean) {
  // display different results if their labels are selected in the PromVisualQuery
  if (withLabels) {
    languageProvider.queryMetricsMetadata = jest.fn().mockResolvedValue({
+      ALERTS: {
+        type: 'gauge',
+        help: 'alerts help text',
+      },
      'with-labels': {
        type: 'with-labels-type',
        help: 'with-labels-help',
@@ -297,7 +301,7 @@ function createProps(query: PromVisualQuery, datasource: PrometheusDatasource, m
  };
 }

-function setup(query: PromVisualQuery, metrics: string[], withlabels?: boolean) {
+function setup(query: PromVisualQuery, metrics: string[]) {
  const withLabels: boolean = query.labels.length > 0;
  const datasource = createDatasource(withLabels);
  const props = createProps(query, datasource, metrics);
@@ -138,7 +138,7 @@ const MetricsModalContent = (props: MetricsModalProps) => {

 export const MetricsModal = (props: MetricsModalProps) => {
  return (
-    <MetricsModalContextProvider languageProvider={props.datasource.languageProvider}>
+    <MetricsModalContextProvider languageProvider={props.datasource.languageProvider} timeRange={props.timeRange}>
      <MetricsModalContent {...props} />
    </MetricsModalContextProvider>
  );
@@ -4,6 +4,7 @@ import { ReactNode } from 'react';
 import { TimeRange } from '@grafana/data';

 import { PrometheusLanguageProviderInterface } from '../../../language_provider';
+import { getMockTimeRange } from '../../../test/mocks/datasource';

 import { DEFAULT_RESULTS_PER_PAGE, MetricsModalContextProvider, useMetricsModal } from './MetricsModalContext';
 import { generateMetricData } from './helpers';
@@ -25,7 +26,9 @@ const mockLanguageProvider: PrometheusLanguageProviderInterface = {
 // Helper to create wrapper component
 const createWrapper = (languageProvider = mockLanguageProvider) => {
  return ({ children }: { children: ReactNode }) => (
-    <MetricsModalContextProvider languageProvider={languageProvider}>{children}</MetricsModalContextProvider>
+    <MetricsModalContextProvider languageProvider={languageProvider} timeRange={getMockTimeRange()}>
+      {children}
+    </MetricsModalContextProvider>
  );
 };

@@ -167,6 +170,7 @@ describe('MetricsModalContext', () => {

    it('should handle empty metadata response', async () => {
      (mockLanguageProvider.queryMetricsMetadata as jest.Mock).mockResolvedValue({});
+      (mockLanguageProvider.queryLabelValues as jest.Mock).mockResolvedValue(['metric1', 'metric2']);

      const { result } = renderHook(() => useMetricsModal(), {
        wrapper: createWrapper(),
@@ -176,7 +180,18 @@ describe('MetricsModalContext', () => {
        expect(result.current.isLoading).toBe(false);
      });

-      expect(result.current.filteredMetricsData).toEqual([]);
+      expect(result.current.filteredMetricsData).toEqual([
+        {
+          value: 'metric1',
+          type: 'counter',
+          description: 'Test metric',
+        },
+        {
+          value: 'metric2',
+          type: 'counter',
+          description: 'Test metric',
+        },
+      ]);
    });

    it('should handle metadata fetch error', async () => {
@@ -239,6 +254,7 @@ describe('MetricsModalContext', () => {
      }));

      (mockLanguageProvider.queryMetricsMetadata as jest.Mock).mockResolvedValue({
+        ALERTS: { type: 'gauge', help: 'Test alerts help' },
        test_metric: { type: 'counter', help: 'Test metric' },
      });

@@ -250,7 +266,7 @@ describe('MetricsModalContext', () => {
        expect(result.current.isLoading).toBe(false);
      });

-      expect(result.current.filteredMetricsData).toHaveLength(1);
+      expect(result.current.filteredMetricsData).toHaveLength(2);
      expect(result.current.selectedTypes).toEqual([]);
    });

@@ -318,7 +334,7 @@ describe('MetricsModalContext', () => {
      };

      const { getByTestId } = render(
-        <MetricsModalContextProvider languageProvider={mockLanguageProvider}>
+        <MetricsModalContextProvider languageProvider={mockLanguageProvider} timeRange={getMockTimeRange()}>
          <TestComponent />
        </MetricsModalContextProvider>
      );
@@ -52,11 +52,13 @@ const MetricsModalContext = createContext<MetricsModalContextValue | undefined>(

 type MetricsModalContextProviderProps = {
  languageProvider: PrometheusLanguageProviderInterface;
+  timeRange: TimeRange;
 };

 export const MetricsModalContextProvider: FC<PropsWithChildren<MetricsModalContextProviderProps>> = ({
  children,
  languageProvider,
+  timeRange,
 }) => {
  const [isLoading, setIsLoading] = useState(true);
  const [metricsData, setMetricsData] = useState<MetricsData>([]);
@@ -111,8 +113,16 @@ export const MetricsModalContextProvider: FC<PropsWithChildren<MetricsModalConte
      setIsLoading(true);
      const metadata = await languageProvider.queryMetricsMetadata(PROMETHEUS_QUERY_BUILDER_MAX_RESULTS);

-      if (Object.keys(metadata).length === 0) {
-        setMetricsData([]);
+      // We receive ALERTS metadata in any case
+      if (Object.keys(metadata).length <= 1) {
+        const fetchedMetrics = await languageProvider.queryLabelValues(
+          timeRange,
+          METRIC_LABEL,
+          undefined,
+          PROMETHEUS_QUERY_BUILDER_MAX_RESULTS
+        );
+        const processedData = fetchedMetrics.map((m) => generateMetricData(m, languageProvider));
+        setMetricsData(processedData);
      } else {
        const processedData = Object.keys(metadata).map((m) => generateMetricData(m, languageProvider));
        setMetricsData(processedData);
@@ -122,7 +132,7 @@ export const MetricsModalContextProvider: FC<PropsWithChildren<MetricsModalConte
    } finally {
      setIsLoading(false);
    }
-  }, [languageProvider]);
+  }, [languageProvider, timeRange]);

  const debouncedBackendSearch = useMemo(
    () =>
@@ -0,0 +1,88 @@
+package auditing
+
+import (
+	"encoding/json"
+	"time"
+)
+
+type Event struct {
+	// The namespace the action was performed in.
+	Namespace string `json:"namespace"`
+
+	// When it happened.
+	ObservedAt time.Time `json:"-"` // see MarshalJSON for why this is omitted
+
+	// Who/what performed the action.
+	SubjectName string `json:"subjectName"`
+	SubjectUID  string `json:"subjectUID"`
+
+	// What was performed.
+	Verb string `json:"verb"`
+
+	// The object the action was performed on. For verbs like "list" this will be empty.
+	Object string `json:"object,omitempty"`
+
+	// API information.
+	APIGroup   string `json:"apiGroup,omitempty"`
+	APIVersion string `json:"apiVersion,omitempty"`
+	Kind       string `json:"kind,omitempty"`
+
+	// Outcome of the action.
+	Outcome EventOutcome `json:"outcome"`
+
+	// Extra fields to add more context to the event.
+	Extra map[string]string `json:"extra,omitempty"`
+}
+
+func (e Event) Time() time.Time {
+	return e.ObservedAt
+}
+
+func (e Event) MarshalJSON() ([]byte, error) {
+	type Alias Event
+	return json.Marshal(&struct {
+		FormattedTimestamp string `json:"observedAt"`
+		Alias
+	}{
+		FormattedTimestamp: e.ObservedAt.UTC().Format(time.RFC3339Nano),
+		Alias:              (Alias)(e),
+	})
+}
+
+func (e Event) KVPairs() []any {
+	args := []any{
+		"audit", true,
+		"namespace", e.Namespace,
+		"observedAt", e.ObservedAt.UTC().Format(time.RFC3339Nano),
+		"subjectName", e.SubjectName,
+		"subjectUID", e.SubjectUID,
+		"verb", e.Verb,
+		"object", e.Object,
+		"apiGroup", e.APIGroup,
+		"apiVersion", e.APIVersion,
+		"kind", e.Kind,
+		"outcome", e.Outcome,
+	}
+
+	if len(e.Extra) > 0 {
+		extraArgs := make([]any, 0, len(e.Extra)*2)
+
+		for k, v := range e.Extra {
+			extraArgs = append(extraArgs, "extra_"+k, v)
+		}
+
+		args = append(args, extraArgs...)
+	}
+
+	return args
+}
+
+type EventOutcome string
+
+const (
+	EventOutcomeUnknown             EventOutcome = "unknown"
+	EventOutcomeSuccess             EventOutcome = "success"
+	EventOutcomeFailureUnauthorized EventOutcome = "failure_unauthorized"
+	EventOutcomeFailureNotFound     EventOutcome = "failure_not_found"
+	EventOutcomeFailureGeneric      EventOutcome = "failure_generic"
+)
@@ -0,0 +1,64 @@
+package auditing_test
+
+import (
+	"encoding/json"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/grafana/grafana/pkg/apiserver/auditing"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEvent_MarshalJSON(t *testing.T) {
+	t.Parallel()
+
+	t.Run("marshals the event", func(t *testing.T) {
+		t.Parallel()
+
+		now := time.Now()
+
+		event := auditing.Event{
+			ObservedAt: now,
+			Extra:      map[string]string{"k1": "v1", "k2": "v2"},
+		}
+
+		data, err := json.Marshal(event)
+		require.NoError(t, err)
+
+		var result map[string]any
+		require.NoError(t, json.Unmarshal(data, &result))
+
+		require.Equal(t, event.Time().UTC().Format(time.RFC3339Nano), result["observedAt"])
+		require.NotNil(t, result["extra"])
+		require.Len(t, result["extra"], 2)
+	})
+}
+
+func TestEvent_KVPairs(t *testing.T) {
+	t.Parallel()
+
+	t.Run("records extra fields", func(t *testing.T) {
+		t.Parallel()
+
+		extraFields := 2
+		extra := make(map[string]string, 0)
+		for i := 0; i < extraFields; i++ {
+			extra[strconv.Itoa(i)] = "value"
+		}
+
+		event := auditing.Event{Extra: extra}
+
+		kvPairs := event.KVPairs()
+
+		extraCount := 0
+		for i := 0; i < len(kvPairs); i += 2 {
+			if strings.HasPrefix(kvPairs[i].(string), "extra_") {
+				extraCount++
+			}
+		}
+
+		require.Equal(t, extraCount, extraFields)
+	})
+}
@@ -0,0 +1,55 @@
+package auditing
+
+import (
+	"context"
+	"encoding/json"
+	"time"
+)
+
+// Sinkable is a log entry abstraction that can be sent to an audit log sink through the different implementing methods.
+type Sinkable interface {
+	json.Marshaler
+	KVPairs() []any
+	Time() time.Time
+}
+
+// Logger specifies the contract for a specific audit logger.
+type Logger interface {
+	Log(entry Sinkable) error
+	Close() error
+	Type() string
+}
+
+// Implementation inspired by https://github.com/grafana/grafana-app-sdk/blob/main/logging/logger.go
+type loggerContextKey struct{}
+
+var (
+	// DefaultLogger is the default Logger if one hasn't been provided in the context.
+	// You may use this to add arbitrary audit logging outside of an API request lifecycle.
+	DefaultLogger Logger = &NoopLogger{}
+
+	contextKey = loggerContextKey{}
+)
+
+// FromContext returns the Logger set in the context with Context(), or the DefaultLogger if no Logger is set in the context.
+// If DefaultLogger is nil, it returns a *NoopLogger so that the return is always valid to call methods on without nil-checking.
+// You may use this to add arbitrary audit logging outside of an API request lifecycle.
+func FromContext(ctx context.Context) Logger {
+	if l := ctx.Value(contextKey); l != nil {
+		if logger, ok := l.(Logger); ok {
+			return logger
+		}
+	}
+
+	if DefaultLogger != nil {
+		return DefaultLogger
+	}
+
+	return &NoopLogger{}
+}
+
+// Context returns a new context built from the provided context with the provided logger in it.
+// The Logger added with Context() can be retrieved with FromContext()
+func Context(ctx context.Context, logger Logger) context.Context {
+	return context.WithValue(ctx, contextKey, logger)
+}
@@ -11,9 +11,9 @@ type NoopBackend struct{}

 func ProvideNoopBackend() audit.Backend { return &NoopBackend{} }

-func (b *NoopBackend) ProcessEvents(k8sEvents ...*auditinternal.Event) bool { return false }
+func (NoopBackend) ProcessEvents(...*auditinternal.Event) bool { return false }

-func (NoopBackend) Run(stopCh <-chan struct{}) error { return nil }
+func (NoopBackend) Run(<-chan struct{}) error { return nil }

 func (NoopBackend) Shutdown() {}

@@ -34,3 +34,14 @@ type NoopPolicyRuleEvaluator struct{}
 func (NoopPolicyRuleEvaluator) EvaluatePolicyRule(authorizer.Attributes) audit.RequestAuditConfig {
 	return audit.RequestAuditConfig{Level: auditinternal.LevelNone}
 }
+
+// NoopLogger is a no-op implementation of Logger
+type NoopLogger struct{}
+
+func ProvideNoopLogger() Logger { return &NoopLogger{} }
+
+func (NoopLogger) Type() string { return "noop" }
+
+func (NoopLogger) Log(Sinkable) error { return nil }
+
+func (NoopLogger) Close() error { return nil }
@@ -46,14 +46,23 @@ func (defaultGrafanaPolicyRuleEvaluator) EvaluatePolicyRule(attrs authorizer.Att
 		}
 	}

+	// Logging the response object allows us to get the resource name for create requests.
+	level := auditinternal.LevelMetadata
+	if attrs.GetVerb() == utils.VerbCreate {
+		level = auditinternal.LevelRequestResponse
+	}
+
 	return audit.RequestAuditConfig{
-		Level: auditinternal.LevelMetadata,
+		Level: level,
+
+		// Only log on StageResponseComplete, to avoid noisy logs.
 		OmitStages: []auditinternal.Stage{
-			// Only log on StageResponseComplete
 			auditinternal.StageRequestReceived,
 			auditinternal.StageResponseStarted,
 			auditinternal.StagePanic,
 		},
-		OmitManagedFields: false, // Setting it to true causes extra copying/unmarshalling.
+
+		// Setting it to true causes extra copying/unmarshalling.
+		OmitManagedFields: false,
 	}
 }
@@ -55,7 +55,7 @@ func TestDefaultGrafanaPolicyRuleEvaluator(t *testing.T) {
 		require.Equal(t, auditinternal.LevelNone, config.Level)
 	})

-	t.Run("return audit level metadata for other resource requests", func(t *testing.T) {
+	t.Run("return audit level request+response for create requests", func(t *testing.T) {
 		t.Parallel()

 		attrs := authorizer.AttributesRecord{
@@ -67,6 +67,22 @@ func TestDefaultGrafanaPolicyRuleEvaluator(t *testing.T) {
 			},
 		}

+		config := evaluator.EvaluatePolicyRule(attrs)
+		require.Equal(t, auditinternal.LevelRequestResponse, config.Level)
+	})
+
+	t.Run("return audit level metadata for other resource requests", func(t *testing.T) {
+		t.Parallel()
+
+		attrs := authorizer.AttributesRecord{
+			ResourceRequest: true,
+			Verb:            utils.VerbGet,
+			User: &user.DefaultInfo{
+				Name:   "test-user",
+				Groups: []string{"test-group"},
+			},
+		}
+
 		config := evaluator.EvaluatePolicyRule(attrs)
 		require.Equal(t, auditinternal.LevelMetadata, config.Level)
 	})
@@ -8,6 +8,7 @@ import (
 	"strconv"
 	"strings"

+	"github.com/grafana/grafana/pkg/configprovider"
 	"github.com/prometheus/client_golang/prometheus"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -62,7 +63,6 @@ import (
 	"github.com/grafana/grafana/pkg/services/quota"
 	"github.com/grafana/grafana/pkg/services/search/sort"
 	"github.com/grafana/grafana/pkg/services/user"
-	"github.com/grafana/grafana/pkg/setting"
 	"github.com/grafana/grafana/pkg/storage/legacysql"
 	"github.com/grafana/grafana/pkg/storage/legacysql/dualwrite"
 	"github.com/grafana/grafana/pkg/storage/unified/apistore"
@@ -128,7 +128,6 @@ type DashboardsAPIBuilder struct {
 }

 func RegisterAPIService(
-	cfg *setting.Cfg,
 	features featuremgmt.FeatureToggles,
 	apiregistration builder.APIRegistrar,
 	dashboardService dashboards.DashboardService,
@@ -154,7 +153,14 @@ func RegisterAPIService(
 	publicDashboardService publicdashboards.Service,
 	snapshotService dashboardsnapshots.Service,
 	dashboardActivityChannel live.DashboardActivityChannel,
+	configProvider configprovider.ConfigProvider,
 ) *DashboardsAPIBuilder {
+	cfg, err := configProvider.Get(context.Background())
+	if err != nil {
+		logging.DefaultLogger.Error("failed to load settings configuration instance", "stackId", cfg.StackID, "err", err)
+		return nil
+	}
+
 	dbp := legacysql.NewDatabaseProvider(sql)
 	namespacer := request.GetNamespaceMapper(cfg)
 	legacyDashboardSearcher := legacysearcher.NewDashboardSearchClient(dashStore, sorter)
@@ -237,7 +243,7 @@ func NewAPIService(ac authlib.AccessClient, features featuremgmt.FeatureToggles,
 }

 func (b *DashboardsAPIBuilder) GetGroupVersions() []schema.GroupVersion {
-	if featuremgmt.AnyEnabled(b.features, featuremgmt.FlagDashboardNewLayouts, featuremgmt.FlagKubernetesDashboardsV2) {
+	if featuremgmt.AnyEnabled(b.features, featuremgmt.FlagDashboardNewLayouts) {
 		// If dashboards v2 is enabled, we want to use v2beta1 as the default API version.
 		return []schema.GroupVersion{
 			dashv2beta1.DashboardResourceInfo.GroupVersion(),
@@ -747,7 +753,6 @@ func (b *DashboardsAPIBuilder) storageForVersion(
 			ResourceInfo: *snapshots,
 			Service:      b.snapshotService,
 			Namespacer:   b.namespacer,
-			Options:      b.snapshotOptions,
 		}
 		storage[snapshots.StoragePath()] = snapshotLegacyStore
 		storage[snapshots.StoragePath("dashboard")], err = snapshot.NewDashboardREST(dashboards, b.snapshotService)
@@ -29,6 +29,8 @@ func GetRoutes(service dashboardsnapshots.Service, options dashv0.SnapshotSharin
 	createCmd := defs["github.com/grafana/grafana/apps/dashboard/pkg/apissnapshot/v0alpha1.DashboardCreateCommand"].Schema
 	createExample := `{"dashboard":{"annotations":{"list":[{"name":"Annotations & Alerts","enable":true,"iconColor":"rgba(0, 211, 255, 1)","snapshotData":[],"type":"dashboard","builtIn":1,"hide":true}]},"editable":true,"fiscalYearStartMonth":0,"graphTooltip":0,"id":203,"links":[],"liveNow":false,"panels":[{"datasource":null,"fieldConfig":{"defaults":{"color":{"mode":"palette-classic"},"custom":{"axisBorderShow":false,"axisCenteredZero":false,"axisColorMode":"text","axisLabel":"","axisPlacement":"auto","barAlignment":0,"drawStyle":"line","fillOpacity":43,"gradientMode":"opacity","hideFrom":{"legend":false,"tooltip":false,"viz":false},"insertNulls":false,"lineInterpolation":"smooth","lineWidth":1,"pointSize":5,"scaleDistribution":{"type":"linear"},"showPoints":"auto","spanNulls":false,"stacking":{"group":"A","mode":"none"},"thresholdsStyle":{"mode":"off"}},"mappings":[],"thresholds":{"mode":"absolute","steps":[{"color":"green","value":null},{"color":"red","value":80}]},"unitScale":true},"overrides":[]},"gridPos":{"h":8,"w":12,"x":0,"y":0},"id":1,"options":{"legend":{"calcs":[],"displayMode":"list","placement":"bottom","showLegend":true},"tooltip":{"mode":"single","sort":"none"}},"pluginVersion":"10.4.0-pre","snapshotData":[{"fields":[{"config":{"color":{"mode":"palette-classic"},"custom":{"axisBorderShow":false,"axisCenteredZero":false,"axisColorMode":"text","axisPlacement":"auto","barAlignment":0,"drawStyle":"line","fillOpacity":43,"gradientMode":"opacity","hideFrom":{"legend":false,"tooltip":false,"viz":false},"lineInterpolation":"smooth","lineWidth":1,"pointSize":5,"showPoints":"auto","thresholdsStyle":{"mode":"off"}},"thresholds":{"mode":"absolute","steps":[{"color":"green","value":null},{"color":"red","value":80}]},"unitScale":true},"name":"time","type":"time","values":[1706030536378,1706034856378,1706039176378,1706043496378,1706047816378,1706052136378]},{"config":{"color":{"mode":"palette-classic"},"custom":{"axisBorderShow":false,"axisCenteredZero":false,"axisColorMode":"text","axisLabel":"","axisPlacement":"auto","barAlignment":0,"drawStyle":"line","fillOpacity":43,"gradientMode":"opacity","hideFrom":{"legend":false,"tooltip":false,"viz":false},"insertNulls":false,"lineInterpolation":"smooth","lineWidth":1,"pointSize":5,"scaleDistribution":{"type":"linear"},"showPoints":"auto","spanNulls":false,"stacking":{"group":"A","mode":"none"},"thresholdsStyle":{"mode":"off"}},"mappings":[],"thresholds":{"mode":"absolute","steps":[{"color":"green","value":null},{"color":"red","value":80}]},"unitScale":true},"name":"A-series","type":"number","values":[1,20,90,30,50,0]}],"refId":"A"}],"targets":[],"title":"Simple example","type":"timeseries","links":[]}],"refresh":"","schemaVersion":39,"snapshot":{"timestamp":"2024-01-23T23:22:16.377Z"},"tags":[],"templating":{"list":[]},"time":{"from":"2024-01-23T17:22:20.380Z","to":"2024-01-23T23:22:20.380Z","raw":{"from":"now-6h","to":"now"}},"timepicker":{},"timezone":"","title":"simple and small","uid":"b22ec8db-399b-403b-b6c7-b0fb30ccb2a5","version":1,"weekStart":""},"name":"simple and small","expires":86400}`
 	createRsp := defs["github.com/grafana/grafana/apps/dashboard/pkg/apissnapshot/v0alpha1.DashboardCreateResponse"].Schema
+	getSettingsRsp := defs["github.com/grafana/grafana/apps/dashboard/pkg/apissnapshot/v0alpha1.SnapshotSharingOptions"].Schema
+	getSettingsRspExample := `{"snapshotsEnabled":true,"externalSnapshotURL":"https://externalurl.com","externalSnapshotName":"external","externalEnabled":true}`

 	return &builder.APIRoutes{
 		Namespace: []builder.APIRouteHandler{
@@ -167,5 +169,84 @@ func GetRoutes(service dashboardsnapshots.Service, options dashv0.SnapshotSharin
 					})
 				},
 			},
+			{
+				Path: prefix + "/settings",
+				Spec: &spec3.PathProps{
+					Get: &spec3.Operation{
+						VendorExtensible: spec.VendorExtensible{
+							Extensions: map[string]any{
+								"x-grafana-action": "get",
+								"x-kubernetes-group-version-kind": metav1.GroupVersionKind{
+									Group:   dashv0.GROUP,
+									Version: dashv0.VERSION,
+									Kind:    "SnapshotSharingOptions",
+								},
+							},
+						},
+						OperationProps: spec3.OperationProps{
+							Tags:        tags,
+							OperationId: "getSnapshotSettings",
+							Description: "Get Snapshot sharing settings",
+							Parameters: []*spec3.Parameter{
+								{
+									ParameterProps: spec3.ParameterProps{
+										Name:        "namespace",
+										In:          "path",
+										Required:    true,
+										Example:     "default",
+										Description: "workspace",
+										Schema:      spec.StringProperty(),
+									},
+								},
+							},
+							Responses: &spec3.Responses{
+								ResponsesProps: spec3.ResponsesProps{
+									StatusCodeResponses: map[int]*spec3.Response{
+										200: {
+											ResponseProps: spec3.ResponseProps{
+												Content: map[string]*spec3.MediaType{
+													"application/json": {
+														MediaTypeProps: spec3.MediaTypeProps{
+															Schema:  &getSettingsRsp,
+															Example: getSettingsRspExample,
+														},
+													},
+												},
+											},
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+				Handler: func(w http.ResponseWriter, r *http.Request) {
+					user, err := identity.GetRequester(r.Context())
+					if err != nil {
+						errhttp.Write(r.Context(), err, w)
+						return
+					}
+					wrap := &contextmodel.ReqContext{
+						Context: &web.Context{
+							Req:  r,
+							Resp: web.NewResponseWriter(r.Method, w),
+						},
+					}
+
+					vars := mux.Vars(r)
+					info, err := authlib.ParseNamespace(vars["namespace"])
+					if err != nil {
+						wrap.JsonApiErr(http.StatusBadRequest, "expected namespace", nil)
+						return
+					}
+					if info.OrgID != user.GetOrgID() {
+						wrap.JsonApiErr(http.StatusBadRequest,
+							fmt.Sprintf("user orgId does not match namespace (%d != %d)", info.OrgID, user.GetOrgID()), nil)
+						return
+					}
+
+					wrap.JSON(http.StatusOK, options)
+				},
+			},
 		}}
 }
@@ -2,7 +2,6 @@ package snapshot

 import (
 	"context"
-	"fmt"

 	"k8s.io/apimachinery/pkg/apis/meta/internalversion"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -29,7 +28,6 @@ type SnapshotLegacyStore struct {
 	ResourceInfo utils.ResourceInfo
 	Service      dashboardsnapshots.Service
 	Namespacer   request.NamespaceMapper
-	Options      dashV0.SnapshotSharingOptions
 }

 func (s *SnapshotLegacyStore) New() runtime.Object {
@@ -117,15 +115,6 @@ func (s *SnapshotLegacyStore) List(ctx context.Context, options *internalversion
 }

 func (s *SnapshotLegacyStore) Get(ctx context.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
-	info, err := request.NamespaceInfoFrom(ctx, true)
-	if err != nil {
-		return nil, err
-	}
-
-	err = s.checkEnabled(info.Value)
-	if err != nil {
-		return nil, err
-	}
 	query := dashboardsnapshots.GetDashboardSnapshotQuery{
 		Key: name,
 	}
@@ -140,10 +129,3 @@ func (s *SnapshotLegacyStore) Get(ctx context.Context, name string, options *met
 	}
 	return nil, s.ResourceInfo.NewNotFound(name)
 }
-
-func (s *SnapshotLegacyStore) checkEnabled(ns string) error {
-	if !s.Options.SnapshotsEnabled {
-		return fmt.Errorf("snapshots not enabled")
-	}
-	return nil
-}
@@ -875,7 +875,7 @@ func Initialize(ctx context.Context, cfg *setting.Cfg, opts Options, apiOpts api
 	ldapImpl := service12.ProvideService(cfg, featureToggles, ssosettingsimplService)
 	apiService := api4.ProvideService(cfg, routeRegisterImpl, accessControl, userService, authinfoimplService, ossGroups, identitySynchronizer, orgService, ldapImpl, userAuthTokenService, bundleregistryService)
 	dashboardActivityChannel := live.ProvideDashboardActivityChannel(grafanaLive)
-	dashboardsAPIBuilder := dashboard.RegisterAPIService(cfg, featureToggles, apiserverService, dashboardService, dashboardProvisioningService, service15, dashboardServiceImpl, dashboardPermissionsService, accessControl, accessClient, provisioningServiceImpl, dashboardsStore, registerer, sqlStore, tracingService, resourceClient, dualwriteService, sortService, quotaService, libraryPanelService, eventualRestConfigProvider, userService, libraryElementService, publicDashboardServiceImpl, serviceImpl, dashboardActivityChannel)
+	dashboardsAPIBuilder := dashboard.RegisterAPIService(featureToggles, apiserverService, dashboardService, dashboardProvisioningService, service15, dashboardServiceImpl, dashboardPermissionsService, accessControl, accessClient, provisioningServiceImpl, dashboardsStore, registerer, sqlStore, tracingService, resourceClient, dualwriteService, sortService, quotaService, libraryPanelService, eventualRestConfigProvider, userService, libraryElementService, publicDashboardServiceImpl, serviceImpl, dashboardActivityChannel, configProvider)
 	dataSourceAPIBuilder, err := datasource.RegisterAPIService(featureToggles, apiserverService, middlewareHandler, scopedPluginDatasourceProvider, plugincontextProvider, accessControl, registerer, sourcesService)
 	if err != nil {
 		return nil, err
@@ -1537,7 +1537,7 @@ func InitializeForTest(ctx context.Context, t sqlutil.ITestDB, testingT interfac
 	ldapImpl := service12.ProvideService(cfg, featureToggles, ssosettingsimplService)
 	apiService := api4.ProvideService(cfg, routeRegisterImpl, accessControl, userService, authinfoimplService, ossGroups, identitySynchronizer, orgService, ldapImpl, userAuthTokenService, bundleregistryService)
 	dashboardActivityChannel := live.ProvideDashboardActivityChannel(grafanaLive)
-	dashboardsAPIBuilder := dashboard.RegisterAPIService(cfg, featureToggles, apiserverService, dashboardService, dashboardProvisioningService, service15, dashboardServiceImpl, dashboardPermissionsService, accessControl, accessClient, provisioningServiceImpl, dashboardsStore, registerer, sqlStore, tracingService, resourceClient, dualwriteService, sortService, quotaService, libraryPanelService, eventualRestConfigProvider, userService, libraryElementService, publicDashboardServiceImpl, serviceImpl, dashboardActivityChannel)
+	dashboardsAPIBuilder := dashboard.RegisterAPIService(featureToggles, apiserverService, dashboardService, dashboardProvisioningService, service15, dashboardServiceImpl, dashboardPermissionsService, accessControl, accessClient, provisioningServiceImpl, dashboardsStore, registerer, sqlStore, tracingService, resourceClient, dualwriteService, sortService, quotaService, libraryPanelService, eventualRestConfigProvider, userService, libraryElementService, publicDashboardServiceImpl, serviceImpl, dashboardActivityChannel, configProvider)
 	dataSourceAPIBuilder, err := datasource.RegisterAPIService(featureToggles, apiserverService, middlewareHandler, scopedPluginDatasourceProvider, plugincontextProvider, accessControl, registerer, sourcesService)
 	if err != nil {
 		return nil, err
@@ -15,6 +15,8 @@ var _ authorizer.Authorizer = &roleAuthorizer{}

 var orgRoleNoneAsViewerAPIGroups = []string{
 	"productactivation.ext.grafana.com",
+	// playlist can be removed after this issue is resolved: https://github.com/grafana/grafana/issues/115712
+	"playlist.grafana.app",
 }

 type roleAuthorizer struct{}
@@ -20,9 +20,10 @@ const (

 // Typed errors
 var (
-	ErrUserTokenNotFound       = errors.New("user token not found")
-	ErrInvalidSessionToken     = usertoken.ErrInvalidSessionToken
-	ErrExternalSessionNotFound = errors.New("external session not found")
+	ErrUserTokenNotFound            = errors.New("user token not found")
+	ErrInvalidSessionToken          = usertoken.ErrInvalidSessionToken
+	ErrExternalSessionNotFound      = errors.New("external session not found")
+	ErrExternalSessionTokenNotFound = errors.New("session token was nil")
 )

 type (
@@ -572,13 +572,6 @@ var (
 			FrontendOnly: false, // The restore backend feature changes behavior based on this flag
 			Owner:        grafanaDashboardsSquad,
 		},
-		{
-			Name:         "kubernetesDashboardsV2",
-			Description:  "Use the v2 kubernetes API in the frontend for dashboards",
-			Stage:        FeatureStageExperimental,
-			FrontendOnly: false,
-			Owner:        grafanaDashboardsSquad,
-		},
 		{
 			Name:         "dashboardUndoRedo",
 			Description:  "Enables undo/redo in dynamic dashboards",
@@ -688,6 +681,14 @@ var (
 			HideFromDocs:    true,
 			RequiresRestart: true,
 		},
+		{
+			Name:            "auditLoggingAppPlatform",
+			Description:     "Enable audit logging with Kubernetes under app platform",
+			Stage:           FeatureStageExperimental,
+			Owner:           grafanaOperatorExperienceSquad,
+			HideFromDocs:    true,
+			RequiresRestart: true,
+		},
 		{
 			Name:        "secretsManagementAppPlatform",
 			Description: "Enable the secrets management API and services under app platform",
@@ -79,7 +79,6 @@ dashboardSceneForViewers,GA,@grafana/dashboards-squad,false,false,true
 dashboardSceneSolo,GA,@grafana/dashboards-squad,false,false,true
 dashboardScene,GA,@grafana/dashboards-squad,false,false,true
 dashboardNewLayouts,experimental,@grafana/dashboards-squad,false,false,false
-kubernetesDashboardsV2,experimental,@grafana/dashboards-squad,false,false,false
 dashboardUndoRedo,experimental,@grafana/dashboards-squad,false,false,true
 unlimitedLayoutsNesting,experimental,@grafana/dashboards-squad,false,false,true
 drilldownRecommendations,experimental,@grafana/dashboards-squad,false,false,true
@@ -95,6 +94,7 @@ kubernetesFeatureToggles,experimental,@grafana/grafana-operator-experience-squad
 cloudRBACRoles,preview,@grafana/identity-access-team,false,true,false
 alertingQueryOptimization,GA,@grafana/alerting-squad,false,false,false
 jitterAlertRulesWithinGroups,preview,@grafana/alerting-squad,false,true,false
+auditLoggingAppPlatform,experimental,@grafana/grafana-operator-experience-squad,false,true,false
 secretsManagementAppPlatform,experimental,@grafana/grafana-operator-experience-squad,false,false,false
 secretsManagementAppPlatformUI,experimental,@grafana/grafana-operator-experience-squad,false,false,false
 alertingSaveStatePeriodic,privatePreview,@grafana/alerting-squad,false,false,false
@@ -259,10 +259,6 @@ const (
 	// Enables experimental new dashboard layouts
 	FlagDashboardNewLayouts = "dashboardNewLayouts"

-	// FlagKubernetesDashboardsV2
-	// Use the v2 kubernetes API in the frontend for dashboards
-	FlagKubernetesDashboardsV2 = "kubernetesDashboardsV2"
-
 	// FlagPdfTables
 	// Enables generating table data as PDF in reporting
 	FlagPdfTables = "pdfTables"
@@ -279,6 +275,10 @@ const (
 	// Distributes alert rule evaluations more evenly over time, including spreading out rules within the same group. Disables sequential evaluation if enabled.
 	FlagJitterAlertRulesWithinGroups = "jitterAlertRulesWithinGroups"

+	// FlagAuditLoggingAppPlatform
+	// Enable audit logging with Kubernetes under app platform
+	FlagAuditLoggingAppPlatform = "auditLoggingAppPlatform"
+
 	// FlagSecretsManagementAppPlatform
 	// Enable the secrets management API and services under app platform
 	FlagSecretsManagementAppPlatform = "secretsManagementAppPlatform"
@@ -658,6 +658,20 @@
        "frontend": true
      }
    },
+    {
+      "metadata": {
+        "name": "auditLoggingAppPlatform",
+        "resourceVersion": "1767013056996",
+        "creationTimestamp": "2025-12-29T12:57:36Z"
+      },
+      "spec": {
+        "description": "Enable audit logging with Kubernetes under app platform",
+        "stage": "experimental",
+        "codeowner": "@grafana/grafana-operator-experience-squad",
+        "requiresRestart": true,
+        "hideFromDocs": true
+      }
+    },
    {
      "metadata": {
        "name": "authZGRPCServer",
@@ -2003,8 +2017,9 @@
    {
      "metadata": {
        "name": "kubernetesDashboardsV2",
-        "resourceVersion": "1764664939750",
-        "creationTimestamp": "2025-12-02T08:42:19Z"
+        "resourceVersion": "1764236054307",
+        "creationTimestamp": "2025-11-27T09:34:14Z",
+        "deletionTimestamp": "2025-12-05T13:43:57Z"
      },
      "spec": {
        "description": "Use the v2 kubernetes API in the frontend for dashboards",
@@ -161,7 +161,7 @@ func (api *API) RegisterAPIEndpoints(m *metrics.API) {
 			authz:           ruleAuthzService,
 			evaluator:       api.EvaluatorFactory,
 			cfg:             &api.Cfg.UnifiedAlerting,
-			backtesting:     backtesting.NewEngine(api.AppUrl, api.EvaluatorFactory, api.Tracer),
+			backtesting:     backtesting.NewEngine(api.AppUrl, api.EvaluatorFactory, api.Tracer, api.Cfg.UnifiedAlerting, api.FeatureManager),
 			featureManager:  api.FeatureManager,
 			appUrl:          api.AppUrl,
 			tracer:          api.Tracer,
@@ -34,7 +34,6 @@ import (
 	"github.com/grafana/grafana/pkg/services/ngalert/state"
 	"github.com/grafana/grafana/pkg/services/ngalert/store"
 	"github.com/grafana/grafana/pkg/setting"
-	"github.com/grafana/grafana/pkg/util"
 )

 type folderService interface {
@@ -230,54 +229,27 @@ func (srv TestingApiSrv) BacktestAlertRule(c *contextmodel.ReqContext, cmd apimo
 		return ErrResp(http.StatusNotFound, nil, "Backgtesting API is not enabled")
 	}

-	if cmd.From.After(cmd.To) {
-		return ErrResp(400, nil, "From cannot be greater than To")
-	}
-
-	noDataState, err := ngmodels.NoDataStateFromString(string(cmd.NoDataState))
-
+	rule, err := apivalidation.ValidateBacktestConfig(c.GetOrgID(), cmd, apivalidation.RuleLimitsFromConfig(srv.cfg, srv.featureManager))
 	if err != nil {
-		return ErrResp(400, err, "")
-	}
-	forInterval := time.Duration(cmd.For)
-	if forInterval < 0 {
-		return ErrResp(400, nil, "Bad For interval")
+		return ErrResp(http.StatusBadRequest, err, "")
 	}

-	intervalSeconds, err := apivalidation.ValidateInterval(time.Duration(cmd.Interval), srv.cfg.BaseInterval)
-	if err != nil {
-		return ErrResp(400, err, "")
-	}
-
-	queries := AlertQueriesFromApiAlertQueries(cmd.Data)
-	if err := srv.authz.AuthorizeDatasourceAccessForRule(c.Req.Context(), c.SignedInUser, &ngmodels.AlertRule{Data: queries}); err != nil {
+	if err := srv.authz.AuthorizeDatasourceAccessForRule(c.Req.Context(), c.SignedInUser, rule); err != nil {
 		return errorToResponse(err)
 	}

-	rule := &ngmodels.AlertRule{
-		// ID:             0,
-		// Updated:        time.Time{},
-		// Version:        0,
-		// NamespaceUID:   "",
-		// DashboardUID:   nil,
-		// PanelID:        nil,
-		// RuleGroup:      "",
-		// RuleGroupIndex: 0,
-		// ExecErrState:   "",
-		Title: cmd.Title,
-		// prefix backtesting- is to distinguish between executions of regular rule and backtesting in logs (like expression engine, evaluator, state manager etc)
-		UID:             "backtesting-" + util.GenerateShortUID(),
-		OrgID:           c.GetOrgID(),
-		Condition:       cmd.Condition,
-		Data:            queries,
-		IntervalSeconds: intervalSeconds,
-		NoDataState:     noDataState,
-		For:             forInterval,
-		Annotations:     cmd.Annotations,
-		Labels:          cmd.Labels,
+	// Fetch folder path for alert labels, fallback to "Backtesting" if not available
+	var folderTitle string
+	if cmd.NamespaceUID != "" {
+		f, err := srv.folderService.GetNamespaceByUID(c.Req.Context(), cmd.NamespaceUID, c.OrgID, c.SignedInUser)
+		if err != nil {
+			srv.log.FromContext(c.Req.Context()).Warn("Failed to fetch folder path for alert labels", "error", err)
+		} else {
+			folderTitle = f.Fullpath
+		}
 	}

-	result, err := srv.backtesting.Test(c.Req.Context(), c.SignedInUser, rule, cmd.From, cmd.To)
+	result, err := srv.backtesting.Test(c.Req.Context(), c.SignedInUser, rule, cmd.From, cmd.To, folderTitle)
 	if err != nil {
 		if errors.Is(err, backtesting.ErrInvalidInputData) {
 			return ErrResp(400, err, "Failed to evaluate")
@@ -285,9 +257,5 @@ func (srv TestingApiSrv) BacktestAlertRule(c *contextmodel.ReqContext, cmd apimo
 		return ErrResp(500, err, "Failed to evaluate")
 	}

-	body, err := data.FrameToJSON(result, data.IncludeAll)
-	if err != nil {
-		return ErrResp(500, err, "Failed to convert frame to JSON")
-	}
-	return response.JSON(http.StatusOK, body)
+	return response.JSONStreaming(http.StatusOK, result)
 }
@@ -81,9 +81,15 @@ func (api *API) authorize(method, path string) web.Handler {
 		// additional authorization is done in the request handler
 		eval = ac.EvalPermission(ac.ActionAlertingRuleRead)
 	// Grafana Rules Testing Paths
-	case http.MethodPost + "/api/v1/rule/backtest":
+	case http.MethodPost + "/api/v1/rule/backtest": // TODO (yuri) this should be protected by dedicated permission
 		// additional authorization is done in the request handler
-		eval = ac.EvalPermission(ac.ActionAlertingRuleRead)
+		eval = ac.EvalAll(
+			ac.EvalPermission(ac.ActionAlertingRuleRead),
+			ac.EvalAny(
+				ac.EvalPermission(ac.ActionAlertingRuleUpdate),
+				ac.EvalPermission(ac.ActionAlertingRuleCreate),
+			),
+		)
 	case http.MethodPost + "/api/v1/eval":
 		// additional authorization is done in the request handler
 		eval = ac.EvalPermission(ac.ActionAlertingRuleRead)
@@ -221,15 +221,21 @@ type BacktestConfig struct {
 	To       time.Time      `json:"to"`
 	Interval model.Duration `json:"interval,omitempty"`

-	Condition string         `json:"condition"`
-	Data      []AlertQuery   `json:"data"`
-	For       model.Duration `json:"for,omitempty"`
+	Condition     string          `json:"condition"`
+	Data          []AlertQuery    `json:"data"`
+	For           *model.Duration `json:"for,omitempty"`
+	KeepFiringFor *model.Duration `json:"keep_firing_for,omitempty"`

-	Title       string            `json:"title"`
-	Labels      map[string]string `json:"labels,omitempty"`
-	Annotations map[string]string `json:"annotations,omitempty"`
+	Title  string            `json:"title"`
+	Labels map[string]string `json:"labels,omitempty"`

-	NoDataState NoDataState `json:"no_data_state"`
+	NoDataState                 NoDataState         `json:"no_data_state"`
+	ExecErrState                ExecutionErrorState `json:"exec_err_state"`
+	MissingSeriesEvalsToResolve *int64              `json:"missing_series_evals_to_resolve,omitempty"`
+
+	UID          string `json:"uid,omitempty"`
+	RuleGroup    string `json:"rule_group,omitempty"`
+	NamespaceUID string `json:"namespace_uid,omitempty"`
 }

 // swagger:model
@@ -249,6 +249,21 @@ func ValidateCondition(condition string, queries []apimodels.AlertQuery, canPatc
 	return nil
 }

+func validateGroupInterval(incoming prommodels.Duration, limits RuleLimits) (time.Duration, error) {
+	interval := time.Duration(incoming)
+	if interval == 0 {
+		// if group interval is 0 (undefined) then we automatically fall back to the default interval
+		interval = limits.DefaultRuleEvaluationInterval
+	}
+
+	if interval < 0 || int64(interval.Seconds())%int64(limits.BaseInterval.Seconds()) != 0 {
+		return 0, fmt.Errorf("rule evaluation interval (%d second) should be positive number that is multiple of the base interval of %d seconds", int64(interval.Seconds()), int64(limits.BaseInterval.Seconds()))
+	}
+
+	// TODO should we validate that interval is >= cfg.MinInterval? Currently, we allow to save but fix the specified interval if it is < cfg.MinInterval
+	return interval, nil
+}
+
 func ValidateInterval(interval, baseInterval time.Duration) (int64, error) {
 	intervalSeconds := int64(interval.Seconds())

@@ -336,18 +351,11 @@ func ValidateRuleGroup(
 		return nil, fmt.Errorf("rule group name is too long. Max length is %d", store.AlertRuleMaxRuleGroupNameLength)
 	}

-	interval := time.Duration(ruleGroupConfig.Interval)
-	if interval == 0 {
-		// if group interval is 0 (undefined) then we automatically fall back to the default interval
-		interval = limits.DefaultRuleEvaluationInterval
+	interval, err := validateGroupInterval(ruleGroupConfig.Interval, limits)
+	if err != nil {
+		return nil, err
 	}

-	if interval < 0 || int64(interval.Seconds())%int64(limits.BaseInterval.Seconds()) != 0 {
-		return nil, fmt.Errorf("rule evaluation interval (%d second) should be positive number that is multiple of the base interval of %d seconds", int64(interval.Seconds()), int64(limits.BaseInterval.Seconds()))
-	}
-
-	// TODO should we validate that interval is >= cfg.MinInterval? Currently, we allow to save but fix the specified interval if it is < cfg.MinInterval
-
 	// If the rule group is reserved for no-group rules, we cannot have multiple rules in it.
 	if isNoGroupRuleGroup && len(ruleGroupConfig.Rules) > 1 {
 		return nil, fmt.Errorf("rule group %s is reserved for no-group rules and cannot be used for rule groups with multiple rules", ruleGroupConfig.Name)
@@ -410,3 +418,32 @@ func ValidateNotificationSettings(n *apimodels.AlertRuleNotificationSettings) ([
 		s,
 	}, nil
 }
+
+func ValidateBacktestConfig(orgId int64, config apimodels.BacktestConfig, limits RuleLimits) (*ngmodels.AlertRule, error) {
+	if config.From.After(config.To) {
+		return nil, fmt.Errorf("invalid testing range: from %s must be before to %s", config.From, config.To)
+	}
+
+	interval, err := validateGroupInterval(config.Interval, limits)
+	if err != nil {
+		return nil, err
+	}
+
+	return ValidateRuleNode(&apimodels.PostableExtendedRuleNode{
+		ApiRuleNode: &apimodels.ApiRuleNode{
+			For:           config.For,
+			KeepFiringFor: config.KeepFiringFor,
+			Labels:        config.Labels,
+			Annotations:   nil,
+		},
+		GrafanaManagedAlert: &apimodels.PostableGrafanaRule{
+			Title:                       config.Title,
+			Condition:                   config.Condition,
+			Data:                        config.Data,
+			UID:                         config.UID,
+			NoDataState:                 config.NoDataState,
+			ExecErrState:                config.ExecErrState,
+			MissingSeriesEvalsToResolve: config.MissingSeriesEvalsToResolve,
+		},
+	}, config.RuleGroup, interval, orgId, config.NamespaceUID, limits)
+}
@@ -15,10 +15,16 @@ import (
 	"github.com/grafana/grafana/pkg/apimachinery/identity"
 	"github.com/grafana/grafana/pkg/infra/log"
 	"github.com/grafana/grafana/pkg/infra/tracing"
+	"github.com/grafana/grafana/pkg/services/featuremgmt"
 	"github.com/grafana/grafana/pkg/services/ngalert/eval"
 	"github.com/grafana/grafana/pkg/services/ngalert/models"
 	"github.com/grafana/grafana/pkg/services/ngalert/schedule"
+	"github.com/grafana/grafana/pkg/services/ngalert/schedule/ticker"
 	"github.com/grafana/grafana/pkg/services/ngalert/state"
+	"github.com/grafana/grafana/pkg/services/ngalert/state/historian"
+	history_model "github.com/grafana/grafana/pkg/services/ngalert/state/historian/model"
+	"github.com/grafana/grafana/pkg/setting"
+	"github.com/grafana/grafana/pkg/util"
 )

 var (
@@ -28,7 +34,7 @@ var (
 	backtestingEvaluatorFactory = newBacktestingEvaluator
 )

-type callbackFunc = func(evaluationIndex int, now time.Time, results eval.Results) error
+type callbackFunc = func(evaluationIndex int, now time.Time, results eval.Results) (bool, error)

 type backtestingEvaluator interface {
 	Eval(ctx context.Context, from time.Time, interval time.Duration, evaluations int, callback callbackFunc) error
@@ -40,11 +46,17 @@ type stateManager interface {
 }

 type Engine struct {
-	evalFactory        eval.EvaluatorFactory
-	createStateManager func() stateManager
+	evalFactory          eval.EvaluatorFactory
+	createStateManager   func() stateManager
+	disableGrafanaFolder bool
+	featureToggles       featuremgmt.FeatureToggles
+	minInterval          time.Duration
+	baseInterval         time.Duration
+	jitterStrategy       schedule.JitterStrategy
+	maxEvaluations       int
 }

-func NewEngine(appUrl *url.URL, evalFactory eval.EvaluatorFactory, tracer tracing.Tracer) *Engine {
+func NewEngine(appUrl *url.URL, evalFactory eval.EvaluatorFactory, tracer tracing.Tracer, cfg setting.UnifiedAlertingSettings, toggles featuremgmt.FeatureToggles) *Engine {
 	return &Engine{
 		evalFactory: evalFactory,
 		createStateManager: func() stateManager {
@@ -60,74 +72,139 @@ func NewEngine(appUrl *url.URL, evalFactory eval.EvaluatorFactory, tracer tracin
 			}
 			return state.NewManager(cfg, state.NewNoopPersister())
 		},
+		disableGrafanaFolder: false,
+		featureToggles:       toggles,
+		minInterval:          cfg.MinInterval,
+		baseInterval:         cfg.BaseInterval,
+		maxEvaluations:       cfg.BacktestingMaxEvaluations,
+		jitterStrategy:       schedule.JitterStrategyFrom(cfg, toggles),
 	}
 }

-func (e *Engine) Test(ctx context.Context, user identity.Requester, rule *models.AlertRule, from, to time.Time) (*data.Frame, error) {
-	ruleCtx := models.WithRuleKey(ctx, rule.GetKey())
-	logger := logger.FromContext(ctx)
-
+func (e *Engine) Test(ctx context.Context, user identity.Requester, rule *models.AlertRule, from, to time.Time, folderTitle string) (res *data.Frame, err error) {
+	if rule == nil {
+		return nil, fmt.Errorf("%w: rule is not defined", ErrInvalidInputData)
+	}
 	if !from.Before(to) {
-		return nil, fmt.Errorf("%w: invalid interval of the backtesting [%d,%d]", ErrInvalidInputData, from.Unix(), to.Unix())
+		return nil, fmt.Errorf("%w: invalid interval [%d,%d]", ErrInvalidInputData, from.Unix(), to.Unix())
 	}
-	if to.Sub(from).Seconds() < float64(rule.IntervalSeconds) {
-		return nil, fmt.Errorf("%w: interval of the backtesting [%d,%d] is less than evaluation interval [%ds]", ErrInvalidInputData, from.Unix(), to.Unix(), rule.IntervalSeconds)
+
+	ruleCtx := models.WithRuleKey(ctx, rule.GetKey())
+	logger := logger.FromContext(ruleCtx).New("backtesting", util.GenerateShortUID())
+
+	var warns []string
+	if rule.GetInterval() < e.minInterval {
+		logger.Warn("Interval adjusted to minimal interval", "originalInterval", rule.GetInterval(), "adjustedInterval", e.minInterval)
+		rule = rule.Copy()
+		rule.IntervalSeconds = int64(e.minInterval.Seconds())
+		warns = append(warns, fmt.Sprintf("Interval adjusted to minimal interval %ds", rule.IntervalSeconds))
 	}
-	length := int(to.Sub(from).Seconds()) / int(rule.IntervalSeconds)

-	stateManager := e.createStateManager()
+	effectiveStrategy := e.jitterStrategy
+	if e.jitterStrategy == schedule.JitterByGroup && (rule.RuleGroup == "" || rule.NamespaceUID == "") ||
+		e.jitterStrategy == schedule.JitterByRule && rule.UID == "" {
+		logger.Warn(fmt.Sprintf("Jitter strategy is set to %s, but rule group or namespace is not set. Ignore jitter", e.jitterStrategy))
+		warns = append(warns, fmt.Sprintf("Jitter strategy is set to %s, but rule group or namespace is not set. Ignore jitter. The results of testing will be different than real evaluations", e.jitterStrategy))
+		effectiveStrategy = schedule.JitterNever
+	}
+	jitterOffset := schedule.JitterOffsetInDuration(rule, e.baseInterval, effectiveStrategy)
+	firstEval, err := getFirstEvaluationTime(from, rule, e.baseInterval, jitterOffset)
+	if err != nil {
+		return nil, fmt.Errorf("%w: %s", ErrInvalidInputData, err)
+	}

-	evaluator, err := backtestingEvaluatorFactory(ruleCtx, e.evalFactory, user, rule.GetEvalCondition().WithSource("backtesting"), &schedule.AlertingResultsFromRuleState{
-		Manager: stateManager,
-		Rule:    rule,
-	})
+	evaluations := calculateNumberOfEvaluations(firstEval, to, rule.GetInterval())
+	if e.maxEvaluations > 0 && evaluations > e.maxEvaluations {
+		logger.Warn("Evaluations adjusted to maximal number", "originalEvaluations", evaluations, "adjustedEvaluations", e.maxEvaluations)
+		warns = append(warns, fmt.Sprintf("Number of evaluations are adjusted to the limit of %d evaluations. Requested: %d", e.maxEvaluations, evaluations))
+		evaluations = e.maxEvaluations
+	}
+
+	start := time.Now()
+	defer func() {
+		if err == nil {
+			logger.Info("Rule testing finished successfully", "duration", time.Since(start))
+		} else {
+			logger.Error("Rule testing finished with error", "duration", time.Since(start), "error", err)
+		}
+	}()
+
+	stateMgr := e.createStateManager()
+
+	evaluator, err := backtestingEvaluatorFactory(ruleCtx,
+		e.evalFactory,
+		user,
+		rule.GetEvalCondition().WithSource("backtesting"),
+		&schedule.AlertingResultsFromRuleState{
+			Manager: stateMgr,
+			Rule:    rule,
+		},
+	)
 	if err != nil {
 		return nil, errors.Join(ErrInvalidInputData, err)
 	}

-	logger.Info("Start testing alert rule", "from", from, "to", to, "interval", rule.IntervalSeconds, "evaluations", length)
+	logger.Info("Start testing alert rule", "from", from, "to", to, "interval", rule.GetInterval(), "firstTick", firstEval, "evaluations", evaluations, "jitterOffset", jitterOffset, "jitterStrategy", effectiveStrategy)

-	start := time.Now()
+	var builder *historian.QueryResultBuilder

-	tsField := data.NewField("Time", nil, make([]time.Time, length))
-	valueFields := make(map[data.Fingerprint]*data.Field)
-
-	err = evaluator.Eval(ruleCtx, from, time.Duration(rule.IntervalSeconds)*time.Second, length, func(idx int, currentTime time.Time, results eval.Results) error {
-		if idx >= length {
-			logger.Info("Unexpected evaluation. Skipping", "from", from, "to", to, "interval", rule.IntervalSeconds, "evaluationTime", currentTime, "evaluationIndex", idx, "expectedEvaluations", length)
-			return nil
-		}
-		states := stateManager.ProcessEvalResults(ruleCtx, currentTime, rule, results, nil, nil)
-		tsField.Set(idx, currentTime)
-		for _, s := range states {
-			field, ok := valueFields[s.CacheID]
-			if !ok {
-				field = data.NewField("", s.Labels, make([]*string, length))
-				valueFields[s.CacheID] = field
-			}
-			if s.State.State != eval.NoData { // set nil if NoData
-				value := s.State.State.String()
-				if s.StateReason != "" {
-					value += " (" + s.StateReason + ")"
-				}
-				field.Set(idx, &value)
-				continue
-			}
-		}
-		return nil
-	})
-	fields := make([]*data.Field, 0, len(valueFields)+1)
-	fields = append(fields, tsField)
-	for _, f := range valueFields {
-		fields = append(fields, f)
+	ruleMeta := history_model.RuleMeta{
+		ID:           rule.ID,
+		OrgID:        rule.OrgID,
+		UID:          rule.UID,
+		Title:        rule.Title,
+		Group:        rule.RuleGroup,
+		NamespaceUID: rule.NamespaceUID,
+		// DashboardUID: "",
+		// PanelID:      0,
+		Condition: rule.Condition,
 	}
-	result := data.NewFrame("Testing results", fields...)
-
+	labels := map[string]string{
+		historian.OrgIDLabel:     fmt.Sprint(ruleMeta.OrgID),
+		historian.GroupLabel:     fmt.Sprint(ruleMeta.Group),
+		historian.FolderUIDLabel: fmt.Sprint(rule.NamespaceUID),
+	}
+	labelsBytes, err := json.Marshal(labels)
 	if err != nil {
 		return nil, err
 	}
-	logger.Info("Rule testing finished successfully", "duration", time.Since(start))
-	return result, nil
+
+	// Ensure fallback if empty string is passed
+	if folderTitle == "" {
+		folderTitle = "Backtesting"
+	}
+	extraLabels := state.GetRuleExtraLabels(logger, rule, folderTitle, !e.disableGrafanaFolder, e.featureToggles)
+
+	processFn := func(idx int, currentTime time.Time, results eval.Results) (bool, error) {
+		// init the builder. Do the best guess for the size of the result
+		if builder == nil {
+			builder = historian.NewQueryResultBuilder(evaluations * len(results))
+			for _, warn := range warns {
+				builder.AddWarn(warn)
+			}
+		}
+		states := stateMgr.ProcessEvalResults(ruleCtx, currentTime, rule, results, extraLabels, nil)
+		for _, s := range states {
+			if !historian.ShouldRecord(s) {
+				continue
+			}
+			entry := historian.StateTransitionToLokiEntry(ruleMeta, s)
+			err := builder.AddRow(currentTime, entry, labelsBytes)
+			if err != nil {
+				return false, err
+			}
+		}
+		return idx <= evaluations, nil
+	}
+
+	err = evaluator.Eval(ruleCtx, firstEval, rule.GetInterval(), evaluations, processFn)
+	if err != nil {
+		return nil, err
+	}
+	if builder == nil {
+		return nil, errors.New("no results were produced")
+	}
+	return builder.ToFrame(), nil
 }

 func newBacktestingEvaluator(ctx context.Context, evalFactory eval.EvaluatorFactory, user identity.Requester, condition models.Condition, reader eval.AlertingResultsReader) (backtestingEvaluator, error) {
@@ -173,3 +250,53 @@ type NoopImageService struct{}
 func (s *NoopImageService) NewImage(_ context.Context, _ *models.AlertRule) (*models.Image, error) {
 	return &models.Image{}, nil
 }
+
+func getNextEvaluationTime(currentTime time.Time, rule *models.AlertRule, baseInterval time.Duration, jitterOffset time.Duration) (time.Time, error) {
+	if rule.IntervalSeconds%int64(baseInterval.Seconds()) != 0 {
+		return time.Time{}, fmt.Errorf("interval %ds is not divisible by base interval %ds", rule.IntervalSeconds, int64(baseInterval.Seconds()))
+	}
+
+	freq := rule.IntervalSeconds / int64(baseInterval.Seconds())
+
+	firstTickNum := currentTime.Unix() / int64(baseInterval.Seconds())
+
+	jitterOffsetTicks := int64(jitterOffset / baseInterval)
+
+	firstEvalTickNum := firstTickNum + (jitterOffsetTicks-(firstTickNum%freq)+freq)%freq
+
+	return time.Unix(firstEvalTickNum*int64(baseInterval.Seconds()), 0), nil
+}
+
+func getFirstEvaluationTime(from time.Time, rule *models.AlertRule, baseInterval time.Duration, jitterOffset time.Duration) (time.Time, error) {
+	// Now calculate the time of the tick the same way as in the scheduler
+	firstTick := ticker.GetStartTick(from, baseInterval)
+
+	// calculate time of the first evaluation that is at or after the first tick
+	firstEval, err := getNextEvaluationTime(firstTick, rule, baseInterval, jitterOffset)
+	if err != nil {
+		return time.Time{}, err
+	}
+
+	// Ensure firstEval is at or after from
+	// Calculate how many intervals to skip to get past 'from'
+	if firstEval.Before(from) {
+		diff := from.Sub(firstEval)
+		interval := rule.GetInterval()
+		// Ceiling division: how many intervals needed to cover the difference
+		intervalsToAdd := (diff + interval - 1) / interval
+		firstEval = firstEval.Add(interval * intervalsToAdd)
+	}
+
+	return firstEval, nil
+}
+
+func calculateNumberOfEvaluations(firstEval, to time.Time, interval time.Duration) int {
+	var evaluations int
+	if to.After(firstEval) {
+		evaluations = int(to.Sub(firstEval).Seconds()) / int(interval.Seconds())
+	}
+	if evaluations == 0 {
+		evaluations = 1
+	}
+	return evaluations
+}
@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
-	"fmt"
 	"math/rand"
 	"testing"
 	"time"
@@ -14,9 +13,11 @@ import (
 	"github.com/grafana/grafana-plugin-sdk-go/data"

 	"github.com/grafana/grafana/pkg/apimachinery/identity"
+	"github.com/grafana/grafana/pkg/services/featuremgmt"
 	"github.com/grafana/grafana/pkg/services/ngalert/eval"
 	"github.com/grafana/grafana/pkg/services/ngalert/eval/eval_mocks"
 	"github.com/grafana/grafana/pkg/services/ngalert/models"
+	"github.com/grafana/grafana/pkg/services/ngalert/schedule"
 	"github.com/grafana/grafana/pkg/services/ngalert/state"
 	"github.com/grafana/grafana/pkg/util"
 )
@@ -158,16 +159,6 @@ func TestNewBacktestingEvaluator(t *testing.T) {
 }

 func TestEvaluatorTest(t *testing.T) {
-	states := []eval.State{eval.Normal, eval.Alerting, eval.Pending}
-	generateState := func(prefix string) *state.State {
-		labels := models.GenerateAlertLabels(rand.Intn(5)+1, prefix+"-")
-		return &state.State{
-			CacheID: labels.Fingerprint(),
-			Labels:  labels,
-			State:   states[rand.Intn(len(states))],
-		}
-	}
-
 	randomResultCallback := func(now time.Time) (eval.Results, error) {
 		return eval.GenerateResults(rand.Intn(5)+1, eval.ResultGen()), nil
 	}
@@ -189,84 +180,17 @@ func TestEvaluatorTest(t *testing.T) {
 		createStateManager: func() stateManager {
 			return manager
 		},
+		disableGrafanaFolder: false,
+		featureToggles:       featuremgmt.WithFeatures(),
+		minInterval:          1 * time.Second,
+		baseInterval:         1 * time.Second,
+		jitterStrategy:       schedule.JitterNever,
+		maxEvaluations:       10000,
 	}
 	gen := models.RuleGen
 	rule := gen.With(gen.WithInterval(time.Second)).GenerateRef()
 	ruleInterval := time.Duration(rule.IntervalSeconds) * time.Second

-	t.Run("should return data frame in specific format", func(t *testing.T) {
-		from := time.Unix(0, 0)
-		to := from.Add(5 * ruleInterval)
-		allStates := [...]eval.State{eval.Normal, eval.Alerting, eval.Pending, eval.NoData, eval.Error}
-
-		var states []state.StateTransition
-
-		for _, s := range allStates {
-			labels := models.GenerateAlertLabels(rand.Intn(5)+1, s.String()+"-")
-			states = append(states, state.StateTransition{
-				State: &state.State{
-					CacheID:     labels.Fingerprint(),
-					Labels:      labels,
-					State:       s,
-					StateReason: util.GenerateShortUID(),
-				},
-			})
-		}
-
-		manager.stateCallback = func(now time.Time) []state.StateTransition {
-			return states
-		}
-
-		frame, err := engine.Test(context.Background(), nil, rule, from, to)
-
-		require.NoError(t, err)
-		require.Len(t, frame.Fields, len(states)+1) // +1 - timestamp
-
-		t.Run("should contain field Time", func(t *testing.T) {
-			timestampField, _ := frame.FieldByName("Time")
-			require.NotNil(t, timestampField, "frame does not contain field 'Time'")
-			require.Equal(t, data.FieldTypeTime, timestampField.Type())
-		})
-
-		fieldByState := make(map[data.Fingerprint]*data.Field, len(states))
-
-		t.Run("should contain a field per state", func(t *testing.T) {
-			for _, s := range states {
-				var f *data.Field
-				for _, field := range frame.Fields {
-					if field.Labels.String() == s.Labels.String() {
-						f = field
-						break
-					}
-				}
-				require.NotNilf(t, f, "Cannot find a field by state labels")
-				fieldByState[s.CacheID] = f
-			}
-		})
-
-		t.Run("should be populated with correct values", func(t *testing.T) {
-			timestampField, _ := frame.FieldByName("Time")
-			expectedLength := timestampField.Len()
-			for _, field := range frame.Fields {
-				require.Equalf(t, expectedLength, field.Len(), "Field %s should have the size %d", field.Name, expectedLength)
-			}
-			for i := 0; i < expectedLength; i++ {
-				expectedTime := from.Add(time.Duration(int64(i)*rule.IntervalSeconds) * time.Second)
-				require.Equal(t, expectedTime, timestampField.At(i).(time.Time))
-				for _, s := range states {
-					f := fieldByState[s.CacheID]
-					if s.State.State == eval.NoData {
-						require.Nil(t, f.At(i))
-					} else {
-						v := f.At(i).(*string)
-						require.NotNilf(t, v, "Field [%s] value at index %d should not be nil", s.CacheID, i)
-						require.Equal(t, fmt.Sprintf("%s (%s)", s.State.State, s.StateReason), *v)
-					}
-				}
-			}
-		})
-	})
-
 	t.Run("should not fail if 'to-from' is not times of interval", func(t *testing.T) {
 		from := time.Unix(0, 0)
 		to := from.Add(5 * ruleInterval)
@@ -287,84 +211,26 @@ func TestEvaluatorTest(t *testing.T) {
 			return states
 		}

-		frame, err := engine.Test(context.Background(), nil, rule, from, to)
+		frame, err := engine.Test(context.Background(), nil, rule, from, to, "")
 		require.NoError(t, err)
 		expectedLen := frame.Rows()
 		for i := 0; i < 100; i++ {
 			jitter := time.Duration(rand.Int63n(ruleInterval.Milliseconds())) * time.Millisecond
-			frame, err = engine.Test(context.Background(), nil, rule, from, to.Add(jitter))
+			frame, err = engine.Test(context.Background(), nil, rule, from, to.Add(jitter), "")
 			require.NoError(t, err)
 			require.Equalf(t, expectedLen, frame.Rows(), "jitter %v caused result to be different that base-line", jitter)
 		}
 	})

-	t.Run("should backfill field with nulls if a new dimension created in the middle", func(t *testing.T) {
-		from := time.Unix(0, 0)
-
-		state1 := state.StateTransition{
-			State: generateState("1"),
-		}
-		state2 := state.StateTransition{
-			State: generateState("2"),
-		}
-		state3 := state.StateTransition{
-			State: generateState("3"),
-		}
-		stateByTime := map[time.Time][]state.StateTransition{
-			from:                       {state1, state2},
-			from.Add(1 * ruleInterval): {state1, state2},
-			from.Add(2 * ruleInterval): {state1, state2},
-			from.Add(3 * ruleInterval): {state1, state2, state3},
-			from.Add(4 * ruleInterval): {state1, state2, state3},
-		}
-		to := from.Add(time.Duration(len(stateByTime)) * ruleInterval)
-
-		manager.stateCallback = func(now time.Time) []state.StateTransition {
-			return stateByTime[now]
-		}
-
-		frame, err := engine.Test(context.Background(), nil, rule, from, to)
-		require.NoError(t, err)
-
-		var field3 *data.Field
-		for _, field := range frame.Fields {
-			if field.Labels.String() == state3.Labels.String() {
-				field3 = field
-				break
-			}
-		}
-		require.NotNilf(t, field3, "Result for state 3 was not found")
-		require.Equalf(t, len(stateByTime), field3.Len(), "State3 result has unexpected number of values")
-
-		idx := 0
-		for curTime, states := range stateByTime {
-			value := field3.At(idx).(*string)
-			if len(states) == 2 {
-				require.Nilf(t, value, "The result should be nil if state3 was not available for time %v", curTime)
-			}
-		}
-	})
-
 	t.Run("should fail", func(t *testing.T) {
 		manager.stateCallback = func(now time.Time) []state.StateTransition {
 			return nil
 		}
-
 		t.Run("when interval is not correct", func(t *testing.T) {
 			from := time.Now()
-			t.Run("when from=to", func(t *testing.T) {
-				to := from
-				_, err := engine.Test(context.Background(), nil, rule, from, to)
-				require.ErrorIs(t, err, ErrInvalidInputData)
-			})
 			t.Run("when from > to", func(t *testing.T) {
 				to := from.Add(-ruleInterval)
-				_, err := engine.Test(context.Background(), nil, rule, from, to)
-				require.ErrorIs(t, err, ErrInvalidInputData)
-			})
-			t.Run("when to-from < interval", func(t *testing.T) {
-				to := from.Add(ruleInterval).Add(-time.Millisecond)
-				_, err := engine.Test(context.Background(), nil, rule, from, to)
+				_, err := engine.Test(context.Background(), nil, rule, from, to, "")
 				require.ErrorIs(t, err, ErrInvalidInputData)
 			})
 		})
@@ -376,7 +242,7 @@ func TestEvaluatorTest(t *testing.T) {
 			}
 			from := time.Now()
 			to := from.Add(ruleInterval)
-			_, err := engine.Test(context.Background(), nil, rule, from, to)
+			_, err := engine.Test(context.Background(), nil, rule, from, to, "")
 			require.ErrorIs(t, err, expectedError)
 		})
 	})
@@ -404,10 +270,188 @@ func (f *fakeBacktestingEvaluator) Eval(_ context.Context, from time.Time, inter
 		if err != nil {
 			return err
 		}
-		err = callback(idx, now, results)
+		c, err := callback(idx, now, results)
 		if err != nil {
 			return err
 		}
+		if !c {
+			break
+		}
 	}
 	return nil
 }
+
+func TestGetNextEvaluationTime(t *testing.T) {
+	baseInterval := 10 * time.Second
+
+	testCases := []struct {
+		name             string
+		ruleInterval     int64
+		currentTimestamp int64
+		jitterOffset     time.Duration
+		expectError      bool
+		expectedNext     int64
+	}{
+		{
+			name:             "interval not divisible by base interval",
+			ruleInterval:     15,
+			currentTimestamp: 0,
+			jitterOffset:     0,
+			expectError:      true,
+		},
+		{
+			name:             "no jitter - from tick 0",
+			ruleInterval:     20,
+			currentTimestamp: 0,
+			jitterOffset:     0,
+			expectedNext:     0,
+		},
+		{
+			name:             "no jitter - from tick 1",
+			ruleInterval:     20,
+			currentTimestamp: 10,
+			jitterOffset:     0,
+			expectedNext:     20,
+		},
+		{
+			name:             "no jitter - from tick 2",
+			ruleInterval:     20,
+			currentTimestamp: 20,
+			jitterOffset:     0,
+			expectedNext:     20,
+		},
+		{
+			name:             "with 20s jitter - from tick 0",
+			ruleInterval:     60,
+			currentTimestamp: 0,
+			jitterOffset:     20 * time.Second,
+			expectedNext:     20,
+		},
+		{
+			name:             "with 20s jitter - from tick 2",
+			ruleInterval:     60,
+			currentTimestamp: 20,
+			jitterOffset:     20 * time.Second,
+			expectedNext:     20,
+		},
+		{
+			name:             "with 20s jitter - from tick 3",
+			ruleInterval:     60,
+			currentTimestamp: 30,
+			jitterOffset:     20 * time.Second,
+			expectedNext:     80,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			rule := &models.AlertRule{IntervalSeconds: tc.ruleInterval}
+			currentTime := time.Unix(tc.currentTimestamp, 0)
+			result, err := getNextEvaluationTime(currentTime, rule, baseInterval, tc.jitterOffset)
+
+			if tc.expectError {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), "is not divisible by base interval")
+				return
+			}
+
+			require.NoError(t, err)
+			require.Equal(t, tc.expectedNext, result.Unix())
+		})
+	}
+}
+
+func TestGetFirstEvaluationTime(t *testing.T) {
+	baseInterval := 10 * time.Second
+
+	testCases := []struct {
+		name         string
+		ruleInterval int64
+		fromUnix     int64
+		jitterOffset time.Duration
+		expectError  bool
+		expectedUnix int64
+	}{
+		{
+			name:         "interval not divisible by base interval",
+			ruleInterval: 15,
+			fromUnix:     0,
+			jitterOffset: 0,
+			expectError:  true,
+		},
+		{
+			name:         "no jitter - from at tick 0",
+			ruleInterval: 20,
+			fromUnix:     0,
+			jitterOffset: 0,
+			expectedUnix: 0,
+		},
+		{
+			name:         "no jitter - from at tick 1",
+			ruleInterval: 20,
+			fromUnix:     10,
+			jitterOffset: 0,
+			expectedUnix: 20,
+		},
+		{
+			name:         "no jitter - from before first tick",
+			ruleInterval: 20,
+			fromUnix:     5,
+			jitterOffset: 0,
+			expectedUnix: 20,
+		},
+		{
+			name:         "no jitter - from after first aligned tick",
+			ruleInterval: 20,
+			fromUnix:     25,
+			jitterOffset: 0,
+			expectedUnix: 40,
+		},
+		{
+			name:         "no jitter - from at tick boundary",
+			ruleInterval: 10,
+			fromUnix:     10,
+			jitterOffset: 0,
+			expectedUnix: 10,
+		},
+		{
+			name:         "with 20s jitter - from epoch",
+			ruleInterval: 60,
+			fromUnix:     0,
+			jitterOffset: 20 * time.Second,
+			expectedUnix: 20,
+		},
+		{
+			name:         "with 20s jitter - from 70s",
+			ruleInterval: 60,
+			fromUnix:     70,
+			jitterOffset: 20 * time.Second,
+			expectedUnix: 80,
+		},
+		{
+			name:         "with 50s jitter - from 25s",
+			ruleInterval: 60,
+			fromUnix:     25,
+			jitterOffset: 50 * time.Second,
+			expectedUnix: 50,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			rule := &models.AlertRule{IntervalSeconds: tc.ruleInterval}
+			from := time.Unix(tc.fromUnix, 0)
+			result, err := getFirstEvaluationTime(from, rule, baseInterval, tc.jitterOffset)
+
+			if tc.expectError {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), "is not divisible by base interval")
+				return
+			}
+
+			require.NoError(t, err)
+			require.Equal(t, tc.expectedUnix, result.Unix())
+			require.GreaterOrEqual(t, result.Unix(), from.Unix(), "first eval should be at or after from")
+		})
+	}
+}
@@ -85,10 +85,13 @@ func (d *dataEvaluator) Eval(_ context.Context, from time.Time, interval time.Du
 				EvaluatedAt: now,
 			})
 		}
-		err := callback(i, now, result)
+		cont, err := callback(i, now, result)
 		if err != nil {
 			return err
 		}
+		if !cont {
+			break
+		}
 	}
 	return nil
 }
@@ -100,11 +100,11 @@ func TestDataEvaluator_Eval(t *testing.T) {

 		resultsCount := int(to.Sub(from).Seconds() / interval.Seconds())

-		err = evaluator.Eval(context.Background(), from, time.Second, resultsCount, func(idx int, now time.Time, res eval.Results) error {
+		err = evaluator.Eval(context.Background(), from, time.Second, resultsCount, func(idx int, now time.Time, res eval.Results) (bool, error) {
 			r = append(r, results{
 				now, res,
 			})
-			return nil
+			return true, nil
 		})
 		require.NoError(t, err)

@@ -164,11 +164,11 @@ func TestDataEvaluator_Eval(t *testing.T) {
 			size := to.Sub(from).Milliseconds() / interval.Milliseconds()
 			r := make([]results, 0, size)

-			err = evaluator.Eval(context.Background(), from, interval, int(size), func(idx int, now time.Time, res eval.Results) error {
+			err = evaluator.Eval(context.Background(), from, interval, int(size), func(idx int, now time.Time, res eval.Results) (bool, error) {
 				r = append(r, results{
 					now, res,
 				})
-				return nil
+				return true, nil
 			})

 			currentRowIdx := 0
@@ -195,11 +195,11 @@ func TestDataEvaluator_Eval(t *testing.T) {
 			size := int(to.Sub(from).Seconds() / interval.Seconds())
 			r := make([]results, 0, size)

-			err = evaluator.Eval(context.Background(), from, interval, size, func(idx int, now time.Time, res eval.Results) error {
+			err = evaluator.Eval(context.Background(), from, interval, size, func(idx int, now time.Time, res eval.Results) (bool, error) {
 				r = append(r, results{
 					now, res,
 				})
-				return nil
+				return true, nil
 			})

 			currentRowIdx := 0
@@ -230,11 +230,11 @@ func TestDataEvaluator_Eval(t *testing.T) {
 		t.Run("should be noData until the frame interval", func(t *testing.T) {
 			newFrom := from.Add(-10 * time.Second)
 			r := make([]results, 0, int(to.Sub(newFrom).Seconds()))
-			err = evaluator.Eval(context.Background(), newFrom, time.Second, cap(r), func(idx int, now time.Time, res eval.Results) error {
+			err = evaluator.Eval(context.Background(), newFrom, time.Second, cap(r), func(idx int, now time.Time, res eval.Results) (bool, error) {
 				r = append(r, results{
 					now, res,
 				})
-				return nil
+				return true, nil
 			})

 			rowIdx := 0
@@ -258,11 +258,11 @@ func TestDataEvaluator_Eval(t *testing.T) {
 		t.Run("should be the last value after the frame interval", func(t *testing.T) {
 			newTo := to.Add(10 * time.Second)
 			r := make([]results, 0, int(newTo.Sub(from).Seconds()))
-			err = evaluator.Eval(context.Background(), from, time.Second, cap(r), func(idx int, now time.Time, res eval.Results) error {
+			err = evaluator.Eval(context.Background(), from, time.Second, cap(r), func(idx int, now time.Time, res eval.Results) (bool, error) {
 				r = append(r, results{
 					now, res,
 				})
-				return nil
+				return true, nil
 			})

 			rowIdx := 0
@@ -282,12 +282,21 @@ func TestDataEvaluator_Eval(t *testing.T) {
 	})
 	t.Run("should stop if callback error", func(t *testing.T) {
 		expectedError := errors.New("error")
-		err = evaluator.Eval(context.Background(), from, time.Second, 6, func(idx int, now time.Time, res eval.Results) error {
+		err = evaluator.Eval(context.Background(), from, time.Second, 6, func(idx int, now time.Time, res eval.Results) (bool, error) {
 			if idx == 5 {
-				return expectedError
+				return false, expectedError
 			}
-			return nil
+			return true, nil
 		})
 		require.ErrorIs(t, err, expectedError)
 	})
+	t.Run("should stop if callback does not want to continue", func(t *testing.T) {
+		evaluated := 0
+		err = evaluator.Eval(context.Background(), from, time.Second, 6, func(idx int, now time.Time, res eval.Results) (bool, error) {
+			evaluated++
+			return evaluated < 2, nil
+		})
+		require.NoError(t, err)
+		require.Equal(t, 2, evaluated)
+	})
 }
@@ -18,10 +18,13 @@ func (d *queryEvaluator) Eval(ctx context.Context, from time.Time, interval time
 		if err != nil {
 			return err
 		}
-		err = callback(idx, now, results)
+		cont, err := callback(idx, now, results)
 		if err != nil {
 			return err
 		}
+		if !cont {
+			break
+		}
 	}
 	return nil
 }
@@ -31,9 +31,9 @@ func TestQueryEvaluator_Eval(t *testing.T) {

 		intervals := make([]time.Time, times)

-		err := evaluator.Eval(ctx, from, interval, times, func(idx int, now time.Time, results eval.Results) error {
+		err := evaluator.Eval(ctx, from, interval, times, func(idx int, now time.Time, results eval.Results) (bool, error) {
 			intervals[idx] = now
-			return nil
+			return true, nil
 		})
 		require.NoError(t, err)
 		require.Len(t, intervals, times)
@@ -49,7 +49,7 @@ func TestQueryEvaluator_Eval(t *testing.T) {
 		}
 	})

-	t.Run("should stop evaluation if error", func(t *testing.T) {
+	t.Run("should stop evaluation", func(t *testing.T) {
 		t.Run("when evaluation fails", func(t *testing.T) {
 			m := &eval_mocks.ConditionEvaluatorMock{}
 			expectedResults := eval.Results{}
@@ -62,9 +62,9 @@ func TestQueryEvaluator_Eval(t *testing.T) {

 			intervals := make([]time.Time, 0, times)

-			err := evaluator.Eval(ctx, from, interval, times, func(idx int, now time.Time, results eval.Results) error {
+			err := evaluator.Eval(ctx, from, interval, times, func(idx int, now time.Time, results eval.Results) (bool, error) {
 				intervals = append(intervals, now)
-				return nil
+				return true, nil
 			})
 			require.ErrorIs(t, err, expectedError)
 			require.Len(t, intervals, 3)
@@ -81,14 +81,31 @@ func TestQueryEvaluator_Eval(t *testing.T) {

 			intervals := make([]time.Time, 0, times)

-			err := evaluator.Eval(ctx, from, interval, times, func(idx int, now time.Time, results eval.Results) error {
+			err := evaluator.Eval(ctx, from, interval, times, func(idx int, now time.Time, results eval.Results) (bool, error) {
 				if len(intervals) > 3 {
-					return expectedError
+					return false, expectedError
 				}
 				intervals = append(intervals, now)
-				return nil
+				return true, nil
 			})
 			require.ErrorIs(t, err, expectedError)
 		})
+
+		t.Run("when callback does not want to continue", func(t *testing.T) {
+			m := &eval_mocks.ConditionEvaluatorMock{}
+			expectedResults := eval.Results{}
+			m.EXPECT().Evaluate(mock.Anything, mock.Anything).Return(expectedResults, nil)
+			evaluator := queryEvaluator{
+				eval: m,
+			}
+
+			evaluated := 0
+			err := evaluator.Eval(ctx, from, interval, times, func(idx int, now time.Time, results eval.Results) (bool, error) {
+				evaluated++
+				return evaluated <= 2, nil
+			})
+			require.NoError(t, err, nil)
+			require.Equal(t, 3, evaluated)
+		})
 	})
 }
@@ -480,6 +480,10 @@ func (alertRule *AlertRule) GetPanelID() int64 {
 	return -1
 }

+func (alertRule *AlertRule) GetInterval() time.Duration {
+	return time.Duration(alertRule.IntervalSeconds) * time.Second
+}
+
 type LabelOption func(map[string]string)

 func WithoutInternalLabels() LabelOption {
@@ -5,6 +5,7 @@ import (
 	"time"

 	"github.com/grafana/grafana-plugin-sdk-go/data"
+
 	"github.com/grafana/grafana/pkg/services/featuremgmt"
 	ngmodels "github.com/grafana/grafana/pkg/services/ngalert/models"
 	"github.com/grafana/grafana/pkg/setting"
@@ -13,6 +14,10 @@ import (
 // JitterStrategy represents a modifier to alert rule timing that affects how evaluations are distributed.
 type JitterStrategy int

+func (s JitterStrategy) String() string {
+	return [...]string{"never", "by group", "by rule"}[s]
+}
+
 const (
 	JitterNever JitterStrategy = iota
 	JitterByGroup
@@ -57,6 +62,11 @@ func jitterOffsetInTicks(r *ngmodels.AlertRule, baseInterval time.Duration, stra
 	return res
 }

+// JitterOffsetInDuration gives the jitter offset for a rule, in terms of a duration relative to its interval and a base interval.
+func JitterOffsetInDuration(r *ngmodels.AlertRule, baseInterval time.Duration, strategy JitterStrategy) time.Duration {
+	return time.Duration(jitterOffsetInTicks(r, baseInterval, strategy)) * baseInterval
+}
+
 func jitterHash(r *ngmodels.AlertRule, strategy JitterStrategy) uint64 {
 	ls := data.Labels{
 		"name":  r.RuleGroup,
@@ -44,7 +44,11 @@ func New(c clock.Clock, interval time.Duration, metric *Metrics, logger log.Logg
 }

 func getStartTick(clk clock.Clock, interval time.Duration) time.Time {
-	nano := clk.Now().UnixNano()
+	return GetStartTick(clk.Now(), interval)
+}
+
+func GetStartTick(t time.Time, interval time.Duration) time.Time {
+	nano := t.UnixNano()
 	return time.Unix(0, nano-(nano%interval.Nanoseconds()))
 }

@@ -17,7 +17,7 @@ import (

 const StateHistoryWriteTimeout = time.Minute

-func shouldRecord(transition state.StateTransition) bool {
+func ShouldRecord(transition state.StateTransition) bool {
 	if !transition.Changed() {
 		return false
 	}
@@ -35,9 +35,9 @@ func shouldRecord(transition state.StateTransition) bool {
 }

 // ShouldRecordAnnotation returns true if an annotation should be created for a given state transition.
-// This is stricter than shouldRecord to avoid cluttering panels with state transitions.
+// This is stricter than ShouldRecord to avoid cluttering panels with state transitions.
 func ShouldRecordAnnotation(t state.StateTransition) bool {
-	if !shouldRecord(t) {
+	if !ShouldRecord(t) {
 		return false
 	}

@@ -92,7 +92,7 @@ func TestShouldRecord(t *testing.T) {
 		}

 		t.Run(fmt.Sprintf("%s -> %s should be %v", trans.PreviousFormatted(), trans.Formatted(), !ok), func(t *testing.T) {
-			require.Equal(t, !ok, shouldRecord(trans))
+			require.Equal(t, !ok, ShouldRecord(trans))
 		})
 	}
 }
@@ -41,6 +41,69 @@ const (
 	dfLabels = "labels"
 )

+// QueryResultBuilder is a builder for a data frame that represents query results from Loki.
+// It contains three fields: time (timestamp), line (JSON data), and labels (JSON labels).
+type QueryResultBuilder struct {
+	frame *data.Frame
+}
+
+// NewQueryResultBuilder creates a new QueryResultBuilder with the specified capacity.
+// The capacity is used to pre-allocate the underlying slices for better performance.
+func NewQueryResultBuilder(capacity int) *QueryResultBuilder {
+	frame := data.NewFrame("states")
+	lbls := data.Labels(map[string]string{})
+
+	// We represent state history as a single merged history, that roughly corresponds to what you get in the Grafana Explore tab when querying Loki directly.
+	// The format is composed of the following vectors:
+	//   1. `time` - timestamp - when the transition happened
+	//   2. `line` - JSON - the full data of the transition
+	//   3. `labels` - JSON - the labels associated with that state transition
+	times := make([]time.Time, 0, capacity)
+	lines := make([]json.RawMessage, 0, capacity)
+	labels := make([]json.RawMessage, 0, capacity)
+
+	frame.Fields = append(frame.Fields, data.NewField(dfTime, lbls, times))
+	frame.Fields = append(frame.Fields, data.NewField(dfLine, lbls, lines))
+	frame.Fields = append(frame.Fields, data.NewField(dfLabels, lbls, labels))
+
+	return &QueryResultBuilder{frame: frame}
+}
+
+func (qr QueryResultBuilder) AddRowRaw(timestamp time.Time, line json.RawMessage, labels json.RawMessage) {
+	frame := qr.frame
+	frame.Fields[0].Append(timestamp)
+	frame.Fields[1].Append(line)
+	frame.Fields[2].Append(labels)
+}
+
+func (qr QueryResultBuilder) AddRow(timestamp time.Time, line LokiEntry, labels json.RawMessage) error {
+	lineBytes, err := json.Marshal(line)
+	if err != nil {
+		return err
+	}
+	qr.AddRowRaw(timestamp, lineBytes, labels)
+	return nil
+}
+
+// ToFrame converts the QueryResultBuilder back to a data.Frame.
+func (qr QueryResultBuilder) ToFrame() *data.Frame {
+	return qr.frame
+}
+
+func (qr QueryResultBuilder) AddWarn(s string) {
+	m := qr.frame.Meta
+	if m == nil {
+		m = &data.FrameMeta{}
+		qr.frame.SetMeta(m)
+	}
+	m.Notices = append(m.Notices, data.Notice{
+		Severity: data.NoticeSeverityWarning,
+		Text:     s,
+		Link:     "",
+		Inspect:  0,
+	})
+}
+
 const (
 	StateHistoryLabelKey   = "from"
 	StateHistoryLabelValue = "state-history"
@@ -191,20 +254,7 @@ func (h RemoteLokiBackend) merge(res []lokiclient.Stream, folderUIDToFilter []st
 		totalLen += len(arr.Values)
 	}

-	// Create a new slice to store the merged elements.
-	frame := data.NewFrame("states")
-
-	// We merge all series into a single linear history.
-	lbls := data.Labels(map[string]string{})
-
-	// We represent state history as a single merged history, that roughly corresponds to what you get in the Grafana Explore tab when querying Loki directly.
-	// The format is composed of the following vectors:
-	//   1. `time` - timestamp - when the transition happened
-	//   2. `line` - JSON - the full data of the transition
-	//   3. `labels` - JSON - the labels associated with that state transition
-	times := make([]time.Time, 0, totalLen)
-	lines := make([]json.RawMessage, 0, totalLen)
-	labels := make([]json.RawMessage, 0, totalLen)
+	queryResult := NewQueryResultBuilder(totalLen)

 	// Initialize a slice of pointers to the current position in each array.
 	pointers := make([]int, len(res))
@@ -259,17 +309,10 @@ func (h RemoteLokiBackend) merge(res []lokiclient.Stream, folderUIDToFilter []st
 			pointers[minElStreamIdx]++
 			continue
 		}
-		times = append(times, time.Unix(0, tsNano))
-		labels = append(labels, lblsJson)
-		lines = append(lines, json.RawMessage(entryBytes))
+		queryResult.AddRowRaw(time.Unix(0, tsNano), entryBytes, lblsJson)
 		pointers[minElStreamIdx]++
 	}
-
-	frame.Fields = append(frame.Fields, data.NewField(dfTime, lbls, times))
-	frame.Fields = append(frame.Fields, data.NewField(dfLine, lbls, lines))
-	frame.Fields = append(frame.Fields, data.NewField(dfLabels, lbls, labels))
-
-	return frame, nil
+	return queryResult.ToFrame(), nil
 }

 func StatesToStream(rule history_model.RuleMeta, states []state.StateTransition, externalLabels map[string]string, logger log.Logger) lokiclient.Stream {
@@ -282,28 +325,11 @@ func StatesToStream(rule history_model.RuleMeta, states []state.StateTransition,

 	samples := make([]lokiclient.Sample, 0, len(states))
 	for _, state := range states {
-		if !shouldRecord(state) {
+		if !ShouldRecord(state) {
 			continue
 		}

-		sanitizedLabels := removePrivateLabels(state.Labels)
-		entry := LokiEntry{
-			SchemaVersion:  1,
-			Previous:       state.PreviousFormatted(),
-			Current:        state.Formatted(),
-			Values:         valuesAsDataBlob(state.State),
-			Condition:      rule.Condition,
-			DashboardUID:   rule.DashboardUID,
-			PanelID:        rule.PanelID,
-			Fingerprint:    labelFingerprint(sanitizedLabels),
-			RuleTitle:      rule.Title,
-			RuleID:         rule.ID,
-			RuleUID:        rule.UID,
-			InstanceLabels: sanitizedLabels,
-		}
-		if state.State.State == eval.Error {
-			entry.Error = state.Error.Error()
-		}
+		entry := StateTransitionToLokiEntry(rule, state)

 		jsn, err := json.Marshal(entry)
 		if err != nil {
@@ -324,6 +350,28 @@ func StatesToStream(rule history_model.RuleMeta, states []state.StateTransition,
 	}
 }

+func StateTransitionToLokiEntry(rule history_model.RuleMeta, state state.StateTransition) LokiEntry {
+	sanitizedLabels := removePrivateLabels(state.Labels)
+	entry := LokiEntry{
+		SchemaVersion:  1,
+		Previous:       state.PreviousFormatted(),
+		Current:        state.Formatted(),
+		Values:         valuesAsDataBlob(state.State),
+		Condition:      rule.Condition,
+		DashboardUID:   rule.DashboardUID,
+		PanelID:        rule.PanelID,
+		Fingerprint:    labelFingerprint(sanitizedLabels),
+		RuleTitle:      rule.Title,
+		RuleID:         rule.ID,
+		RuleUID:        rule.UID,
+		InstanceLabels: sanitizedLabels,
+	}
+	if state.State.State == eval.Error && state.Error != nil {
+		entry.Error = state.Error.Error()
+	}
+	return entry
+}
+
 func (h *RemoteLokiBackend) recordStreams(ctx context.Context, stream lokiclient.Stream, logger log.Logger) error {
 	if err := h.client.Push(ctx, []lokiclient.Stream{stream}); err != nil {
 		return err
@@ -660,6 +660,10 @@ func (o *Service) getExternalSession(ctx context.Context, usr identity.Requester
 		return externalSessions[0], nil
 	}

+	if sessionToken == nil {
+		return nil, auth.ErrExternalSessionTokenNotFound
+	}
+
 	// For regular users, we use the session token ID to fetch the external session
 	return o.sessionService.GetExternalSession(ctx, sessionToken.ExternalSessionId)
 }
@@ -156,6 +156,8 @@ type UnifiedAlertingSettings struct {

 	// AlertmanagerMaxTemplateOutputSize specifies the maximum allowed size for rendered template output in bytes.
 	AlertmanagerMaxTemplateOutputSize int64
+
+	BacktestingMaxEvaluations int
 }

 type RecordingRuleSettings struct {
@@ -594,6 +596,11 @@ func (cfg *Cfg) ReadUnifiedAlertingSettings(iniFile *ini.File) error {
 		return fmt.Errorf("setting 'alertmanager_max_template_output_bytes' is invalid, only 0 or a positive integer are allowed")
 	}

+	uaCfg.BacktestingMaxEvaluations = ua.Key("backtesting_max_evaluations").MustInt(100)
+	if uaCfg.BacktestingMaxEvaluations < 0 {
+		uaCfg.BacktestingMaxEvaluations = 100
+	}
+
 	cfg.UnifiedAlerting = uaCfg
 	return nil
 }
@@ -68,7 +68,7 @@ func TestBacktesting(t *testing.T) {
 			require.Truef(t, ok, "The data file does not contain a field `data`")

 			status, body := apiCli.SubmitRuleForBacktesting(t, request)
-			require.Equal(t, http.StatusOK, status)
+			require.Equalf(t, http.StatusOK, status, "Response: %s", body)
 			var result data.Frame
 			require.NoErrorf(t, json.Unmarshal([]byte(body), &result), "cannot parse response to data frame")
 		})
@@ -107,6 +107,7 @@ func TestBacktesting(t *testing.T) {
 			resourcepermissions.SetResourcePermissionCommand{
 				Actions: []string{
 					accesscontrol.ActionAlertingRuleRead,
+					accesscontrol.ActionAlertingRuleUpdate,
 				},
 				Resource:          "folders",
 				ResourceID:        "*",
@@ -12,6 +12,9 @@
    },
    "condition": "A",
    "no_data_state": "Alerting",
+    "title": "test-rule-backtesting-data",
+    "rule_group": "test-group",
+    "namespace_uid": "test-namespace",
    "data": [
      {
        "refId": "A",
@@ -193,6 +196,9 @@
    },
    "condition": "C",
    "no_data_state": "Alerting",
+    "title": "test-rule-backtesting-data",
+    "rule_group": "test-group",
+    "namespace_uid": "test-namespace",
    "data": [
      {
        "refId": "A",
@@ -2169,6 +2169,43 @@
        ]
      }
    },
+    "/apis/dashboard.grafana.app/v0alpha1/namespaces/{namespace}/snapshots/settings": {
+      "get": {
+        "tags": [
+          "Snapshot"
+        ],
+        "description": "Get Snapshot sharing settings",
+        "operationId": "getSnapshotSettings",
+        "parameters": [
+          {
+            "name": "namespace",
+            "in": "path",
+            "description": "workspace",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "example": "default"
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {},
+                "example": "{\"snapshotsEnabled\":true,\"externalSnapshotURL\":\"https://externalurl.com\",\"externalSnapshotName\":\"external\",\"externalEnabled\":true}"
+              }
+            }
+          }
+        },
+        "x-grafana-action": "get",
+        "x-kubernetes-group-version-kind": {
+          "group": "dashboard.grafana.app",
+          "version": "v0alpha1",
+          "kind": "SnapshotSharingOptions"
+        }
+      }
+    },
    "/apis/dashboard.grafana.app/v0alpha1/namespaces/{namespace}/snapshots/{name}": {
      "get": {
        "tags": [
@@ -426,6 +426,45 @@ func doPlaylistTests(t *testing.T, helper *apis.K8sTestHelper) *apis.K8sTestHelp
 		require.Equal(t, metav1.StatusReasonForbidden, rsp.Status.Reason)
 	})

+	t.Run("Check CRUD operations with None role", func(t *testing.T) {
+		// Create a playlist with admin user
+		clientAdmin := helper.GetResourceClient(apis.ResourceClientArgs{
+			User: helper.Org1.Admin,
+			GVR:  gvr,
+		})
+		created, err := clientAdmin.Resource.Create(context.Background(),
+			helper.LoadYAMLOrJSONFile("testdata/playlist-generate.yaml"),
+			metav1.CreateOptions{},
+		)
+		require.NoError(t, err)
+
+		clientNone := helper.GetResourceClient(apis.ResourceClientArgs{
+			User: helper.Org1.None,
+			GVR:  gvr,
+		})
+
+		// Now check if None user can perform a Get to start a playlist
+		_, err = clientNone.Resource.Get(context.Background(), created.GetName(), metav1.GetOptions{})
+		require.NoError(t, err)
+
+		// None role can get but can not create edit or delete a playlist
+		_, err = clientNone.Resource.Create(context.Background(),
+			helper.LoadYAMLOrJSONFile("testdata/playlist-generate.yaml"),
+			metav1.CreateOptions{},
+		)
+		require.Error(t, err)
+
+		_, err = clientNone.Resource.Update(context.Background(), created, metav1.UpdateOptions{})
+		require.Error(t, err)
+
+		err = clientNone.Resource.Delete(context.Background(), created.GetName(), metav1.DeleteOptions{})
+		require.Error(t, err)
+
+		// delete created resource
+		err = clientAdmin.Resource.Delete(context.Background(), created.GetName(), metav1.DeleteOptions{})
+		require.NoError(t, err)
+	})
+
 	t.Run("Check k8s client-go List from different org users", func(t *testing.T) {
 		// Check Org1 Viewer
 		client := helper.GetResourceClient(apis.ResourceClientArgs{
@@ -1,23 +1,29 @@
-import { isArray, isPlainObject } from 'lodash';
+import { isArray, isPlainObject, isString } from 'lodash';

 /**
 * @returns A deep clone of the object, but with any null value removed.
 * @param value - The object to be cloned and cleaned.
 * @param convertInfinity - If true, -Infinity or Infinity is converted to 0.
 * This is because Infinity is not a valid JSON value, and sometimes we want to convert it to 0 instead of default null.
+ * @param stripBOMs - If true, strips Byte Order Mark (BOM) characters from all strings.
+ * BOMs (U+FEFF) can cause CUE validation errors ("illegal byte order mark").
 */
-export function sortedDeepCloneWithoutNulls<T>(value: T, convertInfinity?: boolean): T {
+export function sortedDeepCloneWithoutNulls<T>(value: T, convertInfinity?: boolean, stripBOMs?: boolean): T {
  if (isArray(value)) {
-    return value.map((item) => sortedDeepCloneWithoutNulls(item, convertInfinity)) as unknown as T;
+    return value.map((item) => sortedDeepCloneWithoutNulls(item, convertInfinity, stripBOMs)) as unknown as T;
  }
  if (isPlainObject(value)) {
    return Object.keys(value as { [key: string]: any })
      .sort()
      .reduce((acc: any, key) => {
-        const v = (value as any)[key];
+        let v = (value as any)[key];
        // Remove null values
        if (v != null) {
-          acc[key] = sortedDeepCloneWithoutNulls(v, convertInfinity);
+          // Strip BOMs from strings
+          if (stripBOMs && isString(v)) {
+            v = v.replace(/\ufeff/g, '');
+          }
+          acc[key] = sortedDeepCloneWithoutNulls(v, convertInfinity, stripBOMs);
        }

        if (convertInfinity && (v === Infinity || v === -Infinity)) {
@@ -0,0 +1,50 @@
+import { DataFrameJSON } from '@grafana/data';
+import { AlertQuery, GrafanaAlertStateDecision, Labels } from 'app/types/unified-alerting-dto';
+
+import { alertingApi } from './alertingApi';
+
+/**
+ * Request body for the backtest API matching the BacktestConfig struct in the backend
+ */
+export interface BacktestRequest {
+  // Required time range fields
+  from: string; // ISO 8601 timestamp
+  to: string; // ISO 8601 timestamp
+  interval: string; // e.g., "1m", "5m"
+
+  // Required alert definition fields
+  condition: string;
+  data: AlertQuery[];
+  title: string;
+  no_data_state?: GrafanaAlertStateDecision;
+  exec_err_state?: GrafanaAlertStateDecision;
+
+  // Optional duration fields
+  for?: string;
+  keep_firing_for?: string;
+
+  // Optional metadata fields
+  labels?: Labels;
+  missing_series_evals_to_resolve?: number;
+
+  // Optional rule identification fields
+  uid?: string;
+  rule_group?: string;
+  namespace_uid?: string;
+}
+
+export const BACKTEST_URL = '/api/v1/rule/backtest';
+
+export const backtestApi = alertingApi.injectEndpoints({
+  endpoints: (build) => ({
+    runBacktest: build.mutation<DataFrameJSON, BacktestRequest>({
+      query: (requestBody) => ({
+        url: BACKTEST_URL,
+        method: 'POST',
+        body: requestBody,
+      }),
+    }),
+  }),
+});
+
+export const { useRunBacktestMutation } = backtestApi;
@@ -0,0 +1,63 @@
+import { useCallback, useState } from 'react';
+
+import { TimeRange, rangeUtil } from '@grafana/data';
+import { Trans, t } from '@grafana/i18n';
+import { Button, Drawer, Dropdown, Menu, MenuItem } from '@grafana/ui';
+
+import { RuleFormValues } from '../../types/rule-form';
+
+import { BacktestPanel } from './BacktestPanel';
+
+interface BacktestDropdownButtonProps {
+  ruleDefinition: RuleFormValues;
+}
+
+export function BacktestDropdownButton({ ruleDefinition }: BacktestDropdownButtonProps) {
+  const [isBacktestPanelOpen, setIsBacktestPanelOpen] = useState(false);
+  const [backtestTimeRange, setBacktestTimeRange] = useState<TimeRange>();
+
+  const handleTimeRangeSelect = useCallback((rawFrom: string) => {
+    const timeRange = rangeUtil.convertRawToRange({ from: rawFrom, to: 'now' });
+    setBacktestTimeRange(timeRange);
+    setIsBacktestPanelOpen(true);
+  }, []);
+
+  const handleCustomSelect = useCallback(() => {
+    setBacktestTimeRange(undefined);
+    setIsBacktestPanelOpen(true);
+  }, []);
+
+  return (
+    <>
+      <Dropdown
+        overlay={
+          <Menu>
+            <MenuItem
+              label={t('alerting.queryAndExpressionsStep.last15m', 'Last 15 minutes')}
+              onClick={() => handleTimeRangeSelect('now-15m')}
+            />
+            <MenuItem
+              label={t('alerting.queryAndExpressionsStep.last1h', 'Last 1 hour')}
+              onClick={() => handleTimeRangeSelect('now-1h')}
+            />
+            <MenuItem label={t('alerting.queryAndExpressionsStep.custom', 'Custom')} onClick={handleCustomSelect} />
+          </Menu>
+        }
+      >
+        <Button icon="bug" variant="secondary">
+          <Trans i18nKey="alerting.queryAndExpressionsStep.testRule">Test Rule</Trans>
+        </Button>
+      </Dropdown>
+
+      {isBacktestPanelOpen && (
+        <Drawer
+          title={t('alerting.backtest.panel-title', 'Rule Retroactive Testing')}
+          onClose={() => setIsBacktestPanelOpen(false)}
+          size="md"
+        >
+          <BacktestPanel ruleDefinition={ruleDefinition} initialTimeRange={backtestTimeRange} />
+        </Drawer>
+      )}
+    </>
+  );
+}
@@ -0,0 +1,200 @@
+import { css } from '@emotion/css';
+import { fromPairs, isEmpty, isEqual } from 'lodash';
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+import { AlertLabels } from '@grafana/alerting/unstable';
+import { DataFrameJSON, GrafanaTheme2, TimeRange, rangeUtil } from '@grafana/data';
+import { Trans, t } from '@grafana/i18n';
+import {
+  Alert,
+  Icon,
+  LoadingPlaceholder,
+  RefreshPicker,
+  Stack,
+  Text,
+  TimeRangePicker,
+  Tooltip,
+  useStyles2,
+} from '@grafana/ui';
+
+import { useRunBacktestMutation } from '../../api/backtestApi';
+import { RuleFormValues } from '../../types/rule-form';
+import { combineMatcherStrings } from '../../utils/alertmanager';
+import { messageFromError } from '../../utils/redux';
+import { formValuesToRulerGrafanaRuleDTO } from '../../utils/rule-form';
+import { LogRecordViewerByTimestamp } from '../rules/state-history/LogRecordViewer';
+import { LogTimelineViewer } from '../rules/state-history/LogTimelineViewer';
+import { useFrameSubset } from '../rules/state-history/LokiStateHistory';
+import { useRuleHistoryRecords } from '../rules/state-history/useRuleHistoryRecords';
+
+interface BacktestPanelProps {
+  ruleDefinition: RuleFormValues;
+  initialTimeRange?: TimeRange;
+}
+
+export function BacktestPanel({ ruleDefinition, initialTimeRange }: BacktestPanelProps) {
+  const styles = useStyles2(getStyles);
+  const [timeRange, setTimeRange] = useState<TimeRange>(
+    initialTimeRange || rangeUtil.convertRawToRange({ from: 'now-15m', to: 'now' })
+  );
+  const [stateHistory, setStateHistory] = useState<DataFrameJSON>();
+  const [instancesFilter, setInstancesFilter] = useState('');
+  const shouldRunInitialBacktest = useRef(!!initialTimeRange);
+
+  const [runBacktest, { isLoading, error: mutationError }] = useRunBacktestMutation();
+
+  const handleRunBacktest = useCallback(async () => {
+    // Convert form values to the proper AlertRule format
+    const alertRule = formValuesToRulerGrafanaRuleDTO(ruleDefinition);
+
+    // Build requestBody matching BacktestConfig struct
+    const requestBody = {
+      // Required time range fields
+      from: timeRange.from.toISOString(),
+      to: timeRange.to.toISOString(),
+      interval: ruleDefinition.evaluateEvery,
+
+      // Required alert definition fields
+      condition: alertRule.grafana_alert.condition,
+      data: alertRule.grafana_alert.data,
+      title: alertRule.grafana_alert.title,
+      no_data_state: alertRule.grafana_alert.no_data_state,
+      exec_err_state: alertRule.grafana_alert.exec_err_state,
+
+      // Optional duration fields
+      for: alertRule.for,
+      keep_firing_for: alertRule.keep_firing_for,
+
+      // Optional metadata fields
+      labels: alertRule.labels,
+      missing_series_evals_to_resolve: alertRule.grafana_alert.missing_series_evals_to_resolve,
+
+      // Optional rule identification fields
+      uid: alertRule.grafana_alert.uid,
+      rule_group: ruleDefinition.group,
+      namespace_uid: ruleDefinition.folder?.uid,
+    };
+
+    try {
+      const result = await runBacktest(requestBody).unwrap();
+      setStateHistory(result);
+    } catch (err) {
+      // Error is handled by RTK Query and available via mutationError
+    }
+  }, [ruleDefinition, timeRange, runBacktest]);
+
+  // Update time range when initialTimeRange prop changes
+  useEffect(() => {
+    if (initialTimeRange) {
+      setTimeRange(initialTimeRange);
+    }
+  }, [initialTimeRange]);
+
+  // Run backtest once after initial mount when timeRange is synchronized with initialTimeRange
+  useEffect(() => {
+    if (shouldRunInitialBacktest.current && initialTimeRange && isEqual(timeRange, initialTimeRange)) {
+      shouldRunInitialBacktest.current = false;
+      handleRunBacktest();
+    }
+  }, [initialTimeRange, timeRange, handleRunBacktest]);
+
+  const { dataFrames, historyRecords, commonLabels } = useRuleHistoryRecords(stateHistory, instancesFilter);
+
+  const { frameSubset, frameTimeRange } = useFrameSubset(dataFrames);
+
+  const onLogRecordLabelClick = useCallback(
+    (label: string) => {
+      const matcherString = combineMatcherStrings(instancesFilter, label);
+      setInstancesFilter(matcherString);
+    },
+    [instancesFilter]
+  );
+
+  const hasResults = stateHistory !== undefined;
+
+  const notices = stateHistory?.schema?.meta?.notices || [];
+  const errorMessage = mutationError ? messageFromError(mutationError) : null;
+
+  return (
+    <div>
+      <Stack direction="row" alignItems="flex-end" justifyContent="flex-end">
+        <TimeRangePicker
+          value={timeRange}
+          onChange={setTimeRange}
+          onChangeTimeZone={() => {}}
+          onMoveBackward={() => {}}
+          onMoveForward={() => {}}
+          onZoom={() => {}}
+        />
+        <RefreshPicker
+          onRefresh={handleRunBacktest}
+          onIntervalChanged={() => {}}
+          isLoading={isLoading}
+          noIntervalPicker={true}
+        />
+      </Stack>
+      <div className={styles.scrollableContent}>
+        {isLoading && <LoadingPlaceholder text={t('alerting.backtest.loading', 'Running backtest...')} />}
+
+        {errorMessage && (
+          <Alert title={t('alerting.backtest.error-title', 'Failed to run backtest')}>{errorMessage}</Alert>
+        )}
+
+        {!isLoading && !mutationError && hasResults && notices.length > 0 && (
+          <Stack direction="column" gap={1}>
+            {notices.map((notice, index) => (
+              <Alert key={index} severity={notice.severity || 'info'} title="">
+                {notice.text}
+              </Alert>
+            ))}
+          </Stack>
+        )}
+
+        {!isLoading && !mutationError && hasResults && (
+          <div className={styles.resultsContainer}>
+            {!isEmpty(commonLabels) && (
+              <Stack gap={1} alignItems="center" wrap="wrap">
+                <Stack gap={0.5} alignItems="center" minWidth="fit-content">
+                  <Text variant="bodySmall">
+                    <Trans i18nKey="alerting.loki-state-history.common-labels">Common labels</Trans>
+                  </Text>
+                  <Tooltip
+                    content={t(
+                      'alerting.loki-state-history.tooltip-common-labels',
+                      'Common labels are the ones attached to all of the alert instances'
+                    )}
+                  >
+                    <Icon name="info-circle" size="sm" />
+                  </Tooltip>
+                </Stack>
+                <AlertLabels labels={fromPairs(commonLabels)} size="sm" />
+              </Stack>
+            )}
+            <LogTimelineViewer frames={frameSubset} timeRange={frameTimeRange} />
+            <LogRecordViewerByTimestamp
+              records={historyRecords}
+              commonLabels={commonLabels}
+              onLabelClick={onLogRecordLabelClick}
+            />
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+const getStyles = (theme: GrafanaTheme2) => ({
+  scrollableContent: css({
+    flex: 1,
+    display: 'flex',
+    flexDirection: 'column',
+    paddingTop: theme.spacing(2),
+    overflow: 'hidden',
+  }),
+  resultsContainer: css({
+    display: 'flex',
+    flexDirection: 'column',
+    gap: theme.spacing(2),
+    flex: 1,
+    overflow: 'hidden',
+  }),
+});
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
idastambuk	ef7693432d	Check that variable isnt null when initializing ds reference	2025-12-31 09:59:55 +01:00
Matheus Macabu	75b2c905cd	Auditing: Move sinkable/logger interfaces and add global default logger implementation (#115743 ) * Auditing: Move sinkable and logger interfaces * Auditing: Add global default logger implementation * Chore: Fix enterprise imports	2025-12-30 14:05:23 +01:00
Ezequiel Victorero	45fc95cfc9	Snapshots: Use settings MT service (#115541 )	2025-12-30 09:54:20 -03:00
Ezequiel Victorero	9c3cdd4814	Playlists: Support get with None role (#115713 )	2025-12-30 08:46:43 -03:00
Marc M.	2dad8b7b5b	DynamicDashboards: Add button to feedback form (#114980 )	2025-12-30 10:54:00 +01:00
Matheus Macabu	9a831ab4e1	Auditing: Set default policy rule level for create to req+resp (#115727 ) Auditing: Set default policy rule level to req+resp	2025-12-30 09:47:00 +01:00
Dominik Prokop	759035a465	Remove kubernetesDashboardsV2 feature toggle (#114912 ) Co-authored-by: Haris Rozajac <haris.rozajac12@gmail.com>	2025-12-30 09:45:33 +01:00
Todd Treece	6e155523a3	Plugins App: Add basic README (#115507 ) * Plugins App: Add basic README * prettier:write --------- Co-authored-by: Ryan McKinley <ryantxu@gmail.com>	2025-12-30 08:14:06 +00:00
Lewis John McGibbney	5c0ee2d746	Documentation: Fix JSON file export relative link (#115650 )	2025-12-30 10:46:57 +03:00
ismail simsek	0c6b97bee2	Prometheus: Fallback to fetch metric names when metadata returns nothing (#115369 ) fallback to fetch metric names when metadata returns nothing	2025-12-29 19:11:44 +01:00
linoman	4c79775b57	auth: Protect from empty session token panic (#115728 ) * Protect from empty session token panic * Rename returned error	2025-12-29 17:19:49 +01:00
Matheus Macabu	e088c9aac9	Auditing: Add feature flag (#115726 )	2025-12-29 16:28:29 +01:00
Rodrigo Vasconcelos de Barros	7182511bcf	Alerting: Auto-format numeric values in Alert Rule History (#115708 ) * Add helper function to format numeric values in alert rule history * Use formatting function in LogRecordViewer * Refactor numerical formatting logic * Handle edge cases when counting decimal places * Cleanup tests and numberFormatter code	2025-12-29 10:18:42 -05:00
Paul Marbach	3023a72175	E2E: Use updated setVisualization from grafana/e2e (#115640 )	2025-12-29 10:10:04 -05:00
Ivan Ortega Alba	30ad61e0e9	Dashboards: Fix adhoc filter click when panel has no panel-level datasource (#115576 ) * V2: Panel datasource is defined only for mixed ds * if getDatasourceFromQueryRunner only returns ds.type, resolve to full ds ref throgh ds service --------- Co-authored-by: Haris Rozajac <haris.rozajac12@gmail.com>	2025-12-29 10:29:50 +01:00
Oscar Kilhed	0b58cd3900	Dashboard: Remove BOMs from links during conversion (#115689 ) * Dashboard: Add test case for BOM characters in link URLs This test demonstrates the issue where BOM (Byte Order Mark) characters in dashboard link URLs cause CUE validation errors during v1 to v2 conversion ('illegal byte order mark'). The test input contains BOMs in various URL locations: - Dashboard links - Panel data links - Field config override links - Options dataLinks - Field config default links * Dashboard: Strip BOM characters from URLs during v1 to v2 conversion BOM (Byte Order Mark) characters in dashboard link URLs cause CUE validation errors ('illegal byte order mark') when opening v2 dashboards. This fix strips BOMs from all URL fields during conversion: - Dashboard links - Panel data links - Field config override links - Options dataLinks - Field config default links The stripBOM helper recursively processes nested structures to ensure all string values have BOMs removed. * Dashboard: Strip BOM characters in frontend v2 conversion Add stripBOMs parameter to sortedDeepCloneWithoutNulls utility to remove Byte Order Mark (U+FEFF) characters from all strings when serializing dashboards to v2 format. This prevents CUE validation errors ('illegal byte order mark') that occur when BOMs are present in any string field. BOMs can be introduced through copy/paste from certain editors or text sources. Applied at the final serialization step so it catches BOMs from: - Existing v1 dashboards being converted - New data entered during dashboard editing	2025-12-29 09:53:45 +01:00
Matheus Macabu	4ba2fe6cce	Auditing: Add Event struct to map audit logs into (#115509 )	2025-12-29 09:31:58 +01:00
grafana-pr-automation[bot]	a345f78ae0	I18n: Download translations from Crowdin (#115717 ) New Crowdin translations by GitHub Action Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2025-12-28 00:34:24 +00:00
Yuri Tseretyan	fa1e6cce5e	Alerting: Rule backtesting with experimental UI (#115525 ) * add function to convert StateTransition to LokiEntry * add QueryResultBuilder * update backtesting to produce result similar to historian * make shouldRecord public * filter out noop transitions * add experimental front-end * add new fields * move conversion of api model to AlertRule to validation * add extra labels * calculate tick timestamp using the same logic as in scheduler * implement correct logic of calculating first evaluation timestamp * add uid, group and folder uid they are needed for jitter strategy * add JitterOffsetInDuration and JitterStrategy.String() * add config `backtesting_max_evaluations` to [unified_alerting] (not documented for now) * remove obsolete tests * elevate permisisons for backtesting endpoint * move backtesting to separate dir	2025-12-26 16:55:57 -05:00