aiagent/backend/app/services/behavior_collector.py

"""
用户行为采集服务 — 非侵入式记录用户操作，用于数字分身学习
"""
from __future__ import annotations

import asyncio
import logging
from typing import Any, Dict, List, Optional

from sqlalchemy.orm import Session
from sqlalchemy import desc

from app.core.database import SessionLocal
from app.models.user_behavior import UserBehaviorLog, BehaviorCategory

logger = logging.getLogger(__name__)


class BehaviorCollector:
    """用户行为采集器（单例）"""

    def log_sync(
        self,
        *,
        user_id: str,
        category: str,
        action: str,
        context: Optional[Dict[str, Any]] = None,
        result: Optional[Dict[str, Any]] = None,
        source: str = "api",
        session_id: Optional[str] = None,
        ip_address: Optional[str] = None,
        user_agent: Optional[str] = None,
    ) -> Optional[str]:
        """同步写入行为日志，返回日志 ID。"""
        db: Optional[Session] = None
        try:
            db = SessionLocal()
            entry = UserBehaviorLog(
                user_id=user_id,
                category=category,
                action=action,
                context=context,
                result=result,
                source=source,
                session_id=session_id,
                ip_address=ip_address,
                user_agent=user_agent,
            )
            db.add(entry)
            db.commit()
            db.refresh(entry)
            return str(entry.id)
        except Exception as e:
            logger.warning("写入用户行为日志失败: %s", e)
            if db:
                try:
                    db.rollback()
                except Exception:
                    pass
            return None
        finally:
            if db:
                try:
                    db.close()
                except Exception:
                    pass

    async def log(self, **kwargs) -> Optional[str]:
        """异步写入（线程池）。"""
        loop = asyncio.get_running_loop()
        return await loop.run_in_executor(None, lambda: self.log_sync(**kwargs))

    def log_fire_and_forget(self, **kwargs):
        """Fire-and-forget 写入。"""
        try:
            asyncio.ensure_future(self.log(**kwargs))
        except Exception:
            pass

    # ─── 查询方法 ───

    def get_user_behaviors(
        self,
        user_id: str,
        category: Optional[str] = None,
        limit: int = 50,
        skip: int = 0,
    ) -> List[Dict[str, Any]]:
        """获取用户行为历史。"""
        db: Optional[Session] = None
        try:
            db = SessionLocal()
            q = db.query(UserBehaviorLog).filter(UserBehaviorLog.user_id == user_id)
            if category:
                q = q.filter(UserBehaviorLog.category == category)
            q = q.order_by(desc(UserBehaviorLog.created_at)).offset(skip).limit(limit)
            rows = q.all()
            return [
                {
                    "id": r.id,
                    "category": r.category,
                    "action": r.action,
                    "context": r.context,
                    "result": r.result,
                    "source": r.source,
                    "created_at": r.created_at.isoformat() if r.created_at else None,
                }
                for r in rows
            ]
        except Exception as e:
            logger.warning("查询用户行为日志失败: %s", e)
            return []
        finally:
            if db:
                try:
                    db.close()
                except Exception:
                    pass

    def get_behavior_stats(self, user_id: str) -> Dict[str, Any]:
        """获取用户行为统计摘要。"""
        db: Optional[Session] = None
        try:
            db = SessionLocal()
            from sqlalchemy import func
            total = db.query(func.count(UserBehaviorLog.id)).filter(
                UserBehaviorLog.user_id == user_id
            ).scalar() or 0
            by_category = {}
            for cat in BehaviorCategory:
                count = db.query(func.count(UserBehaviorLog.id)).filter(
                    UserBehaviorLog.user_id == user_id,
                    UserBehaviorLog.category == cat.value,
                ).scalar() or 0
                by_category[cat.value] = count
            return {
                "user_id": user_id,
                "total_behaviors": total,
                "by_category": by_category,
            }
        except Exception as e:
            logger.warning("查询行为统计失败: %s", e)
            return {"user_id": user_id, "total_behaviors": 0, "by_category": {}}
        finally:
            if db:
                try:
                    db.close()
                except Exception:
                    pass


# 全局单例
behavior_collector = BehaviorCollector()