Skip to content

ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.

fix(api): GET /servers never sent the metrics the servers list renders

Juan Denis3d9bf09bea4f
diff --git a/backend/app/api/servers.py b/backend/app/api/servers.py
index 08da1953..fb422829 100644
--- a/backend/app/api/servers.py
+++ b/backend/app/api/servers.py
@@ -282,11 +282,33 @@ def list_servers():
servers = query.order_by(Server.name).all()
- # Add connection status
+ # Latest metrics per server, under the SAME 'metrics' key the detail
+ # endpoint uses (see get_server_status below) — the servers list renders
+ # CPU/Memory/Disk gauges from it, and without it every one of those cells
+ # fell back to the "no data" dash on a live panel.
+ #
+ # Batched deliberately: `server.metrics` is lazy='dynamic', so doing this
+ # per row inside the loop would be one extra SELECT per server. Newest row
+ # per server = highest id, because the id autoincrements on insert — that
+ # also avoids the tie a max(timestamp) join would hit for same-second rows.
+ metrics_by_server = {}
+ if servers:
+ server_ids = [s.id for s in servers]
+ newest = (
+ db.session.query(db.func.max(ServerMetrics.id))
+ .filter(ServerMetrics.server_id.in_(server_ids))
+ .group_by(ServerMetrics.server_id)
+ )
+ for row in ServerMetrics.query.filter(ServerMetrics.id.in_(newest)).all():
+ metrics_by_server[row.server_id] = row.to_dict()
+
result = []
for server in servers:
server_dict = server.to_dict()
server_dict['is_connected'] = agent_registry.is_agent_connected(server.id)
+ metrics = metrics_by_server.get(server.id)
+ if metrics:
+ server_dict['metrics'] = metrics
result.append(server_dict)
return jsonify(result)
diff --git a/backend/tests/test_servers_list_metrics.py b/backend/tests/test_servers_list_metrics.py
new file mode 100644
index 00000000..d6010bb5
--- /dev/null
+++ b/backend/tests/test_servers_list_metrics.py
@@ -0,0 +1,110 @@
+"""GET /servers must carry each server's latest metrics.
+
+The servers list renders CPU/Memory/Disk gauges from `server.metrics`, the same
+key the per-server status endpoint uses. The list endpoint never populated it —
+`to_dict()` defaults to `include_metrics=False`, and even when asked it emits
+`latest_metrics`, not `metrics` — so on a live panel every gauge cell fell back
+to the "no data" dash. The mock fixtures used for screenshots *did* supply
+`metrics`, which is exactly why the gap survived: the UI looked right in every
+capture and was empty in production.
+"""
+from datetime import datetime, timedelta
+
+import pytest
+
+from app import db
+from app.models.server import Server, ServerMetrics
+
+
+def _mk_server(name, status='online'):
+ server = Server(name=name, hostname=f'{name}.test.local', status=status)
+ db.session.add(server)
+ db.session.flush()
+ return server
+
+
+def _mk_metrics(server, *, cpu, memory, disk, minutes_ago=0):
+ row = ServerMetrics(
+ server_id=server.id,
+ timestamp=datetime.utcnow() - timedelta(minutes=minutes_ago),
+ cpu_percent=cpu,
+ memory_percent=memory,
+ disk_percent=disk,
+ )
+ db.session.add(row)
+ db.session.flush()
+ return row
+
+
+def servers_with_metrics(app):
+ with app.app_context():
+ a = _mk_server('alpha')
+ b = _mk_server('bravo')
+ bare = _mk_server('charlie') # never reported: must not get a key
+
+ # Two samples for alpha — only the newest may be returned.
+ _mk_metrics(a, cpu=10, memory=11, disk=12, minutes_ago=30)
+ _mk_metrics(a, cpu=42, memory=64, disk=71, minutes_ago=0)
+ _mk_metrics(b, cpu=5, memory=6, disk=7)
+ db.session.commit()
+ yield {'a': a.id, 'b': b.id, 'bare': bare.id}
+
+
+def _by_name(payload):
+ return {row['name']: row for row in payload}
+
+
+def test_list_servers_includes_latest_metrics(client, auth_headers, servers_with_metrics):
+ resp = client.get('/api/v1/servers', headers=auth_headers)
+ assert resp.status_code == 200
+ rows = _by_name(resp.get_json())
+
+ # The exact key and field names the servers table reads.
+ assert rows['alpha']['metrics']['cpu_percent'] == 42
+ assert rows['alpha']['metrics']['memory_percent'] == 64
+ assert rows['alpha']['metrics']['disk_percent'] == 71
+ assert rows['bravo']['metrics']['cpu_percent'] == 5
+
+
+def test_list_servers_omits_metrics_for_servers_that_never_reported(client, auth_headers, servers_with_metrics):
+ rows = _by_name(client.get('/api/v1/servers', headers=auth_headers).get_json())
+ # Absent, not a null/empty dict: the UI gates the gauge on truthiness and a
+ # {} would render a 0% bar, which is a claim rather than "no data".
+ assert 'metrics' not in rows['charlie']
+
+
+def test_list_servers_metrics_are_batched_not_per_row(client, auth_headers, servers_with_metrics, app):
+ """The lookup must not scale with the number of servers.
+
+ `Server.metrics` is lazy='dynamic', so the obvious implementation costs one
+ extra SELECT per row. Count statements against server_metrics and assert it
+ stays flat as servers are added.
+ """
+ from sqlalchemy import event
+
+ def count_metric_queries():
+ seen = []
+
+ def before(conn, cursor, statement, params, context, executemany):
+ if 'server_metrics' in statement.lower():
+ seen.append(statement)
+
+ event.listen(db.engine, 'before_cursor_execute', before)
+ try:
+ client.get('/api/v1/servers', headers=auth_headers)
+ finally:
+ event.remove(db.engine, 'before_cursor_execute', before)
+ return len(seen)
+
+ baseline = count_metric_queries()
+
+ with app.app_context():
+ for i in range(6):
+ extra = _mk_server(f'extra-{i}')
+ _mk_metrics(extra, cpu=1, memory=2, disk=3)
+ db.session.commit()
+
+ assert count_metric_queries() == baseline, (
+ 'metrics lookup grew with the server count — it must stay batched'
+ )