openclaw-agent-dashboard 1.0.44 → 1.0.45

package/dashboard/api/performance.py

@@ -3,9 +3,12 @@
 支持按分钟查看调用详情，便于分析调用瓶颈
 """
 from fastapi import APIRouter
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Tuple
+import copy
 import json
 import re
+import asyncio
+import time
 from pathlib import Path
 from datetime import datetime, timedelta, timezone
 from zoneinfo import ZoneInfo
@@ -19,6 +22,31 @@ TZ_DISPLAY = ZoneInfo('Asia/Shanghai')
 
 router = APIRouter()
 
+# 聚合统计多次并发请求（WS + 轮询 + 多标签）共用；TTL 短以保证大致实时
+_perf_stats_cache: Dict[str, Tuple[float, Dict[str, Any]]] = {}
+_PERF_STATS_CACHE_TTL_SEC = 12.0
+
+# 柱体钻取：多次点击 / 并发标签共用短缓存
+_perf_details_cache: Dict[str, Tuple[float, Dict[str, Any]]] = {}
+_PERF_DETAILS_CACHE_TTL_SEC = 12.0
+
+# 轻量解析 envelope ISO 时间，便于跳过明显早于查询窗口的行（避免 json.loads + schema）
+_QUICK_ENV_TS_RE = re.compile(r'"timestamp"\s*:\s*"([^"]+)"')
+
+
+def _quick_envelope_timestamp_utc(line: str) -> Optional[datetime]:
+    m = _QUICK_ENV_TS_RE.search(line)
+    if not m:
+        return None
+    try:
+        return datetime.fromisoformat(m.group(1).replace("Z", "+00:00"))
+    except ValueError:
+        return None
+
+
+def _perf_cache_key(range_minutes: int, range_hours: int, granularity: str) -> str:
+    return f"{range_minutes}:{range_hours}:{granularity}"
+
 
 def _extract_trigger_text(msg: Dict) -> str:
     """从消息中提取触发内容（完整展示）"""
@@ -177,11 +205,25 @@ def parse_session_file(session_path: Path, range_hours: int = 1) -> List[Dict]:
         range_hours: 时间范围（小时），0 表示不限制
     """
     messages = []
+    now = datetime.now(timezone.utc)
+    time_ago = now - timedelta(hours=range_hours) if range_hours > 0 else None
+
+    # 启发式：窗口内若有 assistant usage，文件通常在窗口内有过写入；过久未修改则可跳过整文件
+    if time_ago is not None:
+        try:
+            if session_path.stat().st_mtime < time_ago.timestamp():
+                return []
+        except OSError:
+            return []
 
     try:
         with open(session_path, 'r', encoding='utf-8') as f:
             for line in f:
                 try:
+                    if time_ago is not None:
+                        qt = _quick_envelope_timestamp_utc(line)
+                        if qt is not None and qt < time_ago:
+                            continue
                     envelope, msg = parse_session_jsonl_line(line)
                     if (
                         not envelope
@@ -200,11 +242,8 @@ def parse_session_file(session_path: Path, range_hours: int = 1) -> List[Dict]:
                             str(envelope['timestamp']).replace('Z', '+00:00')
                         )
 
