PyObservability 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

pyobservability/config/settings.py

@@ -51,6 +51,7 @@ def detailed_log_config(filename: str | None = None, debug: bool = False) -> Dic
             "uvicorn": {"handlers": ["default"], "level": level},
             "uvicorn.error": {"handlers": ["default"], "level": level, "propagate": False},
             "uvicorn.access": {"handlers": ["default"], "level": level, "propagate": False},
+            "uvicorn.default": {"handlers": ["default"], "level": level, "propagate": False},
         },
         "root": {"handlers": ["default"], "level": level},
     }

pyobservability/main.py

@@ -2,7 +2,7 @@ import logging
 import pathlib
 import warnings
 from datetime import datetime
-from typing import Dict
+from typing import Any, Dict
 
 import uiauth
 import uvicorn
@@ -39,7 +39,7 @@ async def index(request: Request):
         TemplateResponse:
         Rendered HTML template with targets and version.
     """
-    args = dict(request=request, targets=settings.env.targets, version=__version__)
+    args: Dict[str, Any] = dict(request=request, targets=settings.env.targets, version=__version__)
     if settings.env.username and settings.env.password:
         args["logout"] = uiauth.enums.APIEndpoints.fastapi_logout.value
     return templates.TemplateResponse("index.html", args)
@@ -49,7 +49,7 @@ async def health() -> Dict[str, str]:
     """Health check endpoint.
 
     Returns:
