ran prettier

docs/sources/datasources/mssql/troubleshooting/index.md

@@ -322,7 +322,7 @@ If you continue to experience issues after following this troubleshooting guide:
 1. Review the [Grafana GitHub issues](https://github.com/grafana/grafana/issues) for known bugs.
 1. Enable debug logging in Grafana to capture detailed error information.
 1. Check SQL Server logs for additional error details.
-1. Contact Grafana Support if you're an Enterprise or Cloud customer.
+1. Contact [Grafana Support](https://grafana.com/contact/) if you're an Enterprise or Cloud customer.
 
 When reporting issues, include:
 

docs/sources/datasources/mysql/_index.md

@@ -17,52 +17,145 @@ menuTitle: MySQL
 title: MySQL data source
 weight: 1000
 refs:
-  annotate-visualizations:
-    - pattern: /docs/grafana/
-      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/build-dashboards/annotate-visualizations/
-    - pattern: /docs/grafana-cloud/
-      destination: /docs/grafana-cloud/visualizations/dashboards/build-dashboards/annotate-visualizations/
   configure-mysql-data-source:
     - pattern: /docs/grafana/
-      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/configuration/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/configure/
     - pattern: /docs/grafana-cloud/
-      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/configuration/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/configure/
   mysql-query-editor:
     - pattern: /docs/grafana/
       destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/query-editor/
     - pattern: /docs/grafana-cloud/
       destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/query-editor/
-  alerting:
+  troubleshoot-mysql:
     - pattern: /docs/grafana/
-      destination: /docs/grafana/<GRAFANA_VERSION>/alerting/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/troubleshooting/
     - pattern: /docs/grafana-cloud/
-      destination: /docs/grafana-cloud/alerting-and-irm/alerting/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/troubleshooting/
+  mysql-template-variables:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/template-variables/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/template-variables/
+  mysql-alerting:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/alerting/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/alerting/
+  mysql-annotations:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/annotations/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/annotations/
   transformations:
     - pattern: /docs/grafana/
       destination: /docs/grafana/<GRAFANA_VERSION>/panels-visualizations/query-transform-data/transform-data/
     - pattern: /docs/grafana-cloud/
       destination: /docs/grafana-cloud/visualizations/panels-visualizations/query-transform-data/transform-data/
+  visualizations:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/panels-visualizations/visualizations/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana-cloud/visualizations/panels-visualizations/visualizations/
+  variables:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/variables/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana-cloud/visualizations/dashboards/variables/
+  query-caching:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/administration/data-source-management/#query-and-resource-caching
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/administration/data-source-management/#query-and-resource-caching
+  postgres:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/postgres/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/postgres/
+  mssql:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mssql/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mssql/
 ---
 
 # MySQL data source
 
-Grafana ships with a built-in MySQL data source plugin that allows you to query and visualize data from a MySQL-compatible database like [MariaDB](https://mariadb.org/) or [Percona Server](https://www.percona.com/). You don't need to install a plugin in order to add the MySQL data source to your Grafana instance.
+Grafana ships with built-in support for MySQL.
+You can query and visualize data from MySQL-compatible databases like [MariaDB](https://mariadb.org/) or [Percona Server](https://www.percona.com/).
 
-Grafana offers several configuration options for this data source as well as a visual and code-based query editor.
+Use this data source to create dashboards, explore SQL data, and monitor MySQL-based workloads in real time.
 
-## Get started with the MySQL data source
+{{< docs/play title="MySQL Overview" url="https://play.grafana.org/d/edyh1ib7db6rkb/mysql-overview" >}}
 
-The following documents will help you get started with the MySQL data source in Grafana:
+## Supported databases
+
+This data source supports the following MySQL-compatible databases:
+
+- MySQL 5.7 and newer
+- MySQL 8.0 and newer
+- MariaDB 10.2 and newer
+- Percona Server 5.7 and newer
+- Amazon Aurora MySQL
+- Azure Database for MySQL
+- Google Cloud SQL for MySQL
+
+Grafana recommends using the latest available version for your database for optimal compatibility.
+
+## Key capabilities
+
+The MySQL data source supports:
+
+- **Time series queries:** Visualize metrics over time using built-in time grouping macros.
+- **Table queries:** Display query results in table format for any valid SQL query.
+- **Template variables:** Create dynamic dashboards with variable-driven queries.
+- **Annotations:** Overlay events from MySQL on your dashboard graphs.
+- **Alerting:** Create alerts based on MySQL query results.
+- **Macros:** Simplify queries with built-in macros for time filtering and grouping.
+
+## Get started
+
+The following documentation helps you get started with the MySQL data source:
 
 - [Configure the MySQL data source](ref:configure-mysql-data-source)
 - [MySQL query editor](ref:mysql-query-editor)
+- [MySQL template variables](ref:mysql-template-variables)
+- [MySQL annotations](ref:mysql-annotations)
+- [MySQL alerting](ref:mysql-alerting)
+- [Troubleshoot MySQL data source issues](ref:troubleshoot-mysql)
 
-Once you have configured the data source you can:
+## Additional resources
 
-- Add [annotations](ref:annotate-visualizations)
-- Set up [alerting](ref:alerting)
-- Add [transformations](ref:transformations)
+After configuring the MySQL data source, you can also:
 
-View a MySQL overview on Grafana Play:
+- Create a wide variety of [visualizations](ref:visualizations).
+- Configure and use [templates and variables](ref:variables).
+- Add [transformations](ref:transformations).
+- Optimize performance with [query caching](ref:query-caching).
 
-{{< docs/play title="MySQL Overview" url="https://play.grafana.org/d/edyh1ib7db6rkb/mysql-overview" >}}
+## Pre-configured dashboards
+
+If you want to monitor your MySQL server's performance metrics (connections, queries, replication, and more), Grafana provides pre-configured dashboards through the MySQL integration:
+
+- **MySQL Overview** - Key performance metrics for your MySQL server.
+- **MySQL Logs** - Log analysis for troubleshooting.
+
+The MySQL integration uses the Prometheus MySQL Exporter to collect server metrics and includes 15 pre-configured alert rules.
+
+To use these dashboards:
+
+1. In Grafana Cloud, navigate to **Connections** > **Add new connection**.
+1. Search for **MySQL** and select the MySQL integration.
+1. Follow the setup instructions to install the MySQL Exporter.
+1. Import the pre-configured dashboards from the integration page.
+
+For more MySQL dashboards, browse the [Grafana dashboard catalog](https://grafana.com/grafana/dashboards/?search=mysql).
+
+{{< admonition type="note" >}}
+The MySQL integration monitors your MySQL _server_ using Prometheus metrics. The MySQL _data source_ documented here queries data stored _in_ MySQL tables. These are complementary features for different use cases.
+{{< /admonition >}}
+
+## Related data sources
+
+- [PostgreSQL](ref:postgres) - For PostgreSQL databases.
+- [Microsoft SQL Server](ref:mssql) - For Microsoft SQL Server and Azure SQL databases.

docs/sources/datasources/mysql/alerting/index.md

@@ -0,0 +1,188 @@
+---
+description: Using Grafana Alerting with the MySQL data source
+keywords:
+  - grafana
+  - mysql
+  - alerting
+  - alerts
+labels:
+  products:
+    - cloud
+    - enterprise
+    - oss
+menuTitle: Alerting
+title: MySQL alerting
+weight: 350
+refs:
+  alerting:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/alerting/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana-cloud/alerting-and-irm/alerting/
+  create-alert-rule:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/alerting/alerting-rules/create-grafana-managed-rule/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana-cloud/alerting-and-irm/alerting/alerting-rules/create-grafana-managed-rule/
+  mysql-query-editor:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/query-editor/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/query-editor/
+---
+
+# MySQL alerting
+
+You can use Grafana Alerting with MySQL to create alerts based on your MySQL data. This allows you to monitor metrics, detect anomalies, and receive notifications when specific conditions are met.
+
+For general information about Grafana Alerting, refer to [Grafana Alerting](ref:alerting).
+
+## Before you begin
+
+Before creating alerts with MySQL, ensure you have:
+
+- A MySQL data source configured in Grafana.
+- Appropriate permissions to create alert rules.
+- Understanding of the metrics you want to monitor.
+
+## Supported query types
+
+MySQL alerting works with **time series queries** that return numeric data over time. Table formatted queries are not supported in alert rule conditions.
+
+To create a valid alert query:
+
+- Include a `time` column that returns a SQL datetime or UNIX epoch timestamp
+- Return numeric values for the metrics you want to alert on
+- Sort results by the time column
+
+For more information on writing time series queries, refer to [MySQL query editor](ref:mysql-query-editor).
+
+### Query format requirements
+
+| Query format | Alerting support | Notes                                    |
+| ------------ | ---------------- | ---------------------------------------- |
+| Time series  | Yes              | Required for alerting                    |
+| Table        | No               | Convert to time series format for alerts |
+
+## Create an alert rule
+
+To create an alert rule using MySQL:
+
+1. Navigate to **Alerting** > **Alert rules**.
+1. Click **New alert rule**.
+1. Enter a name for the alert rule.
+1. Select your **MySQL** data source.
+1. Build your query using the query editor:
+   - Set the **Format** to **Time series**
+   - Include a time column using the `$__time()` or `$__timeGroup()` macro
+   - Add numeric columns for the values to monitor
+   - Use `$__timeFilter()` to filter data by the dashboard time range
+1. Configure the alert condition (for example, when the average is above a threshold).
+1. Set the evaluation interval and pending period.
+1. Configure notifications and labels.
+1. Click **Save rule**.
+
+For detailed instructions, refer to [Create a Grafana-managed alert rule](ref:create-alert-rule).
+
+## Example alert queries
+
+The following examples show common alerting scenarios with MySQL.
+
+### Alert on high error count
+
+Monitor the number of errors over time:
+
+```sql
+SELECT
+  $__timeGroup(created_at, '1m') AS time,
+  COUNT(*) AS error_count
+FROM error_logs
+WHERE $__timeFilter(created_at)
+  AND level = 'error'
+GROUP BY time
+ORDER BY time
+```
+
+**Condition:** When error_count is above 100.
+
+### Alert on average response time
+
+Monitor API response times:
+
+```sql
+SELECT
+  $__timeGroup(request_time, '5m') AS time,
+  AVG(response_time_ms) AS avg_response_time
+FROM api_requests
+WHERE $__timeFilter(request_time)
+GROUP BY time
+ORDER BY time
+```
+
+**Condition:** When avg_response_time is above 500 (milliseconds).
+
+### Alert on low order volume
+
+Detect drops in order activity:
+
+```sql
+SELECT
+  $__timeGroup(order_date, '1h') AS time,
+  COUNT(*) AS order_count
+FROM orders
+WHERE $__timeFilter(order_date)
+GROUP BY time
+ORDER BY time
+```
+
+**Condition:** When order_count is below 10.
+
+### Alert on disk usage percentage
+
+Monitor database storage metrics:
+
+```sql
+SELECT
+  $__timeGroup(recorded_at, '5m') AS time,
+  AVG(disk_used_percent) AS disk_usage
+FROM system_metrics
+WHERE $__timeFilter(recorded_at)
+  AND metric_type = 'disk'
+GROUP BY time
+ORDER BY time
+```
+
+**Condition:** When disk_usage is above 85.
+
+## Limitations
+
+When using MySQL with Grafana Alerting, be aware of the following limitations:
+
+### Template variables not supported
+
+Alert queries cannot contain template variables. Grafana evaluates alert rules on the backend without dashboard context, so variables like `$hostname` or `$environment` won't be resolved.
+
+If your dashboard query uses template variables, create a separate query for alerting with hard coded values.
+
+### Table format not supported
+
+Queries using the **Table** format cannot be used for alerting. Set the query format to **Time series** and ensure your query returns a time column.
+
+### Query timeout
+
+Complex queries with large datasets may timeout during alert evaluation. Optimize queries for alerting by:
+
+- Adding appropriate `WHERE` clauses to limit data
+- Using indexes on time and filter columns
+- Reducing the time range evaluated
+
+## Best practices
+
+Follow these best practices when creating MySQL alerts:
+
+- **Use time series format:** Always set the query format to Time series for alert queries.
+- **Include time filters:** Use the `$__timeFilter()` macro to limit data to the evaluation window.
+- **Optimize queries:** Add indexes on columns used in `WHERE` clauses and `GROUP BY`.
+- **Test queries first:** Verify your query returns expected results in Explore before creating an alert.
+- **Set realistic thresholds:** Base alert thresholds on historical data patterns.
+- **Use meaningful names:** Give alert rules descriptive names that indicate what they monitor.

docs/sources/datasources/mysql/annotations/index.md

@@ -0,0 +1,163 @@
+---
+description: Using annotations with MySQL in Grafana
+keywords:
+  - grafana
+  - mysql
+  - annotations
+  - events
+labels:
+  products:
+    - cloud
+    - enterprise
+    - oss
+menuTitle: Annotations
+title: MySQL annotations
+weight: 340
+refs:
+  annotate-visualizations:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/build-dashboards/annotate-visualizations/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/build-dashboards/annotate-visualizations/
+---
+
+# MySQL annotations
+
+Annotations overlay event data on your dashboard graphs, helping you correlate events with metrics.
+You can use MySQL as a data source for annotations to display events such as deployments, alerts, or other significant occurrences on your visualizations.
+
+For general information about annotations, refer to [Annotate visualizations](ref:annotate-visualizations).
+
+## Before you begin
+
+Before creating MySQL annotations, ensure you have:
+
+- A MySQL data source configured in Grafana.
+- Tables containing event data with timestamp fields.
+- Read access to the tables containing your events.
+
+## Create an annotation query
+
+To add a MySQL annotation to your dashboard:
+
+1. Navigate to your dashboard and click **Dashboard settings** (gear icon).
+1. Select **Annotations** in the left menu.
+1. Click **Add annotation query**.
+1. Enter a **Name** for the annotation.
+1. Select your **MySQL** data source from the **Data source** drop-down.
+1. Write a SQL query that returns the required columns.
+1. Click **Save dashboard**.
+
+## Query columns
+
+Your annotation query must return a `time` column and can optionally include `timeend`, `text`, and `tags` columns.
+
+| Column    | Required | Description                                                                                   |
+| --------- | -------- | --------------------------------------------------------------------------------------------- |
+| `time`    | Yes      | The timestamp for the annotation. Can be a SQL datetime or UNIX epoch value.                  |
+| `timeend` | No       | The end timestamp for range annotations. Creates a shaded region instead of a vertical line.  |
+| `text`    | No       | The annotation description displayed when you hover over the annotation.                      |
+| `tags`    | No       | Tags for the annotation as a comma-separated string. Helps categorize and filter annotations. |
+
+## Example queries
+
+The following examples show common annotation query patterns.
+
+### Basic annotation with epoch time
+
+Display events using UNIX epoch timestamps:
+
+```sql
+SELECT
+  epoch_time as time,
+  description as text,
+  CONCAT(tag1, ',', tag2) as tags
+FROM events
+WHERE $__unixEpochFilter(epoch_time)
+```
+
+### Annotation with a single tag
+
+Display events with a single tag value:
+
+```sql
+SELECT
+  epoch_time as time,
+  message as text,
+  category as tags
+FROM event_log
+WHERE $__unixEpochFilter(epoch_time)
+```
+
+### Range annotation with start and end time
+
+Display events with duration as shaded regions:
+
+```sql
+SELECT
+  start_time as time,
+  end_time as timeend,
+  description as text,
+  CONCAT(type, ',', severity) as tags
+FROM incidents
+WHERE $__unixEpochFilter(start_time)
+```
+
+### Annotation with native SQL datetime
+
+Display events using native MySQL datetime columns:
+
+```sql
+SELECT
+  event_date as time,
+  message as text,
+  CONCAT(category, ',', priority) as tags
+FROM system_events
+WHERE $__timeFilter(event_date)
+```
+
+### Deployment annotations
+
+Display deployment events:
+
+```sql
+SELECT
+  deployed_at as time,
+  CONCAT('Deployed ', version, ' to ', environment) as text,
+  environment as tags
+FROM deployments
+WHERE $__timeFilter(deployed_at)
+```
+
+### Maintenance window annotations
+
+Display maintenance windows as range annotations:
+
+```sql
+SELECT
+  start_time as time,
+  end_time as timeend,
+  CONCAT('Maintenance: ', description) as text,
+  'maintenance' as tags
+FROM maintenance_windows
+WHERE $__timeFilter(start_time)
+```
+
+## Macros
+
+Use these macros in your annotation queries to filter by the dashboard time range:
+
+| Macro                        | Description                                                      |
+| ---------------------------- | ---------------------------------------------------------------- |
+| `$__timeFilter(column)`      | Filters by time range using a native SQL datetime column.        |
+| `$__unixEpochFilter(column)` | Filters by time range using a column with UNIX epoch timestamps. |
+
+## Best practices
+
+Follow these best practices when creating MySQL annotations:
+
+- **Use time filters:** Always include `$__timeFilter()` or `$__unixEpochFilter()` to limit results to the dashboard time range.
+- **Keep queries efficient:** Add indexes on time columns and filter columns to improve query performance.
+- **Use meaningful text:** Include descriptive information in the `text` column to make annotations useful.
+- **Organize with tags:** Use consistent tag values to categorize annotations and enable filtering.
+- **Test queries first:** Verify your query returns expected results in Explore before adding it as an annotation.

docs/sources/datasources/mysql/configure/_index.md

@@ -1,4 +1,6 @@
 ---
+aliases:
+  - ../configuration/
 description: This document provides instructions for configuring the MySQL data source and explains available configuration options.
 keywords:
   - grafana
@@ -10,7 +12,7 @@ labels:
     - cloud
     - enterprise
     - oss
-menuTitle: Configure the MySQL data source
+menuTitle: Configure
 title: Configure the MySQL data source
 weight: 10
 refs:
@@ -34,6 +36,41 @@ refs:
       destination: /docs/grafana/<GRAFANA_VERSION>/administration/data-source-management/
     - pattern: /docs/grafana-cloud/
       destination: /docs/grafana/<GRAFANA_VERSION>/administration/data-source-management/
+  mysql-query-editor:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/query-editor/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/query-editor/
+  annotate-visualizations:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/build-dashboards/annotate-visualizations/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana-cloud/visualizations/dashboards/build-dashboards/annotate-visualizations/
+  alerting:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/alerting/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana-cloud/alerting-and-irm/alerting/
+  mysql-alerting:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/alerting/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/alerting/
+  mysql-annotations:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/annotations/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/annotations/
+  mysql-troubleshoot:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/troubleshooting/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/troubleshooting/
+  mysql-template-variables:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/template-variables/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/template-variables/
 ---
 
 # Configure the MySQL data source
@@ -42,24 +79,35 @@ This document provides instructions for configuring the MySQL data source and ex
 
 ## Before you begin
 
-You must have the `Organization administrator` role in order to configure the MySQL data source.
-Administrators can also [configure the data source via YAML](#provision-the-data-source) with Grafana's provisioning system.
+Before configuring the MySQL data source, ensure you have the following:
+
+- **Grafana permissions:** You must have the `Organization administrator` role to configure data sources. Organization administrators can also [configure the data source via YAML](#provision-the-data-source) with the Grafana provisioning system.
+
+- **A running MySQL instance:** MySQL 5.7 or newer, MariaDB 10.2 or newer, or a compatible MySQL-based database such as Percona Server.
+
+- **Network access:** Grafana must be able to reach your MySQL server. The default port is `3306`.
+
+- **Authentication credentials:** A MySQL user with at least `SELECT` permissions on the databases and tables you want to query.
+
+- **Security certificates:** If using encrypted connections, gather any necessary TLS/SSL certificates.
 
 {{< admonition type="note" >}}
-Grafana ships with the MySQL data source by default, so no additional installation is required.
+Grafana ships with a built-in MySQL data source plugin. No additional installation is required.
 {{< /admonition >}}
 
-{{< admonition type="caution" >}}
-When adding a data source, ensure the database user you specify has only `SELECT` permissions on the relevant database and tables. Grafana does not validate the safety of queries, which means they can include potentially harmful SQL statements, such as `USE otherdb;` or `DROP TABLE user;`, which could get executed.
-
-To minimize this risk, Grafana strongly recommends creating a dedicated MySQL user with restricted permissions.
+{{< admonition type="tip" >}}
+**Grafana Cloud users:** If your MySQL server is in a private network, you can configure [Private data source connect](https://grafana.com/docs/grafana-cloud/connect-externally-hosted/private-data-source-connect/) to establish connectivity.
 {{< /admonition >}}
 
-Example:
+### Database user permissions
+
+When adding a data source, ensure the database user you specify has only `SELECT` permissions on the relevant database and tables. Grafana doesn't validate the safety of queries, which means they can include potentially harmful SQL statements, such as `USE otherdb;` or `DROP TABLE user;`, which could get executed.
+
+To minimize this risk, Grafana strongly recommends creating a dedicated MySQL user with restricted permissions:
 
 ```sql
- CREATE USER 'grafanaReader' IDENTIFIED BY 'password';
- GRANT SELECT ON mydatabase.mytable TO 'grafanaReader';
+CREATE USER 'grafanaReader' IDENTIFIED BY 'password';
+GRANT SELECT ON mydatabase.mytable TO 'grafanaReader';
 ```
 
 Use wildcards (`*`) in place of a database or table if you want to grant access to more databases and tables.
@@ -213,3 +261,46 @@ datasources:
       tlsClientCert: ${GRAFANA_TLS_CLIENT_CERT}
       tlsCACert: ${GRAFANA_TLS_CA_CERT}
 ```
+
+## Configure with Terraform
+
+You can configure the MySQL data source using [Terraform](https://www.terraform.io/) with the [Grafana Terraform provider](https://registry.terraform.io/providers/grafana/grafana/latest/docs).
+
+For more information about provisioning resources with Terraform, refer to the [Grafana as code using Terraform](https://grafana.com/docs/grafana-cloud/developer-resources/infrastructure-as-code/terraform/) documentation.
+
+### Terraform example
+
+The following example creates a basic MySQL data source:
+
+```hcl
+resource "grafana_data_source" "mysql" {
+  name = "MySQL"
+  type = "mysql"
+  url  = "localhost:3306"
+  user = "grafana"
+
+  json_data_encoded = jsonencode({
+    database         = "grafana"
+    maxOpenConns     = 100
+    maxIdleConns     = 100
+    maxIdleConnsAuto = true
+    connMaxLifetime  = 14400
+  })
+
+  secure_json_data_encoded = jsonencode({
+    password = "password"
+  })
+}
+```
+
+For all available configuration options, refer to the [Grafana provider data source resource documentation](https://registry.terraform.io/providers/grafana/grafana/latest/docs/resources/data_source).
+
+## Next steps
+
+After configuring your MySQL data source, you can:
+
+- [Write queries](ref:mysql-query-editor) using the query editor to explore and visualize your data.
+- [Use template variables](ref:mysql-template-variables) to create dynamic, reusable dashboards.
+- [Add annotations](ref:mysql-annotations) to overlay MySQL events on your graphs.
+- [Set up alerting](ref:mysql-alerting) to create alert rules based on your MySQL data.
+- [Troubleshoot issues](ref:mysql-troubleshoot) if you encounter problems with your data source.

docs/sources/datasources/mysql/query-editor/_index.md

@@ -9,7 +9,7 @@ labels:
     - cloud
     - enterprise
     - oss
-menuTitle: MySQL query editor
+menuTitle: Query editor
 title: MySQL query editor
 weight: 30
 refs:
@@ -61,6 +61,21 @@ refs:
   configure-standard-options:
     - pattern: /docs/grafana/
     - destination: /docs/grafana/<GRAFANA_VERSION>/panels-visualizations/configure-standard-options/
+  mysql-template-variables:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/template-variables/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/template-variables/
+  mysql-alerting:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/alerting/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/alerting/
+  mysql-annotations:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/annotations/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/annotations/
 ---
 
 # MySQL query editor
@@ -305,171 +320,20 @@ Table panel result:
 
 The query returns multiple columns representing minimum and maximum values within the defined range.
 
-## Templating
+## Template variables
 
-Instead of hardcoding values like server, application, or sensor names in your metric queries, you can use variables. Variables appear as drop-down select boxes at the top of the dashboard. These drop-downs make it easy to change the data being displayed in your dashboard.
+Instead of hard-coding values like server, application, or sensor names in your metric queries, you can use variables. Variables appear as drop-down select boxes at the top of the dashboard, making it easy to change the data displayed in your dashboard.
 
-Refer to [Templates](ref:variables) for an introduction to creating template variables as well as the different types.
-
-### Query variable
-
-If you add a `Query` template variable you can write a MySQL query to retrieve items such as measurement names, key names, or key values, which will be displayed in the drop-down menu.
-
-For example, you can use a variable to retrieve all the values from the `hostname` column in a table by creating the following query in the templating variable _Query_ setting.
-
-```sql
-SELECT hostname FROM my_host
-```
-
-A query can return multiple columns, and Grafana will automatically generate a list based on the query results. For example, the following query returns a list with values from `hostname` and `hostname2`.
-
-```sql
-SELECT my_host.hostname, my_other_host.hostname2 FROM my_host JOIN my_other_host ON my_host.city = my_other_host.city
-```
-
-To use time range dependent macros like `$__timeFilter(column)` in your query,you must set the template variable's refresh mode to _On Time Range Change_.
-
-```sql
-SELECT event_name FROM event_log WHERE $__timeFilter(time_column)
-```
-
-Another option is a query that can create a key/value variable. The query should return two columns that are named `__text` and `__value`. The `__text` column must contain unique values (if not, only the first value is used). This allows the drop-down options to display a text-friendly name as the text while using an ID as the value. For example, a query could use `hostname` as the text and `id` as the value:
-
-```sql
-SELECT hostname AS __text, id AS __value FROM my_host
-```
-
-You can also create nested variables. For example, if you have a variable named `region`, you can configure the `hosts` variable to display only the hosts within the currently selected region as shown in the following example. If `region` is a multi-value variable, use the `IN` operator instead of `=` to match multiple values.
-
-```sql
-SELECT hostname FROM my_host  WHERE region IN($region)
-```
-
-#### Use `__searchFilter` to filter results in a query variable
-
-Using `__searchFilter` in the query field allows the query results to be filtered based on the user’s input in the drop-down selection box. If you do not enter anything, the default value for `__searchFilter` is %
-
-Note that you must enclose the `__searchFilter` expression in quotes as Grafana does not add them automatically.
-
-The following example demonstrates how to use `__searchFilter` in the query field to enable real-time searching for `hostname` as the user type in the drop-down selection box.
-
-```sql
-SELECT hostname FROM my_host  WHERE hostname LIKE '$__searchFilter'
-```
-
-### Using variables in queries
-
-Template variable values are only quoted when the template variable is a `multi-value`.
-
-If the variable is a multi-value variable, use the `IN` comparison operator instead of `=` to match against multiple values.
-
-You can use two different syntaxes:
-
-`$<varname>` Example with a template variable named `hostname`:
-
-```sql
-SELECT
-  UNIX_TIMESTAMP(atimestamp) as time,
-  aint as value,
-  avarchar as metric
-FROM my_table
-WHERE $__timeFilter(atimestamp) and hostname in($hostname)
-ORDER BY atimestamp ASC
-```
-
-`[[varname]]` Example with a template variable named `hostname`:
-
-```sql
-SELECT
-  UNIX_TIMESTAMP(atimestamp) as time,
-  aint as value,
-  avarchar as metric
-FROM my_table
-WHERE $__timeFilter(atimestamp) and hostname in([[hostname]])
-ORDER BY atimestamp ASC
-```
-
-#### Disabling quoting for multi-value variables
-
-Grafana automatically creates a quoted, comma-separated string for multi-value variables. For example: if `server01` and `server02` are selected then it will be formatted as: `'server01', 'server02'`. To disable quoting, use the csv formatting option for variables:
-
-Grafana automatically formats multi-value variables as a quoted, comma-separated string. For example, if `server01` and `server02` are selected, they are formatted as `'server01'`, `'server02'`. To remove the quotes, enable the CSV formatting option for the variables.
-
-`${servers:csv}`
-
-Read more about variable formatting options in the [Variables](ref:variable-syntax-advanced-variable-format-options) documentation.
+For detailed information on using template variables with MySQL, refer to [MySQL template variables](ref:mysql-template-variables).
 
 ## Annotations
 
-[Annotations](ref:annotate-visualizations) allow you to overlay rich event information on top of graphs. You add annotation queries via the **Dashboard settings > Annotations view**.
+Annotations allow you to overlay event information on your graphs, helping you correlate events with metrics. You can write SQL queries that return event data to display as annotations on your dashboards.
 
-**Example query using a`time` column with epoch values:**
-
-```sql
-SELECT
-  epoch_time as time,
-  metric1 as text,
-  CONCAT(tag1, ',', tag2) as tags
-FROM
-  public.test_data
-WHERE
-  $__unixEpochFilter(epoch_time)
-```
-
-You may use one or more tags to show them as annotations in a common-separate string.
-
-**Example query using a `time` column with epoch values for a single tag:**
-
-```sql
-SELECT
-  epoch_time as time,
-  metric1 as text,
-  tag1 as tag
-FROM
-  my_data
-WHERE
-  $__unixEpochFilter(epoch_time)
-```
-
-**Example region query using `time` and `timeend` columns with epoch values:**
-
-```sql
-SELECT
-  epoch_time as time,
-  epoch_timeend as timeend,
-  metric1 as text,
-  CONCAT(tag1, ',', tag2) as tags
-FROM
-  public.test_data
-WHERE
-  $__unixEpochFilter(epoch_time)
-```
-
-**Example query using a `time` column with a native SQL date/time data type:**
-
-```sql
-SELECT
-  native_date_time as time,
-  metric1 as text,
-  CONCAT(tag1, ',', tag2) as tags
-FROM
-  public.test_data
-WHERE
-  $__timeFilter(native_date_time)
-```
-
-| Name      | Description                                                                                                           |
-| --------- | --------------------------------------------------------------------------------------------------------------------- |
-| `time`    | The name of the date/time field, which can be a column with a native SQL date/time data type or epoch value.          |
-| `timeend` | Optional name of the end date/time field, which can be a column with a native SQL date/time data type or epoch value. |
-| `text`    | Event description field.                                                                                              |
-| `tags`    | Optional field name to use for event tags as a comma separated string.                                                |
+For detailed information on creating annotations with MySQL, refer to [MySQL annotations](ref:mysql-annotations).
 
 ## Alerting
 
-Use time series queries to create alerts. Table formatted queries aren't yet supported in alert rule conditions.
+You can use time series queries to create Grafana-managed alert rules. Table formatted queries are not supported in alert rule conditions.
 
-For more information regarding alerting refer to the following:
-
-- [Alert rules](ref:alert-rules)
-- [Template annotations and labels](ref:template-annotations-and-labels)
+For detailed information on creating alerts with MySQL, refer to [MySQL alerting](ref:mysql-alerting).

docs/sources/datasources/mysql/template-variables/index.md

@@ -0,0 +1,146 @@
+---
+description: Using template variables with MySQL in Grafana
+keywords:
+  - grafana
+  - mysql
+  - templates
+  - variables
+  - queries
+labels:
+  products:
+    - cloud
+    - enterprise
+    - oss
+menuTitle: Template variables
+title: MySQL template variables
+weight: 300
+refs:
+  variables:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/variables/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/variables/
+  variable-syntax-advanced-variable-format-options:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/variables/variable-syntax/#advanced-variable-format-options
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/variables/variable-syntax/#advanced-variable-format-options
+  add-template-variables:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/variables/add-template-variables/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/variables/add-template-variables/
+---
+
+# MySQL template variables
+
+Instead of hard-coding details such as server, application, and sensor names in metric queries, you can use variables.
+Grafana displays these variables in drop-down select boxes at the top of the dashboard to help you change the data displayed in your dashboard.
+Grafana refers to such variables as **template variables**.
+
+For an introduction to templating and template variables, refer to [Templating](ref:variables) and [Add and manage variables](ref:add-template-variables).
+
+## Query variable
+
+A query variable in Grafana dynamically retrieves values from your data source using a query. With a query variable, you can write a SQL query that returns values such as measurement names, key names, or key values that are shown in a drop-down select box.
+
+For example, the following query returns all values from the `hostname` column:
+
+```sql
+SELECT hostname FROM my_host
+```
+
+A query can return multiple columns, and Grafana automatically generates a list using the values from those columns. For example, the following query returns values from both the `hostname` and `hostname2` columns, which are included in the variable's drop-down list.
+
+```sql
+SELECT my_host.hostname, my_other_host.hostname2 FROM my_host JOIN my_other_host ON my_host.city = my_other_host.city
+```
+
+To use time range dependent macros like `$__timeFilter(column)` in your query, you must set the template variable's refresh mode to **On Time Range Change**.
+
+```sql
+SELECT event_name FROM event_log WHERE $__timeFilter(time_column)
+```
+
+### Key/value variables
+
+You can create a key/value variable using a query that returns two columns named `__text` and `__value`.
+
+- The `__text` column defines the label shown in the drop-down.
+- The `__value` column defines the value passed to panel queries.
+
+This is useful when you want to display a user-friendly label (like a hostname) but use a different underlying value (like an ID).
+
+Note that the values in the `__text` column should be unique. If there are duplicates, Grafana uses only the first matching entry.
+
+```sql
+SELECT hostname AS __text, id AS __value FROM my_host
+```
+
+### Nested variables
+
+You can create nested variables, where one variable depends on the value of another. For example, if you have a variable named `region`, you can configure a `hosts` variable to only show hosts from the selected region. If `region` is a multi-value variable, use the `IN` operator instead of `=` to match against multiple selected values.
+
+```sql
+SELECT hostname FROM my_host WHERE region IN($region)
+```
+
+### Filter results with `__searchFilter`
+
+Using `__searchFilter` in the query field allows the query results to be filtered based on the user's input in the drop-down selection box. If you don't enter anything, the default value for `__searchFilter` is `%`.
+
+Note that you must enclose the `__searchFilter` expression in quotes as Grafana doesn't add them automatically.
+
+The following example demonstrates how to use `__searchFilter` in the query field to enable real-time searching for `hostname` as the user types in the drop-down selection box.
+
+```sql
+SELECT hostname FROM my_host WHERE hostname LIKE '$__searchFilter'
+```
+
+## Use variables in queries
+
+Grafana automatically quotes template variable values only when the template variable is a `multi-value`.
+
+When using a multi-value variable, use the `IN` comparison operator instead of `=` to match against multiple values.
+
+Grafana supports two syntaxes for using variables in queries:
+
+- **`$<varname>` syntax**
+
+Example with a template variable named `hostname`:
+
+```sql
+SELECT
+  UNIX_TIMESTAMP(atimestamp) as time,
+  aint as value,
+  avarchar as metric
+FROM my_table
+WHERE $__timeFilter(atimestamp) and hostname in($hostname)
+ORDER BY atimestamp ASC
+```
+
+- **`[[varname]]` syntax**
+
+Example with a template variable named `hostname`:
+
+```sql
+SELECT
+  UNIX_TIMESTAMP(atimestamp) as time,
+  aint as value,
+  avarchar as metric
+FROM my_table
+WHERE $__timeFilter(atimestamp) and hostname in([[hostname]])
+ORDER BY atimestamp ASC
+```
+
+### Disable quoting for multi-value variables
+
+By default, Grafana formats multi-value variables as a quoted, comma-separated string. For example, if `server01` and `server02` are selected, the result will be `'server01'`, `'server02'`. To disable quoting, use the `csv` formatting option for variables:
+
+```text
+${servers:csv}
+```
+
+This outputs the values as an unquoted comma-separated list.
+
+Refer to [Advanced variable format options](ref:variable-syntax-advanced-variable-format-options) for additional information.

docs/sources/datasources/mysql/troubleshoot/index.md

@@ -1,80 +0,0 @@
----
-description: Learn how to troubleshoot common problems with the Grafana MySQL data source plugin
-keywords:
-  - grafana
-  - mysql
-  - query
-labels:
-  products:
-    - cloud
-    - enterprise
-    - oss
-menuTitle: Troubleshoot
-title: Troubleshoot common problems with the Grafana MySQL data source plugin
-weight: 40
-refs:
-  variables:
-    - pattern: /docs/grafana/
-      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/variables/
-    - pattern: /docs/grafana-cloud/
-      destination: /docs/grafana-cloud/visualizations/dashboards/variables/
-  variable-syntax-advanced-variable-format-options:
-    - pattern: /docs/grafana/
-      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/variables/variable-syntax/#advanced-variable-format-options
-    - pattern: /docs/grafana-cloud/
-      destination: /docs/grafana-cloud/visualizations/dashboards/variables/variable-syntax/#advanced-variable-format-options
-  annotate-visualizations:
-    - pattern: /docs/grafana/
-      destination: /docs/grafana/<GRAFANA_VERSION>/dashboards/build-dashboards/annotate-visualizations/
-    - pattern: /docs/grafana-cloud/
-      destination: /docs/grafana-cloud/visualizations/dashboards/build-dashboards/annotate-visualizations/
-  explore:
-    - pattern: /docs/grafana/
-      destination: /docs/grafana/<GRAFANA_VERSION>/explore/
-    - pattern: /docs/grafana-cloud/
-      destination: /docs/grafana/<GRAFANA_VERSION>/explore/
-  query-transform-data:
-    - pattern: /docs/grafana/
-      destination: /docs/grafana/<GRAFANA_VERSION>/panels-visualizations/query-transform-data/
-    - pattern: /docs/grafana-cloud/
-      destination: /docs/grafana-cloud/visualizations/panels-visualizations/query-transform-data/
-  panel-inspector:
-    - pattern: /docs/grafana/
-      destination: /docs/grafana/<GRAFANA_VERSION>/panels-visualizations/panel-inspector/
-    - pattern: /docs/grafana-cloud/
-      destination: /docs/grafana-cloud/visualizations/panels-visualizations/panel-inspector/
-  query-editor:
-    - pattern: /docs/grafana/
-      destination: /docs/grafana/<GRAFANA_VERSION>/panels-visualizations/query-transform-data/#query-editors
-    - pattern: /docs/grafana-cloud/
-      destination: /docs/grafana-cloud/visualizations/panels-visualizations/query-transform-data/#query-editors
-  alert-rules:
-    - pattern: /docs/grafana/
-      destination: /docs/grafana/<GRAFANA_VERSION>/alerting/fundamentals/alert-rules/
-    - pattern: /docs/grafana-cloud/
-      destination: /docs/grafana-cloud/alerting-and-irm/alerting/alerting-rules/
-  template-annotations-and-labels:
-    - pattern: /docs/grafana/
-      destination: /docs/grafana/<GRAFANA_VERSION>/alerting/alerting-rules/templates/
-    - pattern: /docs/grafana-cloud/
-      destination: /docs/grafana-cloud/alerting-and-irm/alerting/alerting-rules/templates/
-  configure-standard-options:
-    - pattern: /docs/grafana/
-    - destination: /docs/grafana/<GRAFANA_VERSION>/panels-visualizations/configure-standard-options/
----
-
-# Troubleshoot common problems with the Grafana MySQL data source plugin
-
-This page lists common issues you might experience when setting up the Grafana MySQL data source plugin.
-
-### My data source connection fails when using the Grafana MySQL data source plugin
-
-- Check if the MySQL server is up and running.
-- Make sure that your firewall is open for MySQL server (default port is `3306`).
-- Ensure that you have the correct permissions to access the MySQL server and also have permission to access the database.
-- If the error persists, create a new user for the Grafana MySQL data source plugin with correct permissions and try to connect with it.
-
-### What should I do if I see "An unexpected error happened" or "Could not connect to MySQL" after trying all of the above?
-
-- Check the Grafana logs for more details about the error.
-- For Grafana Cloud customers, contact support.

docs/sources/datasources/mysql/troubleshooting/index.md

@@ -0,0 +1,370 @@
+---
+aliases:
+  - ../troubleshoot/
+description: Troubleshoot common problems with the MySQL data source in Grafana
+keywords:
+  - grafana
+  - mysql
+  - troubleshooting
+  - errors
+labels:
+  products:
+    - cloud
+    - enterprise
+    - oss
+menuTitle: Troubleshooting
+title: Troubleshoot MySQL data source issues
+weight: 400
+refs:
+  configure-mysql-data-source:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/configure/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/configure/
+  mysql-query-editor:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/query-editor/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana/<GRAFANA_VERSION>/datasources/mysql/query-editor/
+  private-data-source-connect:
+    - pattern: /docs/grafana/
+      destination: /docs/grafana-cloud/connect-externally-hosted/private-data-source-connect/
+    - pattern: /docs/grafana-cloud/
+      destination: /docs/grafana-cloud/connect-externally-hosted/private-data-source-connect/
+---
+
+# Troubleshoot MySQL data source issues
+
+This document provides solutions to common issues you may encounter when configuring or using the MySQL data source in Grafana.
+
+## Connection errors
+
+These errors occur when Grafana cannot establish or maintain a connection to the MySQL server.
+
+### Unable to connect to the server
+
+**Error message:** "dial tcp: connection refused" or "Could not connect to MySQL"
+
+**Cause:** Grafana cannot establish a network connection to the MySQL server.
+
+**Solution:**
+
+1. Verify that the MySQL server is running and accessible.
+1. Check that the host and port are correct in the data source configuration. The default MySQL port is `3306`.
+1. Ensure there are no firewall rules blocking the connection between Grafana and MySQL.
+1. Verify that MySQL is configured to allow remote connections by checking the `bind-address` setting in your MySQL configuration.
+1. For Grafana Cloud, ensure you have configured [Private data source connect](ref:private-data-source-connect) if your MySQL instance isn't publicly accessible.
+
+### Connection timeout
+
+**Error message:** "Connection timed out" or "I/O timeout"
+
+**Cause:** The connection to MySQL timed out before receiving a response.
+
+**Solution:**
+
+1. Check the network latency between Grafana and MySQL.
+1. Verify that MySQL isn't overloaded or experiencing performance issues.
+1. Check if any network devices (load balancers, proxies) are timing out the connection.
+1. Increase the `wait_timeout` setting in MySQL if connections are timing out during idle periods.
+
+### TLS/SSL connection failures
+
+**Error message:** "TLS handshake failed" or "x509: certificate verify failed"
+
+**Cause:** There is a mismatch between the TLS settings in Grafana and what the MySQL server supports or requires.
+
+**Solution:**
+
+1. Verify that the MySQL server has a valid SSL certificate if encryption is enabled.
+1. Check that the certificate is trusted by the Grafana server.
+1. If using a self-signed certificate, enable **With CA Cert** and provide the root certificate under **TLS/SSL Root Certificate**.
+1. To bypass certificate validation (not recommended for production), enable **Skip TLS Verification** in the data source configuration.
+1. Ensure the SSL certificate hasn't expired.
+
+### Connection reset by peer
+
+**Error message:** "Connection reset by peer" or "EOF"
+
+**Cause:** The MySQL server closed the connection unexpectedly.
+
+**Solution:**
+
+1. Check the `max_connections` setting on the MySQL server to ensure it isn't being exceeded.
+1. Verify the `wait_timeout` and `interactive_timeout` settings in MySQL aren't set too low.
+1. Increase the **Max lifetime** setting in Grafana's data source configuration to be lower than MySQL's `wait_timeout`.
+1. Check MySQL server logs for any errors or connection-related messages.
+
+## Authentication errors
+
+These errors occur when there are issues with authentication credentials or permissions.
+
+### Access denied for user
+
+**Error message:** "Access denied for user 'username'@'host'" or "Authentication failed"
+
+**Cause:** The authentication credentials are invalid or the user doesn't have permission to connect from the Grafana server's host.
+
+**Solution:**
+
+1. Verify that the username and password are correct.
+1. Check that the user exists in MySQL and is enabled.
+1. Ensure the user has permission to connect from the Grafana server's IP address. MySQL restricts access based on the connecting host:
+
+   ```sql
+   SELECT user, host FROM mysql.user WHERE user = 'your_user';
+   ```
+
+1. If necessary, create a user that can connect from the Grafana server:
+
+   ```sql
+   CREATE USER 'grafana'@'grafana_server_ip' IDENTIFIED BY 'password';
+   ```
+
+1. If using the `mysql_native_password` authentication plugin, ensure it's enabled on the server.
+
+### Cannot access database
+
+**Error message:** "Access denied for user 'username'@'host' to database 'dbname'"
+
+**Cause:** The authenticated user doesn't have permission to access the specified database.
+
+**Solution:**
+
+1. Verify that the database name is correct in the data source configuration.
+1. Ensure the user has the required permissions on the database:
+
+   ```sql
+   GRANT SELECT ON your_database.* TO 'grafana'@'grafana_server_ip';
+   FLUSH PRIVILEGES;
+   ```
+
+1. For production environments, grant permissions only on specific tables:
+
+   ```sql
+   GRANT SELECT ON your_database.your_table TO 'grafana'@'grafana_server_ip';
+   ```
+
+### PAM authentication issues
+
+**Error message:** "Authentication plugin 'auth_pam' cannot be loaded" or cleartext password errors
+
+**Cause:** PAM (Pluggable Authentication Modules) authentication requires cleartext password transmission.
+
+**Solution:**
+
+1. Enable **Allow Cleartext Passwords** in the data source configuration if using PAM authentication.
+1. Ensure TLS is enabled to protect password transmission when using cleartext passwords.
+1. Verify that the PAM plugin is correctly installed and configured on the MySQL server.
+
+## Query errors
+
+These errors occur when there are issues with query syntax or configuration.
+
+### Time column not found or invalid
+
+**Error message:** "Could not find time column" or time series visualization shows no data
+
+**Cause:** The query doesn't return a properly formatted `time` column for time series visualization.
+
+**Solution:**
+
+1. Ensure your query includes a column named `time` when using the **Time series** format.
+1. Use the `$__time()` macro to convert your date column: `$__time(your_date_column)`.
+1. Verify the time column is of a valid MySQL date/time type (`DATETIME`, `TIMESTAMP`, `DATE`) or contains Unix epoch values.
+1. Ensure the result set is sorted by the time column using `ORDER BY`.
+
+### Macro expansion errors
+
+**Error message:** "Error parsing query" or macros appear unexpanded in the query
+
+**Cause:** Grafana macros are being used incorrectly.
+
+**Solution:**
+
+1. Verify macro syntax: use `$__timeFilter(column)` not `$_timeFilter(column)`.
+1. Check that the column name passed to macros exists in your table.
+1. View the expanded query by clicking **Generated SQL** after running the query to debug macro expansion.
+1. Ensure backticks are used for reserved words or special characters in column names: `$__timeFilter(\`time-column\`)`.
+
+### Timezone and time shift issues
+
+**Cause:** Time series data appears shifted or doesn't align with expected times.
+
+**Solution:**
+
+1. Store timestamps in UTC in your database to avoid timezone issues.
+1. Time macros (`$__time`, `$__timeFilter`, etc.) always expand to UTC values.
+1. Set the **Session Timezone** in the data source configuration to match your data's timezone, or use `+00:00` for UTC.
+1. If your timestamps are stored in local time, convert them to UTC in your query:
+
+   ```sql
+   SELECT
+     CONVERT_TZ(your_datetime_column, 'Your/Timezone', 'UTC') AS time,
+     value
+   FROM your_table
+   ```
+
+### Query returns too many rows
+
+**Error message:** "Result set too large" or browser becomes unresponsive
+
+**Cause:** The query returns more data than can be efficiently processed.
+
+**Solution:**
+
+1. Add time filters using `$__timeFilter(column)` to limit data to the dashboard time range.
+1. Use aggregations (`AVG`, `SUM`, `COUNT`) with `GROUP BY` instead of returning raw rows.
+1. Add a `LIMIT` clause to restrict results: `SELECT ... LIMIT 1000`.
+1. Use the `$__timeGroup()` macro to aggregate data into time intervals.
+
+### Syntax error in SQL statement
+
+**Error message:** "You have an error in your SQL syntax" followed by specific error details
+
+**Cause:** The SQL query contains invalid syntax.
+
+**Solution:**
+
+1. Check for missing or extra commas, parentheses, or quotes.
+1. Ensure reserved words used as identifiers are enclosed in backticks: `` `table` ``, `` `select` ``.
+1. Verify that template variable syntax is correct: `$variable` or `${variable}`.
+1. Test the query directly in a MySQL client to isolate Grafana-specific issues.
+
+### Unknown column in field list
+
+**Error message:** "Unknown column 'column_name' in 'field list'"
+
+**Cause:** The specified column doesn't exist in the table or is misspelled.
+
+**Solution:**
+
+1. Verify the column name is spelled correctly.
+1. Check that the column exists in the specified table.
+1. If the column name contains special characters or spaces, enclose it in backticks: `` `column-name` ``.
+1. Ensure the correct database is selected if you're referencing columns without the full table path.
+
+## Performance issues
+
+These issues relate to slow queries or high resource usage.
+
+### Slow query execution
+
+**Cause:** Queries take a long time to execute.
+
+**Solution:**
+
+1. Reduce the dashboard time range to limit data volume.
+1. Add indexes to columns used in `WHERE` clauses and time filters:
+
+   ```sql
+   CREATE INDEX idx_time ON your_table(time_column);
+   ```
+
+1. Use aggregations instead of returning individual rows.
+1. Increase the **Min time interval** setting to reduce the number of data points.
+1. Review the query execution plan using `EXPLAIN` to identify bottlenecks:
+
+   ```sql
+   EXPLAIN SELECT * FROM your_table WHERE time_column > NOW() - INTERVAL 1 HOUR;
+   ```
+
+### Connection pool exhaustion
+
+**Error message:** "Too many connections" or "Connection pool exhausted"
+
+**Cause:** Too many concurrent connections to the database.
+
+**Solution:**
+
+1. Increase the **Max open** connection limit in the data source configuration.
+1. Enable **Auto (max idle)** to automatically manage idle connections.
+1. Reduce the number of panels querying the same data source simultaneously.
+1. Check for long-running queries that might be holding connections.
+1. Increase the `max_connections` setting in MySQL if necessary:
+
+   ```sql
+   SHOW VARIABLES LIKE 'max_connections';
+   SET GLOBAL max_connections = 200;
+   ```
+
+### Query timeout
+
+**Error message:** "Query execution was interrupted" or "Lock wait timeout exceeded"
+
+**Cause:** The query takes too long and exceeds the configured timeout.
+
+**Solution:**
+
+1. Optimize the query by adding appropriate indexes.
+1. Reduce the amount of data being queried by narrowing the time range.
+1. Use aggregations to reduce the result set size.
+1. Check for table locks that might be blocking the query.
+
+## Other common issues
+
+The following issues don't produce specific error messages but are commonly encountered.
+
+### Template variable queries fail
+
+**Cause:** Variable queries return unexpected results or errors.
+
+**Solution:**
+
+1. Verify the variable query syntax is valid SQL that returns a single column.
+1. Check that the data source connection is working.
+1. Ensure the user has permission to access the tables referenced in the variable query.
+1. Test the query in the query editor before using it as a variable query.
+
+### Data appears incorrect or misaligned
+
+**Cause:** Data formatting or type conversion issues.
+
+**Solution:**
+
+1. Use explicit column aliases to ensure consistent naming: `SELECT value AS metric`.
+1. Verify numeric columns are actually numeric types, not strings.
+1. Check for `NULL` values that might affect aggregations.
+1. Use the `FILL` option in `$__timeGroup()` macro to handle missing data points.
+
+### Special characters in database or table names
+
+**Cause:** Queries fail when tables or databases contain reserved words or special characters.
+
+**Solution:**
+
+1. Enclose identifiers with special characters in backticks: `` `my-database`.`my-table` ``.
+1. The query editor automatically handles this for selections, but manual queries require backticks.
+1. Avoid using reserved words as identifiers when possible.
+
+### An unexpected error happened
+
+**Error message:** "An unexpected error happened"
+
+**Cause:** A general error occurred that doesn't have a specific error message.
+
+**Solution:**
+
+1. Check the Grafana server logs for more details about the error.
+1. Verify all data source configuration settings are correct.
+1. Test the connection using the **Save & test** button.
+1. Ensure the MySQL server is accessible and responding to queries.
+1. For Grafana Cloud customers, contact support for assistance.
+
+## Get additional help
+
+If you continue to experience issues after following this troubleshooting guide:
+
+1. Check the [Grafana community forums](https://community.grafana.com/) for similar issues.
+1. Review the [Grafana GitHub issues](https://github.com/grafana/grafana/issues) for known bugs.
+1. Enable debug logging in Grafana to capture detailed error information.
+1. Check MySQL error logs for additional details.
+1. Contact Grafana Support if you're an Enterprise or Cloud customer.
+
+When reporting issues, include:
+
+- Grafana version
+- MySQL version
+- Error messages (redact sensitive information)
+- Steps to reproduce
+- Relevant query examples (redact sensitive data)

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

@@ -695,6 +695,10 @@ export interface FeatureToggles {
   */
   passwordlessMagicLinkAuthentication?: boolean;
   /**
+  * Display Related Logs in Grafana Metrics Drilldown
+  */
+  exploreMetricsRelatedLogs?: boolean;
+  /**
   * Adds support for quotes and special characters in label values for Prometheus queries
   */
   prometheusSpecialCharsInLabelValues?: boolean;

pkg/services/featuremgmt/registry.go

@@ -1148,6 +1148,14 @@ var (
 			Owner:        identityAccessTeam,
 			HideFromDocs: true,
 		},
+		{
+			Name:         "exploreMetricsRelatedLogs",
+			Description:  "Display Related Logs in Grafana Metrics Drilldown",
+			Stage:        FeatureStageExperimental,
+			Owner:        grafanaObservabilityMetricsSquad,
+			FrontendOnly: true,
+			HideFromDocs: false,
+		},
 		{
 			Name:         "prometheusSpecialCharsInLabelValues",
 			Description:  "Adds support for quotes and special characters in label values for Prometheus queries",

pkg/services/featuremgmt/toggles_gen.csv

@@ -159,6 +159,7 @@ newTimeRangeZoomShortcuts,experimental,@grafana/dataviz-squad,false,false,true
 azureMonitorDisableLogLimit,GA,@grafana/partner-datasources,false,false,false
 playlistsReconciler,experimental,@grafana/grafana-app-platform-squad,false,true,false
 passwordlessMagicLinkAuthentication,experimental,@grafana/identity-access-team,false,false,false
+exploreMetricsRelatedLogs,experimental,@grafana/observability-metrics,false,false,true
 prometheusSpecialCharsInLabelValues,experimental,@grafana/oss-big-tent,false,false,true
 enableExtensionsAdminPage,experimental,@grafana/plugins-platform-backend,false,true,false
 enableSCIM,preview,@grafana/identity-access-team,false,false,false

pkg/services/featuremgmt/toggles_gen.json

@@ -348,20 +348,6 @@
         "expression": "true"
       }
     },
-    {
-      "metadata": {
-        "name": "alertingNavigationV2",
-        "resourceVersion": "1767827323622",
-        "creationTimestamp": "2026-01-07T23:08:43Z",
-        "deletionTimestamp": "2026-01-12T18:34:54Z"
-      },
-      "spec": {
-        "description": "Enable new grouped navigation structure for Alerting",
-        "stage": "experimental",
-        "codeowner": "@grafana/alerting-squad",
-        "expression": "false"
-      }
-    },
     {
       "metadata": {
         "name": "alertingNotificationHistory",
@@ -1422,8 +1408,7 @@
       "metadata": {
         "name": "exploreMetricsRelatedLogs",
         "resourceVersion": "1764664939750",
-        "creationTimestamp": "2024-11-05T16:28:43Z",
-        "deletionTimestamp": "2026-01-09T22:14:53Z"
+        "creationTimestamp": "2024-11-05T16:28:43Z"
       },
       "spec": {
         "description": "Display Related Logs in Grafana Metrics Drilldown",

pkg/services/navtree/navtreeimpl/navtree.go

@@ -436,212 +436,97 @@ func (s *ServiceImpl) buildAlertNavLinks(c *contextmodel.ReqContext) *navtree.Na
 	hasAccess := ac.HasAccess(s.accessControl, c)
 	var alertChildNavs []*navtree.NavLink
 
-	var alertActivityChildren []*navtree.NavLink
 	//nolint:staticcheck // not yet migrated to OpenFeature
 	if s.features.IsEnabled(c.Req.Context(), featuremgmt.FlagAlertingTriage) {
 		if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingRuleRead), ac.EvalPermission(ac.ActionAlertingRuleExternalRead))) {
-			alertActivityChildren = append(alertActivityChildren, &navtree.NavLink{
-				Text:     "Alerts",
-				SubTitle: "Visualize active and pending alerts",
-				Id:       "alert-activity-alerts",
-				Url:      s.cfg.AppSubURL + "/alerting/alerts",
-				Icon:     "bell",
-			})
-		}
-
-		if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingInstanceRead), ac.EvalPermission(ac.ActionAlertingInstancesExternalRead))) {
-			alertActivityChildren = append(alertActivityChildren, &navtree.NavLink{
-				Text:     "Active notifications",
-				SubTitle: "See grouped alerts with active notifications",
-				Id:       "alert-activity-groups",
-				Url:      s.cfg.AppSubURL + "/alerting/groups",
-				Icon:     "layer-group",
-			})
-		}
-		if len(alertActivityChildren) > 0 {
 			alertChildNavs = append(alertChildNavs, &navtree.NavLink{
-				Text:     "Alert activity",
-				SubTitle: "Visualize active and pending alerts",
-				Id:       "alert-activity",
-				Url:      s.cfg.AppSubURL + "/alerting/alerts",
-				Icon:     "bell",
-				IsNew:    true,
-				Children: alertActivityChildren,
+				Text: "Alert activity", SubTitle: "Visualize active and pending alerts", Id: "alert-alerts", Url: s.cfg.AppSubURL + "/alerting/alerts", Icon: "bell", IsNew: true,
 			})
 		}
 	}
 
-	var alertRulesChildren []*navtree.NavLink
 	if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingRuleRead), ac.EvalPermission(ac.ActionAlertingRuleExternalRead))) {
-		alertRulesChildren = append(alertRulesChildren, &navtree.NavLink{
-			Text:     "Alert rules",
-			SubTitle: "Rules that determine whether an alert will fire",
-			Id:       "alert-rules-list",
-			Url:      s.cfg.AppSubURL + "/alerting/list",
-			Icon:     "list-ul",
-		})
-	}
-	//nolint:staticcheck // not yet migrated to OpenFeature
-	if c.GetOrgRole() == org.RoleAdmin && s.features.IsEnabled(c.Req.Context(), featuremgmt.FlagAlertRuleRestore) && s.features.IsEnabled(c.Req.Context(), featuremgmt.FlagAlertingRuleRecoverDeleted) {
-		alertRulesChildren = append(alertRulesChildren, &navtree.NavLink{
-			Text:     "Recently deleted",
-			SubTitle: "Any items listed here for more than 30 days will be automatically deleted.",
-			Id:       "alert-rules-recently-deleted",
-			Url:      s.cfg.AppSubURL + "/alerting/recently-deleted",
-		})
-	}
-	if len(alertRulesChildren) > 0 {
 		alertChildNavs = append(alertChildNavs, &navtree.NavLink{
-			Text:     "Alert rules",
-			SubTitle: "Manage alert and recording rules",
-			Id:       "alert-rules",
-			Url:      s.cfg.AppSubURL + "/alerting/list",
-			Icon:     "list-ul",
-			Children: alertRulesChildren,
+			Text: "Alert rules", SubTitle: "Rules that determine whether an alert will fire", Id: "alert-list", Url: s.cfg.AppSubURL + "/alerting/list", Icon: "list-ul",
 		})
 	}
 
-	var notificationConfigChildren []*navtree.NavLink
-
 	contactPointsPerms := []ac.Evaluator{
 		ac.EvalPermission(ac.ActionAlertingNotificationsRead),
 		ac.EvalPermission(ac.ActionAlertingNotificationsExternalRead),
+
 		ac.EvalPermission(ac.ActionAlertingReceiversRead),
 		ac.EvalPermission(ac.ActionAlertingReceiversReadSecrets),
 		ac.EvalPermission(ac.ActionAlertingReceiversCreate),
+
 		ac.EvalPermission(ac.ActionAlertingNotificationsTemplatesRead),
 		ac.EvalPermission(ac.ActionAlertingNotificationsTemplatesWrite),
 		ac.EvalPermission(ac.ActionAlertingNotificationsTemplatesDelete),
 	}
 
 	if hasAccess(ac.EvalAny(contactPointsPerms...)) {
-		notificationConfigChildren = append(notificationConfigChildren, &navtree.NavLink{
-			Text:     "Contact points",
-			SubTitle: "Choose how to notify your contact points when an alert instance fires",
-			Id:       "notification-config-contact-points",
-			Url:      s.cfg.AppSubURL + "/alerting/notifications",
-			Icon:     "comment-alt-share",
-		})
-	}
-
-	if hasAccess(ac.EvalAny(
-		ac.EvalPermission(ac.ActionAlertingNotificationsRead),
-		ac.EvalPermission(ac.ActionAlertingNotificationsExternalRead),
-		ac.EvalPermission(ac.ActionAlertingRoutesRead),
-		ac.EvalPermission(ac.ActionAlertingRoutesWrite),
-		ac.EvalPermission(ac.ActionAlertingNotificationsTimeIntervalsRead),
-		ac.EvalPermission(ac.ActionAlertingNotificationsTimeIntervalsWrite),
-	)) {
-		notificationConfigChildren = append(notificationConfigChildren, &navtree.NavLink{
-			Text:     "Notification policies",
-			SubTitle: "Determine how alerts are routed to contact points",
-			Id:       "notification-config-policies",
-			Url:      s.cfg.AppSubURL + "/alerting/routes",
-			Icon:     "sitemap",
-		})
-	}
-
-	if hasAccess(ac.EvalAny(contactPointsPerms...)) {
-		notificationConfigChildren = append(notificationConfigChildren, &navtree.NavLink{
-			Text:     "Notification templates",
-			SubTitle: "Manage notification templates",
-			Id:       "notification-config-templates",
-			Url:      s.cfg.AppSubURL + "/alerting/notifications/templates",
-			Icon:     "file-alt",
-		})
-	}
-
-	if hasAccess(ac.EvalAny(
-		ac.EvalPermission(ac.ActionAlertingNotificationsRead),
-		ac.EvalPermission(ac.ActionAlertingNotificationsExternalRead),
-		ac.EvalPermission(ac.ActionAlertingRoutesRead),
-		ac.EvalPermission(ac.ActionAlertingRoutesWrite),
-		ac.EvalPermission(ac.ActionAlertingNotificationsTimeIntervalsRead),
-		ac.EvalPermission(ac.ActionAlertingNotificationsTimeIntervalsWrite),
-	)) {
-		notificationConfigChildren = append(notificationConfigChildren, &navtree.NavLink{
-			Text:     "Time intervals",
-			SubTitle: "Configure time intervals for notification policies",
-			Id:       "notification-config-time-intervals",
-			Url:      s.cfg.AppSubURL + "/alerting/routes?tab=time_intervals",
-			Icon:     "clock-nine",
-		})
-	}
-
-	if len(notificationConfigChildren) > 0 {
 		alertChildNavs = append(alertChildNavs, &navtree.NavLink{
-			Text:     "Notification configuration",
-			SubTitle: "Configure how alerts are notified",
-			Id:       "notification-config",
-			Url:      s.cfg.AppSubURL + "/alerting/notifications",
-			Icon:     "cog",
-			Children: notificationConfigChildren,
+			Text: "Contact points", SubTitle: "Choose how to notify your contact points when an alert instance fires", Id: "receivers", Url: s.cfg.AppSubURL + "/alerting/notifications",
+			Icon: "comment-alt-share",
 		})
 	}
 
-	var insightsChildren []*navtree.NavLink
-
-	if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingRuleRead), ac.EvalPermission(ac.ActionAlertingRuleExternalRead))) {
-		insightsChildren = append(insightsChildren, &navtree.NavLink{
-			Text:     "System Insights",
-			SubTitle: "View system insights and analytics",
-			Id:       "insights-system", Url: s.cfg.AppSubURL + "/alerting/insights",
-			Icon: "chart-line",
-		})
+	if hasAccess(ac.EvalAny(
+		ac.EvalPermission(ac.ActionAlertingNotificationsRead),
+		ac.EvalPermission(ac.ActionAlertingNotificationsExternalRead),
+		ac.EvalPermission(ac.ActionAlertingRoutesRead),
+		ac.EvalPermission(ac.ActionAlertingRoutesWrite),
+		ac.EvalPermission(ac.ActionAlertingNotificationsTimeIntervalsRead),
+		ac.EvalPermission(ac.ActionAlertingNotificationsTimeIntervalsWrite),
+	)) {
+		alertChildNavs = append(alertChildNavs, &navtree.NavLink{Text: "Notification policies", SubTitle: "Determine how alerts are routed to contact points", Id: "am-routes", Url: s.cfg.AppSubURL + "/alerting/routes", Icon: "sitemap"})
 	}
-	// Alert state history
+
+	if hasAccess(ac.EvalAny(
+		ac.EvalPermission(ac.ActionAlertingInstanceRead),
+		ac.EvalPermission(ac.ActionAlertingInstancesExternalRead),
+		ac.EvalPermission(ac.ActionAlertingSilencesRead),
+	)) {
+		alertChildNavs = append(alertChildNavs, &navtree.NavLink{Text: "Silences", SubTitle: "Stop notifications from one or more alerting rules", Id: "silences", Url: s.cfg.AppSubURL + "/alerting/silences", Icon: "bell-slash"})
+	}
+
+	if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingInstanceRead), ac.EvalPermission(ac.ActionAlertingInstancesExternalRead))) {
+		alertChildNavs = append(alertChildNavs, &navtree.NavLink{Text: "Alert groups", SubTitle: "See grouped alerts with active notifications", Id: "groups", Url: s.cfg.AppSubURL + "/alerting/groups", Icon: "layer-group"})
+	}
+
 	//nolint:staticcheck // not yet migrated to OpenFeature
 	if s.features.IsEnabled(c.Req.Context(), featuremgmt.FlagAlertingCentralAlertHistory) {
 		if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingRuleRead))) {
-			insightsChildren = append(insightsChildren, &navtree.NavLink{
-				Text:     "Alert state history",
+			alertChildNavs = append(alertChildNavs, &navtree.NavLink{
+				Text:     "History",
 				SubTitle: "View a history of all alert events generated by your Grafana-managed alert rules. All alert events are displayed regardless of whether silences or mute timings are set.",
-				Id:       "insights-history",
+				Id:       "alerts-history",
 				Url:      s.cfg.AppSubURL + "/alerting/history",
 				Icon:     "history",
 			})
 		}
 	}
-
-	if len(insightsChildren) > 0 {
+	//nolint:staticcheck // not yet migrated to OpenFeature
+	if c.GetOrgRole() == org.RoleAdmin && s.features.IsEnabled(c.Req.Context(), featuremgmt.FlagAlertRuleRestore) && s.features.IsEnabled(c.Req.Context(), featuremgmt.FlagAlertingRuleRecoverDeleted) {
 		alertChildNavs = append(alertChildNavs, &navtree.NavLink{
-			Text:     "Insights",
-			SubTitle: "Analytics and history for alerting",
-			Id:       "insights",
-			Url:      s.cfg.AppSubURL + "/alerting/insights",
-			Icon:     "chart-line",
-			Children: insightsChildren,
+			Text:     "Recently deleted",
+			SubTitle: "Any items listed here for more than 30 days will be automatically deleted.",
+			Id:       "alerts/recently-deleted",
+			Url:      s.cfg.AppSubURL + "/alerting/recently-deleted",
 		})
 	}
 
 	if c.GetOrgRole() == org.RoleAdmin {
-		settingsChildren := []*navtree.NavLink{
-			{
-				Text: "Settings",
-				Id:   "alerting-admin",
-				Url:  s.cfg.AppSubURL + "/alerting/admin",
-				Icon: "cog",
-			},
-		}
 		alertChildNavs = append(alertChildNavs, &navtree.NavLink{
-			Text:     "Settings",
-			SubTitle: "Alerting configuration and administration",
-			Id:       "alerting-settings",
-			Url:      s.cfg.AppSubURL + "/alerting/admin",
-			Icon:     "cog",
-			Children: settingsChildren,
+			Text: "Settings", Id: "alerting-admin", Url: s.cfg.AppSubURL + "/alerting/admin",
+			Icon: "cog",
 		})
 	}
 
 	if hasAccess(ac.EvalAny(ac.EvalPermission(ac.ActionAlertingRuleCreate), ac.EvalPermission(ac.ActionAlertingRuleExternalWrite))) {
 		alertChildNavs = append(alertChildNavs, &navtree.NavLink{
-			Text:           "Create alert rule",
-			SubTitle:       "Create an alert rule",
-			Id:             "alert",
-			Icon:           "plus",
-			Url:            s.cfg.AppSubURL + "/alerting/new",
-			HideFromTabs:   true,
-			IsCreateAction: true,
+			Text: "Create alert rule", SubTitle: "Create an alert rule", Id: "alert",
+			Icon: "plus", Url: s.cfg.AppSubURL + "/alerting/new", HideFromTabs: true, IsCreateAction: true,
 		})
 	}
 

pkg/services/navtree/navtreeimpl/navtree_alerting_test.go

@@ -1,158 +0,0 @@
-package navtreeimpl
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/grafana/grafana/pkg/infra/log"
-	ac "github.com/grafana/grafana/pkg/services/accesscontrol"
-	accesscontrolmock "github.com/grafana/grafana/pkg/services/accesscontrol/mock"
-	contextmodel "github.com/grafana/grafana/pkg/services/contexthandler/model"
-	"github.com/grafana/grafana/pkg/services/featuremgmt"
-	"github.com/grafana/grafana/pkg/services/navtree"
-	"github.com/grafana/grafana/pkg/services/org"
-	"github.com/grafana/grafana/pkg/services/user"
-	"github.com/grafana/grafana/pkg/setting"
-	"github.com/grafana/grafana/pkg/web"
-)
-
-// Test fixtures
-func setupTestContext() *contextmodel.ReqContext {
-	httpReq, _ := http.NewRequest(http.MethodGet, "", nil)
-	return &contextmodel.ReqContext{
-		SignedInUser: &user.SignedInUser{
-			UserID:  1,
-			OrgID:   1,
-			OrgRole: org.RoleAdmin,
-		},
-		Context: &web.Context{Req: httpReq},
-	}
-}
-
-func setupTestService(permissions []ac.Permission, featureFlags ...string) ServiceImpl {
-	// Convert string slice to []any for WithFeatures
-	flags := make([]any, len(featureFlags))
-	for i, flag := range featureFlags {
-		flags[i] = flag
-	}
-	return ServiceImpl{
-		log:           log.New("navtree"),
-		cfg:           setting.NewCfg(),
-		accessControl: accesscontrolmock.New().WithPermissions(permissions),
-		features:      featuremgmt.WithFeatures(flags...),
-	}
-}
-
-func fullPermissions() []ac.Permission {
-	return []ac.Permission{
-		{Action: ac.ActionAlertingRuleRead, Scope: "*"},
-		{Action: ac.ActionAlertingNotificationsRead, Scope: "*"},
-		{Action: ac.ActionAlertingRoutesRead, Scope: "*"},
-		{Action: ac.ActionAlertingInstanceRead, Scope: "*"},
-	}
-}
-
-// Helper to find a nav link by ID
-func findNavLink(navLink *navtree.NavLink, id string) *navtree.NavLink {
-	if navLink == nil {
-		return nil
-	}
-	if navLink.Id == id {
-		return navLink
-	}
-	for _, child := range navLink.Children {
-		if found := findNavLink(child, id); found != nil {
-			return found
-		}
-	}
-	return nil
-}
-
-// Helper to check if a nav link has a child with given ID
-func hasChildWithId(parent *navtree.NavLink, childId string) bool {
-	if parent == nil {
-		return false
-	}
-	for _, child := range parent.Children {
-		if child.Id == childId {
-			return true
-		}
-	}
-	return false
-}
-
-func TestBuildAlertNavLinks(t *testing.T) {
-	reqCtx := setupTestContext()
-	allFeatureFlags := []string{"alertingTriage", "alertingCentralAlertHistory", "alertRuleRestore", "alertingRuleRecoverDeleted"}
-	service := setupTestService(fullPermissions(), allFeatureFlags...)
-
-	t.Run("Should have correct parent structure", func(t *testing.T) {
-		navLink := service.buildAlertNavLinks(reqCtx)
-		require.NotNil(t, navLink)
-		require.NotEmpty(t, navLink.Children)
-
-		// Verify all parent items exist with children
-		parentIds := []string{"alert-rules", "notification-config", "insights", "alerting-settings"}
-		for _, parentId := range parentIds {
-			parent := findNavLink(navLink, parentId)
-			require.NotNil(t, parent, "Should have parent %s", parentId)
-			require.NotEmpty(t, parent.Children, "Parent %s should have children", parentId)
-		}
-	})
-
-	t.Run("Should have correct tabs under each parent", func(t *testing.T) {
-		navLink := service.buildAlertNavLinks(reqCtx)
-		require.NotNil(t, navLink)
-
-		// Table-driven test for tab verification
-		tests := []struct {
-			parentId     string
-			expectedTabs []string
-		}{
-			{"alert-rules", []string{"alert-rules-list", "alert-rules-recently-deleted"}},
-			{"notification-config", []string{"notification-config-contact-points", "notification-config-policies", "notification-config-templates", "notification-config-time-intervals"}},
-			{"insights", []string{"insights-system", "insights-history"}},
-		}
-
-		for _, tt := range tests {
-			parent := findNavLink(navLink, tt.parentId)
-			require.NotNil(t, parent, "Should have %s parent", tt.parentId)
-
-			for _, expectedTab := range tt.expectedTabs {
-				require.True(t, hasChildWithId(parent, expectedTab), "Parent %s should have tab %s", tt.parentId, expectedTab)
-			}
-		}
-	})
-
-	t.Run("Should respect permissions", func(t *testing.T) {
-		limitedPermissions := []ac.Permission{
-			{Action: ac.ActionAlertingRuleRead, Scope: "*"},
-		}
-		limitedService := setupTestService(limitedPermissions)
-
-		navLink := limitedService.buildAlertNavLinks(reqCtx)
-		require.NotNil(t, navLink)
-
-		// Should not have notification-config without notification permissions
-		require.Nil(t, findNavLink(navLink, "notification-config"), "Should not have notification-config without permissions")
-	})
-
-	t.Run("Should exclude future items", func(t *testing.T) {
-		navLink := service.buildAlertNavLinks(reqCtx)
-		require.NotNil(t, navLink)
-
-		// Verify future items are not present
-		futureIds := []string{
-			"alert-rules-recording-rules",
-			"alert-rules-evaluation-chains",
-			"insights-alert-optimizer",
-			"insights-notification-history",
-		}
-
-		for _, futureId := range futureIds {
-			require.Nil(t, findNavLink(navLink, futureId), "Should not have future item %s", futureId)
-		}
-	})
-}

pkg/storage/unified/resource/notifier.go

@@ -78,13 +78,13 @@ func (n *notifier) Watch(ctx context.Context, opts watchOptions) <-chan Event {
 	cache := gocache.New(cacheTTL, cacheCleanupInterval)
 	events := make(chan Event, opts.BufferSize)
 
-	lastRV, err := n.lastEventResourceVersion(ctx)
+	initialRV, err := n.lastEventResourceVersion(ctx)
 	if errors.Is(err, ErrNotFound) {
-		lastRV = 0 // No events yet, start from the beginning
+		initialRV = snowflakeFromTime(time.Now()) // No events yet, start from the beginning
 	} else if err != nil {
 		n.log.Error("Failed to get last event resource version", "error", err)
 	}
-	lastRV = lastRV + 1 // We want to start watching from the next event
+	lastRV := initialRV + 1 // We want to start watching from the next event
 
 	go func() {
 		defer close(events)
@@ -110,7 +110,7 @@ func (n *notifier) Watch(ctx context.Context, opts watchOptions) <-chan Event {
 					}
 
 					// Skip old events lower than the requested resource version
-					if evt.ResourceVersion < lastRV {
+					if evt.ResourceVersion <= initialRV {
 						continue
 					}
 

pkg/storage/unified/resource/notifier_test.go

@@ -25,6 +25,7 @@ func setupTestNotifier(t *testing.T) (*notifier, *eventStore) {
 	return notifier, eventStore
 }
 
+// nolint:unused
 func setupTestNotifierSqlKv(t *testing.T) (*notifier, *eventStore) {
 	dbstore := db.InitTestDB(t)
 	eDB, err := dbimpl.ProvideResourceDB(dbstore, setting.NewCfg(), nil)
@@ -59,7 +60,8 @@ func runNotifierTestWith(t *testing.T, storeName string, newStoreFn func(*testin
 
 func TestNotifier_lastEventResourceVersion(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierLastEventResourceVersion)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierLastEventResourceVersion)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierLastEventResourceVersion)
 }
 
 func testNotifierLastEventResourceVersion(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {
@@ -110,7 +112,8 @@ func testNotifierLastEventResourceVersion(t *testing.T, ctx context.Context, not
 
 func TestNotifier_cachekey(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierCachekey)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierCachekey)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierCachekey)
 }
 
 func testNotifierCachekey(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {
@@ -164,7 +167,8 @@ func testNotifierCachekey(t *testing.T, ctx context.Context, notifier *notifier,
 
 func TestNotifier_Watch_NoEvents(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierWatchNoEvents)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchNoEvents)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchNoEvents)
 }
 
 func testNotifierWatchNoEvents(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {
@@ -205,7 +209,8 @@ func testNotifierWatchNoEvents(t *testing.T, ctx context.Context, notifier *noti
 
 func TestNotifier_Watch_WithExistingEvents(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierWatchWithExistingEvents)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchWithExistingEvents)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchWithExistingEvents)
 }
 
 func testNotifierWatchWithExistingEvents(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {
@@ -279,7 +284,8 @@ func testNotifierWatchWithExistingEvents(t *testing.T, ctx context.Context, noti
 
 func TestNotifier_Watch_EventDeduplication(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierWatchEventDeduplication)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchEventDeduplication)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchEventDeduplication)
 }
 
 func testNotifierWatchEventDeduplication(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {
@@ -345,7 +351,8 @@ func testNotifierWatchEventDeduplication(t *testing.T, ctx context.Context, noti
 
 func TestNotifier_Watch_ContextCancellation(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierWatchContextCancellation)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchContextCancellation)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchContextCancellation)
 }
 
 func testNotifierWatchContextCancellation(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {
@@ -391,7 +398,8 @@ func testNotifierWatchContextCancellation(t *testing.T, ctx context.Context, not
 
 func TestNotifier_Watch_MultipleEvents(t *testing.T) {
 	runNotifierTestWith(t, "badger", setupTestNotifier, testNotifierWatchMultipleEvents)
-	runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchMultipleEvents)
+	// enable this when sqlkv is ready
+	// runNotifierTestWith(t, "sqlkv", setupTestNotifierSqlKv, testNotifierWatchMultipleEvents)
 }
 
 func testNotifierWatchMultipleEvents(t *testing.T, ctx context.Context, notifier *notifier, eventStore *eventStore) {

pkg/storage/unified/resource/storage_backend.go

@@ -346,8 +346,7 @@ func (k *kvStorageBackend) WriteEvent(ctx context.Context, event WriteEvent) (in
 			return 0, fmt.Errorf("failed to write data: %w", err)
 		}
 
-		rv = rvmanager.SnowflakeFromRv(rv)
-		dataKey.ResourceVersion = rv
+		dataKey.ResourceVersion = rvmanager.SnowflakeFromRv(rv)
 	} else {
 		err := k.dataStore.Save(ctx, dataKey, bytes.NewReader(event.Value))
 		if err != nil {

pkg/storage/unified/testing/storage_backend_sql_compatibility.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/bwmarrin/snowflake"
 	"github.com/stretchr/testify/require"
 
 	claims "github.com/grafana/authlib/types"
@@ -186,30 +187,13 @@ func runKeyPathTest(t *testing.T, backend resource.StorageBackend, nsPrefix stri
 
 // verifyKeyPath is a helper function to verify key_path generation
 func verifyKeyPath(t *testing.T, db sqldb.DB, ctx context.Context, key *resourcepb.ResourceKey, action string, resourceVersion int64, expectedFolder string) {
-	// For SQL backend (namespace contains "-sql"), resourceVersion is in microsecond format
-	// but key_path stores snowflake RV, so convert to snowflake
-	// For KV backend (namespace contains "-kv"), resourceVersion is already in snowflake format
-	isSqlBackend := strings.Contains(key.Namespace, "-sql")
-
-	var keyPathRV int64
-	if isSqlBackend {
-		// Convert microsecond RV to snowflake for key_path construction
-		keyPathRV = rvmanager.SnowflakeFromRv(resourceVersion)
-	} else {
-		// KV backend already provides snowflake RV
-		keyPathRV = resourceVersion
-	}
-
-	// Build the expected key_path using DataKey format: unified/data/group/resource/namespace/name/resourceVersion~action~folder
-	expectedKeyPath := fmt.Sprintf("unified/data/%s/%s/%s/%s/%d~%s~%s", key.Group, key.Resource, key.Namespace, key.Name, keyPathRV, action, expectedFolder)
-
 	var query string
 	if db.DriverName() == "postgres" {
-		query = "SELECT key_path, resource_version, action, folder FROM resource_history WHERE key_path = $1"
+		query = "SELECT key_path, resource_version, action, folder FROM resource_history WHERE namespace = $1 AND name = $2 AND resource_version = $3"
 	} else {
-		query = "SELECT key_path, resource_version, action, folder FROM resource_history WHERE key_path = ?"
+		query = "SELECT key_path, resource_version, action, folder FROM resource_history WHERE namespace = ? AND name = ? AND resource_version = ?"
 	}
-	rows, err := db.QueryContext(ctx, query, expectedKeyPath)
+	rows, err := db.QueryContext(ctx, query, key.Namespace, key.Name, resourceVersion)
 	require.NoError(t, err)
 
 	require.True(t, rows.Next(), "Resource not found in resource_history table - both SQL and KV backends should write to this table")
@@ -236,6 +220,10 @@ func verifyKeyPath(t *testing.T, db sqldb.DB, ctx context.Context, key *resource
 	// Verify action suffix
 	require.Contains(t, keyPath, fmt.Sprintf("~%s~", action))
 
+	// Verify snowflake calculation
+	expectedSnowflake := (((resourceVersion / 1000) - snowflake.Epoch) << (snowflake.NodeBits + snowflake.StepBits)) + (resourceVersion % 1000)
+	require.Contains(t, keyPath, fmt.Sprintf("/%d~", expectedSnowflake), "actual RV: %d", actualRV)
+
 	// Verify folder if specified
 	if expectedFolder != "" {
 		require.Equal(t, expectedFolder, actualFolder)
@@ -504,10 +492,10 @@ func verifyResourceHistoryRecord(t *testing.T, record ResourceHistoryRecord, exp
 	}
 
 	// Validate previous_resource_version
-	// For KV backend operations, expectedPrevRV is now in snowflake format (returned by KV backend)
-	// but resource_history table stores microsecond RV, so we need to use IsRvEqual for comparison
+	// For KV backend operations, resource versions are stored as snowflake format
+	// but expectedPrevRV is in microsecond format, so we need to use IsRvEqual for comparison
 	if strings.Contains(record.Namespace, "-kv") {
-		require.True(t, rvmanager.IsRvEqual(expectedPrevRV, record.PreviousResourceVersion),
+		require.True(t, rvmanager.IsRvEqual(record.PreviousResourceVersion, expectedPrevRV),
 			"Previous resource version should match (KV backend snowflake format)")
 	} else {
 		require.Equal(t, expectedPrevRV, record.PreviousResourceVersion)
@@ -517,10 +505,9 @@ func verifyResourceHistoryRecord(t *testing.T, record ResourceHistoryRecord, exp
 	require.Equal(t, expectedGeneration, record.Generation)
 
 	// Validate resource_version
-	// For KV backend operations, expectedRV is now in snowflake format (returned by KV backend)
-	// but resource_history table stores microsecond RV, so we need to use IsRvEqual for comparison
+	// For KV backend operations, resource versions are stored as snowflake format
 	if strings.Contains(record.Namespace, "-kv") {
-		require.True(t, rvmanager.IsRvEqual(expectedRV, record.ResourceVersion),
+		require.True(t, rvmanager.IsRvEqual(record.ResourceVersion, expectedRV),
 			"Resource version should match (KV backend snowflake format)")
 	} else {
 		require.Equal(t, expectedRV, record.ResourceVersion)
@@ -587,7 +574,7 @@ func verifyResourceTable(t *testing.T, db sqldb.DB, namespace string, resources
 	// Resource version should match the expected version for test-resource-3 (updated version)
 	expectedRV := resourceVersions[2][1] // test-resource-3's update version
 	if strings.Contains(namespace, "-kv") {
-		require.True(t, rvmanager.IsRvEqual(expectedRV, record.ResourceVersion),
+		require.True(t, rvmanager.IsRvEqual(record.ResourceVersion, expectedRV),
 			"Resource version should match (KV backend snowflake format)")
 	} else {
 		require.Equal(t, expectedRV, record.ResourceVersion)
@@ -638,16 +625,9 @@ func verifyResourceVersionTable(t *testing.T, db sqldb.DB, namespace string, res
 
 	// The resource_version table should contain the latest RV for the group+resource
 	// It might be slightly higher due to RV manager operations, so check it's at least our max
-	// For KV backend, maxRV is in snowflake format but record.ResourceVersion is in microsecond format
-	// Use IsRvEqual for proper comparison between different RV formats
-	isKvBackend := strings.Contains(namespace, "-kv")
-	recordResourceVersion := record.ResourceVersion
-	if isKvBackend {
-		recordResourceVersion = rvmanager.SnowflakeFromRv(record.ResourceVersion)
-	}
-
-	require.Less(t, recordResourceVersion, int64(9223372036854775807), "resource_version should be reasonable")
-	require.Greater(t, recordResourceVersion, maxRV, "resource_version should be at least the latest RV we tracked")
+	require.GreaterOrEqual(t, record.ResourceVersion, maxRV, "resource_version should be at least the latest RV we tracked")
+	// But it shouldn't be too much higher (within a reasonable range)
+	require.LessOrEqual(t, record.ResourceVersion, maxRV+100, "resource_version shouldn't be much higher than expected")
 }
 
 // runTestCrossBackendConsistency tests basic consistency between SQL and KV backends (lightweight)

pkg/storage/unified/testing/storage_backend_test.go

@@ -38,6 +38,7 @@ func TestBadgerKVStorageBackend(t *testing.T) {
 
 func TestSQLKVStorageBackend(t *testing.T) {
 	skipTests := map[string]bool{
+		TestHappyPath:                 true,
 		TestWatchWriteEvents:          true,
 		TestList:                      true,
 		TestBlobSupport:               true,
@@ -50,24 +51,21 @@ func TestSQLKVStorageBackend(t *testing.T) {
 		TestGetResourceLastImportTime: true,
 		TestOptimisticLocking:         true,
 	}
-
-	t.Run("Without RvManager", func(t *testing.T) {
-		RunStorageBackendTest(t, func(ctx context.Context) resource.StorageBackend {
-			backend, _ := NewTestSqlKvBackend(t, ctx, false)
-			return backend
-		}, &TestOptions{
-			NSPrefix:  "sqlkvstorage-test",
-			SkipTests: skipTests,
-		})
+	// without RvManager
+	RunStorageBackendTest(t, func(ctx context.Context) resource.StorageBackend {
+		backend, _ := NewTestSqlKvBackend(t, ctx, false)
+		return backend
+	}, &TestOptions{
+		NSPrefix:  "sqlkvstorage-test",
+		SkipTests: skipTests,
 	})
 
-	t.Run("With RvManager", func(t *testing.T) {
-		RunStorageBackendTest(t, func(ctx context.Context) resource.StorageBackend {
-			backend, _ := NewTestSqlKvBackend(t, ctx, true)
-			return backend
-		}, &TestOptions{
-			NSPrefix:  "sqlkvstorage-withrvmanager-test",
-			SkipTests: skipTests,
-		})
+	// with RvManager
+	RunStorageBackendTest(t, func(ctx context.Context) resource.StorageBackend {
+		backend, _ := NewTestSqlKvBackend(t, ctx, true)
+		return backend
+	}, &TestOptions{
+		NSPrefix:  "sqlkvstorage-withrvmanager-test",
+		SkipTests: skipTests,
 	})
 }

public/app/core/components/AppChrome/MegaMenu/MegaMenu.tsx

@@ -37,24 +37,9 @@ export const MegaMenu = memo(
     const pinnedItems = usePinnedItems();
 
     // Remove profile + help from tree
-    // For Alerting navigation, flatten the sidebar to show only top-level items (hide nested children/tabs)
     const navItems = navTree
       .filter((item) => item.id !== 'profile' && item.id !== 'help')
-      .map((item) => {
-        const enriched = enrichWithInteractionTracking(item, state.megaMenuDocked);
-        // If this is Alerting section, flatten children for sidebar display
-        // Children are still available in navIndex for breadcrumbs and page navigation
-        if (item.id === 'alerting' && enriched.children) {
-          return {
-            ...enriched,
-            children: enriched.children.map((child) => ({
-              ...child,
-              children: undefined, // Remove nested children from sidebar, but keep them for page navigation
-            })),
-          };
-        }
-        return enriched;
-      });
+      .map((item) => enrichWithInteractionTracking(item, state.megaMenuDocked));
 
     const bookmarksItem = navItems.find((item) => item.id === 'bookmarks');
     if (bookmarksItem) {

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

@@ -35,18 +35,11 @@ export function buildBreadcrumbs(sectionNav: NavModelItem, pageNav?: NavModelIte
 
     if (shouldAddCrumb) {
       const activeChildIndex = node.children?.findIndex((child) => child.active) ?? -1;
-      // Add active tab to breadcrumbs if it exists and its URL is different from the node's URL
-      // This ensures tabs show in breadcrumbs (including the first tab) while preventing duplication
-      if (activeChildIndex >= 0) {
+      // Add tab to breadcrumbs if it's not the first active child
+      if (activeChildIndex > 0) {
         const activeChild = node.children?.[activeChildIndex];
         if (activeChild) {
-          // Only add the active child if its URL doesn't match the node's URL
-          // This prevents duplication when the pageNav is the active tab
-          const nodeUrl = node.url?.split('?')[0] ?? '';
-          const childUrl = activeChild.url?.split('?')[0] ?? '';
-          if (nodeUrl !== childUrl) {
-            crumbs.unshift({ text: activeChild.text, href: activeChild.url ?? '' });
-          }
+          crumbs.unshift({ text: activeChild.text, href: activeChild.url ?? '' });
         }
       }
       crumbs.unshift({ text: node.text, href: node.url ?? '' });

public/app/features/alerting/routes.tsx

@@ -56,17 +56,6 @@ export function getAlertingRoutes(cfg = config): RouteDescriptor[] {
           )
       ),
     },
-    {
-      path: '/alerting/time-intervals',
-      roles: evaluateAccess([
-        AccessControlAction.AlertingNotificationsRead,
-        AccessControlAction.AlertingNotificationsExternalRead,
-        ...PERMISSIONS_TIME_INTERVALS_READ,
-      ]),
-      component: importAlertingComponent(
-        () => import(/* webpackChunkName: "TimeIntervalsPage" */ 'app/features/alerting/unified/TimeIntervalsPage')
-      ),
-    },
     {
       path: '/alerting/routes/mute-timing/new',
       roles: evaluateAccess([
@@ -223,13 +212,6 @@ export function getAlertingRoutes(cfg = config): RouteDescriptor[] {
           )
       ),
     },
-    {
-      path: '/alerting/insights',
-      roles: evaluateAccess([AccessControlAction.AlertingRuleRead, AccessControlAction.AlertingRuleExternalRead]),
-      component: importAlertingComponent(
-        () => import(/* webpackChunkName: "InsightsPage" */ 'app/features/alerting/unified/insights/InsightsPage')
-      ),
-    },
     {
       path: '/alerting/recently-deleted/',
       roles: () => ['Admin'],

public/app/features/alerting/unified/AlertGroups.tsx

@@ -14,7 +14,6 @@ import { AlertGroupFilter } from './components/alert-groups/AlertGroupFilter';
 import { useFilteredAmGroups } from './hooks/useFilteredAmGroups';
 import { useGroupedAlerts } from './hooks/useGroupedAlerts';
 import { useUnifiedAlertingSelector } from './hooks/useUnifiedAlertingSelector';
-import { useAlertActivityNav } from './navigation/useAlertActivityNav';
 import { useAlertmanager } from './state/AlertmanagerContext';
 import { fetchAlertGroupsAction } from './state/actions';
 import { NOTIFICATIONS_POLL_INTERVAL_MS } from './utils/constants';
@@ -114,9 +113,8 @@ const AlertGroups = () => {
 };
 
 function AlertGroupsPage() {
-  const { navId, pageNav } = useAlertActivityNav();
   return (
-    <AlertmanagerPageWrapper navId={navId || 'groups'} pageNav={pageNav} accessType="instance">
+    <AlertmanagerPageWrapper navId="groups" accessType="instance">
       <AlertGroups />
     </AlertmanagerPageWrapper>
   );

public/app/features/alerting/unified/NotificationPoliciesPage.test.tsx

@@ -140,35 +140,6 @@ const getRootRoute = async () => {
 };
 
 describe('NotificationPolicies', () => {
-  beforeEach(() => {
-    setupDataSources(dataSources.am);
-    grantUserPermissions([
-      AccessControlAction.AlertingNotificationsRead,
-      AccessControlAction.AlertingNotificationsWrite,
-      ...PERMISSIONS_NOTIFICATION_POLICIES,
-    ]);
-  });
-
-  it('shows only notification policies without internal tabs', async () => {
-    renderNotificationPolicies();
-
-    // Should show notification policies directly
-    expect(await ui.rootRouteContainer.find()).toBeInTheDocument();
-
-    // Should not have tabs
-    expect(screen.queryByRole('tab')).not.toBeInTheDocument();
-  });
-
-  it('does not show time intervals tab', async () => {
-    renderNotificationPolicies();
-
-    // Should show notification policies
-    expect(await ui.rootRouteContainer.find()).toBeInTheDocument();
-
-    // Should not show time intervals tab
-    expect(screen.queryByText(/time intervals/i)).not.toBeInTheDocument();
-  });
-
   // combobox hack :/
   beforeAll(() => {
     const mockGetBoundingClientRect = jest.fn(() => ({

public/app/features/alerting/unified/NotificationPoliciesPage.tsx

@@ -1,29 +1,115 @@
+import { css } from '@emotion/css';
+import { useState } from 'react';
+
+import { GrafanaTheme2, UrlQueryMap } from '@grafana/data';
+import { t } from '@grafana/i18n';
+import { Tab, TabContent, TabsBar, useStyles2 } from '@grafana/ui';
+import { useQueryParams } from 'app/core/hooks/useQueryParams';
+import { useMuteTimings } from 'app/features/alerting/unified/components/mute-timings/useMuteTimings';
 import { NotificationPoliciesList } from 'app/features/alerting/unified/components/notification-policies/NotificationPoliciesList';
+import { AlertmanagerAction, useAlertmanagerAbility } from 'app/features/alerting/unified/hooks/useAbilities';
 
 import { AlertmanagerPageWrapper } from './components/AlertingPageWrapper';
 import { GrafanaAlertmanagerWarning } from './components/GrafanaAlertmanagerWarning';
-import { useNotificationConfigNav } from './navigation/useNotificationConfigNav';
+import { TimeIntervalsTable } from './components/mute-timings/MuteTimingsTable';
 import { useAlertmanager } from './state/AlertmanagerContext';
 import { withPageErrorBoundary } from './withPageErrorBoundary';
 
-const NotificationPoliciesContent = () => {
+enum ActiveTab {
+  NotificationPolicies = 'notification_policies',
+  TimeIntervals = 'time_intervals',
+}
+
+const NotificationPoliciesTabs = () => {
+  const styles = useStyles2(getStyles);
+
+  // Alertmanager logic and data hooks
   const { selectedAlertmanager = '' } = useAlertmanager();
+  const [policiesSupported, canSeePoliciesTab] = useAlertmanagerAbility(AlertmanagerAction.ViewNotificationPolicyTree);
+  const [timingsSupported, canSeeTimingsTab] = useAlertmanagerAbility(AlertmanagerAction.ViewTimeInterval);
+  const availableTabs = [
+    canSeePoliciesTab && ActiveTab.NotificationPolicies,
+    canSeeTimingsTab && ActiveTab.TimeIntervals,
+  ].filter((tab) => !!tab);
+  const { data: muteTimings = [] } = useMuteTimings({
+    alertmanager: selectedAlertmanager,
+    skip: !canSeeTimingsTab,
+  });
+
+  // Tab state management
+  const [queryParams, setQueryParams] = useQueryParams();
+  const { tab } = getActiveTabFromUrl(queryParams, availableTabs[0]);
+  const [activeTab, setActiveTab] = useState<ActiveTab>(tab);
+
+  const muteTimingsTabActive = activeTab === ActiveTab.TimeIntervals;
+  const policyTreeTabActive = activeTab === ActiveTab.NotificationPolicies;
+
+  const numberOfMuteTimings = muteTimings.length;
+
   return (
     <>
       <GrafanaAlertmanagerWarning currentAlertmanager={selectedAlertmanager} />
-      <NotificationPoliciesList />
+      <TabsBar>
+        {policiesSupported && canSeePoliciesTab && (
+          <Tab
+            label={t('alerting.notification-policies-tabs.label-notification-policies', 'Notification Policies')}
+            active={policyTreeTabActive}
+            onChangeTab={() => {
+              setActiveTab(ActiveTab.NotificationPolicies);
+              setQueryParams({ tab: ActiveTab.NotificationPolicies });
+            }}
+          />
+        )}
+        {timingsSupported && canSeeTimingsTab && (
+          <Tab
+            label={t('alerting.notification-policies-tabs.label-time-intervals', 'Time intervals')}
+            active={muteTimingsTabActive}
+            counter={numberOfMuteTimings}
+            onChangeTab={() => {
+              setActiveTab(ActiveTab.TimeIntervals);
+              setQueryParams({ tab: ActiveTab.TimeIntervals });
+            }}
+          />
+        )}
+      </TabsBar>
+      <TabContent className={styles.tabContent}>
+        {policyTreeTabActive && <NotificationPoliciesList />}
+        {muteTimingsTabActive && <TimeIntervalsTable />}
+      </TabContent>
     </>
   );
 };
 
-function NotificationPoliciesPage() {
-  const { navId, pageNav } = useNotificationConfigNav();
+const getStyles = (theme: GrafanaTheme2) => ({
+  tabContent: css({
+    marginTop: theme.spacing(2),
+  }),
+});
 
-  // Show only notification policies (no internal tabs)
-  // Time intervals are accessible via the sidebar navigation
+interface QueryParamValues {
+  tab: ActiveTab;
+}
+
+function getActiveTabFromUrl(queryParams: UrlQueryMap, defaultTab: ActiveTab): QueryParamValues {
+  let tab = defaultTab;
+
+  if (queryParams.tab === ActiveTab.NotificationPolicies) {
+    tab = ActiveTab.NotificationPolicies;
+  }
+
+  if (queryParams.tab === ActiveTab.TimeIntervals) {
+    tab = ActiveTab.TimeIntervals;
+  }
+
+  return {
+    tab,
+  };
+}
+
+function NotificationPoliciesPage() {
   return (
-    <AlertmanagerPageWrapper navId={navId || 'am-routes'} pageNav={pageNav} accessType="notification">
-      <NotificationPoliciesContent />
+    <AlertmanagerPageWrapper navId="am-routes" accessType="notification">
+      <NotificationPoliciesTabs />
     </AlertmanagerPageWrapper>
   );
 }

public/app/features/alerting/unified/Templates.tsx

@@ -1,52 +1,13 @@
 import { Route, Routes } from 'react-router-dom-v5-compat';
 
-import { Trans } from '@grafana/i18n';
-import { LinkButton, Stack, Text } from '@grafana/ui';
-
-import { AlertmanagerPageWrapper } from './components/AlertingPageWrapper';
 import DuplicateMessageTemplate from './components/contact-points/DuplicateMessageTemplate';
 import EditMessageTemplate from './components/contact-points/EditMessageTemplate';
 import NewMessageTemplate from './components/contact-points/NewMessageTemplate';
-import { NotificationTemplates } from './components/contact-points/NotificationTemplates';
-import { AlertmanagerAction, useAlertmanagerAbility } from './hooks/useAbilities';
-import { useNotificationConfigNav } from './navigation/useNotificationConfigNav';
 import { withPageErrorBoundary } from './withPageErrorBoundary';
 
-const TemplatesList = () => {
-  const [createTemplateSupported, createTemplateAllowed] = useAlertmanagerAbility(
-    AlertmanagerAction.CreateNotificationTemplate
-  );
-
-  return (
-    <>
-      <Stack direction="row" alignItems="center" justifyContent="space-between">
-        <Text variant="body" color="secondary">
-          <Trans i18nKey="alerting.notification-templates-tab.create-notification-templates-customize-notifications">
-            Create notification templates to customize your notifications.
-          </Trans>
-        </Text>
-        {createTemplateSupported && (
-          <LinkButton
-            icon="plus"
-            variant="primary"
-            href="/alerting/notifications/templates/new"
-            disabled={!createTemplateAllowed}
-          >
-            <Trans i18nKey="alerting.notification-templates-tab.add-notification-template-group">
-              Add notification template group
-            </Trans>
-          </LinkButton>
-        )}
-      </Stack>
-      <NotificationTemplates />
-    </>
-  );
-};
-
-function NotificationTemplatesRoutes() {
+function NotificationTemplates() {
   return (
     <Routes>
-      <Route path="" element={<TemplatesList />} />
       <Route path="new" element={<NewMessageTemplate />} />
       <Route path=":name/edit" element={<EditMessageTemplate />} />
       <Route path=":name/duplicate" element={<DuplicateMessageTemplate />} />
@@ -54,14 +15,4 @@ function NotificationTemplatesRoutes() {
   );
 }
 
-function NotificationTemplatesPage() {
-  const { navId, pageNav } = useNotificationConfigNav();
-
-  return (
-    <AlertmanagerPageWrapper navId={navId || 'receivers'} pageNav={pageNav} accessType="notification">
-      <NotificationTemplatesRoutes />
-    </AlertmanagerPageWrapper>
-  );
-}
-
-export default withPageErrorBoundary(NotificationTemplatesPage);
+export default withPageErrorBoundary(NotificationTemplates);

public/app/features/alerting/unified/TimeIntervalsPage.test.tsx

@@ -1,65 +0,0 @@
-import { render, screen } from 'test/test-utils';
-
-import { configureStore } from 'app/store/configureStore';
-import { AccessControlAction } from 'app/types/accessControl';
-
-import TimeIntervalsPage from './TimeIntervalsPage';
-import { defaultConfig } from './components/mute-timings/mocks';
-import { setupMswServer } from './mockApi';
-import { grantUserPermissions, mockDataSource } from './mocks';
-import { setTimeIntervalsListEmpty } from './mocks/server/configure';
-import { setAlertmanagerConfig } from './mocks/server/entities/alertmanagers';
-import { setupDataSources } from './testSetup/datasources';
-import { DataSourceType, GRAFANA_RULES_SOURCE_NAME } from './utils/datasource';
-
-setupMswServer();
-
-const alertManager = mockDataSource({
-  name: 'Alertmanager',
-  type: DataSourceType.Alertmanager,
-});
-
-describe('TimeIntervalsPage', () => {
-  beforeEach(() => {
-    setupDataSources(alertManager);
-    setAlertmanagerConfig(GRAFANA_RULES_SOURCE_NAME, defaultConfig);
-    setTimeIntervalsListEmpty(); // Mock empty time intervals list so component renders
-    grantUserPermissions([
-      AccessControlAction.AlertingNotificationsRead,
-      AccessControlAction.AlertingTimeIntervalsRead,
-    ]);
-  });
-
-  it('renders time intervals table', async () => {
-    const mockNavIndex = {
-      'notification-config': {
-        id: 'notification-config',
-        text: 'Notification configuration',
-        url: '/alerting/notifications',
-      },
-      'notification-config-time-intervals': {
-        id: 'notification-config-time-intervals',
-        text: 'Time intervals',
-        url: '/alerting/time-intervals',
-      },
-    };
-    const store = configureStore({
-      navIndex: mockNavIndex,
-    });
-
-    render(<TimeIntervalsPage />, {
-      store,
-      historyOptions: {
-        initialEntries: ['/alerting/time-intervals'],
-      },
-    });
-
-    // Should show time intervals content
-    // When empty, it shows "You haven't created any time intervals yet"
-    // When loading, it shows "Loading time intervals..."
-    // When error, it shows "Error loading time intervals"
-    // All contain "time intervals" - use getAllByText since there are multiple matches (tab, description, empty state)
-    const timeIntervalsTexts = await screen.findAllByText(/time intervals/i, {}, { timeout: 5000 });
-    expect(timeIntervalsTexts.length).toBeGreaterThan(0);
-  });
-});

public/app/features/alerting/unified/TimeIntervalsPage.tsx

@@ -1,31 +0,0 @@
-import { AlertmanagerPageWrapper } from './components/AlertingPageWrapper';
-import { GrafanaAlertmanagerWarning } from './components/GrafanaAlertmanagerWarning';
-import { TimeIntervalsTable } from './components/mute-timings/MuteTimingsTable';
-import { useNotificationConfigNav } from './navigation/useNotificationConfigNav';
-import { useAlertmanager } from './state/AlertmanagerContext';
-import { withPageErrorBoundary } from './withPageErrorBoundary';
-
-// Content component that uses AlertmanagerContext
-// This must be rendered within AlertmanagerPageWrapper
-function TimeIntervalsPageContent() {
-  const { selectedAlertmanager } = useAlertmanager();
-
-  return (
-    <>
-      <GrafanaAlertmanagerWarning currentAlertmanager={selectedAlertmanager!} />
-      <TimeIntervalsTable />
-    </>
-  );
-}
-
-function TimeIntervalsPage() {
-  const { navId, pageNav } = useNotificationConfigNav();
-
-  return (
-    <AlertmanagerPageWrapper navId={navId || 'am-routes'} pageNav={pageNav} accessType="notification">
-      <TimeIntervalsPageContent />
-    </AlertmanagerPageWrapper>
-  );
-}
-
-export default withPageErrorBoundary(TimeIntervalsPage);

public/app/features/alerting/unified/components/contact-points/ContactPoints.test.tsx

@@ -170,26 +170,6 @@ describe('contact points', () => {
       });
     });
 
-    test('shows only contact points without internal tabs', async () => {
-      renderWithProvider(<ContactPointsPageContents />);
-
-      // Should show contact points directly
-      expect(await screen.findByText(/create contact point/i)).toBeInTheDocument();
-
-      // Should not have tabs
-      expect(screen.queryByRole('tab')).not.toBeInTheDocument();
-    });
-
-    test('does not show templates tab', async () => {
-      renderWithProvider(<ContactPointsPageContents />);
-
-      // Should show contact points
-      expect(await screen.findByText(/create contact point/i)).toBeInTheDocument();
-
-      // Should not show templates tab
-      expect(screen.queryByText(/notification templates/i)).not.toBeInTheDocument();
-    });
-
     describe('templates tab', () => {
       it('does not show a warning for a "misconfigured" template', async () => {
         renderWithProvider(
@@ -278,6 +258,14 @@ describe('contact points', () => {
       // there should be view buttons though - one for provisioned, and one for the un-editable contact point
       const viewButtons = screen.getAllByRole('link', { name: /^view$/i });
       expect(viewButtons).toHaveLength(2);
+
+      // check buttons in Notification Templates
+      const notificationTemplatesTab = screen.getByRole('tab', { name: 'Notification Templates' });
+      await user.click(notificationTemplatesTab);
+      expect(screen.getByRole('link', { name: 'Add notification template group' })).toHaveAttribute(
+        'aria-disabled',
+        'true'
+      );
     });
 
     it('allows deleting when not disabled', async () => {
@@ -482,6 +470,11 @@ describe('contact points', () => {
       const viewButton = screen.getByRole('link', { name: /^view$/i });
       expect(viewButton).toBeInTheDocument();
       expect(viewButton).toBeEnabled();
+
+      // check buttons in Notification Templates
+      const notificationTemplatesTab = screen.getByRole('tab', { name: 'Notification Templates' });
+      await user.click(notificationTemplatesTab);
+      expect(screen.queryByRole('link', { name: 'Add notification template group' })).not.toBeInTheDocument();
     });
   });
 

public/app/features/alerting/unified/components/contact-points/ContactPoints.tsx

@@ -1,5 +1,19 @@
+import { useMemo } from 'react';
+
 import { Trans, t } from '@grafana/i18n';
-import { Alert, Button, EmptyState, LinkButton, LoadingPlaceholder, Pagination, Stack } from '@grafana/ui';
+import {
+  Alert,
+  Button,
+  EmptyState,
+  LinkButton,
+  LoadingPlaceholder,
+  Pagination,
+  Stack,
+  Tab,
+  TabContent,
+  TabsBar,
+  Text,
+} from '@grafana/ui';
 import { contextSrv } from 'app/core/services/context_srv';
 import { shouldUseK8sApi } from 'app/features/alerting/unified/utils/k8s/utils';
 import { makeAMLink, stringifyErrorLike } from 'app/features/alerting/unified/utils/misc';
@@ -8,7 +22,6 @@ import { AccessControlAction } from 'app/types/accessControl';
 import { AlertmanagerAction, useAlertmanagerAbility } from '../../hooks/useAbilities';
 import { usePagination } from '../../hooks/usePagination';
 import { useURLSearchParams } from '../../hooks/useURLSearchParams';
-import { useNotificationConfigNav } from '../../navigation/useNotificationConfigNav';
 import { useAlertmanager } from '../../state/AlertmanagerContext';
 import { isExtraConfig } from '../../utils/alertmanager/extraConfigs';
 import { GRAFANA_RULES_SOURCE_NAME } from '../../utils/datasource';
@@ -17,6 +30,7 @@ import { AlertmanagerPageWrapper } from '../AlertingPageWrapper';
 import { GrafanaAlertmanagerWarning } from '../GrafanaAlertmanagerWarning';
 
 import { ContactPoint } from './ContactPoint';
+import { NotificationTemplates } from './NotificationTemplates';
 import { ContactPointsFilter } from './components/ContactPointsFilter';
 import { GlobalConfigAlert } from './components/GlobalConfigAlert';
 import { useContactPointsWithStatus } from './useContactPoints';
@@ -85,7 +99,7 @@ const ContactPointsTab = () => {
   }
 
   return (
-    <Stack direction="column" gap={1}>
+    <>
       {/* TODO we can add some additional info here with a ToggleTip */}
       <Stack direction="row" alignItems="end" justifyContent="space-between">
         <ContactPointsFilter />
@@ -134,19 +148,109 @@ const ContactPointsTab = () => {
         <GlobalConfigAlert alertManagerName={selectedAlertmanager!} />
       )}
       {ExportDrawer}
-    </Stack>
+    </>
   );
 };
 
+const NotificationTemplatesTab = () => {
+  const [createTemplateSupported, createTemplateAllowed] = useAlertmanagerAbility(
+    AlertmanagerAction.CreateNotificationTemplate
+  );
+
+  return (
+    <>
+      <Stack direction="row" alignItems="center" justifyContent="space-between">
+        <Text variant="body" color="secondary">
+          <Trans i18nKey="alerting.notification-templates-tab.create-notification-templates-customize-notifications">
+            Create notification templates to customize your notifications.
+          </Trans>
+        </Text>
+        {createTemplateSupported && (
+          <LinkButton
+            icon="plus"
+            variant="primary"
+            href="/alerting/notifications/templates/new"
+            disabled={!createTemplateAllowed}
+          >
+            <Trans i18nKey="alerting.notification-templates-tab.add-notification-template-group">
+              Add notification template group
+            </Trans>
+          </LinkButton>
+        )}
+      </Stack>
+      <NotificationTemplates />
+    </>
+  );
+};
+
+const useTabQueryParam = (defaultTab: ActiveTab) => {
+  const [queryParams, setQueryParams] = useURLSearchParams();
+  const param = useMemo(() => {
+    const queryParam = queryParams.get('tab');
+
+    if (!queryParam || !Object.values(ActiveTab).map(String).includes(queryParam)) {
+      return defaultTab;
+    }
+
+    return queryParam || defaultTab;
+  }, [defaultTab, queryParams]);
+
+  const setParam = (tab: ActiveTab) => setQueryParams({ tab });
+  return [param, setParam] as const;
+};
+
 export const ContactPointsPageContents = () => {
   const { selectedAlertmanager } = useAlertmanager();
+  const [, canViewContactPoints] = useAlertmanagerAbility(AlertmanagerAction.ViewContactPoint);
+  const [, canCreateContactPoints] = useAlertmanagerAbility(AlertmanagerAction.CreateContactPoint);
+  const [, showTemplatesTab] = useAlertmanagerAbility(AlertmanagerAction.ViewNotificationTemplate);
+
+  const showContactPointsTab = canViewContactPoints || canCreateContactPoints;
+
+  // Depending on permissions, user may not have access to all tabs,
+  // but we can default to picking the first one that they definitely _do_ have access to
+  const defaultTab = [
+    showContactPointsTab && ActiveTab.ContactPoints,
+    showTemplatesTab && ActiveTab.NotificationTemplates,
+  ].filter((tab) => !!tab)[0];
+
+  const [activeTab, setActiveTab] = useTabQueryParam(defaultTab);
+
+  const { contactPoints } = useContactPointsWithStatus({
+    alertmanager: selectedAlertmanager!,
+  });
+
+  const showingContactPoints = activeTab === ActiveTab.ContactPoints;
+  const showNotificationTemplates = activeTab === ActiveTab.NotificationTemplates;
 
-  // Show only contact points (no internal tabs)
-  // Templates are accessible via the sidebar navigation
   return (
     <>
       <GrafanaAlertmanagerWarning currentAlertmanager={selectedAlertmanager!} />
-      <ContactPointsTab />
+      <Stack direction="column">
+        <TabsBar>
+          {showContactPointsTab && (
+            <Tab
+              label={t('alerting.contact-points-page-contents.label-contact-points', 'Contact Points')}
+              active={showingContactPoints}
+              counter={contactPoints.length}
+              onChangeTab={() => setActiveTab(ActiveTab.ContactPoints)}
+            />
+          )}
+          {showTemplatesTab && (
+            <Tab
+              label={t('alerting.contact-points-page-contents.label-notification-templates', 'Notification Templates')}
+              active={showNotificationTemplates}
+              onChangeTab={() => setActiveTab(ActiveTab.NotificationTemplates)}
+            />
+          )}
+        </TabsBar>
+        <TabContent>
+          <Stack direction="column">
+            {showingContactPoints && <ContactPointsTab />}
+            {showNotificationTemplates && <NotificationTemplatesTab />}
+          </Stack>
+        </TabContent>
+      </Stack>
     </>
   );
 };
@@ -178,9 +282,8 @@ const ContactPointsList = ({ contactPoints, search, pageSize = DEFAULT_PAGE_SIZE
 };
 
 function ContactPointsPage() {
-  const { navId, pageNav } = useNotificationConfigNav();
   return (
-    <AlertmanagerPageWrapper navId={navId || 'receivers'} pageNav={pageNav} accessType="notification">
+    <AlertmanagerPageWrapper navId="receivers" accessType="notification">
       <ContactPointsPageContents />
     </AlertmanagerPageWrapper>
   );

public/app/features/alerting/unified/components/rules/central-state-history/CentralAlertHistoryPage.tsx

@@ -1,13 +1,11 @@
-import { useInsightsNav } from '../../../navigation/useInsightsNav';
 import { withPageErrorBoundary } from '../../../withPageErrorBoundary';
 import { AlertingPageWrapper } from '../../AlertingPageWrapper';
 
 import { CentralAlertHistoryScene } from './CentralAlertHistoryScene';
 
 function HistoryPage() {
-  const { navId, pageNav } = useInsightsNav();
   return (
-    <AlertingPageWrapper navId={navId || 'alerts-history'} pageNav={pageNav} isLoading={false}>
+    <AlertingPageWrapper navId="alerts-history" isLoading={false}>
       <CentralAlertHistoryScene />
     </AlertingPageWrapper>
   );

public/app/features/alerting/unified/components/rules/deleted-rules/DeletedRulesPage.tsx

@@ -3,7 +3,6 @@ import { Alert } from '@grafana/ui';
 
 import { alertRuleApi } from '../../../api/alertRuleApi';
 import { GRAFANA_RULER_CONFIG } from '../../../api/featureDiscoveryApi';
-import { useAlertRulesNav } from '../../../navigation/useAlertRulesNav';
 import { stringifyErrorLike } from '../../../utils/misc';
 import { withPageErrorBoundary } from '../../../withPageErrorBoundary';
 import { AlertingPageWrapper } from '../../AlertingPageWrapper';
@@ -19,10 +18,9 @@ function DeletedrulesPage() {
     rulerConfig: GRAFANA_RULER_CONFIG,
     filter: {}, // todo: add filters, and limit?????
   });
-  const { navId, pageNav } = useAlertRulesNav();
 
   return (
-    <AlertingPageWrapper navId={navId || 'alerts/recently-deleted'} pageNav={pageNav} isLoading={isLoading}>
+    <AlertingPageWrapper navId="alerts/recently-deleted" isLoading={isLoading}>
       <>
         {error && (
           <Alert title={t('alerting.deleted-rules.errorloading', 'Failed to load alert deleted rules')}>

public/app/features/alerting/unified/home/Home.tsx

@@ -1,24 +1,23 @@
-import { useMemo, useState } from 'react';
+import { useState } from 'react';
 
 import { t } from '@grafana/i18n';
 import { Box, Stack, Tab, TabContent, TabsBar } from '@grafana/ui';
 
 import { AlertingPageWrapper } from '../components/AlertingPageWrapper';
+import { isLocalDevEnv } from '../utils/misc';
 import { withPageErrorBoundary } from '../withPageErrorBoundary';
 
 import GettingStarted, { WelcomeHeader } from './GettingStarted';
 import IRMCard from './IRMCard';
-import { getInsightsScenes } from './Insights';
+import { getInsightsScenes, insightsIsAvailable } from './Insights';
 import { PluginIntegrations } from './PluginIntegrations';
 import SyntheticMonitoringCard from './SyntheticMonitoringCard';
 
 function Home() {
-  // Insights tab is not shown on Home page - Insights is available via the sidebar menu instead
-  const insightsEnabled = false;
+  const insightsEnabled = insightsIsAvailable() || isLocalDevEnv();
 
   const [activeTab, setActiveTab] = useState<'insights' | 'overview'>(insightsEnabled ? 'insights' : 'overview');
-  // Memoize the scene so it's only created once and properly initialized
-  const insightsScene = useMemo(() => getInsightsScenes(), []);
+  const insightsScene = getInsightsScenes();
 
   return (
     <AlertingPageWrapper subTitle="Learn about problems in your systems moments after they occur" navId="alerting">

public/app/features/alerting/unified/insights/InsightsPage.tsx

@@ -1,44 +0,0 @@
-import { useMemo } from 'react';
-
-import { Trans, t } from '@grafana/i18n';
-
-import { AlertingPageWrapper } from '../components/AlertingPageWrapper';
-import { getInsightsScenes, insightsIsAvailable } from '../home/Insights';
-import { useInsightsNav } from '../navigation/useInsightsNav';
-import { isLocalDevEnv } from '../utils/misc';
-import { withPageErrorBoundary } from '../withPageErrorBoundary';
-
-function InsightsPage() {
-  const insightsEnabled = insightsIsAvailable() || isLocalDevEnv();
-  const { navId, pageNav } = useInsightsNav();
-  // Memoize the scene so it's only created once and properly initialized
-  const insightsScene = useMemo(() => getInsightsScenes(), []);
-
-  if (!insightsEnabled) {
-    return (
-      <AlertingPageWrapper
-        navId={navId || 'insights'}
-        pageNav={pageNav}
-        subTitle={t('alerting.insights.subtitle', 'Analytics and history for alerting')}
-      >
-        <div>
-          <Trans i18nKey="alerting.insights.not-available">
-            Insights are not available. Please configure the required data sources.
-          </Trans>
-        </div>
-      </AlertingPageWrapper>
-    );
-  }
-
-  return (
-    <AlertingPageWrapper
-      navId={navId || 'insights'}
-      pageNav={pageNav}
-      subTitle={t('alerting.insights.subtitle', 'Analytics and history for alerting')}
-    >
-      <insightsScene.Component model={insightsScene} />
-    </AlertingPageWrapper>
-  );
-}
-
-export default withPageErrorBoundary(InsightsPage);

public/app/features/alerting/unified/navigation/useAlertActivityNav.test.tsx

@@ -1,134 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { getWrapper } from 'test/test-utils';
-
-import { configureStore } from 'app/store/configureStore';
-
-import { useAlertActivityNav } from './useAlertActivityNav';
-
-describe('useAlertActivityNav', () => {
-  const mockNavIndex = {
-    'alert-activity': {
-      id: 'alert-activity',
-      text: 'Alert activity',
-      url: '/alerting/alerts',
-    },
-    'alert-activity-alerts': {
-      id: 'alert-activity-alerts',
-      text: 'Alerts',
-      url: '/alerting/alerts',
-    },
-    'alert-activity-groups': {
-      id: 'alert-activity-groups',
-      text: 'Active notifications',
-      url: '/alerting/groups',
-    },
-  };
-
-  const defaultPreloadedState = {
-    navIndex: mockNavIndex,
-  };
-
-  it('should return navigation with pageNav for Alerts tab', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/alerts'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertActivityNav(), { wrapper });
-
-    expect(result.current.navId).toBe('alert-activity');
-    expect(result.current.pageNav).toBeDefined();
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children).toBeDefined();
-    // The pageNav should represent Alert Activity (not the active tab) for consistent title
-    expect(result.current.pageNav?.text).toBe('Alert activity');
-  });
-
-  it('should return navigation with pageNav for Active notifications tab', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/groups'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertActivityNav(), { wrapper });
-
-    expect(result.current.navId).toBe('alert-activity');
-    expect(result.current.pageNav).toBeDefined();
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children).toBeDefined();
-    // The pageNav should represent Alert Activity (not the active tab) for consistent title
-    expect(result.current.pageNav?.text).toBe('Alert activity');
-  });
-
-  it('should set active tab based on current path', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/groups'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertActivityNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    const activeNotificationsTab = result.current.pageNav?.children?.find((tab) => tab.id === 'alert-activity-groups');
-    expect(activeNotificationsTab?.active).toBe(true);
-
-    // eslint-disable-next-line testing-library/no-node-access
-    const alertsTab = result.current.pageNav?.children?.find((tab) => tab.id === 'alert-activity-alerts');
-    expect(alertsTab?.active).toBe(false);
-  });
-
-  it('should filter tabs based on permissions', () => {
-    const limitedNavIndex = {
-      'alert-activity': mockNavIndex['alert-activity'],
-      'alert-activity-alerts': mockNavIndex['alert-activity-alerts'],
-      // Missing 'alert-activity-groups' - user doesn't have permission
-    };
-    const store = configureStore({
-      navIndex: limitedNavIndex,
-    });
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/alerts'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertActivityNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.length).toBe(1);
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.[0].id).toBe('alert-activity-alerts');
-  });
-
-  it('should return undefined when alert-activity nav is missing', () => {
-    const store = configureStore({
-      navIndex: {},
-    });
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/groups'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertActivityNav(), { wrapper });
-
-    expect(result.current.navId).toBeUndefined();
-    expect(result.current.pageNav).toBeUndefined();
-  });
-});

public/app/features/alerting/unified/navigation/useAlertActivityNav.ts

@@ -1,57 +0,0 @@
-import { useLocation } from 'react-router-dom-v5-compat';
-
-import { NavModelItem } from '@grafana/data';
-import { t } from '@grafana/i18n';
-import { useSelector } from 'app/types/store';
-
-export function useAlertActivityNav() {
-  const location = useLocation();
-  const navIndex = useSelector((state) => state.navIndex);
-
-  const alertActivityNav = navIndex['alert-activity'];
-  if (!alertActivityNav) {
-    return {
-      navId: undefined,
-      pageNav: undefined,
-    };
-  }
-
-  // All available tabs
-  const allTabs = [
-    {
-      id: 'alert-activity-alerts',
-      text: t('alerting.navigation.alerts', 'Alerts'),
-      url: '/alerting/alerts',
-      active: location.pathname === '/alerting/alerts',
-      icon: 'bell',
-      parentItem: alertActivityNav,
-    },
-    {
-      id: 'alert-activity-groups',
-      text: t('alerting.navigation.active-notifications', 'Active notifications'),
-      url: '/alerting/groups',
-      active: location.pathname === '/alerting/groups',
-      icon: 'layer-group',
-      parentItem: alertActivityNav,
-    },
-  ].filter((tab) => {
-    // Filter based on permissions - if nav item doesn't exist, user doesn't have permission
-    const navItem = navIndex[tab.id];
-    return navItem !== undefined;
-  });
-
-  // Create pageNav structure following the same pattern as useNotificationConfigNav
-  // Keep "Alert Activity" as the pageNav (not the active tab) so the title and subtitle stay consistent
-  // The tabs are children, and the breadcrumb utility will add the active tab to breadcrumbs
-  // (including the first tab, after our fix to the breadcrumb utility)
-  const pageNav: NavModelItem = {
-    ...alertActivityNav,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    children: allTabs as NavModelItem[],
-  };
-
-  return {
-    navId: 'alert-activity',
-    pageNav,
-  };
-}

public/app/features/alerting/unified/navigation/useAlertRulesNav.test.tsx

@@ -1,95 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { getWrapper } from 'test/test-utils';
-
-import { configureStore } from 'app/store/configureStore';
-
-import { useAlertRulesNav } from './useAlertRulesNav';
-
-describe('useAlertRulesNav', () => {
-  const mockNavIndex = {
-    'alert-rules': {
-      id: 'alert-rules',
-      text: 'Alert rules',
-      url: '/alerting/list',
-      icon: 'list-ul' as const,
-    },
-    'alert-rules-list': {
-      id: 'alert-rules-list',
-      text: 'Alert rules',
-      url: '/alerting/list',
-    },
-    'alert-rules-recently-deleted': {
-      id: 'alert-rules-recently-deleted',
-      text: 'Recently deleted',
-      url: '/alerting/recently-deleted',
-    },
-  };
-
-  const defaultPreloadedState = {
-    navIndex: mockNavIndex,
-  };
-
-  it('should return navigation with pageNav', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/list'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertRulesNav(), { wrapper });
-
-    expect(result.current.navId).toBe('alert-rules');
-    expect(result.current.pageNav).toBeDefined();
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children).toBeDefined();
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.length).toBeGreaterThan(0);
-  });
-
-  it('should filter tabs based on permissions', () => {
-    const limitedNavIndex = {
-      'alert-rules': mockNavIndex['alert-rules'],
-      'alert-rules-list': mockNavIndex['alert-rules-list'],
-      // Missing 'alert-rules-recently-deleted' - user doesn't have permission
-    };
-    const store = configureStore({
-      navIndex: limitedNavIndex,
-    });
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/list'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertRulesNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.length).toBe(1);
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.[0].id).toBe('alert-rules-list');
-  });
-
-  it('should set active tab based on current path', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/recently-deleted'],
-      },
-    });
-
-    const { result } = renderHook(() => useAlertRulesNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    const recentlyDeletedTab = result.current.pageNav?.children?.find(
-      (tab) => tab.id === 'alert-rules-recently-deleted'
-    );
-    expect(recentlyDeletedTab?.active).toBe(true);
-  });
-});

public/app/features/alerting/unified/navigation/useAlertRulesNav.ts

@@ -1,54 +0,0 @@
-import { useLocation } from 'react-router-dom-v5-compat';
-
-import { NavModelItem } from '@grafana/data';
-import { t } from '@grafana/i18n';
-import { useSelector } from 'app/types/store';
-
-export function useAlertRulesNav() {
-  const location = useLocation();
-  const navIndex = useSelector((state) => state.navIndex);
-
-  const alertRulesNav = navIndex['alert-rules'];
-  if (!alertRulesNav) {
-    return {
-      navId: undefined,
-      pageNav: undefined,
-    };
-  }
-
-  // All available tabs
-  const allTabs = [
-    {
-      id: 'alert-rules-list',
-      text: t('alerting.navigation.alert-rules', 'Alert rules'),
-      url: '/alerting/list',
-      active: location.pathname === '/alerting/list',
-      icon: 'list-ul',
-      parentItem: alertRulesNav,
-    },
-    {
-      id: 'alert-rules-recently-deleted',
-      text: t('alerting.navigation.recently-deleted', 'Recently deleted'),
-      url: '/alerting/recently-deleted',
-      active: location.pathname === '/alerting/recently-deleted',
-      icon: 'trash-alt',
-      parentItem: alertRulesNav,
-    },
-  ].filter((tab) => {
-    // Filter based on permissions - if nav item doesn't exist, user doesn't have permission
-    const navItem = navIndex[tab.id];
-    return navItem !== undefined;
-  });
-
-  // Create pageNav that represents the Alert rules page with tabs as children
-  const pageNav: NavModelItem = {
-    ...alertRulesNav,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    children: allTabs as NavModelItem[],
-  };
-
-  return {
-    navId: 'alert-rules',
-    pageNav,
-  };
-}

public/app/features/alerting/unified/navigation/useInsightsNav.test.tsx

@@ -1,90 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { getWrapper } from 'test/test-utils';
-
-import { configureStore } from 'app/store/configureStore';
-
-import { useInsightsNav } from './useInsightsNav';
-
-describe('useInsightsNav', () => {
-  const mockNavIndex = {
-    insights: {
-      id: 'insights',
-      text: 'Insights',
-      url: '/alerting/insights',
-    },
-    'insights-system': {
-      id: 'insights-system',
-      text: 'System Insights',
-      url: '/alerting/insights',
-    },
-    'insights-history': {
-      id: 'insights-history',
-      text: 'Alert state history',
-      url: '/alerting/history',
-    },
-  };
-
-  const defaultPreloadedState = {
-    navIndex: mockNavIndex,
-  };
-
-  it('should return navigation with pageNav', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/insights'],
-      },
-    });
-
-    const { result } = renderHook(() => useInsightsNav(), { wrapper });
-
-    expect(result.current.navId).toBe('insights');
-    expect(result.current.pageNav).toBeDefined();
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children).toBeDefined();
-  });
-
-  it('should set active tab based on current path', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/history'],
-      },
-    });
-
-    const { result } = renderHook(() => useInsightsNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    const historyTab = result.current.pageNav?.children?.find((tab) => tab.id === 'insights-history');
-    expect(historyTab?.active).toBe(true);
-  });
-
-  it('should filter tabs based on permissions', () => {
-    const limitedNavIndex = {
-      insights: mockNavIndex.insights,
-      'insights-system': mockNavIndex['insights-system'],
-      // Missing 'insights-history' - user doesn't have permission
-    };
-    const store = configureStore({
-      navIndex: limitedNavIndex,
-    });
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/insights'],
-      },
-    });
-
-    const { result } = renderHook(() => useInsightsNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.length).toBe(1);
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.[0].id).toBe('insights-system');
-  });
-});

public/app/features/alerting/unified/navigation/useInsightsNav.ts

@@ -1,54 +0,0 @@
-import { useLocation } from 'react-router-dom-v5-compat';
-
-import { NavModelItem } from '@grafana/data';
-import { t } from '@grafana/i18n';
-import { useSelector } from 'app/types/store';
-
-export function useInsightsNav() {
-  const location = useLocation();
-  const navIndex = useSelector((state) => state.navIndex);
-
-  const insightsNav = navIndex.insights;
-  if (!insightsNav) {
-    return {
-      navId: undefined,
-      pageNav: undefined,
-    };
-  }
-
-  // All available tabs
-  const allTabs = [
-    {
-      id: 'insights-system',
-      text: t('alerting.navigation.system-insights', 'System Insights'),
-      url: '/alerting/insights',
-      active: location.pathname === '/alerting/insights',
-      icon: 'chart-line',
-      parentItem: insightsNav,
-    },
-    {
-      id: 'insights-history',
-      text: t('alerting.navigation.alert-state-history', 'Alert state history'),
-      url: '/alerting/history',
-      active: location.pathname === '/alerting/history',
-      icon: 'history',
-      parentItem: insightsNav,
-    },
-  ].filter((tab) => {
-    // Filter based on permissions - if nav item doesn't exist, user doesn't have permission
-    const navItem = navIndex[tab.id];
-    return navItem !== undefined;
-  });
-
-  // Create pageNav that represents the Insights page with tabs as children
-  const pageNav: NavModelItem = {
-    ...insightsNav,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    children: allTabs as NavModelItem[],
-  };
-
-  return {
-    navId: 'insights',
-    pageNav,
-  };
-}

public/app/features/alerting/unified/navigation/useNotificationConfigNav.test.tsx

@@ -1,102 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { getWrapper } from 'test/test-utils';
-
-import { configureStore } from 'app/store/configureStore';
-
-import { useNotificationConfigNav } from './useNotificationConfigNav';
-
-describe('useNotificationConfigNav', () => {
-  const mockNavIndex = {
-    'notification-config': {
-      id: 'notification-config',
-      text: 'Notification configuration',
-      url: '/alerting/notifications',
-    },
-    'notification-config-contact-points': {
-      id: 'notification-config-contact-points',
-      text: 'Contact points',
-      url: '/alerting/notifications',
-    },
-    'notification-config-policies': {
-      id: 'notification-config-policies',
-      text: 'Notification policies',
-      url: '/alerting/routes',
-    },
-    'notification-config-templates': {
-      id: 'notification-config-templates',
-      text: 'Notification templates',
-      url: '/alerting/notifications/templates',
-    },
-    'notification-config-time-intervals': {
-      id: 'notification-config-time-intervals',
-      text: 'Time intervals',
-      url: '/alerting/time-intervals',
-    },
-  };
-
-  const defaultPreloadedState = {
-    navIndex: mockNavIndex,
-  };
-
-  it('should return navigation with pageNav', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/notifications'],
-      },
-    });
-
-    const { result } = renderHook(() => useNotificationConfigNav(), { wrapper });
-
-    expect(result.current.navId).toBe('notification-config');
-    expect(result.current.pageNav).toBeDefined();
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children).toBeDefined();
-  });
-
-  it('should detect time intervals tab from path', () => {
-    const store = configureStore(defaultPreloadedState);
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/time-intervals'],
-      },
-    });
-
-    const { result } = renderHook(() => useNotificationConfigNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    const timeIntervalsTab = result.current.pageNav?.children?.find(
-      (tab) => tab.id === 'notification-config-time-intervals'
-    );
-    expect(timeIntervalsTab?.active).toBe(true);
-  });
-
-  it('should filter tabs based on permissions', () => {
-    const limitedNavIndex = {
-      'notification-config': mockNavIndex['notification-config'],
-      'notification-config-contact-points': mockNavIndex['notification-config-contact-points'],
-      // Missing other tabs - user doesn't have permission
-    };
-    const store = configureStore({
-      navIndex: limitedNavIndex,
-    });
-    const wrapper = getWrapper({
-      store,
-      renderWithRouter: true,
-      historyOptions: {
-        initialEntries: ['/alerting/notifications'],
-      },
-    });
-
-    const { result } = renderHook(() => useNotificationConfigNav(), { wrapper });
-
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.length).toBe(1);
-    // eslint-disable-next-line testing-library/no-node-access
-    expect(result.current.pageNav?.children?.[0].id).toBe('notification-config-contact-points');
-  });
-});

public/app/features/alerting/unified/navigation/useNotificationConfigNav.ts

@@ -1,86 +0,0 @@
-import { useLocation } from 'react-router-dom-v5-compat';
-
-import { NavModelItem } from '@grafana/data';
-import { t } from '@grafana/i18n';
-import { useSelector } from 'app/types/store';
-
-export function useNotificationConfigNav() {
-  const location = useLocation();
-  const navIndex = useSelector((state) => state.navIndex);
-
-  const notificationConfigNav = navIndex['notification-config'];
-  if (!notificationConfigNav) {
-    // Fallback to legacy navIds
-    if (location.pathname.includes('/alerting/notifications/templates')) {
-      return {
-        navId: 'receivers',
-        pageNav: undefined,
-      };
-    }
-    if (location.pathname === '/alerting/routes') {
-      return {
-        navId: 'am-routes',
-        pageNav: undefined,
-      };
-    }
-    return {
-      navId: 'receivers',
-      pageNav: undefined,
-    };
-  }
-
-  // Check if we're on the time intervals page
-  const isTimeIntervalsTab = location.pathname === '/alerting/time-intervals';
-
-  // All available tabs
-  const allTabs = [
-    {
-      id: 'notification-config-contact-points',
-      text: t('alerting.navigation.contact-points', 'Contact points'),
-      url: '/alerting/notifications',
-      active: location.pathname === '/alerting/notifications' && !location.pathname.includes('/templates'),
-      icon: 'comment-alt-share',
-      parentItem: notificationConfigNav,
-    },
-    {
-      id: 'notification-config-policies',
-      text: t('alerting.navigation.notification-policies', 'Notification policies'),
-      url: '/alerting/routes',
-      active: location.pathname === '/alerting/routes' && !isTimeIntervalsTab,
-      icon: 'sitemap',
-      parentItem: notificationConfigNav,
-    },
-    {
-      id: 'notification-config-templates',
-      text: t('alerting.navigation.notification-templates', 'Notification templates'),
-      url: '/alerting/notifications/templates',
-      active: location.pathname.includes('/alerting/notifications/templates'),
-      icon: 'file-alt',
-      parentItem: notificationConfigNav,
-    },
-    {
-      id: 'notification-config-time-intervals',
-      text: t('alerting.navigation.time-intervals', 'Time intervals'),
-      url: '/alerting/time-intervals',
-      active: isTimeIntervalsTab,
-      icon: 'clock-nine',
-      parentItem: notificationConfigNav,
-    },
-  ].filter((tab) => {
-    // Filter based on permissions - if nav item doesn't exist, user doesn't have permission
-    const navItem = navIndex[tab.id];
-    return navItem !== undefined;
-  });
-
-  // Create pageNav that represents the Notification configuration page with tabs as children
-  const pageNav: NavModelItem = {
-    ...notificationConfigNav,
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    children: allTabs as NavModelItem[],
-  };
-
-  return {
-    navId: 'notification-config',
-    pageNav,
-  };
-}

public/app/features/alerting/unified/rule-list/RuleList.v1.tsx

@@ -20,7 +20,6 @@ import { shouldUsePrometheusRulesPrimary } from '../featureToggles';
 import { useCombinedRuleNamespaces } from '../hooks/useCombinedRuleNamespaces';
 import { useFilteredRules, useRulesFilter } from '../hooks/useFilteredRules';
 import { useUnifiedAlertingSelector } from '../hooks/useUnifiedAlertingSelector';
-import { useAlertRulesNav } from '../navigation/useAlertRulesNav';
 import { fetchAllPromAndRulerRulesAction, fetchAllPromRulesAction, fetchRulerRulesAction } from '../state/actions';
 import { RULE_LIST_POLL_INTERVAL_MS } from '../utils/constants';
 import { GRAFANA_RULES_SOURCE_NAME, getAllRulesSourceNames } from '../utils/datasource';
@@ -116,14 +115,11 @@ const RuleListV1 = () => {
 
   const combinedNamespaces: CombinedRuleNamespace[] = useCombinedRuleNamespaces();
   const filteredNamespaces = useFilteredRules(combinedNamespaces, filterState);
-  const { navId, pageNav } = useAlertRulesNav();
-
   return (
     // We don't want to show the Loading... indicator for the whole page.
     // We show separate indicators for Grafana-managed and Cloud rules
     <AlertingPageWrapper
-      navId={navId}
-      pageNav={pageNav}
+      navId="alert-list"
       isLoading={false}
       renderTitle={(title) => <RuleListPageTitle title={title} />}
       actions={<RuleListActionButtons hasAlertRulesCreated={hasAlertRulesCreated} />}

public/app/features/alerting/unified/rule-list/RuleList.v2.tsx

@@ -13,7 +13,6 @@ import { useListViewMode } from '../components/rules/Filter/RulesViewModeSelecto
 import { AIAlertRuleButtonComponent } from '../enterprise-components/AI/AIGenAlertRuleButton/addAIAlertRuleButton';
 import { AlertingAction, useAlertingAbility } from '../hooks/useAbilities';
 import { useRulesFilter } from '../hooks/useFilteredRules';
-import { useAlertRulesNav } from '../navigation/useAlertRulesNav';
 import { getRulesDataSources } from '../utils/datasource';
 
 import { FilterView } from './FilterView';
@@ -124,12 +123,10 @@ export function RuleListActions() {
 
 export default function RuleListPage() {
   const { isApplying } = useApplyDefaultSearch();
-  const { navId, pageNav } = useAlertRulesNav();
 
   return (
     <AlertingPageWrapper
-      navId={navId}
-      pageNav={pageNav}
+      navId="alert-list"
       renderTitle={(title) => <RuleListPageTitle title={title} />}
       isLoading={isApplying}
       actions={<RuleListActions />}

public/app/features/alerting/unified/triage/Triage.tsx

@@ -1,16 +1,23 @@
+import { t } from '@grafana/i18n';
 import { UrlSyncContextProvider } from '@grafana/scenes';
 import { withErrorBoundary } from '@grafana/ui';
 
 import { AlertingPageWrapper } from '../components/AlertingPageWrapper';
-import { useAlertActivityNav } from '../navigation/useAlertActivityNav';
 
 import { TriageScene, triageScene } from './scene/TriageScene';
 
 export const TriagePage = () => {
-  const { navId, pageNav } = useAlertActivityNav();
-
   return (
-    <AlertingPageWrapper navId={navId || 'alert-alerts'} pageNav={pageNav}>
+    <AlertingPageWrapper
+      navId="alert-alerts"
+      subTitle={t(
+        'alerting.pages.triage.subtitle',
+        'See what is currently alerting and explore historical data to investigate current or past issues.'
+      )}
+      pageNav={{
+        text: t('alerting.pages.triage.title', 'Alerts'),
+      }}
+    >
       <UrlSyncContextProvider scene={triageScene} updateUrlOnInit={true} createBrowserHistorySteps={true}>
         <TriageScene key={triageScene.state.key} />
       </UrlSyncContextProvider>

public/app/features/dashboard-scene/scene/VariableControls.test.tsx

@@ -1,84 +0,0 @@
-import { render, screen } from '@testing-library/react';
-
-import { VariableHide } from '@grafana/data';
-import { SceneGridLayout, SceneVariable, SceneVariableSet, ScopesVariable, TextBoxVariable } from '@grafana/scenes';
-
-import { DashboardScene } from './DashboardScene';
-import { VariableControls } from './VariableControls';
-import { DefaultGridLayoutManager } from './layout-default/DefaultGridLayoutManager';
-
-jest.mock('@grafana/runtime', () => {
-  const runtime = jest.requireActual('@grafana/runtime');
-  return {
-    ...runtime,
-    config: {
-      ...runtime.config,
-      featureToggles: {
-        dashboardNewLayouts: true,
-      },
-    },
-  };
-});
-
-describe('VariableControls', () => {
-  it('should not render scopes variable', () => {
-    const variables = [new ScopesVariable({})];
-    const dashboard = buildScene(variables);
-    dashboard.activate();
-
-    render(<VariableControls dashboard={dashboard} />);
-
-    expect(screen.queryByText('__scopes')).not.toBeInTheDocument();
-  });
-
-  it('should not render regular hidden variables', () => {
-    const hiddenVariable = new TextBoxVariable({
-      name: 'HiddenVar',
-      hide: VariableHide.hideVariable,
-    });
-    const variables = [hiddenVariable];
-    const dashboard = buildScene(variables);
-    dashboard.activate();
-
-    render(<VariableControls dashboard={dashboard} />);
-
-    expect(screen.queryByText('HiddenVar')).not.toBeInTheDocument();
-  });
-
-  it('should render regular hidden variables in edit mode', async () => {
-    const hiddenVariable = new TextBoxVariable({
-      name: 'HiddenVar',
-      hide: VariableHide.hideVariable,
-    });
-    const variables = [hiddenVariable];
-    const dashboard = buildScene(variables);
-    dashboard.activate();
-
-    dashboard.setState({ isEditing: true });
-    render(<VariableControls dashboard={dashboard} />);
-
-    expect(await screen.findByText('HiddenVar')).toBeInTheDocument();
-  });
-
-  it('should not render variables hidden in controls menu in edit mode', async () => {
-    const dashboard = buildScene([new TextBoxVariable({ name: 'TextVarControls', hide: VariableHide.inControlsMenu })]);
-    dashboard.activate();
-
-    dashboard.setState({ isEditing: true });
-    render(<VariableControls dashboard={dashboard} />);
-
-    expect(screen.queryByText('TextVarControls')).not.toBeInTheDocument();
-  });
-});
-
-function buildScene(variables: SceneVariable[] = []) {
-  const dashboard = new DashboardScene({
-    $variables: new SceneVariableSet({ variables }),
-    body: new DefaultGridLayoutManager({
-      grid: new SceneGridLayout({
-        children: [],
-      }),
-    }),
-  });
-  return dashboard;
-}

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

@@ -39,9 +39,8 @@ export function VariableControls({ dashboard }: { dashboard: DashboardScene }) {
     ? restVariables.filter((v) => v.state.hide !== VariableHide.inControlsMenu)
     : variables.filter(
         (v) =>
-          // used for scopes variables, should always be hidden
           // if we're editing in dynamic dashboards, still shows hidden variable but greyed out
-          (!v.UNSAFE_renderAsHidden && isEditingNewLayouts && v.state.hide === VariableHide.hideVariable) ||
+          (isEditingNewLayouts && v.state.hide === VariableHide.hideVariable) ||
           v.state.hide !== VariableHide.inControlsMenu
       );
 

public/locales/en-US/grafana.json

@@ -938,6 +938,10 @@
       "label-search-by-name-or-type": "Search by name or type",
       "placeholder-search": "Search"
     },
+    "contact-points-page-contents": {
+      "label-contact-points": "Contact Points",
+      "label-notification-templates": "Notification Templates"
+    },
     "contact-points-tab": {
       "aria-label-add-contact-point": "add contact point",
       "aria-label-export-all": "export all",
@@ -1641,9 +1645,7 @@
     "insights": {
       "monitor-status-of-system": "Monitor the status of your system",
       "monitor-status-system-tooltip": "Alerting insights provides pre-built dashboards to monitor your alerting data.",
-      "monitor-status-system-tooltip-identify": "You can identify patterns in why things go wrong and discover trends in alerting performance within your organization.",
-      "not-available": "Insights are not available. Please configure the required data sources.",
-      "subtitle": "Analytics and history for alerting"
+      "monitor-status-system-tooltip-identify": "You can identify patterns in why things go wrong and discover trends in alerting performance within your organization."
     },
     "insights-menu-button-renderer": {
       "aria-label-rate-this-panel": "Rate this panel",
@@ -1926,18 +1928,6 @@
       "select-group": "Select group",
       "select-namespace": "Select namespace"
     },
-    "navigation": {
-      "active-notifications": "Active notifications",
-      "alert-rules": "Alert rules",
-      "alert-state-history": "Alert state history",
-      "alerts": "Alerts",
-      "contact-points": "Contact points",
-      "notification-policies": "Notification policies",
-      "notification-templates": "Notification templates",
-      "recently-deleted": "Recently deleted",
-      "system-insights": "System Insights",
-      "time-intervals": "Time intervals"
-    },
     "need-help-info": {
       "need-help": "Need help?"
     },
@@ -1986,6 +1976,10 @@
       "title-error-loading-alertmanager-config": "Error loading Alertmanager config",
       "title-notification-policies-have-changed": "Notification policies have changed"
     },
+    "notification-policies-tabs": {
+      "label-notification-policies": "Notification Policies",
+      "label-time-intervals": "Time intervals"
+    },
     "notification-policy-drawer": {
       "view-notification-policy-tree": "View notification policy tree"
     },
@@ -2051,6 +2045,12 @@
       "body-selected-alertmanager-not-found": "The selected Alertmanager no longer exists or you may not have permission to access it. You can select a different Alertmanager from the dropdown.",
       "title-selected-alertmanager-not-found": "Selected Alertmanager not found."
     },
+    "pages": {
+      "triage": {
+        "subtitle": "See what is currently alerting and explore historical data to investigate current or past issues.",
+        "title": "Alerts"
+      }
+    },
     "panel-alert-tab-content": {
       "alert": {
         "title-errors-loading-rules": "Errors loading rules"