Update hub_dashboard_service.py

hub_dashboard_service.py

@@ -365,54 +365,132 @@ def api_trades_closed():
 
 @app.route("/api/ranker/logs/recent")
 def api_logs_recent():
-    """Get recent ranker logs (minimal implementation)."""
-    limit = int(request.args.get("limit", 50))
-    
-    # Read directly from log file
+    """Get recent ranker logs — reads directly from /app/ranker_logs/*.log"""
+    limit    = int(request.args.get("limit", 50))
+    category = request.args.get("category")          # optional filter
+
     logs = []
+
+    # ── Collect the 3 newest log files ───────────────────────────────────────
     pattern = str(Path(_LOG_DIR) / "*.log")
-    files = sorted(glob.glob(pattern))
-    
-    for fpath in files[-3:]:  # Last 3 log files
+    files   = sorted(glob.glob(pattern))
+    if not files:
+        return jsonify({"logs": [], "count": 0, "error": f"No *.log files in {_LOG_DIR}"})
+
+    # Read enough lines from the tail of each file
+    raw_lines = []
+    for fpath in files[-3:]:
         try:
-            with open(fpath, "r") as f:
-                lines = f.readlines()[-limit:]
-                for line in lines:
-                    # Parse log line into structured format
-                    match = re.match(r'\[([^\]]+)\] \| (\w+) \| (\w+) \| (.*)', line.strip())
-                    if match:
-                        logs.append({
-                            "ts": match.group(1),
-                            "level": match.group(2),
-                            "category": match.group(3),
-                            "message": match.group(4),
-                        })
-        except Exception:
+            with open(fpath, "r", encoding="utf-8", errors="replace") as f:
+                raw_lines.extend(f.readlines())
+        except OSError:
             pass
-    
-    return jsonify({"logs": logs[-limit:], "count": len(logs)})
+
+    # Keep only the last `limit` lines before parsing so we don't over-parse
+    raw_lines = raw_lines[-limit * 3:]
+
+    # ── Log line format (from ranker_logging.py  to_file_line) ───────────────
+    # WITH asset:
+    #   [2026-03-30 17:14:35] | INFO     | TRADE           | V100_1s | TRADE OPENED | ID=… | …
+    # WITHOUT asset:
+    #   [2026-03-30 17:14:35] | DEBUG    | RANKING         | rankings | top=… | …
+    #
+    # Padding: level=8 chars, category=15 chars → use \s+ / \s* to absorb them.
+    #
+    # Strategy: capture everything after the category into `rest`, then decide
+    # whether the first token of `rest` is a known short asset id or the start
+    # of the message text.
+
+    # Categories that always carry an asset field
+    ASSET_CATEGORIES = {"TRADE", "SIGNAL", "PROCESSING"}
+
+    LINE_RE = re.compile(
+        r'^\[([^\]]+)\] \| '          # [timestamp]
+        r'(\w+)\s*\| '                # LEVEL (padded)  |
+        r'(\w+)\s*'                   # CATEGORY (padded, no trailing | yet)
+        r'(?:\| (\S+) )?\| '          # optional  | asset  |
+        r'(.*)'                       # rest of message
+    )
+
+    for line in raw_lines:
+        line = line.rstrip('\n')
+        m = LINE_RE.match(line)
+        if not m:
+            continue
+
+        ts_str, level, cat, asset, message = m.groups()
+        level = level.strip()
+        cat   = cat.strip()
+
+        # When the optional asset group matched something that is NOT a real
+        # asset (e.g. the word "rankings" on a RANKING line), pull it back
+        # into the message.
+        if asset and cat not in ASSET_CATEGORIES:
+            message = f"{asset} | {message}" if message else asset
+            asset   = None
+
+        entry = {
+            "ts":       ts_str,
+            "level":    level,
+            "category": cat,
+            "message":  message or "",
+        }
+        if asset:
+            entry["asset"] = asset
+
+        if category and cat != category:
+            continue
+
+        logs.append(entry)
+
+    logs = logs[-limit:]
+    return jsonify({"logs": logs, "count": len(logs)})
 
 
 @app.route("/api/ranker/logs/stats")
 def api_logs_stats():
-    """Get log statistics."""
+    """Get real log statistics — counts by level, category and asset."""
     pattern = str(Path(_LOG_DIR) / "*.log")
-    files = glob.glob(pattern)
-    
-    total_lines = 0
+    files   = glob.glob(pattern)
+
+    total    = 0
+    by_level: Dict[str, int]    = defaultdict(int)
+    by_cat:   Dict[str, int]    = defaultdict(int)
+    by_asset: Dict[str, int]    = defaultdict(int)
+    errors:   Dict[str, int]    = defaultdict(int)
+
+    STAT_RE = re.compile(
+        r'^\[([^\]]+)\] \| (\w+)\s*\| (\w+)\s*(?:\| (\S+) )?\|'
+    )
+
     for fpath in files:
         try:
-            with open(fpath, "r") as f:
-                total_lines += sum(1 for _ in f)
-        except Exception:
+            with open(fpath, "r", encoding="utf-8", errors="replace") as f:
+                for line in f:
+                    m = STAT_RE.match(line)
+                    if not m:
+                        continue
+                    _, level, cat, asset = m.groups()
+                    level = level.strip()
+                    cat   = cat.strip()
+                    total += 1
+                    by_level[level] += 1
+                    by_cat[cat]     += 1
+                    if asset:
+                        by_asset[asset] += 1
+                    if level in ("ERROR", "CRITICAL"):
+                        errors[cat] += 1
+        except OSError:
             pass
-    
+
     return jsonify({
-        "total_events": total_lines,
-        "by_level": {"INFO": total_lines},
-        "by_category": {},
-        "by_asset": {},
-        "errors": {}
+        "total_events": total,
+        "by_level":     dict(by_level),
+        "by_category":  dict(by_cat),
+        "by_asset":     dict(by_asset),
+        "errors":       dict(errors),
+        "log_files":    len(files),
+        "log_dir":      str(_LOG_DIR),
     })