-        dict:
+        Dict[str, str]:
         Health status.
     """
     return {"status": "ok"}

pyobservability/monitor.py

@@ -174,7 +174,7 @@ class Monitor:
                         "ts": asyncio.get_event_loop().time(),
                         "data": [
                             {
-                                "name": self.base_url,
+                                "name": self.name,
                                 "base_url": self.base_url,
                                 "metrics": payload,
                             }
@@ -188,13 +188,12 @@ class Monitor:
                             _ = q.get_nowait()
                             q.put_nowait(result)
             except Exception as err:
-                LOGGER.debug("Stream error for %s: %s", self.base_url, err)
                 if errors.get(self.base_url):
                     if errors[self.base_url] < 10:
+                        LOGGER.debug("Stream error for %s: %s", self.base_url, err)
                         errors[self.base_url] += 1
                     else:
-                        LOGGER.error(err.with_traceback())
-                        LOGGER.error("%s exceeded error threshold.", self.base_url)
+                        LOGGER.error("Stream error for %s: %s", self.base_url, err)
 
                         # notify subscribers before stopping
                         error_msg = {
@@ -209,7 +208,7 @@ class Monitor:
                             except asyncio.QueueFull as warn:
                                 LOGGER.warning(warn)
                                 _ = q.get_nowait()
-                                q.put_nowait(result)
+                                q.put_nowait(error_msg)
                         await self.stop()
                         return
                 else:

pyobservability/static/app.js

@@ -224,14 +224,63 @@
         }
 
         function setData(arr, columns) {
-            if (JSON.stringify(state.data) === JSON.stringify(arr)) {
-                return; // do not re-render if data didn't change
-            }
             headEl.innerHTML = "<tr>" + columns.map(c => `<th>${c}</th>`).join("") + "</tr>";
-            state.data = arr.map(row => {
-                return "<tr>" + columns.map(c => `<td>${row[c] ?? ""}</td>`).join("") + "</tr>";
+            state.dataRaw = arr.slice();
+            state.columns = columns;
+            // Sorting logic
+            Array.from(headEl.querySelectorAll("th")).forEach((th, idx) => {
+                th.style.cursor = "pointer";
+                th.onclick = (e) => {
+                    // Prevent sort if reset button was clicked
+                    if (e.target.classList.contains("sort-reset")) return;
+                    const col = columns[idx];
+                    if (state.sortCol === col) {
+                        state.sortAsc = !state.sortAsc;
+                    } else {
+                        state.sortCol = col;
+                        state.sortAsc = true;
+                    }
+                    sortAndRender();
+                };
             });
-            render();
+
+            function sortAndRender() {
+                // Rebuild all headers with correct HTML
+                headEl.querySelectorAll("th").forEach((th, idx) => {
+                    const col = state.columns[idx];
+                    if (state.sortCol === col) {
+                        th.innerHTML = `${col} <span style="font-size:0.9em">${state.sortAsc ? "▲" : "▼"}</span>&nbsp;<span class="sort-reset" style="cursor:pointer;font-size:0.9em;color:#888;margin-left:8px;" title="Reset sort">⨯</span>`;
+                        th.querySelector(".sort-reset").onclick = (e) => {
+                            e.stopPropagation();
+                            state.sortCol = null;
+                            state.sortAsc = true;
+                            state.dataRaw = arr.slice();
+                            sortAndRender();
+                        };
+                    } else {
+                        th.innerHTML = col;
+                    }
+                });
+                if (state.sortCol) {
+                    state.dataRaw.sort((a, b) => {
+                        let va = a[state.sortCol], vb = b[state.sortCol];
+                        let na = parseFloat(va), nb = parseFloat(vb);
+                        if (!isNaN(na) && !isNaN(nb)) {
+                            return state.sortAsc ? na - nb : nb - na;
+                        }
+                        va = (va ?? "").toString().toLowerCase();
+                        vb = (vb ?? "").toString().toLowerCase();
+                        if (va < vb) return state.sortAsc ? -1 : 1;
+                        if (va > vb) return state.sortAsc ? 1 : -1;
+                        return 0;
+                    });
+                }
+                state.data = state.dataRaw.map(row =>
+                    "<tr>" + state.columns.map(c => `<td>${row[c] ?? ""}</td>`).join("") + "</tr>"
+                );
+                render();
+            }
+            sortAndRender();
         }
 
         return {setData};
@@ -321,6 +370,149 @@
     const memChart = makeMainChart(memCtx, "Memory %");
     const loadChart = makeMainChart(loadCtx, "CPU Load");
 
+    // Unified metrics: three parallel charts (memory, CPU, disk)
+    const unifiedPanel = document.getElementById("unified-panel");
+    const unifiedLegend = document.getElementById("unified-legend");
+    const unifiedMemCtx = document.getElementById("unified-mem-chart").getContext("2d");
+    const unifiedCpuCtx = document.getElementById("unified-cpu-chart").getContext("2d");
+    const unifiedDiskCtx = document.getElementById("unified-disk-chart").getContext("2d");
+
+    let unifiedNodes = [];
+    const colorPalette = ["#63b3ff", "#ff99c8", "#7dd3fc", "#fbbf24", "#a3e635", "#f87171", "#c084fc", "#38bdf8"];
+    const nodeColor = {};
+    const unifiedCharts = {memory: null, cpu: null, disk: null};
+
+    function normalizeNodes(nodes) {
+        return nodes
+            .filter(node => node.base_url && node.base_url !== "*")
+            .sort((a, b) => (a.name || a.base_url).localeCompare(b.name || b.base_url));
+    }
+
+    function assignColors(nodes) {
+        nodes.forEach((node, idx) => {
+            nodeColor[node.base_url] = colorPalette[idx % colorPalette.length];
+        });
+    }
+
+    function renderLegend(nodes) {
+        unifiedLegend.innerHTML = "";
+        nodes.forEach(node => {
+            const item = document.createElement("div");
+            item.className = "unified-legend-item";
+            item.innerHTML = `<span class="legend-dot" style="background:${nodeColor[node.base_url]}"></span>${node.name || node.base_url}`;
+            unifiedLegend.appendChild(item);
+        });
+    }
+
+    function makeUnifiedChart(ctx, nodes) {
+        return new Chart(ctx, {
+            type: "line",
+            data: {
+                labels: Array(MAX_POINTS).fill(""),
+                datasets: nodes.map(node => ({
+                    label: node.name || node.base_url,
+                    meta: {base_url: node.base_url},
+                    data: Array(MAX_POINTS).fill(null),
+                    borderColor: nodeColor[node.base_url],
+                    backgroundColor: `${nodeColor[node.base_url]}33`,
+                    borderWidth: 2,
+                    fill: false,
+                    tension: 0.3,
+                    pointRadius: 0,
+                }))
+            },
+            options: {
+                animation: false,
+                responsive: true,
+                maintainAspectRatio: false,
+                scales: {
+                    x: {display: false},
+                    y: {beginAtZero: true, suggestedMax: 100}
+                },
+                plugins: {legend: {display: false}}
+            }
+        });
+    }
+
+    function setUnifiedMode(enabled) {
+        document.body.classList.toggle("unified-mode", enabled);
+        if (!enabled) {
+            unifiedPanel.classList.add("hidden");
+        }
+    }
+
+    function ensureUnifiedChart(metrics) {
+        const nodes = normalizeNodes(metrics);
+        if (!nodes.length) return false;
+        const changed =
+            nodes.length !== unifiedNodes.length ||
+            nodes.some((node, idx) => unifiedNodes[idx]?.base_url !== node.base_url);
+
+        if (changed) {
+            // Destroy any existing unified charts
+            Object.keys(unifiedCharts).forEach(key => {
+                if (unifiedCharts[key]) {
+                    unifiedCharts[key].destroy();
+                    unifiedCharts[key] = null;
+                }
+            });
+            assignColors(nodes);
+            unifiedCharts.memory = makeUnifiedChart(unifiedMemCtx, nodes);
+            unifiedCharts.cpu = makeUnifiedChart(unifiedCpuCtx, nodes);
+            unifiedCharts.disk = makeUnifiedChart(unifiedDiskCtx, nodes);
+            unifiedNodes = nodes;
+        }
+
+        unifiedPanel.classList.remove("hidden");
+        renderLegend(nodes);
+        return true;
+    }
+
+    function sampleForMetric(host, metric) {
+        if (!host.metrics) return null;
+        if (metric === "memory") return host.metrics.memory_info?.percent ?? null;
+        if (metric === "cpu") {
+            const values = (host.metrics.cpu_usage || [])
+                .map(v => Number(v))
+                .filter(Number.isFinite);
+            if (!values.length) return null;
+            return values.reduce((a, b) => a + b, 0) / values.length;
+        }
+        if (metric === "disk") {
+            const m = host.metrics;
+            if (m.disk_info && m.disk_info[0]) {
+                const m = host.metrics;
+                const agg = aggregateDiskInfo(m.disk_info);
+                return agg.percent;
+            }
+            return host.metrics.disk_info?.[0]?.percent ?? null;
+        }
+        return null;
+    }
+
+    function updateUnified(metrics) {
+        const ts = new Date().toLocaleTimeString();
+        const metricKeys = ["memory", "cpu", "disk"];
+        metricKeys.forEach(metric => {
+            const chart = unifiedCharts[metric];
+            if (!chart) return;
+
+            chart.data.labels.push(ts);
+            if (chart.data.labels.length > MAX_POINTS) {
+                chart.data.labels.shift();
+            }
+
+            chart.data.datasets.forEach(ds => {
+                const host = metrics.find(h => h.base_url === ds.meta.base_url);
+                const value = host ? sampleForMetric(host, metric) : null;
+                ds.data.push(value);
+                if (ds.data.length > MAX_POINTS) ds.data.shift();
+            });
+
+            chart.update("none");
+        });
+    }
+
     // ------------------------------------------------------------
     // CORE CHARTS
     // ------------------------------------------------------------
@@ -349,9 +541,9 @@
         return coreMini[coreName] || createCoreChart(coreName);
     }
 
-    function pruneOldCores(latest) {
+    function pruneOldCores(keep) {
         for (const name of Object.keys(coreMini)) {
-            if (!latest.includes(name)) {
+            if (!keep.includes(name)) {
                 try {
                     coreMini[name].chart.destroy();
                 } catch {
@@ -391,11 +583,23 @@
         resetChart(memChart);
         resetChart(loadChart);
 
+        // Reset unified charts as well
+        Object.keys(unifiedCharts).forEach(key => {
+            const chart = unifiedCharts[key];
+            if (chart) {
+                try {
+                    chart.destroy();
+                } catch {}
+                unifiedCharts[key] = null;
+            }
+        });
+        unifiedNodes = [];
+        unifiedPanel.classList.add("hidden");
+
         for (const name of Object.keys(coreMini)) {
             try {
                 coreMini[name].chart.destroy();
-            } catch {
-            }
+            } catch {}
             coreMini[name].el.remove();
             delete coreMini[name];
         }
@@ -411,6 +615,19 @@
     // ------------------------------------------------------------
     // MISC HELPERS
     // ------------------------------------------------------------
+    function aggregateDiskInfo(diskInfo) {
+        let totalDisk = 0;
+        let usedDisk = 0;
+        let freeDisk = 0;
+        diskInfo.forEach(d => {
+            totalDisk += num(d.total || 0);
+            usedDisk += num(d.used || 0);
+            freeDisk += num(d.free || 0);
+        });
+        let percentDisk = totalDisk > 0 ? (usedDisk / totalDisk) * 100 : 0.0;
+        return {"total": totalDisk, "used": usedDisk, "free": freeDisk, "percent": percentDisk};
+    }
+
     function pushPoint(chart, value) {
         const ts = new Date().toLocaleTimeString();
         chart.data.labels.push(ts);
@@ -470,6 +687,16 @@
 
         const now = new Date().toLocaleTimeString();
 
+        if (selectedBase === "*") {
+            if (ensureUnifiedChart(list)) {
+                setUnifiedMode(true);
+                updateUnified(list);
+            }
+            return;
+        }
+
+        setUnifiedMode(false);
+
         for (const host of list) {
             if (host.base_url !== selectedBase) continue;
             const m = host.metrics || {};
@@ -492,17 +719,19 @@
                 `GPU: ${m.gpu_name || "-"}`;
 
             if (m.disk_info && m.disk_info[0]) {
-                const d = m.disk_info[0];
+                const agg = aggregateDiskInfo(m.disk_info);
                 diskEl.textContent =
-                    `Total: ${formatBytes(d.total)}\n` +
-                    `Used: ${formatBytes(d.used)}\n` +
-                    `Free: ${formatBytes(d.free)}`;
+                    `Total: ${formatBytes(agg.total)}\n` +
+                    `Used: ${formatBytes(agg.used)}\n` +
+                    `Free: ${formatBytes(agg.free)}\n` +
+                    `Percent: ${round2(agg.percent)}%`;
             }
 
             if (m.memory_info) {
                 memEl.textContent =
                     `Total: ${formatBytes(m.memory_info.total)}\n` +
                     `Used: ${formatBytes(m.memory_info.used)}\n` +
+                    `Free: ${formatBytes(m.memory_info.free)}\n` +
                     `Percent: ${round2(m.memory_info.percent)}%`;
                 pushPoint(memChart, num(m.memory_info.percent));
             }
@@ -595,11 +824,30 @@
                 hideSpinner("certificates-table");
             }
         }
+
+        if (selectedBase === "*") {
+            if (ensureUnifiedChart(list)) {
+                updateUnified(list);
+            }
+        } else {
+            unifiedPanel.classList.add("hidden");
+            unifiedNodes = [];
+            Object.keys(unifiedCharts).forEach(key => {
+                if (unifiedCharts[key]) {
+                    unifiedCharts[key].destroy();
+                    unifiedCharts[key] = null;
+                }
+            });
+        }
     }
 
     // ------------------------------------------------------------
     // EVENT BINDINGS
     // ------------------------------------------------------------
+    targets.push({
+        base_url: "*",
+        name: "*"
+    });
     targets.forEach(t => {
         const opt = document.createElement("option");
         opt.value = t.base_url;
@@ -615,6 +863,7 @@
         resetUI();
         resetTables();
         showAllSpinners();
+        if (selectedBase !== "*") unifiedPanel.classList.add("hidden");
         ws.send(JSON.stringify({type: "select_target", base_url: selectedBase}));
     });
 

pyobservability/static/styles.css

@@ -265,6 +265,10 @@ input#proc-filter {
     .meta-row {
         grid-template-columns: 1fr;
     }
+
+    .unified-grid {
+        grid-template-columns: 1fr;
+    }
 }
 
 /* ---------------- SPINNER ------------------- */
@@ -324,3 +328,111 @@ input#proc-filter {
     margin-bottom: 4px;
     opacity: 0.85;
 }
+
+.panel-helper {
+    margin: 0 0 8px;
+    font-size: 12px;
+    color: var(--muted);
+}
+
+.metric-switch {
+    display: inline-flex;
+    border: 1px solid rgba(255, 255, 255, 0.08);
+    border-radius: 4px;
+    overflow: hidden;
+}
+
+.metric-btn {
+    background: transparent;
+    color: inherit;
+    border: none;
+    padding: 6px 12px;
+    font-size: 12px;
+    cursor: pointer;
+    transition: background 0.2s, color 0.2s;
+}
+
+.metric-btn:not(.active):hover {
+    background: rgba(255, 255, 255, 0.05);
+}
+
+.metric-btn.active {
+    background: var(--accent);
+    color: #020617;
+}
+
+.unified-header {
+    align-items: center;
+    justify-content: center;
+    gap: 12px;
+}
+
+.unified-title-group {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    gap: 2px;
+}
+
+.unified-indicator {
+    font-size: 12px;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--muted);
+}
+
+.unified-legend {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    margin-top: 10px;
+}
+
+.unified-legend-item {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 4px 8px;
+    border-radius: 4px;
+    background: rgba(255, 255, 255, 0.05);
+    font-size: 12px;
+}
+
+.legend-dot {
+    width: 10px;
+    height: 10px;
+    border-radius: 50%;
+}
+
+/* New unified-grid layout for three unified charts */
+.unified-grid {
+    display: grid;
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+    gap: 12px;
+    margin-top: 8px;
+}
+
+.unified-metric-panel {
+    background: var(--panel);
+    border-radius: 8px;
+    padding: 8px 8px 4px;
+    box-shadow: 0 4px 12px rgba(2, 6, 23, 0.6);
+}
+
+.unified-metric-panel .panel-header h3 {
+    font-size: 13px;
+}
+
+body.unified-mode .meta-row,
+body.unified-mode .charts-row > :not(#unified-panel),
+body.unified-mode .details-row,
+body.unified-mode .tables-row,
+body.unified-mode footer {
+    display: none !important;
+}
+
+body.unified-mode #unified-panel {
+    flex: 1;
+}

pyobservability/templates/index.html

@@ -75,6 +75,31 @@
             <div class="panel-header"><h3>Memory (%)</h3></div>
             <canvas id="mem-chart" class="chart"></canvas>
         </div>
+
+        <div class="panel hidden" id="unified-panel">
+            <div class="panel-header unified-header">
+                <div class="unified-title-group">
+                    <h3>Aggregated Metrics</h3>
+                    <span class="unified-indicator">Holistic node comparison</span>
+                </div>
+            </div>
+            {# <p class="panel-helper">Select "All nodes" (*) to compare every host.</p> #}
+            <div class="unified-grid">
+                <div class="unified-metric-panel">
+                    <div class="panel-header"><h3>Memory (%)</h3></div>
+                    <canvas id="unified-mem-chart" class="chart"></canvas>
+                </div>
+                <div class="unified-metric-panel">
+                    <div class="panel-header"><h3>CPU Avg (%)</h3></div>
+                    <canvas id="unified-cpu-chart" class="chart"></canvas>
+                </div>
+                <div class="unified-metric-panel">
+                    <div class="panel-header"><h3>Disk (%)</h3></div>
+                    <canvas id="unified-disk-chart" class="chart"></canvas>
+                </div>
+            </div>
+            <div id="unified-legend" class="unified-legend"></div>
+        </div>
     </section>
 
     <section class="details-row">

pyobservability/transport.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import logging
+from typing import Dict, List
 
 from fastapi import WebSocket, WebSocketDisconnect
 
@@ -22,6 +23,99 @@ async def _forward_metrics(websocket: WebSocket, q: asyncio.Queue) -> None:
         await websocket.send_json(payload)
 
 
+def _normalize_targets() -> List[Dict[str, str]]:
+    """Return configuration targets sorted so legend colors are consistent."""
+    return sorted(settings.env.targets, key=lambda t: t["name"].lower())
+
+
+async def _forward_metrics_multi(
+    websocket: WebSocket,
+    queues: List[asyncio.Queue],
+    targets: List[Dict[str, str]],
+) -> None:
+    """Fan-in metrics from multiple monitors and emit once every node updates.
+
+    Args:
+        websocket: FastAPI WebSocket connection.
+        queues: List of asyncio.Queues from multiple monitors.
+        targets: List of target configurations corresponding to the queues.
+
+    Notes:
+        This is resilient to individual node failures.
+        If a monitor starts emitting an ``error`` payload (e.g. exceeded error threshold),
+        that node is marked as failed and removed from the unified stream,
+        so that the remaining nodes keep updating in the UI.
+    """
+    # Track active (non-failed) indices
+    active = [True] * len(queues)
+
+    # Latest payload per node keyed by base_url
+    latest: Dict[str, dict] = {}
+    try:
+        while True:
+            # If all nodes have failed, stop the unified stream loop.
+            if not any(active):
+                LOGGER.info("All targets in unified stream have failed; stopping multi-node forwarder")
+                return
+
+            # Wait for at least one payload from any active queue.
+            # We gather one payload per active queue in a "round", but we do
+            # not block forever on failed queues because we mark them inactive
+            # as soon as they send an error.
+            for idx, q in enumerate(queues):
+                if not active[idx]:
+                    continue
+
+                payload = await q.get()
+
+                # Handle error payloads from monitors: mark this node as failed
+                # and notify the UI once, then skip it from future
+                # rounds so the rest of the nodes continue streaming.
+                if isinstance(payload, dict) and payload.get("type") == "error":
+                    base_url = targets[idx]["base_url"]
+                    LOGGER.warning("Unified stream: target %s reported error and will be skipped", base_url)
+
+                    # Forward the error to the websocket so the UI can show it.
+                    try:
+                        await websocket.send_json(payload)
+                    except Exception as send_err:  # pragma: no cover - defensive
+                        LOGGER.debug("Failed to send error payload to WS: %s", send_err)
+
+                    # Mark this target as inactive and remove its latest sample
+                    active[idx] = False
+                    latest.pop(base_url, None)
+                    continue
+
+                # Normal metrics payload: remember latest per base_url
+                base_url = targets[idx]["base_url"]
+                latest[base_url] = payload
+
+            # Build merged message from all currently active targets that have
+            # produced at least one metrics payload.
+            merged = {
+                "type": "metrics",
+                "ts": asyncio.get_event_loop().time(),
+                "data": [],
+            }
+
+            for idx, target in enumerate(targets):
+                if not active[idx]:
+                    continue
+                sample = latest.get(target["base_url"])
+                if not sample:
+                    continue
+                merged["data"].extend(sample.get("data", []))
+
+            # If we have no data (e.g. new round before any active node
+            # produced metrics), skip sending to avoid spamming empty payloads.
+            if not merged["data"]:
+                continue
+
+            await websocket.send_json(merged)
+    except asyncio.CancelledError:
+        LOGGER.debug("Unified stream task cancelled")
+
+
 async def websocket_endpoint(websocket: WebSocket) -> None:
     """Websocket endpoint to handle observability data streaming.
 
