Refactor: stat service deprecated stats (#9658)

* refactor(dashboard): migrate get_stat off deprecated stats methods

Rewrite StatService.get_stat to query PlatformStat directly via
db_helper.get_db(), following the existing get_provider_token_stats
pattern in the same file, instead of the deprecated
get_base_stats/get_grouped_base_stats/get_total_message_count.

- Windowed rows are fetched once with an explicit ORDER BY timestamp
  (the old get_base_stats relied on insertion order)
- Per-platform sums and hourly time-series buckets are aggregated in
  Python; total message count uses func.coalesce(func.sum(...), 0)
- Response shape is unchanged: platform entries keep the
  {name, count, timestamp} keys, now built as plain dicts so no
  deprecated po.Platform/Stats classes are instantiated
- Verified semantically identical against the old methods with an A/B
  comparison over a seeded database (time series, per-platform sums,
  total count, and empty-window case all match)

* test(dashboard): cover StatService.get_stat aggregation semantics

The existing test_get_stat route test only asserts the HTTP status and
the presence of the platform key, so an aggregation regression would
pass unnoticed. Add focused unit tests that seed PlatformStat rows and
assert the windowed per-platform sums, the global message total, the
hourly time-series bucket shape, the response key set, and the
empty-window behavior.

Author: RC-CHN

astrbot/dashboard/services/stat_service.py

@@ -13,7 +13,7 @@
 
 import aiohttp
 import psutil
-from sqlmodel import col, select
+from sqlmodel import col, func, select
 
 from astrbot.core import DEMO_MODE, logger
 from astrbot.core.config import VERSION
@@ -23,7 +23,7 @@
     get_dashboard_version,
 )
 from astrbot.core.db import BaseDatabase
-from astrbot.core.db.po import ProviderStat
+from astrbot.core.db.po import PlatformStat, ProviderStat
 from astrbot.core.desktop_runtime import (
     DESKTOP_MANAGED_RESTART_MESSAGE,
     is_desktop_managed_backend,
@@ -210,23 +210,49 @@ async def cleanup_storage(self, target: str) -> dict:
 
     async def get_stat(self, offset_sec: int) -> dict:
         try:
-            stat = self.db_helper.get_base_stats(offset_sec)
             now = int(time.time())
             start_time = now - offset_sec
-            message_time_based_stats = []
 
+            async with self.db_helper.get_db() as session:
+                window_start = datetime.now() - timedelta(seconds=offset_sec)
+                result = await session.execute(
+                    select(PlatformStat)
+                    .where(PlatformStat.timestamp >= window_start)
+                    .order_by(col(PlatformStat.timestamp)),
+                )
+                # Convert to (epoch_seconds, count, platform_id) tuples once.
+                rows = [
+                    (int(r.timestamp.timestamp()), r.count, r.platform_id)
+                    for r in result.scalars().all()
+                ]
+                total_messages = (
+                    await session.execute(
+                        select(func.coalesce(func.sum(PlatformStat.count), 0)),
+                    )
+                ).scalar_one()
+
+            # Bucket message counts into hourly slots for the time series chart.
+            message_time_based_stats = []
             idx = 0
             for bucket_end in range(start_time, now, 3600):
                 cnt = 0
-                while (
-                    idx < len(stat.platform)
-                    and stat.platform[idx].timestamp < bucket_end
-                ):
-                    cnt += stat.platform[idx].count
+                while idx < len(rows) and rows[idx][0] < bucket_end:
+                    cnt += rows[idx][1]
                     idx += 1
                 message_time_based_stats.append([bucket_end, cnt])
 
-            stat_dict = stat.__dict__
+            # Aggregate per-platform message counts within the window.
+            per_platform: dict[str, int] = defaultdict(int)
+            for _, count, platform_id in rows:
+                per_platform[platform_id] += count
+            platform_stats = [
+                {
+                    "name": platform_id,
+                    "count": count,
+                    "timestamp": int(window_start.timestamp()),
+                }
+                for platform_id, count in per_platform.items()
+            ]
 
             process_cpu = await asyncio.to_thread(psutil.Process().cpu_percent, 0.5)
             cpu_percent = process_cpu / (psutil.cpu_count() or 1)
@@ -246,29 +272,24 @@ async def get_stat(self, offset_sec: int) -> dict:
                 int(time.time()) - self.core_lifecycle.start_time,
             )
 
