v1.9.42: full Grafana/Prometheus GUI & CLI improvements

Grafana tab:
- Datasources table (Name, Type, URL, Default)
- Open Grafana button (opens browser)
- Switch to AlertManager endpoint for real-time active alerts

Prometheus tab:
- Quick query buttons (up, CPU, Memory)
- Metrics browser popup with filter (loads all metric names)
- Rules section (recording + alerting rules Treeview)

CLI:
- --grafana-datasources ALIAS
- --prom-rules ALIAS

i18n: 28 new keys (EN/RU/ZH)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

core/grafana_client.py

@@ -138,6 +138,16 @@ class GrafanaClient:
             log.error("Grafana list_alerts failed: %s", exc)
             return []
 
+    def get_active_alerts(self) -> list[dict]:
+        """List active (firing) alerts via AlertManager endpoint."""
+        try:
+            results = self._get("/api/alertmanager/grafana/api/v2/alerts")
+            log.info("Grafana: %d active alerts", len(results))
+            return results
+        except Exception as exc:
+            log.error("Grafana get_active_alerts failed: %s", exc)
+            return []
+
     def list_datasources(self) -> list[dict]:
         """
         List all datasources via GET /api/datasources.

core/i18n.py

@@ -429,6 +429,19 @@ _EN = {
     "grafana_connected": "Connected to {alias}",
     "grafana_no_dashboards": "No dashboards found",
     "grafana_no_alerts": "No alerts",
+    "grafana_loading": "Loading...",
+    "grafana_loaded": "{dashboards} dashboards, {alerts} alerts, {datasources} datasources",
+    "grafana_no_server": "No server selected",
+    "grafana_open_browser": "Open Grafana",
+    "grafana_datasources": "Datasources",
+    "grafana_ds_name": "Name",
+    "grafana_ds_type": "Type",
+    "grafana_ds_default": "Default",
+    "grafana_dash_title": "Title",
+    "grafana_dash_folder": "Folder",
+    "grafana_alert_state": "State",
+    "grafana_alert_name": "Name",
+    "grafana_alert_severity": "Severity",
 
     # Prometheus tab
     "prom_refresh": "Refresh",
@@ -444,6 +457,23 @@ _EN = {
     "prom_no_targets": "No targets",
     "prom_no_alerts": "No alerts",
     "prom_placeholder": "up",
+    "prom_loading": "Loading...",
+    "prom_loaded": "{targets} targets, {alerts} alerts, {rules} rules",
+    "prom_no_server": "No server selected",
+    "prom_executing": "Executing...",
+    "prom_results": "Results",
+    "prom_query_placeholder": "e.g. up, node_cpu_seconds_total",
+    "prom_metrics_browser": "Metrics",
+    "prom_filter_metrics": "Filter metrics...",
+    "prom_rules": "Rules",
+    "prom_rule_type": "Type",
+    "prom_rule_name": "Name",
+    "prom_rule_group": "Group",
+    "prom_rule_health": "Health",
+    "prom_target_job": "Job",
+    "prom_target_instance": "Instance",
+    "prom_target_health": "Health",
+    "prom_target_scrape": "Last Scrape",
 
     # PowerShell tab
     "ps_execute": "Execute",
@@ -956,6 +986,19 @@ _RU = {
     "grafana_connected": "Подключено к {alias}",
     "grafana_no_dashboards": "Дашборды не найдены",
     "grafana_no_alerts": "Нет оповещений",
+    "grafana_loading": "Загрузка...",
+    "grafana_loaded": "{dashboards} дашб., {alerts} оповещ., {datasources} источн.",
+    "grafana_no_server": "Сервер не выбран",
+    "grafana_open_browser": "Открыть Grafana",
+    "grafana_datasources": "Источники данных",
+    "grafana_ds_name": "Имя",
+    "grafana_ds_type": "Тип",
+    "grafana_ds_default": "По умолч.",
+    "grafana_dash_title": "Название",
+    "grafana_dash_folder": "Папка",
+    "grafana_alert_state": "Состояние",
+    "grafana_alert_name": "Имя",
+    "grafana_alert_severity": "Серьёзность",
 
     # Prometheus tab
     "prom_refresh": "Обновить",
@@ -971,6 +1014,23 @@ _RU = {
     "prom_no_targets": "Нет целей",
     "prom_no_alerts": "Нет оповещений",
     "prom_placeholder": "up",
+    "prom_loading": "Загрузка...",
+    "prom_loaded": "{targets} целей, {alerts} оповещ., {rules} правил",
+    "prom_no_server": "Сервер не выбран",
+    "prom_executing": "Выполнение...",
+    "prom_results": "Результаты",
+    "prom_query_placeholder": "напр. up, node_cpu_seconds_total",
+    "prom_metrics_browser": "Метрики",
+    "prom_filter_metrics": "Фильтр метрик...",
+    "prom_rules": "Правила",
+    "prom_rule_type": "Тип",
+    "prom_rule_name": "Имя",
+    "prom_rule_group": "Группа",
+    "prom_rule_health": "Здоровье",
+    "prom_target_job": "Job",
+    "prom_target_instance": "Инстанс",
+    "prom_target_health": "Здоровье",
+    "prom_target_scrape": "Последний опрос",
 
     # PowerShell tab
     "ps_execute": "Выполнить",
@@ -1483,6 +1543,19 @@ _ZH = {
     "grafana_connected": "已连接到 {alias}",
     "grafana_no_dashboards": "未找到仪表盘",
     "grafana_no_alerts": "无告警",
+    "grafana_loading": "加载中...",
+    "grafana_loaded": "{dashboards}仪表盘, {alerts}告警, {datasources}数据源",
+    "grafana_no_server": "未选择服务器",
+    "grafana_open_browser": "打开Grafana",
+    "grafana_datasources": "数据源",
+    "grafana_ds_name": "名称",
+    "grafana_ds_type": "类型",
+    "grafana_ds_default": "默认",
+    "grafana_dash_title": "标题",
+    "grafana_dash_folder": "文件夹",
+    "grafana_alert_state": "状态",
+    "grafana_alert_name": "名称",
+    "grafana_alert_severity": "严重程度",
 
     # Prometheus tab
     "prom_refresh": "刷新",
@@ -1498,6 +1571,23 @@ _ZH = {
     "prom_no_targets": "无目标",
     "prom_no_alerts": "无告警",
     "prom_placeholder": "up",
+    "prom_loading": "加载中...",
+    "prom_loaded": "{targets}目标, {alerts}告警, {rules}规则",
+    "prom_no_server": "未选择服务器",
+    "prom_executing": "执行中...",
+    "prom_results": "结果",
+    "prom_query_placeholder": "例如 up, node_cpu_seconds_total",
+    "prom_metrics_browser": "指标",
+    "prom_filter_metrics": "过滤指标...",
+    "prom_rules": "规则",
+    "prom_rule_type": "类型",
+    "prom_rule_name": "名称",
+    "prom_rule_group": "组",
+    "prom_rule_health": "健康",
+    "prom_target_job": "任务",
+    "prom_target_instance": "实例",
+    "prom_target_health": "健康",
+    "prom_target_scrape": "最后抓取",
 
     # PowerShell tab
     "ps_execute": "执行",

gui/tabs/grafana_tab.py

@@ -1,5 +1,5 @@
 """