@@ -32,6 +126,10 @@ async def websocket_endpoint(websocket: WebSocket) -> None:
 
     monitor: Monitor | None = None
     q: asyncio.Queue | None = None
+    monitors: List[Monitor] = []
+    queues: List[asyncio.Queue] = []
+    multi_task: asyncio.Task | None = None
+    forward_task: asyncio.Task | None = None
 
     try:
         while True:
@@ -42,6 +140,15 @@ async def websocket_endpoint(websocket: WebSocket) -> None:
                     await monitor.update_flags(
                         all_services=data.get("all_services", False),
                     )
+                elif monitors:
+                    await asyncio.gather(
+                        *(
+                            mon.update_flags(
+                                all_services=data.get("all_services", False),
+                            )
+                            for mon in monitors
+                        )
+                    )
                 continue
 
             # -------------------------------------------
@@ -50,10 +157,42 @@ async def websocket_endpoint(websocket: WebSocket) -> None:
             if data.get("type") == "select_target":
                 base_url = data["base_url"]
 
-                # stop old monitor
+                # stop old monitor / tasks
+                if forward_task:
+                    LOGGER.info("Stopping previous forwarder task")
+                    forward_task.cancel()
+                    forward_task = None
+
                 if monitor:
+                    LOGGER.info("Stopping previous monitor task")
                     monitor.unsubscribe(q)
                     await monitor.stop()