-            stat_dict.update(
-                {
-                    "platform": self.db_helper.get_grouped_base_stats(
-                        offset_sec,
-                    ).platform,
-                    "message_count": self.db_helper.get_total_message_count() or 0,
-                    "platform_count": len(
-                        self.core_lifecycle.platform_manager.get_insts(),
-                    ),
-                    "plugin_count": len(plugins),
-                    "plugins": plugin_info,
-                    "message_time_series": message_time_based_stats,
-                    "running": running_time,
-                    "memory": {
-                        "process": psutil.Process().memory_info().rss >> 20,
-                        "system": psutil.virtual_memory().total >> 20,
-                    },
-                    "cpu_percent": round(cpu_percent, 1),
-                    "thread_count": thread_count,
-                    "start_time": self.core_lifecycle.start_time,
+            return {
+                "platform": platform_stats,
+                "message_count": total_messages,
+                "platform_count": len(
+                    self.core_lifecycle.platform_manager.get_insts(),
+                ),
+                "plugin_count": len(plugins),
+                "plugins": plugin_info,
+                "message_time_series": message_time_based_stats,
+                "running": running_time,
+                "memory": {
+                    "process": psutil.Process().memory_info().rss >> 20,
+                    "system": psutil.virtual_memory().total >> 20,
                 },
-            )
-            return stat_dict
+                "cpu_percent": round(cpu_percent, 1),
+                "thread_count": thread_count,
+                "start_time": self.core_lifecycle.start_time,
+            }
         except Exception as exc:
             logger.error(traceback.format_exc())
             raise StatServiceError(str(exc)) from exc

tests/unit/test_stat_service.py

@@ -0,0 +1,80 @@
+import time
+from datetime import datetime, timedelta
+from unittest.mock import MagicMock
+
+import pytest
+
+from astrbot.dashboard.services.stat_service import StatService
+
+
+def _make_service(db) -> StatService:
+    """Build a StatService with a real DB and a mocked core lifecycle."""
+    core_lifecycle = MagicMock()
+    core_lifecycle.star_context.get_all_stars.return_value = []
+    core_lifecycle.platform_manager.get_insts.return_value = []
+    core_lifecycle.start_time = int(time.time()) - 100
+    return StatService(db_helper=db, core_lifecycle=core_lifecycle, config={})
+
+
+@pytest.mark.asyncio
+async def test_get_stat_aggregates_platform_stats(temp_db):
+    """Seeded rows must aggregate into windowed platform sums and a global total."""
+    now = datetime.now()
+    seed = [
+        ("aiocqhttp", 3, now - timedelta(hours=1)),
+        ("aiocqhttp", 5, now - timedelta(hours=1, minutes=30)),
+        ("qqofficial", 2, now - timedelta(hours=2)),
+        ("webchat", 7, now - timedelta(minutes=10)),
+        # Outside the 24h window: counted in the total but not in window stats.
+        ("aiocqhttp", 4, now - timedelta(hours=26)),
+    ]
+    for platform_id, count, ts in seed:
+        await temp_db.insert_platform_stats(platform_id, platform_id, count, ts)
+
+    result = await _make_service(temp_db).get_stat(86400)
+
+    # Global total counts every row, including the one outside the window.
+    assert result["message_count"] == 21
+
+    # Windowed per-platform sums, serialized with the legacy response keys.
+    platform = {entry["name"]: entry["count"] for entry in result["platform"]}
+    assert platform == {"aiocqhttp": 8, "qqofficial": 2, "webchat": 7}
+    for entry in result["platform"]:
+        assert set(entry) == {"name", "count", "timestamp"}
+
+    # Hourly buckets cover [now - offset, now) in ascending order.
+    series = result["message_time_series"]
+    assert len(series) == 24
+    bucket_ends = [bucket_end for bucket_end, _ in series]
+    assert bucket_ends == sorted(bucket_ends)
+    assert all(count >= 0 for _, count in series)
+    # Rows within the current partial hour are not bucketed yet, so the
+    # series sum never exceeds the windowed total of 17.
+    assert sum(count for _, count in series) <= 17
+
+    assert set(result) == {
+        "platform",
+        "message_count",
+        "platform_count",
+        "plugin_count",
+        "plugins",
+        "message_time_series",
+        "running",
+        "memory",
+        "cpu_percent",
+        "thread_count",
+        "start_time",
+    }
+
+
+@pytest.mark.asyncio
+async def test_get_stat_empty_window(temp_db):
+    """A window with no rows yields empty platform stats but keeps the total."""
+    old_ts = datetime.now() - timedelta(hours=2)
+    await temp_db.insert_platform_stats("aiocqhttp", "aiocqhttp", 4, old_ts)
+
+    result = await _make_service(temp_db).get_stat(1)
+
+    assert result["platform"] == []
+    assert result["message_count"] == 4
+    assert all(count == 0 for _, count in result["message_time_series"])