-Grafana tab — dashboards browser and alerts overview.
+Grafana tab — dashboards browser, active alerts, and datasources overview.
 """
 
 import threading
@@ -9,7 +9,7 @@ from tkinter import ttk
 import customtkinter as ctk
 from core.grafana_client import GrafanaClient
 from core.i18n import t
-from core.icons import icon_text, make_icon_button, reconfigure_icon_button
+from core.icons import make_icon_button, reconfigure_icon_button
 from gui.tabs.query_tab import apply_dark_scrollbar_style
 
 
@@ -25,18 +25,23 @@ class GrafanaTab(ctk.CTkFrame):
 
     def _build_ui(self):
         apply_dark_scrollbar_style()
-        # ── Header + Refresh ──
+        # ── Header + buttons ──
         header_frame = ctk.CTkFrame(self, fg_color="transparent")
         header_frame.pack(fill="x", padx=15, pady=(15, 5))
 
-        title = ctk.CTkLabel(header_frame, text=t("grafana_title"),
+        title = ctk.CTkLabel(header_frame, text="Grafana",
                              font=ctk.CTkFont(size=18, weight="bold"))
         title.pack(side="left")
 
-        self._refresh_btn = make_icon_button(header_frame, "refresh", t("grafana_refresh"), width=110,
+        self._refresh_btn = make_icon_button(header_frame, "refresh", t("grafana_refresh"), width=100,
                                              command=self._refresh)
         self._refresh_btn.pack(side="right")
 
+        self._open_btn = make_icon_button(header_frame, "browser", t("grafana_open_browser"), width=130,
+                                          fg_color="#6b7280", hover_color="#4b5563",
+                                          command=self._open_grafana)
+        self._open_btn.pack(side="right", padx=(0, 5))
+
         # ── Dashboards section ──
         dash_label = ctk.CTkLabel(self, text=t("grafana_dashboards"),
                                   font=ctk.CTkFont(size=14, weight="bold"), anchor="w")
@@ -47,7 +52,7 @@ class GrafanaTab(ctk.CTkFrame):
 
         columns = ("uid", "title", "folder")
         self._dash_tree = ttk.Treeview(dash_frame, columns=columns, show="headings",
-                                       selectmode="browse", height=8)
+                                       selectmode="browse", height=6)
         self._dash_tree.heading("uid", text="UID")
         self._dash_tree.heading("title", text=t("grafana_dash_title"))
         self._dash_tree.heading("folder", text=t("grafana_dash_folder"))
@@ -59,7 +64,6 @@ class GrafanaTab(ctk.CTkFrame):
         dash_scroll = ttk.Scrollbar(dash_frame, orient="vertical", command=self._dash_tree.yview, style="Dark.Vertical.TScrollbar")
         dash_scroll.pack(side="right", fill="y")
         self._dash_tree.configure(yscrollcommand=dash_scroll.set)
-
         self._dash_tree.bind("<Double-1>", self._on_dashboard_click)
 
         # ── Alerts section ──
@@ -72,7 +76,7 @@ class GrafanaTab(ctk.CTkFrame):
 
         alert_columns = ("state", "name", "severity")
         self._alerts_tree = ttk.Treeview(alerts_frame, columns=alert_columns, show="headings",
-                                         selectmode="browse", height=6)
+                                         selectmode="browse", height=5)
         self._alerts_tree.heading("state", text=t("grafana_alert_state"))
         self._alerts_tree.heading("name", text=t("grafana_alert_name"))
         self._alerts_tree.heading("severity", text=t("grafana_alert_severity"))
@@ -85,6 +89,31 @@ class GrafanaTab(ctk.CTkFrame):
         alerts_scroll.pack(side="right", fill="y")
         self._alerts_tree.configure(yscrollcommand=alerts_scroll.set)
 
+        # ── Datasources section ──
+        ds_label = ctk.CTkLabel(self, text=t("grafana_datasources"),
+                                font=ctk.CTkFont(size=14, weight="bold"), anchor="w")
+        ds_label.pack(fill="x", padx=15, pady=(10, 3))
+
+        ds_frame = ctk.CTkFrame(self, fg_color="transparent")
+        ds_frame.pack(fill="both", expand=True, padx=15, pady=(0, 5))
+
+        ds_columns = ("name", "type", "url", "default")
+        self._ds_tree = ttk.Treeview(ds_frame, columns=ds_columns, show="headings",
+                                     selectmode="browse", height=4)
+        self._ds_tree.heading("name", text=t("grafana_ds_name"))
+        self._ds_tree.heading("type", text=t("grafana_ds_type"))
+        self._ds_tree.heading("url", text="URL")
+        self._ds_tree.heading("default", text=t("grafana_ds_default"))
+        self._ds_tree.column("name", width=150, minwidth=100)
+        self._ds_tree.column("type", width=120, minwidth=80)
+        self._ds_tree.column("url", width=250, minwidth=120)
+        self._ds_tree.column("default", width=60, minwidth=40)
+        self._ds_tree.pack(side="left", fill="both", expand=True)
+
+        ds_scroll = ttk.Scrollbar(ds_frame, orient="vertical", command=self._ds_tree.yview, style="Dark.Vertical.TScrollbar")
+        ds_scroll.pack(side="right", fill="y")
+        self._ds_tree.configure(yscrollcommand=ds_scroll.set)
+
         # ── Status bar ──
         self._status_bar = ctk.CTkLabel(self, text=t("grafana_no_server"), anchor="w",
                                         font=ctk.CTkFont(size=11), text_color="#9ca3af")
@@ -93,7 +122,6 @@ class GrafanaTab(ctk.CTkFrame):
     # ── Public API ──
 
     def set_server(self, alias: str | None):
-        """Called when user selects a server in sidebar."""
         self._current_alias = alias
         self._client = None
         self._dashboards.clear()
@@ -109,24 +137,26 @@ class GrafanaTab(ctk.CTkFrame):
 
     def _refresh(self):
         if not self._current_alias:
-            self._set_status(t("no_server_selected"), "#ef4444")
+            self._set_status(t("grafana_no_server"), "#ef4444")
             return
 
-        self._refresh_btn.configure(state="disabled", text=t("grafana_loading"))
+        self._refresh_btn.configure(state="disabled")
         self._set_status(t("grafana_loading"), "#ccaa00")
 
         def _do():
             try:
                 client = self._get_client()
-
                 dashboards = client.list_dashboards()
-                alerts = client.list_alerts()
+                alerts = client.get_active_alerts()
+                datasources = client.list_datasources()
 
                 self.after(0, lambda: self._populate_dashboards(dashboards))
                 self.after(0, lambda: self._populate_alerts(alerts))
+                self.after(0, lambda: self._populate_datasources(datasources))
                 self.after(0, lambda: self._set_status(
                     t("grafana_loaded").format(
-                        dashboards=len(dashboards), alerts=len(alerts)
+                        dashboards=len(dashboards), alerts=len(alerts),
+                        datasources=len(datasources)
                     ), "#22c55e"))
             except Exception as e:
                 self.after(0, lambda: self._set_status(f"(error) {e}", "#ef4444"))
@@ -160,28 +190,37 @@ class GrafanaTab(ctk.CTkFrame):
     def _populate_alerts(self, alerts: list[dict]):
         self._alerts_tree.delete(*self._alerts_tree.get_children())
         for a in alerts:
-            state = a.get("state", a.get("status", "unknown"))
-            name = a.get("name", a.get("title", ""))
-            severity = a.get("severity", a.get("labels", {}).get("severity", "—"))
+            status = a.get("status", {})
+            state = status.get("state", "unknown") if isinstance(status, dict) else str(status)
+            labels = a.get("labels", {})
+            name = labels.get("alertname", a.get("name", ""))
+            severity = labels.get("severity", "---")
             tag = ""
-            if state in ("alerting", "firing"):
+            if state in ("active", "firing", "alerting"):
                 tag = "alerting"
-            elif state in ("ok", "normal", "inactive"):
+            elif state in ("suppressed", "resolved", "inactive"):
                 tag = "ok"
             self._alerts_tree.insert("", "end", values=(state, name, severity), tags=(tag,))
-
-        # Color-code alert states
         self._alerts_tree.tag_configure("alerting", foreground="#ef4444")
         self._alerts_tree.tag_configure("ok", foreground="#22c55e")
 
+    def _populate_datasources(self, datasources: list[dict]):
+        self._ds_tree.delete(*self._ds_tree.get_children())
+        for ds in datasources:
+            name = ds.get("name", "")
+            ds_type = ds.get("type", "")
+            url = ds.get("url", "")
+            is_default = "Yes" if ds.get("isDefault", False) else ""
+            self._ds_tree.insert("", "end", values=(name, ds_type, url, is_default))
+
     def _clear_tables(self):
         self._dash_tree.delete(*self._dash_tree.get_children())
         self._alerts_tree.delete(*self._alerts_tree.get_children())
+        self._ds_tree.delete(*self._ds_tree.get_children())
 
     # ── Events ──
 
     def _on_dashboard_click(self, _event):
-        """Open dashboard URL in browser on double-click."""
         selection = self._dash_tree.selection()
         if not selection:
             return
@@ -189,20 +228,26 @@ class GrafanaTab(ctk.CTkFrame):
         uid = item["values"][0] if item["values"] else None
         if not uid:
             return
-
-        # Find the dashboard data to get the URL
         for d in self._dashboards:
             if d.get("uid") == uid:
                 url = d.get("url", "")
                 if url:
                     try:
                         client = self._get_client()
-                        full_url = f"{client.base_url}{url}"
-                        webbrowser.open(full_url)
+                        webbrowser.open(f"{client.base_url}{url}")
                     except Exception:
                         webbrowser.open(url)
                 break
 
+    def _open_grafana(self):
+        if not self._current_alias:
+            return
+        try:
+            client = self._get_client()
+            webbrowser.open(client.base_url)
+        except Exception:
+            pass
+
     # ── Helpers ──
 
     def _set_status(self, text: str, color: str = "#9ca3af"):

gui/tabs/prometheus_tab.py

@@ -1,5 +1,5 @@
 """