+                    monitor = None
+                    q = None
+
+                if multi_task:
+                    LOGGER.info("Stopping previous multi-target forwarder task")
+                    multi_task.cancel()
+                    multi_task = None
+
+                LOGGER.info("Unsubscribing from previous monitors") if monitor else None
+                for idx, mon in enumerate(monitors):
+                    mon.unsubscribe(queues[idx])
+                    await mon.stop()
+
+                monitors.clear()
+                queues.clear()
+
+                if base_url == "*":
+                    LOGGER.info("Gathering metrics for all targets in unified stream")
+                    targets = _normalize_targets()
+                    for target in targets:
+                        mon = Monitor(target)
+                        await mon.start()
+                        monitors.append(mon)
+                        queues.append(mon.subscribe())
+                    multi_task = asyncio.create_task(_forward_metrics_multi(websocket, queues, targets))
+                    continue
 
                 if target := settings.targets_by_url.get(base_url):
                     LOGGER.info("Gathering metrics for: %s", target["name"])
@@ -69,14 +208,24 @@ async def websocket_endpoint(websocket: WebSocket) -> None:
                 q = monitor.subscribe()
 
                 # start forwarding metrics
-                asyncio.create_task(_forward_metrics(websocket, q))
+                forward_task = asyncio.create_task(_forward_metrics(websocket, q))
     except WebSocketDisconnect:
         pass
     except Exception as err:
         LOGGER.error("WS error: %s", err)
 
     # cleanup