-                        if range_hours > 0:
-                            now = datetime.now(timezone.utc)
-                            time_ago = now - timedelta(hours=range_hours)
-                            if timestamp < time_ago:
-                                continue
+                        if time_ago is not None and timestamp < time_ago:
+                            continue
 
                         messages.append({
                             'timestamp': timestamp,
@@ -240,14 +279,8 @@ async def get_performance_stats(range: str = "20m"):
     return stats
 
 
-async def get_real_stats(range_minutes: int = 20, range_hours: int = 1, granularity: str = "minute") -> Dict:
-    """获取真实的 TPM/RPM 统计
-
-    Args:
-        range_minutes: 时间范围（分钟）
-        range_hours: 用于解析 session 的时间范围（小时）
-        granularity: 聚合粒度 (minute, hour)
-    """
+def _compute_real_stats_sync(range_minutes: int = 20, range_hours: int = 1, granularity: str = "minute") -> Dict:
+    """同步聚合 TPM/RPM（在线程池中运行，避免阻塞事件循环）。"""
     stats = {
         'current': {
             'tpm': 0,
@@ -381,24 +414,38 @@ async def get_real_stats(range_minutes: int = 20, range_hours: int = 1, granular
     return stats
 
 
-async def get_minute_details(
+async def get_real_stats(range_minutes: int = 20, range_hours: int = 1, granularity: str = "minute") -> Dict:
+    """获取真实的 TPM/RPM 统计（线程池计算 + 短时缓存，减轻重复扫盘）。"""
+    key = _perf_cache_key(range_minutes, range_hours, granularity)
+    now = time.monotonic()
+    hit = _perf_stats_cache.get(key)
+    if hit is not None and (now - hit[0]) < _PERF_STATS_CACHE_TTL_SEC:
+        return hit[1]
+    data = await asyncio.to_thread(_compute_real_stats_sync, range_minutes, range_hours, granularity)
+    _perf_stats_cache[key] = (now, data)
+    return data
+
+
+def _perf_details_cache_key(
+    timestamp_ms: int,
+    granularity: str,
+    agent: str,
+    search: str,
+    sort: str,
+    limit: int,
+) -> str:
+    return f"{timestamp_ms}:{granularity}:{agent}:{search}:{sort}:{limit}"
+
+
+def _compute_minute_details_sync(
     timestamp_ms: int,
     granularity: str = "minute",
     agent: Optional[str] = None,
     search: Optional[str] = None,
     sort: str = "tokens_desc",
-    limit: int = 50
+    limit: int = 50,
 ) -> Dict[str, Any]:
-    """获取指定时间窗口的调用详情，用于柱体点击钻取。时间展示使用 Asia/Shanghai 时区
-
-    Args:
-        timestamp_ms: Unix 毫秒时间戳
-        granularity: 粒度 (minute, hour)
-        agent: 筛选指定 Agent
-        search: 搜索触发内容
-        sort: 排序方式 (tokens_desc, tokens_asc, time_asc, time_desc)
-        limit: 返回数量限制
-    """
+    """同步聚合柱体钻取数据（线程池 + 短 TTL 缓存）。"""
     try:
         ts = datetime.fromtimestamp(timestamp_ms / 1000, tz=timezone.utc)
         ts_local = ts.astimezone(TZ_DISPLAY)
@@ -419,6 +466,7 @@ async def get_minute_details(
 
         all_calls = []
         agent_set = set()
+        window_start_ts = time_start.timestamp()
 
         for agent_dir in agents_path.iterdir():
             if not agent_dir.is_dir():
@@ -437,6 +485,12 @@ async def get_minute_details(
             for session_file in sessions_path.glob('*.jsonl'):
                 if 'lock' in session_file.name or 'deleted' in session_file.name:
                     continue
+                try:
+                    # 与 parse_session_file 相同启发式：窗口开始后未修改的文件不可能含该窗内的 assistant 记录
+                    if session_file.stat().st_mtime < window_start_ts:
+                        continue
+                except OSError:
+                    continue
                 records = parse_session_file_with_details(session_file, agent_id)
                 for r in records:
                     if time_start <= r['timestamp'] < time_end:
@@ -503,6 +557,44 @@ async def get_minute_details(
         return {'timeWindow': '', 'calls': [], 'totalCalls': 0, 'totalTokens': 0, 'summary': {'avgTokens': 0}, 'agents': [], 'pagination': {'total': 0, 'limit': limit, 'hasMore': False}}
 
 
+async def get_minute_details(
+    timestamp_ms: int,
+    granularity: str = "minute",
+    agent: Optional[str] = None,
+    search: Optional[str] = None,
+    sort: str = "tokens_desc",
+    limit: int = 50
+) -> Dict[str, Any]:
+    """获取指定时间窗口的调用详情，用于柱体点击钻取。时间展示使用 Asia/Shanghai 时区
+
+    Args:
+        timestamp_ms: Unix 毫秒时间戳
+        granularity: 粒度 (minute, hour)
+        agent: 筛选指定 Agent
+        search: 搜索触发内容
+        sort: 排序方式 (tokens_desc, tokens_asc, time_asc, time_desc)
+        limit: 返回数量限制
+    """
+    ag = agent or ""
+    sr = search or ""
+    key = _perf_details_cache_key(timestamp_ms, granularity, ag, sr, sort, limit)
+    now = time.monotonic()
+    hit = _perf_details_cache.get(key)
+    if hit is not None and (now - hit[0]) < _PERF_DETAILS_CACHE_TTL_SEC:
+        return copy.deepcopy(hit[1])
+    data = await asyncio.to_thread(
+        _compute_minute_details_sync,
+        timestamp_ms,
+        granularity,
+        agent,
+        search,
+        sort,
+        limit,
+    )
+    _perf_details_cache[key] = (now, copy.deepcopy(data))
+    return data
+
+
 @router.get("/performance/details")
 async def get_performance_details(
     timestamp: int,

package/dashboard/api/timeline.py

@@ -1,11 +1,13 @@
 """
 Timeline API 路由 - 实时执行时序图
 """
+import asyncio
+import copy
 import logging
 import time
 from fastapi import APIRouter, Query, HTTPException
 from pydantic import BaseModel
-from typing import Optional, List, Dict, Any
+from typing import Optional, List, Dict, Any, Tuple
 import sys
 from pathlib import Path
 
@@ -20,6 +22,14 @@ from data.config_reader import get_agent_config
 
 router = APIRouter()
 
+# 切换 agent / 轮询重复命中时减轻重复读盘解析（短时 stale 可接受）
+_timeline_cache: Dict[str, Tuple[float, Dict[str, Any]]] = {}
+_TIMELINE_CACHE_TTL_SEC = 5.0
+
+
+def _timeline_cache_key(agent_id: str, session_key: Optional[str], limit: int) -> str:
+    return f"{agent_id}\x00{session_key or ''}\x00{limit}"
+
 
 class TimelineStats(BaseModel):
     totalDuration: int
@@ -80,11 +90,18 @@ async def get_timeline(
         raise HTTPException(status_code=404, detail=f"Agent {agent_id} not found")
 
     t0 = time.perf_counter()
-    try:
-        result = get_timeline_steps(agent_id, session_key, limit)
-    except Exception as e:
-        record_error("unknown", str(e), "api:timeline:get", exc=e)
-        raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
+    cache_key = _timeline_cache_key(agent_id, session_key, limit)
+    now_mono = time.monotonic()
+    hit = _timeline_cache.get(cache_key)
+    if hit is not None and (now_mono - hit[0]) < _TIMELINE_CACHE_TTL_SEC:
+        result = copy.deepcopy(hit[1])
+    else:
+        try:
+            result = await asyncio.to_thread(get_timeline_steps, agent_id, session_key, limit)
+        except Exception as e:
+            record_error("unknown", str(e), "api:timeline:get", exc=e)
+            raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
+        _timeline_cache[cache_key] = (now_mono, copy.deepcopy(result))
     elapsed_ms = (time.perf_counter() - t0) * 1000
     steps_count = len(result.get("steps", []))
     if elapsed_ms >= 100.0:
@@ -127,7 +144,7 @@ async def get_timeline_steps_only(
         raise HTTPException(status_code=404, detail=f"Agent {agent_id} not found")
 
     try:
-        result = get_timeline_steps(agent_id, session_key, limit)
+        result = await asyncio.to_thread(get_timeline_steps, agent_id, session_key, limit)
     except Exception as e:
         record_error("unknown", str(e), "api:timeline:steps", exc=e)
         raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
@@ -153,7 +170,7 @@ async def get_timeline_summary(agent_id: str, session_key: Optional[str] = Query
         raise HTTPException(status_code=404, detail=f"Agent {agent_id} not found")
 
     try:
-        result = get_timeline_steps(agent_id, session_key, limit=10)  # 只需基本信息
+        result = await asyncio.to_thread(get_timeline_steps, agent_id, session_key, 10)  # 只需基本信息
     except Exception as e:
         record_error("unknown", str(e), "api:timeline:summary", exc=e)
         raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e

package/dashboard/api/websocket.py

@@ -7,6 +7,7 @@ from typing import Set, List, Dict, Any
 import json
 import asyncio
 import sys
+import time
 from pathlib import Path
 
 sys.path.append(str(Path(__file__).parent.parent))
@@ -18,30 +19,46 @@ router = APIRouter()
 # 活跃的 WebSocket 连接
 active_connections: Set[WebSocket] = set()
 
-# 周期性推送间隔（秒）- 优化：从 3 秒缩短到 1 秒
-BROADCAST_INTERVAL_SEC = 1
+# 周期性增量检查基准间隔（秒）；空闲时会自动退避拉长（见 _periodic_broadcast_loop）
+BROADCAST_INTERVAL_SEC = 5
 _broadcast_task: asyncio.Task | None = None
+_broadcast_sleep_sec: float = float(BROADCAST_INTERVAL_SEC)
+_broadcast_idle_streak: int = 0
+
+# 文件监听等高频触发下合并 full_state，降低前端解析与重绘压力
+FULL_STATE_MIN_INTERVAL_SEC = 2.0
+_last_full_state_monotonic: float = 0.0
 
 
 async def _periodic_broadcast_loop():
-    """周期性广播状态更新（增量），确保无文件变更时也有更新"""
+    """周期性广播状态更新（增量）；连续无变更则拉长睡眠间隔，上限 30s。"""
+    global _broadcast_sleep_sec, _broadcast_idle_streak
     while True:
-        await asyncio.sleep(BROADCAST_INTERVAL_SEC)
+        await asyncio.sleep(_broadcast_sleep_sec)
         if active_connections:
-            # 只推送状态变化的 Agent
             try:
                 from status.status_calculator import get_changed_agents
                 changed_agents = await get_changed_agents()
                 if changed_agents:
+                    _broadcast_idle_streak = 0
+                    _broadcast_sleep_sec = float(BROADCAST_INTERVAL_SEC)
                     await broadcast_state_update(changed_agents)
+                else:
+                    _broadcast_idle_streak += 1
+                    if _broadcast_idle_streak >= 3:
+                        _broadcast_sleep_sec = min(_broadcast_sleep_sec * 2.0, 30.0)
+            except asyncio.CancelledError:
+                raise
             except Exception as e:
                 record_error("unknown", str(e), "websocket:periodic_broadcast", exc=e)
 
 
 def _ensure_broadcast_task():
     """有连接时启动周期性推送"""
-    global _broadcast_task
+    global _broadcast_task, _broadcast_sleep_sec, _broadcast_idle_streak
     if active_connections and (_broadcast_task is None or _broadcast_task.done()):
+        _broadcast_sleep_sec = float(BROADCAST_INTERVAL_SEC)
+        _broadcast_idle_streak = 0
         _broadcast_task = asyncio.create_task(_periodic_broadcast_loop())
 
 
@@ -210,9 +227,15 @@ async def broadcast_full_state():
     优化点：
     1. 使用 get_collaboration_dynamic() 代替 get_collaboration()
     2. 只推送动态数据，减少数据量
+    3. 短时间重复调用节流，避免监听线程连震时频繁全量推送
     """
+    global _last_full_state_monotonic
     if not active_connections:
         return
+    now = time.monotonic()
+    if now - _last_full_state_monotonic < FULL_STATE_MIN_INTERVAL_SEC:
+        return
+    _last_full_state_monotonic = now
     try:
         from .agents import get_agents as get_agents_list
         from .subagents import get_subagents

package/dashboard/core/schemas/base.py

@@ -25,19 +25,20 @@ class SchemaValidator:
         self.schema = schema
         self.strict = strict
         self._validator = Draft202012Validator(schema)
-        self._last_errors: List[str] = []
 
     def validate(self, data: Any) -> ValidationResult:
-        self._last_errors = []
+        """线程安全：校验结果仅通过返回值给出，实例上不保留最后一次错误（避免并发覆盖）。"""
+        errors: List[str] = []
         if not isinstance(data, (dict, list)) and self.schema.get("type") == "object":
-            self._last_errors.append("expected object")
-            return ValidationResult(False, list(self._last_errors))
+            errors.append("expected object")
+            return ValidationResult(False, errors)
         try:
             self._validator.validate(data)
             return ValidationResult(True, [])
         except jsonschema.ValidationError as e:
-            self._last_errors.append(e.message)
-            return ValidationResult(False, list(self._last_errors))
+            errors.append(e.message)
+            return ValidationResult(False, errors)
 
     def get_error_details(self) -> Dict[str, Any]:
-        return {"errors": list(self._last_errors)}
+        """兼容旧接口；共享校验器实例时不代表「最后一次校验」。请使用 validate() 的返回值。"""
+        return {"errors": []}

package/dashboard/utils/data_repair.py

@@ -17,6 +17,15 @@ from core.schemas.session_schema import session_envelope_schema, session_message
 
 _audit_log = logging.getLogger("openclaw.fortify.audit")
 
+# 模块级复用：避免每条 JSONL 构造 Draft202012Validator（CPU 大户）。实例线程安全见 SchemaValidator.validate。
+_MSG_SCHEMA_OPTIONAL = dict(session_message_schema)
+_MSG_SCHEMA_OPTIONAL.pop("required", None)
+_ENVELOPE_STRICT = SchemaValidator(session_envelope_schema, strict=True)
+_ENVELOPE_LOOSE = SchemaValidator(session_envelope_schema, strict=False)
+_MSG_STRICT_FULL = SchemaValidator(session_message_schema, strict=True)
+_MSG_LOOSE_OPTIONAL = SchemaValidator(_MSG_SCHEMA_OPTIONAL, strict=False)
+_RELAXED_MESSAGE = SchemaValidator(_MSG_SCHEMA_OPTIONAL, strict=False)
+
 
 def _ensure_audit_logging() -> None:
     if _audit_log.handlers:
@@ -123,7 +132,7 @@ def parse_session_jsonl_line(
         record_error("parsing-error", "json_decode session line", "session_jsonl")
         return None, None
 
-    env_validator = SchemaValidator(session_envelope_schema, strict=strict)
+    env_validator = _ENVELOPE_STRICT if strict else _ENVELOPE_LOOSE
     env_res = env_validator.validate(data)
     if not env_res.is_valid:
         from core.error_handler import record_error
@@ -144,11 +153,7 @@ def parse_session_jsonl_line(
         else:
             return data, None
 
-    msg_schema = dict(session_message_schema)
-    if not strict:
-        msg_schema = dict(msg_schema)
-        msg_schema.pop("required", None)
-    mv = SchemaValidator(msg_schema, strict=strict)
+    mv = _MSG_STRICT_FULL if strict else _MSG_LOOSE_OPTIONAL
     mv_res = mv.validate(msg)
     if mv_res.is_valid:
         return data, msg
@@ -157,10 +162,7 @@ def parse_session_jsonl_line(
         repaired_msg = dict(msg)
         if "role" not in repaired_msg:
             repaired_msg["role"] = "assistant"
-        relaxed = dict(msg_schema)
-        relaxed.pop("required", None)
-        mv2 = SchemaValidator(relaxed, strict=False)
-        if mv2.validate(repaired_msg).is_valid:
+        if _RELAXED_MESSAGE.validate(repaired_msg).is_valid:
             audit_repair("message_schema_repair", json.dumps(msg), json.dumps(repaired_msg))
             return data, repaired_msg
 
@@ -174,10 +176,7 @@ def parse_session_jsonl_line(
 
 def validate_message_dict(msg: Dict[str, Any]) -> Tuple[bool, List[str]]:
     cfg = get_fortify_config()
-    msg_schema = dict(session_message_schema)
-    if not cfg.json_strict:
-        msg_schema.pop("required", None)
-    mv = SchemaValidator(msg_schema, strict=cfg.json_strict)
+    mv = _MSG_STRICT_FULL if cfg.json_strict else _MSG_LOOSE_OPTIONAL
     r = mv.validate(msg)
     return r.is_valid, r.errors
 

package/dashboard/watchers/file_watcher.py

@@ -17,7 +17,7 @@ _LOG = logging.getLogger("openclaw.fortify.watcher")
 from core.config_fortify import get_fortify_config
 from core.error_handler import record_error, record_watcher_failure, record_watcher_recovery
 
-DEBOUNCE_SECONDS = 0.3
+DEBOUNCE_SECONDS = 1.5
 
 
 def _extract_agent_id_from_path(filepath: str) -> Optional[str]:
@@ -260,8 +260,8 @@ def _on_file_changed(filepath: Optional[str] = None) -> None:
 
         loop = _event_loop
         if loop and broadcast_full_state:
-            future = asyncio.run_coroutine_threadsafe(broadcast_full_state(), loop)
-            future.result(timeout=10)
+            # fire-and-forget：避免阻塞 watchdog 线程；节流由 websocket.broadcast_full_state 负责
+            asyncio.run_coroutine_threadsafe(broadcast_full_state(), loop)
     except Exception as e:
         _last_error = str(e)
         record_error("unknown", str(e), "file_watcher_push")