-Prometheus tab — PromQL query executor, targets overview, and alerts.
+Prometheus tab — PromQL query executor, targets overview, alerts, and rules.
 """
 
 import threading
@@ -8,7 +8,7 @@ from tkinter import ttk
 import customtkinter as ctk
 from core.prometheus_client import PrometheusClient
 from core.i18n import t
-from core.icons import icon_text, make_icon_button, reconfigure_icon_button
+from core.icons import make_icon_button, reconfigure_icon_button
 from gui.tabs.query_tab import apply_dark_scrollbar_style
 
 
@@ -41,19 +41,35 @@ class PrometheusTab(ctk.CTkFrame):
                                          command=self._execute_query)
         self._exec_btn.pack(side="left")
 
+        # ── Quick query buttons ──
+        quick_frame = ctk.CTkFrame(self, fg_color="transparent")
+        quick_frame.pack(fill="x", padx=15, pady=(0, 5))
+
+        for label, query in [("up", "up"), ("CPU", "process_cpu_seconds_total"),
+                             ("Memory", "node_memory_MemFree_bytes")]:
+            btn = make_icon_button(quick_frame, "metrics", label, width=80,
+                                   fg_color="#6b7280", hover_color="#4b5563",
+                                   command=lambda q=query: self._run_quick(q))
+            btn.pack(side="left", padx=(0, 5))
+
+        self._metrics_btn = make_icon_button(quick_frame, "search", t("prom_metrics_browser"), width=100,
+                                              fg_color="#6b7280", hover_color="#4b5563",
+                                              command=self._open_metrics_browser)
+        self._metrics_btn.pack(side="left", padx=(0, 5))
+
         # ── Query results ──
         results_label = ctk.CTkLabel(self, text=t("prom_results"),
                                      font=ctk.CTkFont(size=12, weight="bold"), anchor="w")
-        results_label.pack(fill="x", padx=15, pady=(10, 3))
+        results_label.pack(fill="x", padx=15, pady=(5, 3))
 
-        self._results_box = ctk.CTkTextbox(self, height=150,
+        self._results_box = ctk.CTkTextbox(self, height=120,
                                            font=ctk.CTkFont(family="Consolas", size=12),
                                            state="disabled")
         self._results_box.pack(fill="x", padx=15, pady=(0, 5))
 
         # ── Targets section ──
         targets_header = ctk.CTkFrame(self, fg_color="transparent")
-        targets_header.pack(fill="x", padx=15, pady=(10, 3))
+        targets_header.pack(fill="x", padx=15, pady=(5, 3))
 
         targets_label = ctk.CTkLabel(targets_header, text=t("prom_targets"),
                                      font=ctk.CTkFont(size=14, weight="bold"), anchor="w")
@@ -68,7 +84,7 @@ class PrometheusTab(ctk.CTkFrame):
 
         target_columns = ("job", "instance", "health", "last_scrape")
         self._targets_tree = ttk.Treeview(targets_frame, columns=target_columns, show="headings",
-                                          selectmode="browse", height=6)
+                                          selectmode="browse", height=5)
         self._targets_tree.heading("job", text=t("prom_target_job"))
         self._targets_tree.heading("instance", text=t("prom_target_instance"))
         self._targets_tree.heading("health", text=t("prom_target_health"))
@@ -88,13 +104,39 @@ class PrometheusTab(ctk.CTkFrame):
         # ── Alerts section ──
         alerts_label = ctk.CTkLabel(self, text=t("prom_alerts"),
                                     font=ctk.CTkFont(size=14, weight="bold"), anchor="w")
-        alerts_label.pack(fill="x", padx=15, pady=(10, 3))
+        alerts_label.pack(fill="x", padx=15, pady=(5, 3))
 
-        self._alerts_box = ctk.CTkTextbox(self, height=100,
+        self._alerts_box = ctk.CTkTextbox(self, height=80,
                                           font=ctk.CTkFont(family="Consolas", size=12),
                                           state="disabled")
         self._alerts_box.pack(fill="x", padx=15, pady=(0, 5))
 
+        # ── Rules section ──
+        rules_label = ctk.CTkLabel(self, text=t("prom_rules"),
+                                   font=ctk.CTkFont(size=14, weight="bold"), anchor="w")
+        rules_label.pack(fill="x", padx=15, pady=(5, 3))
+
+        rules_frame = ctk.CTkFrame(self, fg_color="transparent")
+        rules_frame.pack(fill="both", expand=True, padx=15, pady=(0, 5))
+
+        rules_columns = ("type", "name", "group", "health")
+        self._rules_tree = ttk.Treeview(rules_frame, columns=rules_columns, show="headings",
+                                        selectmode="browse", height=5)
+        self._rules_tree.heading("type", text=t("prom_rule_type"))
+        self._rules_tree.heading("name", text=t("prom_rule_name"))
+        self._rules_tree.heading("group", text=t("prom_rule_group"))
+        self._rules_tree.heading("health", text=t("prom_rule_health"))
+        self._rules_tree.column("type", width=80, minwidth=60)
+        self._rules_tree.column("name", width=250, minwidth=120)
+        self._rules_tree.column("group", width=150, minwidth=80)
+        self._rules_tree.column("health", width=80, minwidth=60)
+        self._rules_tree.pack(side="left", fill="both", expand=True)
+
+        rules_scroll = ttk.Scrollbar(rules_frame, orient="vertical", command=self._rules_tree.yview,
+                                     style="Dark.Vertical.TScrollbar")
+        rules_scroll.pack(side="right", fill="y")
+        self._rules_tree.configure(yscrollcommand=rules_scroll.set)
+
         # ── Status bar ──
         self._status_bar = ctk.CTkLabel(self, text=t("prom_no_server"), anchor="w",
                                         font=ctk.CTkFont(size=11), text_color="#9ca3af")
@@ -103,7 +145,6 @@ class PrometheusTab(ctk.CTkFrame):
     # ── Public API ──
 
     def set_server(self, alias: str | None):
-        """Called when user selects a server in sidebar."""
         self._current_alias = alias
         self._client = None
         self._clear_all()
@@ -114,6 +155,13 @@ class PrometheusTab(ctk.CTkFrame):
         else:
             self._set_status(t("prom_no_server"), "#9ca3af")
 
+    # ── Quick query ──
+
+    def _run_quick(self, query: str):
+        self._query_entry.delete(0, "end")
+        self._query_entry.insert(0, query)
+        self._execute_query()
+
     # ── PromQL execution ──
 
     def _execute_query(self):
@@ -121,7 +169,7 @@ class PrometheusTab(ctk.CTkFrame):
         if not query:
             return
         if not self._current_alias:
-            self._set_results(t("no_server_selected"))
+            self._set_results(t("prom_no_server"))
             return
 
         self._exec_btn.configure(state="disabled")
@@ -141,11 +189,9 @@ class PrometheusTab(ctk.CTkFrame):
         threading.Thread(target=_do, daemon=True).start()
 
     def _format_query_result(self, result: dict) -> str:
-        """Format Prometheus query API response for display."""
         status = result.get("status", "unknown")
         if status != "success":
-            error = result.get("error", "Unknown error")
-            return f"Error: {error}"
+            return f"Error: {result.get('error', 'Unknown error')}"
 
         data = result.get("data", {})
         result_type = data.get("resultType", "")
@@ -166,7 +212,7 @@ class PrometheusTab(ctk.CTkFrame):
             elif result_type == "matrix":
                 values = item.get("values", [])
                 lines.append(f"{{{metric_str}}}")
-                for ts, val in values[-10:]:  # Show last 10 points
+                for ts, val in values[-10:]:
                     lines.append(f"  @{ts} => {val}")
                 if len(values) > 10:
                     lines.append(f"  ... ({len(values)} total points)")
@@ -175,14 +221,84 @@ class PrometheusTab(ctk.CTkFrame):
 
         return "\n".join(lines)
 
-    # ── Refresh targets & alerts ──
+    # ── Metrics browser ──
+
+    def _open_metrics_browser(self):
+        if not self._current_alias:
+            self._set_status(t("prom_no_server"), "#ef4444")
+            return
+
+        self._metrics_btn.configure(state="disabled")
+
+        def _do():
+            try:
+                client = self._get_client()
+                resp = client._get("/api/v1/label/__name__/values")
+                metrics = resp.get("data", [])
+                self.after(0, lambda: self._show_metrics_popup(metrics))
+            except Exception as e:
+                self.after(0, lambda: self._set_status(f"(error) {e}", "#ef4444"))
+            finally:
+                self.after(0, lambda: self._metrics_btn.configure(state="normal"))
+
+        threading.Thread(target=_do, daemon=True).start()
+
+    def _show_metrics_popup(self, metrics: list[str]):
+        popup = ctk.CTkToplevel(self)
+        popup.title(t("prom_metrics_browser"))
+        popup.geometry("450x500")
+        popup.transient(self.winfo_toplevel())
+
+        filter_entry = ctk.CTkEntry(popup, placeholder_text=t("prom_filter_metrics"))
+        filter_entry.pack(fill="x", padx=10, pady=(10, 5))
+
+        listbox_frame = ctk.CTkFrame(popup, fg_color="transparent")
+        listbox_frame.pack(fill="both", expand=True, padx=10, pady=(0, 10))
+
+        tree = ttk.Treeview(listbox_frame, columns=("metric",), show="headings",
+                            selectmode="browse")
+        tree.heading("metric", text="Metric Name")
+        tree.column("metric", width=400)
+        tree.pack(side="left", fill="both", expand=True)
+
+        scroll = ttk.Scrollbar(listbox_frame, orient="vertical", command=tree.yview,
+                               style="Dark.Vertical.TScrollbar")
+        scroll.pack(side="right", fill="y")
+        tree.configure(yscrollcommand=scroll.set)
+
+        all_metrics = sorted(metrics)
+
+        def populate(filter_text=""):
+            tree.delete(*tree.get_children())
+            for m in all_metrics:
+                if filter_text.lower() in m.lower():
+                    tree.insert("", "end", values=(m,))
+
+        def on_filter(*_):
+            populate(filter_entry.get())
+
+        filter_entry.bind("<KeyRelease>", on_filter)
+
+        def on_select(event):
+            sel = tree.selection()
+            if sel:
+                metric = tree.item(sel[0])["values"][0]
+                self._query_entry.delete(0, "end")
+                self._query_entry.insert(0, metric)
+                popup.destroy()
+
+        tree.bind("<Double-1>", on_select)
+        populate()
+        filter_entry.focus_set()
+
+    # ── Refresh targets, alerts & rules ──
 
     def _refresh_all(self):
         if not self._current_alias:
-            self._set_status(t("no_server_selected"), "#ef4444")
+            self._set_status(t("prom_no_server"), "#ef4444")
             return
 
-        self._refresh_btn.configure(state="disabled", text=t("prom_loading"))
+        self._refresh_btn.configure(state="disabled")
         self._set_status(t("prom_loading"), "#ccaa00")
 
         def _do():
@@ -193,12 +309,17 @@ class PrometheusTab(ctk.CTkFrame):
                 targets = targets_resp.get("data", {}).get("activeTargets", [])
                 alerts_resp = client.alerts()
                 alerts = alerts_resp.get("data", {}).get("alerts", [])
+                rules_resp = client.rules()
+                rule_groups = rules_resp.get("data", {}).get("groups", [])
 
                 self.after(0, lambda: self._populate_targets(targets))
                 self.after(0, lambda: self._populate_alerts(alerts))
+                self.after(0, lambda: self._populate_rules(rule_groups))
+
+                rule_count = sum(len(g.get("rules", [])) for g in rule_groups)
                 self.after(0, lambda: self._set_status(
                     t("prom_loaded").format(
-                        targets=len(targets), alerts=len(alerts)
+                        targets=len(targets), alerts=len(alerts), rules=rule_count
                     ), "#22c55e"))
             except Exception as e:
                 self.after(0, lambda: self._set_status(f"(error) {e}", "#ef4444"))
@@ -223,28 +344,19 @@ class PrometheusTab(ctk.CTkFrame):
     def _populate_targets(self, targets: list[dict]):
         self._targets_tree.delete(*self._targets_tree.get_children())
         for target in targets:
-            job = target.get("labels", {}).get("job", "—")
-            instance = target.get("labels", {}).get("instance", "—")
+            job = target.get("labels", {}).get("job", "---")
+            instance = target.get("labels", {}).get("instance", "---")
             health = target.get("health", "unknown")
-            last_scrape = target.get("lastScrape", "—")
-
-            tag = ""
-            if health == "up":
-                tag = "up"
-            elif health == "down":
-                tag = "down"
-
+            last_scrape = target.get("lastScrape", "---")
+            tag = "up" if health == "up" else ("down" if health == "down" else "")
             self._targets_tree.insert("", "end",
-                                      values=(job, instance, health, last_scrape),
-                                      tags=(tag,))
-
+                                      values=(job, instance, health, last_scrape), tags=(tag,))
         self._targets_tree.tag_configure("up", foreground="#22c55e")
         self._targets_tree.tag_configure("down", foreground="#ef4444")
 
     def _populate_alerts(self, alerts: list[dict]):
         self._alerts_box.configure(state="normal")
         self._alerts_box.delete("1.0", "end")
-
         if not alerts:
             self._alerts_box.insert("1.0", t("prom_no_alerts"))
         else:
@@ -252,12 +364,25 @@ class PrometheusTab(ctk.CTkFrame):
             for a in alerts:
                 name = a.get("labels", {}).get("alertname", a.get("name", "unknown"))
                 state = a.get("state", "unknown")
-                severity = a.get("labels", {}).get("severity", "—")
+                severity = a.get("labels", {}).get("severity", "---")
                 lines.append(f"[{state.upper()}] {name} (severity: {severity})")
             self._alerts_box.insert("1.0", "\n".join(lines))
-
         self._alerts_box.configure(state="disabled")
 
+    def _populate_rules(self, groups: list[dict]):
+        self._rules_tree.delete(*self._rules_tree.get_children())
+        for group in groups:
+            group_name = group.get("name", "")
+            for rule in group.get("rules", []):
+                rtype = rule.get("type", "")
+                name = rule.get("name", "")
+                health = rule.get("health", "")
+                tag = "up" if health == "ok" else ("down" if health == "err" else "")
+                self._rules_tree.insert("", "end",
+                                        values=(rtype, name, group_name, health), tags=(tag,))
+        self._rules_tree.tag_configure("up", foreground="#22c55e")
+        self._rules_tree.tag_configure("down", foreground="#ef4444")
+
     # ── Helpers ──
 
     def _set_results(self, text: str):
@@ -268,6 +393,7 @@ class PrometheusTab(ctk.CTkFrame):
 
     def _clear_all(self):
         self._targets_tree.delete(*self._targets_tree.get_children())
+        self._rules_tree.delete(*self._rules_tree.get_children())
         self._set_results("")
         self._alerts_box.configure(state="normal")
         self._alerts_box.delete("1.0", "end")

tools/ssh.py

@@ -1569,6 +1569,25 @@ def grafana_alerts(server: dict):
     print(f"\n({len(rows)} alert{'s' if len(rows) != 1 else ''})")
 
 
+def grafana_datasources(server: dict):
+    """List Grafana datasources."""
+    data = _grafana_request(server, "datasources")
+    if not data:
+        print("(no datasources found)")
+        return
+    headers = ["Name", "Type", "URL", "Default"]
+    rows = []
+    for ds in data:
+        rows.append([
+            ds.get("name", ""),
+            ds.get("type", ""),
+            ds.get("url", ""),
+            "yes" if ds.get("isDefault", False) else "",
+        ])
+    _print_table(headers, rows)
+    print(f"\n({len(rows)} datasource{'s' if len(rows) != 1 else ''})")
+
+
 # ── Prometheus commands ───────────────────────────────
 
 def _prom_request(server: dict, endpoint: str, params: dict = None) -> dict:
@@ -1681,6 +1700,29 @@ def prom_alerts(server: dict):
     print(f"\n({len(rows)} alert{'s' if len(rows) != 1 else ''})")
 
 
+def prom_rules(server: dict):
+    """List Prometheus rules (recording + alerting)."""
+    data = _prom_request(server, "rules")
+    groups = data.get("data", {}).get("groups", [])
+    if not groups:
+        print("(no rules)")
+        return
+    headers = ["Type", "Name", "Group", "Health", "Query/Expr"]
+    rows = []
+    for group in groups:
+        gname = group.get("name", "")
+        for rule in group.get("rules", []):
+            rows.append([
+                rule.get("type", ""),
+                rule.get("name", ""),
+                gname,
+                rule.get("health", ""),
+                (rule.get("query", rule.get("expr", "")))[:60],
+            ])
+    _print_table(headers, rows)
+    print(f"\n({len(rows)} rule{'s' if len(rows) != 1 else ''} in {len(groups)} group{'s' if len(groups) != 1 else ''})")
+
+
 # ── WinRM commands ────────────────────────────────────
 
 def _get_winrm_session(server: dict):
@@ -1834,6 +1876,11 @@ def main():
         alias = _resolve_alias(sys.argv[2], servers)
         grafana_alerts(servers[alias])
         sys.exit(0)
+    if cmd == "--grafana-datasources" and len(sys.argv) >= 3:
+        _, servers = load_servers()
+        alias = _resolve_alias(sys.argv[2], servers)
+        grafana_datasources(servers[alias])
+        sys.exit(0)
 
     # ── Prometheus commands ──
     if cmd == "--prom-query" and len(sys.argv) >= 4:
@@ -1851,6 +1898,11 @@ def main():
         alias = _resolve_alias(sys.argv[2], servers)
         prom_alerts(servers[alias])
         sys.exit(0)
+    if cmd == "--prom-rules" and len(sys.argv) >= 3:
+        _, servers = load_servers()
+        alias = _resolve_alias(sys.argv[2], servers)
+        prom_rules(servers[alias])
+        sys.exit(0)
 
     # ── WinRM commands ──
     if cmd == "--ps" and len(sys.argv) >= 4:

version.py

@@ -1,6 +1,6 @@
 """Version info for ServerManager."""
 
-__version__ = "1.9.41"
+__version__ = "1.9.42"
 __app_name__ = "ServerManager"
 __author__ = "aibot777"
 __description__ = "Desktop GUI for managing remote servers"