Spaces:
Running
Running
Download backend/session_logger.py from bep40/ml-intern: direct link, hf CLI and curl.
- Browser
- Download file 17.1 kB
-
https://huggingface.co/spaces/bep40/ml-intern/resolve/main/backend/session_logger.py
- Command line
-
hf download hf://spaces/bep40/ml-intern/backend/session_logger.py
-
curl -L -o session_logger.py https://huggingface.co/spaces/bep40/ml-intern/resolve/main/backend/session_logger.py
17.1 kB
| """ | |
| Permanent session & user context logger. | |
| Lưu vĩnh viễn ngữ cảnh từng phiên và từng user vào dataset HuggingFace ngay khi | |
| có message/event mới — fire-and-forget, robust, không bao giờ block agent. | |
| FIX (anti-hang, bounded single-file-per-session): | |
| Trước đây mỗi message spawn ra 1 subprocess riêng và upload 1 file riêng | |
| ``sessions/{date}/{session_id}_{seq}.jsonl``, kèm toàn bộ ``content`` có thể | |
| rất dài. Với session ngữ cảnh lớn (hàng nghìn message, content tới hàng chục | |
| MB) điều này tạo hàng nghìn subprocess + hàng nghìn API upload -> Space treo. | |
| Bản vá này: | |
| 1. Gộp toàn bộ ngữ cảnh session vào MOT file duy nhat | |
| ``sessions/{date}/{session_id}.jsonl``. | |
| 2. KHONG luu tung message bang subprocess - chi append vao buffer bo nho + | |
| file local (re, khong block); mot flusher nen dinh ky upload file gop | |
| bang MOT lan goi ``upload_file``. | |
| 3. Gioi han dung luong luu tru: content message qua dai bi cat gon, va so | |
| dong luu moi session bi chan (giu cac message gan nhat); cac message cu | |
| bi loai duoc gop thanh mot dong tom tat ngan gon bao luu ngucanh truoc do. | |
| Nho do dataset file luon nho -> khong con loi treo, van giu duoc ngucanh | |
| truoc do de restore/catch-up. | |
| """ | |
| from __future__ import annotations | |
| import json | |
| import logging | |
| import os | |
| import threading | |
| import time | |
| from datetime import datetime | |
| from pathlib import Path | |
| from typing import Optional | |
| from huggingface_hub import HfApi, hf_hub_download | |
| logger = logging.getLogger(__name__) | |
| PUBLIC_SESSIONS_DATASET = os.environ.get( | |
| "ML_INTERN_SESSIONS_DATASET", "bep40/ml-intern-sessions" | |
| ) | |
| DEFAULT_LOG_DIR = Path(os.environ.get("ML_INTERN_SESSION_LOG_DIR", "/tmp/session_logs")) | |
| # ---- Bounding knobs: keep dataset small -> no hang ---- | |
| FLUSH_INTERVAL = float(os.environ.get("ML_INTERN_FLUSH_INTERVAL", "20")) | |
| MAX_STORED_CONTENT = int(os.environ.get("ML_INTERN_MAX_CONTENT", "12000")) | |
| MAX_STORED_ROWS = int(os.environ.get("ML_INTERN_MAX_ROWS", "400")) | |
| MAX_SUMMARY_CHARS = int(os.environ.get("ML_INTERN_MAX_SUMMARY", "4000")) | |
| def _now_iso() -> str: | |
| return datetime.now().astimezone().isoformat() | |
| def _get_hf_token() -> Optional[str]: | |
| return ( | |
| os.environ.get("HF_TOKEN") | |
| or os.environ.get("_ML_INTERN_PERSONAL_TOKEN") | |
| or os.environ.get("HF_SESSION_UPLOAD_TOKEN") | |
| or os.environ.get("HF_ADMIN_TOKEN") | |
| ) | |
| def _dataset_card_readme() -> str: | |
| return """--- | |
| pretty_name: "ML Intern Session Context" | |
| language: | |
| - en | |
| license: other | |
| task_categories: | |
| - text-generation | |
| tags: | |
| - ml-intern | |
| - session-traces | |
| - conversation | |
| - agent-traces | |
| configs: | |
| - config_name: default | |
| data_files: | |
| - split: train | |
| path: "sessions/**/*.jsonl" | |
| --- | |
| # ML Intern Session Context | |
| **Luu tru vinh vien ngucanh tung phien va tung user.** | |
| Moi session duoc gop thanh MOT file `sessions/{date}/{session_id}.jsonl`. | |
| Noi dung message qua dai duoc cat gon va so dong moi session duoc chan (cac | |
| message cu gop thanh dong tom tat) de tranh treo Space, nhung van bao luu ngucanh | |
| truoc do cho restore/catch-up. | |
| """ | |
| # ---- In-process aggregated buffer + throttled flusher ---- | |
| _lock = threading.Lock() | |
| _session_buffers: dict[str, list[dict]] = {} | |
| _session_hf_user: dict[str, Optional[str]] = {} | |
| _dirty: set[str] = set() | |
| _last_upload: dict[str, float] = {} | |
| _flusher_started = False | |
| def _ensure_flusher() -> None: | |
| global _flusher_started | |
| if _flusher_started: | |
| return | |
| with _lock: | |
| if _flusher_started: | |
| return | |
| _flusher_started = True | |
| t = threading.Thread(target=_flusher_loop, name="session-flusher", daemon=True) | |
| t.start() | |
| def _flusher_loop() -> None: | |
| while True: | |
| time.sleep(FLUSH_INTERVAL) | |
| try: | |
| _flush_once() | |
| except Exception as e: | |
| logger.debug("Session flusher error: %s", e) | |
| def _truncate_text(s: str, limit: int) -> str: | |
| s = s if isinstance(s, str) else (str(s) if s is not None else "") | |
| if len(s) <= limit: | |
| return s | |
| head = s[: max(limit // 2, 1)] | |
| tail = s[-max(limit // 2, 1):] | |
| return f"{head} ...[{len(s)} chars trimmed]... {tail}" | |
| def _build_condensed_summary(dropped: list[dict]) -> str: | |
| parts = [] | |
| for r in dropped: | |
| role = r.get("role", "") | |
| content = (r.get("content") or "") | |
| if isinstance(content, str) and content.strip(): | |
| c = content.strip().replace("\n", " ") | |
| if len(c) > 300: | |
| c = c[:150] + " ... " + c[-80:] | |
| parts.append(f"[{role}] {c}") | |
| text = " | ".join(parts) | |
| if len(text) > MAX_SUMMARY_CHARS: | |
| text = text[:MAX_SUMMARY_CHARS] + " ...(summary truncated)" | |
| return text | |
| def _bound_rows(rows: list[dict]) -> None: | |
| for r in rows: | |
| if r.get("role") == "event" and r.get("event_type") == "context_summary": | |
| continue | |
| r["content"] = _truncate_text(r.get("content", ""), MAX_STORED_CONTENT) | |
| if len(rows) <= MAX_STORED_ROWS: | |
| return | |
| keep = rows[-(MAX_STORED_ROWS - 1):] | |
| dropped = rows[: -(MAX_STORED_ROWS - 1)] | |
| summary_text = _build_condensed_summary(dropped) | |
| summary_row = { | |
| "session_id": rows[0].get("session_id", ""), | |
| "user_id": rows[0].get("user_id", ""), | |
| "model_name": rows[0].get("model_name", ""), | |
| "timestamp": rows[0].get("timestamp", ""), | |
| "role": "system", | |
| "content": "CONTEXT SUMMARY (earlier conversation, preserved for restore): " + summary_text, | |
| "event_type": "context_summary", | |
| "seq": dropped[0].get("seq", 0), | |
| "extra": "{}", | |
| } | |
| rows[:] = [summary_row] + keep | |
| def _flush_once() -> None: | |
| now = time.time() | |
| candidates: list[str] = [] | |
| with _lock: | |
| for sid in list(_dirty): | |
| if now - _last_upload.get(sid, 0) >= FLUSH_INTERVAL: | |
| _dirty.discard(sid) | |
| candidates.append(sid) | |
| for sid in candidates: | |
| try: | |
| _upload_session_aggregate(sid) | |
| except Exception as e: | |
| logger.debug("Session %s upload failed: %s", sid, e) | |
| with _lock: | |
| _dirty.add(sid) | |
| with _lock: | |
| _last_upload[sid] = time.time() | |
| def _upload_session_aggregate(session_id: str) -> None: | |
| with _lock: | |
| rows = list(_session_buffers.get(session_id, [])) | |
| hf_user = _session_hf_user.get(session_id) | |
| if not rows: | |
| return | |
| rows = list(rows) | |
| _bound_rows(rows) | |
| content = "\n".join(json.dumps(r, default=str) for r in rows) + "\n" | |
| date_str = rows[0].get("timestamp", "")[:10] or datetime.now().strftime("%Y-%m-%d") | |
| path_in_repo = f"sessions/{date_str}/{session_id}.jsonl" | |
| token = _get_hf_token() | |
| if not token: | |
| return | |
| api = HfApi() | |
| try: | |
| api.upload_file( | |
| path_or_fileobj=content.encode("utf-8"), | |
| path_in_repo=path_in_repo, | |
| repo_id=PUBLIC_SESSIONS_DATASET, | |
| repo_type="dataset", | |
| token=token, | |
| commit_message=f"Update session {session_id[:8]} context ({len(rows)} msgs)", | |
| ) | |
| except Exception as e: | |
| logger.debug("Public session upload failed: %s", e) | |
| if hf_user and hf_user != "dev": | |
| try: | |
| api.create_repo( | |
| repo_id=f"{hf_user}/ml-intern-sessions", | |
| repo_type="dataset", | |
| private=True, | |
| token=token, | |
| exist_ok=True, | |
| ) | |
| api.upload_file( | |
| path_or_fileobj=content.encode("utf-8"), | |
| path_in_repo=path_in_repo, | |
| repo_id=f"{hf_user}/ml-intern-sessions", | |
| repo_type="dataset", | |
| token=token, | |
| commit_message=f"Update session {session_id[:8]} context ({len(rows)} msgs)", | |
| ) | |
| except Exception as e: | |
| logger.debug("Personal session upload failed: %s", e) | |
| def _append_to_local_log( | |
| session_id: str, | |
| user_id: str, | |
| model_name: str, | |
| role: str, | |
| content: str, | |
| event_type: str, | |
| seq: int, | |
| extra: dict | None = None, | |
| directory: str = str(DEFAULT_LOG_DIR), | |
| ) -> Optional[str]: | |
| try: | |
| log_dir = Path(directory) | |
| log_dir.mkdir(parents=True, exist_ok=True) | |
| row = { | |
| "session_id": session_id, | |
| "user_id": user_id, | |
| "model_name": model_name, | |
| "timestamp": _now_iso(), | |
| "role": role, | |
| "content": content, | |
| "event_type": event_type, | |
| "seq": seq, | |
| "extra": json.dumps(extra) if extra else "{}", | |
| } | |
| date_str = datetime.now().strftime("%Y-%m-%d") | |
| filename = f"session_{session_id}_{date_str}.jsonl" | |
| filepath = log_dir / filename | |
| with open(filepath, "a") as f: | |
| f.write(json.dumps(row, default=str) + "\n") | |
| return str(filepath) | |
| except Exception as e: | |
| logger.debug("Local log write failed: %s", e) | |
| return None | |
| # ---- Dataset reader: per-file scan ---- | |
| _file_list_cache: list[str] | None = None | |
| _file_list_cache_time: float = 0 | |
| def _list_dataset_files() -> list[str]: | |
| global _file_list_cache, _file_list_cache_time | |
| now = time.time() | |
| if _file_list_cache is not None and (now - _file_list_cache_time) < 60: | |
| return _file_list_cache | |
| try: | |
| api = HfApi(token=_get_hf_token()) | |
| files = api.list_repo_files(PUBLIC_SESSIONS_DATASET, repo_type="dataset") | |
| _file_list_cache = [f for f in files if f.endswith(".jsonl")] | |
| _file_list_cache_time = now | |
| except Exception as e: | |
| logger.warning("Failed to list dataset files: %s", e) | |
| _file_list_cache = [] | |
| _file_list_cache_time = now | |
| return _file_list_cache | |
| def _normalize_row(row: dict) -> dict | None: | |
| if not isinstance(row, dict): | |
| return None | |
| if "session_id" in row and "role" in row: | |
| return row | |
| if "type" in row and "message" in row: | |
| session_id = row.get("sessionId") or row.get("session_id") or "" | |
| if not session_id: | |
| return None | |
| msg = row.get("message") | |
| role = row.get("type", "unknown") | |
| content_text = "" | |
| model_name = "" | |
| if isinstance(msg, dict): | |
| role = msg.get("role", role) | |
| content_val = msg.get("content", "") | |
| model_name = msg.get("model", "") | |
| if isinstance(content_val, str): | |
| content_text = content_val | |
| elif isinstance(content_val, list): | |
| parts = [] | |
| for block in content_val: | |
| if isinstance(block, dict): | |
| t = block.get("text") or block.get("content") | |
| if isinstance(t, str): | |
| parts.append(t) | |
| elif isinstance(block, str): | |
| parts.append(block) | |
| content_text = " ".join(parts) | |
| elif content_val is None: | |
| content_text = "" | |
| return { | |
| "session_id": session_id, | |
| "user_id": "", | |
| "model_name": model_name, | |
| "timestamp": row.get("timestamp", ""), | |
| "role": role, | |
| "content": content_text, | |
| "event_type": row.get("type", "message"), | |
| "seq": 0, | |
| "extra": "{}", | |
| } | |
| return None | |
| def _read_jsonl_file(file_path: str) -> list[dict]: | |
| try: | |
| local = hf_hub_download( | |
| PUBLIC_SESSIONS_DATASET, | |
| file_path, | |
| repo_type="dataset", | |
| token=_get_hf_token(), | |
| ) | |
| rows: list[dict] = [] | |
| with open(local, encoding="utf-8", errors="replace") as fh: | |
| for line in fh: | |
| line = line.strip() | |
| if not line: | |
| continue | |
| try: | |
| row = json.loads(line) | |
| normalized = _normalize_row(row) | |
| if normalized is not None: | |
| rows.append(normalized) | |
| except json.JSONDecodeError: | |
| continue | |
| return rows | |
| except Exception as e: | |
| logger.debug("Failed to read %s: %s", file_path, e) | |
| return [] | |
| def load_session_history(session_id: str) -> list[dict]: | |
| try: | |
| all_files = _list_dataset_files() | |
| matching = [f for f in all_files if session_id in os.path.basename(f)] | |
| rows: list[dict] = [] | |
| for f in matching: | |
| for row in _read_jsonl_file(f): | |
| if row.get("session_id") == session_id: | |
| rows.append(row) | |
| rows.sort(key=lambda r: (r.get("seq", 0), r.get("timestamp", ""))) | |
| return rows | |
| except Exception as e: | |
| import traceback | |
| logger.warning( | |
| "Failed to load session history: %s\n%s", | |
| e, | |
| traceback.format_exc(), | |
| ) | |
| return [] | |
| def get_user_sessions(user_id: str, limit: int = 50) -> list[dict]: | |
| sessions: dict[str, dict] = {} | |
| for f in _list_dataset_files(): | |
| for row in _read_jsonl_file(f): | |
| if row.get("user_id") == user_id: | |
| sid = row.get("session_id") | |
| if sid and sid not in sessions: | |
| sessions[sid] = { | |
| "session_id": sid, | |
| "user_id": user_id, | |
| "model_name": row.get("model_name"), | |
| "last_timestamp": row.get("timestamp"), | |
| "message_count": 0, | |
| } | |
| sessions[sid]["message_count"] += 1 | |
| result = list(sessions.values()) | |
| result.sort(key=lambda s: s.get("last_timestamp", ""), reverse=True) | |
| return result[:limit] | |
| # ---- Public API ---- | |
| def log_message( | |
| session_id: str, | |
| user_id: str, | |
| model_name: str, | |
| role: str, | |
| content: str, | |
| event_type: str = "message", | |
| seq: int = 0, | |
| extra: dict | None = None, | |
| hf_user: str | None = None, | |
| ) -> None: | |
| """Log a single message/event permanently to dataset. Fire-and-forget.""" | |
| row_data = { | |
| "session_id": session_id, | |
| "user_id": user_id, | |
| "model_name": model_name, | |
| "timestamp": _now_iso(), | |
| "role": role, | |
| "content": content, | |
| "event_type": event_type, | |
| "seq": seq, | |
| "extra": json.dumps(extra) if extra else "{}", | |
| } | |
| _append_to_local_log( | |
| session_id=session_id, | |
| user_id=user_id, | |
| model_name=model_name, | |
| role=role, | |
| content=content, | |
| event_type=event_type, | |
| seq=seq, | |
| extra=extra, | |
| ) | |
| with _lock: | |
| _session_buffers.setdefault(session_id, []).append(row_data) | |
| _session_hf_user[session_id] = hf_user | |
| _dirty.add(session_id) | |
| _ensure_flusher() | |
| def log_trajectory( | |
| trajectory: dict, | |
| user_id: str, | |
| hf_user: str | None = None, | |
| hf_token: str | None = None, | |
| private: bool = False, | |
| ) -> Optional[str]: | |
| """Upload complete session trajectory to dataset (final flush, bounded).""" | |
| session_id = trajectory.get("session_id", "unknown") | |
| model_name = trajectory.get("model_name", "") | |
| messages = trajectory.get("messages", []) | |
| events = trajectory.get("events", []) | |
| log_dir = Path(str(DEFAULT_LOG_DIR)) | |
| log_dir.mkdir(parents=True, exist_ok=True) | |
| date_str = datetime.now().strftime("%Y-%m-%d") | |
| filepath = log_dir / f"session_{session_id}_{date_str}.jsonl" | |
| rows: list[dict] = [] | |
| with open(filepath, "w") as f: | |
| for msg in messages: | |
| row = { | |
| "session_id": session_id, | |
| "user_id": user_id, | |
| "model_name": model_name, | |
| "timestamp": msg.get("timestamp") or _now_iso(), | |
| "role": msg.get("role", "unknown"), | |
| "content": msg.get("content", ""), | |
| "event_type": "message", | |
| "seq": msg.get("seq", 0), | |
| "extra": json.dumps({ | |
| "tool_calls": msg.get("tool_calls"), | |
| "tool_call_id": msg.get("tool_call_id"), | |
| }) if any(k in msg for k in ("tool_calls", "tool_call_id")) else "{}", | |
| } | |
| rows.append(row) | |
| f.write(json.dumps(row, default=str) + "\n") | |
| for event in events: | |
| row = { | |
| "session_id": session_id, | |
| "user_id": user_id, | |
| "model_name": model_name, | |
| "timestamp": event.get("timestamp", _now_iso()), | |
| "role": "event", | |
| "content": json.dumps(event.get("data", {})), | |
| "event_type": event.get("event_type", "unknown"), | |
| "seq": event.get("seq", 0), | |
| "extra": "{}", | |
| } | |
| rows.append(row) | |
| f.write(json.dumps(row, default=str) + "\n") | |
| with _lock: | |
| _session_buffers[session_id] = rows | |
| _session_hf_user[session_id] = hf_user | |
| _dirty.add(session_id) | |
| _ensure_flusher() | |
| return str(filepath) |