+    if forward_task:
+        forward_task.cancel()
+
     if monitor:
         if q:
             monitor.unsubscribe(q)
         await monitor.stop()
+
+    if multi_task:
+        multi_task.cancel()
+
+    for idx, mon in enumerate(monitors):
+        mon.unsubscribe(queues[idx])
+        await mon.stop()

pyobservability/version.py

@@ -1 +1 @@
-__version__ = "1.2.0"
+__version__ = "1.4.0"

{pyobservability-1.2.0.dist-info → pyobservability-1.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyObservability
-Version: 1.2.0
+Version: 1.4.0
 Summary: Lightweight OS-agnostic observability UI for PyNinja
 Author-email: Vignesh Rao <svignesh1793@gmail.com>
 License: MIT License
@@ -64,8 +64,6 @@ Dynamic: license-file
 **Deployments**
 
 [![pypi][label-actions-pypi]][gha_pypi]
-[![notes][label-actions-notes]][gha_notes]
-[![release][label-actions-release]][gha_release]
 [![docker][label-actions-docker]][gha_docker]
 
 [![Pypi][label-pypi]][pypi]
@@ -158,15 +156,11 @@ Licensed under the [MIT License][license]
 [label-pypi]: https://img.shields.io/pypi/v/PyObservability
 [label-pypi-format]: https://img.shields.io/pypi/format/PyObservability
 [label-pypi-status]: https://img.shields.io/pypi/status/PyObservability
-[label-actions-notes]: https://github.com/thevickypedia/PyObservability/actions/workflows/notes.yml/badge.svg
-[label-actions-release]: https://github.com/thevickypedia/PyObservability/actions/workflows/release.yml/badge.svg
 [label-actions-docker]: https://github.com/thevickypedia/PyObservability/actions/workflows/docker.yml/badge.svg
 
 [3.11]: https://docs.python.org/3/whatsnew/3.11.html
 [virtual environment]: https://docs.python.org/3/tutorial/venv.html
 [gha_pypi]: https://github.com/thevickypedia/PyObservability/actions/workflows/python-publish.yml
-[gha_notes]: https://github.com/thevickypedia/PyObservability/actions/workflows/notes.yml
-[gha_release]: https://github.com/thevickypedia/PyObservability/actions/workflows/release.yml
 [gha_docker]: https://github.com/thevickypedia/PyObservability/actions/workflows/docker.yml
 [pypi]: https://pypi.org/project/PyObservability
 [pypi-files]: https://pypi.org/project/PyObservability/#files

pyobservability-1.4.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+pyobservability/__init__.py,sha256=yVBLyTohBiBKp0Otyl04IggPh8mhg3Er25u6eFyxMto,2618
+pyobservability/main.py,sha256=EJ49ENDnKy07jKHQ0IYEVmsyc_4O3uxCHpn1faQD5VM,4534
+pyobservability/monitor.py,sha256=i_Xf_DB-qLOp1b9wryekjwHIM8AnMrGTkuEg7e08bcM,7539
+pyobservability/transport.py,sha256=S-84mgf-9yMj0H7VSAmueW9yosX_1XxdyNJC2EuQHQQ,8493
+pyobservability/version.py,sha256=8UhoYEXHs1Oai7BW_ExBmuwWnRI-yMG_u1fQAXMizHQ,22
+pyobservability/config/enums.py,sha256=EhvD9kB5EMW3ARxr5KmISmf-rP3D4IKqOIjw6Tb8SB8,294
+pyobservability/config/settings.py,sha256=ylhiT0SARHuzkyon_1otgsO74AfA6aiUKp5uczZQj08,5980
+pyobservability/static/app.js,sha256=lel2ZZH-ifjehzy2d-5UQxOhnBIHxla05xjokW1nXXA,33919
+pyobservability/static/styles.css,sha256=0Vagj7nDac27JC0M870V3yqc1XN4rB5pDYuy4zjit3c,7618
+pyobservability/templates/index.html,sha256=JdGn7Bg9w-4zzcMzX78p0q5760ao7sioaqB1s_8d0Fs,8421
+pyobservability-1.4.0.dist-info/licenses/LICENSE,sha256=_sOIKJWdD2o1WwwDIwYB2qTP2nlSWqT5Tyg9jr1Xa4w,1070
+pyobservability-1.4.0.dist-info/METADATA,sha256=DHbIRiPU0Vi_5PjsT0k5NgMInO8_YgY5azP9fGQM8VQ,6537
+pyobservability-1.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyobservability-1.4.0.dist-info/entry_points.txt,sha256=DSGIr_VA8Tb3FYa2iNUYpf55eAvuFCAoInNS4ngXaME,57
+pyobservability-1.4.0.dist-info/top_level.txt,sha256=p20T0EmihDYW1uMintRXr7X9bg3XWYKyoSbBHOVC1xI,16
+pyobservability-1.4.0.dist-info/RECORD,,

pyobservability-1.2.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-pyobservability/__init__.py,sha256=yVBLyTohBiBKp0Otyl04IggPh8mhg3Er25u6eFyxMto,2618
-pyobservability/main.py,sha256=6Ozyxi-XVq9ojkrTEjw9oYWJaW49JJZ-ezBNzEM951Y,4503
-pyobservability/monitor.py,sha256=Y38zDJFPDbQqz_2jQcNmJBnRpeobC_SV2uhN-13e9RU,7591
-pyobservability/transport.py,sha256=zHLAodX20bKkPOuacKjzv1Dqj3JbNAB75o1ABwzum0U,2534
-pyobservability/version.py,sha256=MpAT5hgNoHnTtG1XRD_GV_A7QrHVU6vJjGSw_8qMGA4,22
-pyobservability/config/enums.py,sha256=EhvD9kB5EMW3ARxr5KmISmf-rP3D4IKqOIjw6Tb8SB8,294
-pyobservability/config/settings.py,sha256=l1xtD8teYS5ozXWm6JqpyyrcQsu95Syjs02xsd0m6MI,5886
-pyobservability/static/app.js,sha256=lb0IjLle-FibG_ee0VN6qAe5LGJuSurgXVhHXCQL6WI,24281
-pyobservability/static/styles.css,sha256=4-VCDhzv_FnrvUffETTHkNnyGOFDUJU0qz2eLHCz_QI,5569
-pyobservability/templates/index.html,sha256=OvFDydHMquBtFr_2cy3iXP0I-pax6_RKBJinVVEIzQY,7193
-pyobservability-1.2.0.dist-info/licenses/LICENSE,sha256=_sOIKJWdD2o1WwwDIwYB2qTP2nlSWqT5Tyg9jr1Xa4w,1070
-pyobservability-1.2.0.dist-info/METADATA,sha256=WEEJiWj1F32ixoMA7n8Cc-3bOQpeGn_p586qh9PjfEk,7037
-pyobservability-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyobservability-1.2.0.dist-info/entry_points.txt,sha256=DSGIr_VA8Tb3FYa2iNUYpf55eAvuFCAoInNS4ngXaME,57
-pyobservability-1.2.0.dist-info/top_level.txt,sha256=p20T0EmihDYW1uMintRXr7X9bg3XWYKyoSbBHOVC1xI,16
-pyobservability-1.2.0.dist-info/RECORD,,