@ngocsangairvds/vsaf 3.2.15 → 4.0.0

package/tools/vds-scripts/memory_orchestrator/src/vds_memory_orchestrator/service/services/memory_admin_service.py

@@ -1,1011 +0,0 @@
-"""MemoryAdminService — export, history, feedback, analytics, and stats.
-
-Extracted from VDSAIMemoryService (VAMI-008 Sub-Wave B, TSK-8.07).
-Accepts all collaborators via constructor injection.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import hashlib
-import json
-import logging
-from collections import Counter
-from datetime import UTC, datetime, timedelta
-from typing import Any
-
-from sqlalchemy import text
-
-from vds_memory_orchestrator.service.core.ai_memory_exceptions import (
-    NotFoundError,
-    ServiceUnavailableError,
-    ValidationError,
-)
-from vds_memory_orchestrator.service.core.config import (
-    REDIS_ANALYTICS_DB,
-    REDIS_MEMORY_CACHE_DB,
-    REDIS_SESSION_STORE_DB,
-)
-from vds_memory_orchestrator.service.database.postgres_manager import database_service
-from vds_memory_orchestrator.service.database.redis_manager import redis_manager
-from vds_memory_orchestrator.service.models.ai_memory_models import (
-    Analytics,
-    AnalyticsRequest,
-    MemoryExportCreateRequest,
-    MemoryExportStatusResponse,
-    MemoryFeedbackRequest,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class MemoryAdminService:
-    """Handles admin-domain operations: export, history, feedback, analytics, and statistics."""
-
-    def __init__(
-        self,
-        config: Any,
-        mem0_sync: Any,
-        redis_service: Any,
-        resolve_mem0_from_event_fn: Any = None,
-        resolve_mem0_by_search_fn: Any = None,
-        startup_time: datetime | None = None,
-        get_background_task_count_fn: Any = None,
-    ) -> None:
-        self.config = config
-        self._mem0_sync = mem0_sync
-        self._redis_service = redis_service
-        self._resolve_mem0_from_event_fn = resolve_mem0_from_event_fn
-        self._resolve_mem0_by_search_fn = resolve_mem0_by_search_fn
-        self._startup_time = startup_time
-        self._get_background_task_count_fn = get_background_task_count_fn
-
-    @property
-    def _mem0_client(self) -> Any:
-        if self._mem0_sync is not None:
-            return self._mem0_sync._mem0_client
-        return None
-
-    async def _mem0_call(self, method_name: str, **kwargs: Any) -> Any:
-        if self._mem0_sync is not None:
-            return await self._mem0_sync.mem0_call(method_name, **kwargs)
-        raise ServiceUnavailableError("Mem0 client not initialized")
-
-    # ── Export / History / Feedback ─────────────────────────────────────────
-
-    async def create_memory_export(
-        self, request: MemoryExportCreateRequest
-    ) -> MemoryExportStatusResponse:
-        if not self._mem0_client:
-            raise ServiceUnavailableError("Mem0 client not initialized")
-        payload = request.model_dump()
-        payload.setdefault("include_metadata", True)
-        payload.setdefault("include_relations", True)
-        result = await self._mem0_call("create_memory_export", **payload)
-        export_id = result.get("export_id") or result.get("id") or result.get("job_id")
-        return MemoryExportStatusResponse(
-            export_id=export_id,
-            status=result.get("status"),
-            url=result.get("url"),
-            detail=result,
-        )
-
-    async def get_memory_export(self, export_id: str) -> MemoryExportStatusResponse:
-        if not self._mem0_client:
-            raise ServiceUnavailableError("Mem0 client not initialized")
-        result = await self._mem0_call("get_memory_export", export_id=export_id)
-        detail = result if isinstance(result, dict) else {"raw": result}
-        if isinstance(detail, dict):
-            if "storage_tier" not in detail:
-                detail["storage_tier"] = "mem0_pro"
-            if "relations" not in detail and detail.get("include_relations"):
-                detail["relations"] = detail.get("include_relations")
-            detail.setdefault("include_metadata", True)
-            detail.setdefault("include_relations", bool(detail.get("relations")))
-        return MemoryExportStatusResponse(
-            export_id=export_id,
-            status=detail.get("status"),
-            url=detail.get("url"),
-            detail=detail,
-        )
-
-    async def get_memory_history(self, memory_id: str) -> dict[str, Any]:
-        if not self._mem0_client:
-            raise ServiceUnavailableError("Mem0 client not initialized")
-        for method in ("history_memory", "history"):
-            try:
-                return await self._mem0_call(method, memory_id=memory_id)
-            except Exception:
-                continue
-        raise ServiceUnavailableError("Mem0 history not available")
-
-    async def submit_memory_feedback(self, request: MemoryFeedbackRequest) -> dict[str, Any]:
-        # Resolve canonical memory and Mem0 mapping
-        mem_record = await database_service.get_memory(request.memory_id)
-        if not mem_record:
-            raise NotFoundError(f"Memory {request.memory_id} not found")
-
-        mem0_id = None
-        metadata = getattr(mem_record, "metadata_dict", None) or getattr(mem_record, "metadata", {})
-        if isinstance(metadata, str):
-            try:
-                import json as _json
-
-                metadata = _json.loads(metadata)
-            except Exception:
-                metadata = {}
-        event_id = None
-        if isinstance(metadata, dict):
-            mem0_id = metadata.get("mem0_id")
-            event_id = metadata.get("mem0_event_id")
-
-        # If we don't yet have a Mem0 ID but we do have an event_id, try to resolve it
-        if not mem0_id and event_id and self._mem0_client and self._resolve_mem0_from_event_fn is not None:
-                mem0_id = await self._resolve_mem0_from_event_fn(
-                    event_id, request.memory_id, metadata
-                )
-
-        # Fallback: try to search Mem0 by metadata memory_id if still missing
-        if not mem0_id and self._resolve_mem0_by_search_fn is not None:
-            for delay in (0, 2, 4, 8):
-                if delay:
-                    await asyncio.sleep(delay)
-                mem0_id = await self._resolve_mem0_by_search_fn(request.memory_id)
-                if mem0_id:
-                    async with database_service.postgres.engine.begin() as conn:
-                        meta = metadata if isinstance(metadata, dict) else {}
-                        meta["mem0_id"] = mem0_id
-                        await database_service.update_memory(
-                            conn,
-                            request.memory_id,
-                            {"metadata": meta, "storage_tier": "mem0_pro"},
-                        )
-                    break
-
-        if not request.memory_id:
-            raise ValidationError("memory_id is required for feedback")
-
-        allowed = {"POSITIVE", "NEGATIVE", "VERY_NEGATIVE"}
-        fb = str(request.feedback).upper()
-        if fb not in allowed:
-            raise ValidationError(f"feedback must be one of {sorted(allowed)}, got {fb}")
-
-        target_id = mem0_id or request.memory_id
-
-        payload = {
-            "memory_id": target_id,
-            "feedback": fb,
-        }
-        if request.feedback_reason:
-            payload["feedback_reason"] = request.feedback_reason
-
-        if not mem0_id:
-            return {
-                "status": "pending",
-                "reason": "mem0_id not available yet; memory not promoted",
-                "memory_id": request.memory_id,
-            }
-
-        if not self._mem0_client:
-            return {"status": "skipped", "reason": "mem0 not configured"}
-        try:
-            result = await self._mem0_call("feedback", **payload)
-            return result
-        except Exception as exc:
-            logger.debug("Mem0 feedback failed: %s", exc, exc_info=True)
-            detail = getattr(exc, "response", None)
-            body = None
-            status = None
-            if detail is not None:
-                status = getattr(detail, "status_code", None)
-                try:
-                    body = detail.json()
-                except Exception:
-                    try:
-                        body = detail.text
-                    except Exception:
-                        body = None
-            return {
-                "status": "error",
-                "error": type(exc).__name__,
-                "http_status": status,
-                "body": body,
-            }
-
-    # ── Statistics ───────────────────────────────────────────────────────────
-
-    async def count_memories(self, include_internal: bool = False) -> int:
-        """Count total memories in Postgres, optionally excluding internal users."""
-        if not (
-            getattr(database_service, "postgres", None)
-            and getattr(database_service.postgres, "engine", None)
-        ):
-            return 0
-        try:
-            async with database_service.postgres.engine.begin() as conn:
-                if include_internal:
-                    result = await conn.execute(text("SELECT COUNT(*) FROM memories"))
-                else:
-                    result = await conn.execute(
-                        text(
-                            "SELECT COUNT(*) FROM memories"
-                            " WHERE user_id NOT LIKE :hc AND user_id NOT LIKE :tst"
-                        ),
-                        {"hc": "_healthcheck_%", "tst": "_test_%"},
-                    )
-                row = result.fetchone()
-                return int(row[0]) if row else 0
-        except Exception:
-            return 0
-
-    async def count_active_sessions(self, include_internal: bool = False) -> int:
-        """Count active sessions via Redis user index, optionally excluding internal users."""
-        try:
-            async with redis_manager.get_redis(REDIS_SESSION_STORE_DB) as conn:
-                cursor = 0
-                total = 0
-                while True:
-                    cursor, keys = await conn.scan(cursor, match="session:index:user:*", count=200)
-                    for key in keys:
-                        key_str = key.decode("utf-8") if isinstance(key, bytes) else key
-                        user_id = key_str.split("session:index:user:", 1)[-1]
-                        if not include_internal and any(
-                            user_id.startswith(p) for p in ("_healthcheck_", "_test_")
-                        ):
-                            continue
-                        count = await conn.scard(key)
-                        total += count or 0
-                    if int(cursor) == 0:
-                        break
-                return total
-        except Exception:
-            return 0
-
-    # ── Analytics ────────────────────────────────────────────────────────────
-
-    # Test-friendly hook stubs – overridden by patch.object in unit tests so
-    # get_analytics short-circuits without touching real Redis.
-    async def _calculate_user_analytics(self, _user_id: str | None, _start: Any, _end: Any) -> dict:
-        return {}
-
-    async def _calculate_system_analytics(self, _start: Any, _end: Any) -> dict:
-        return {}
-
-    async def _analyze_usage_patterns(self, _analytics: Any, *_args: Any, **_kwargs: Any) -> dict:
-        return {}
-
-    def _build_analytics_cache_key(self, request: AnalyticsRequest) -> str:
-        """Create a deterministic cache key for analytics requests."""
-        key_components = {
-            "user_id": request.user_id or "global",
-            "timeframe_hours": request.timeframe_hours,
-            "sessions": int(bool(request.include_sessions)),
-            "memories": int(bool(request.include_memories)),
-            "operations": int(bool(request.include_operations)),
-            "patterns": int(bool(request.include_patterns)),
-        }
-        generator = getattr(self._redis_service, "generate_cache_key", None)
-        if generator:
-            return generator("analytics", **key_components)
-
-        digest_source = "|".join(f"{k}={v}" for k, v in key_components.items())
-        digest = hashlib.md5(digest_source.encode()).hexdigest()
-        return f"analytics:{digest}"
-
-    async def get_analytics(self, request: AnalyticsRequest) -> Analytics:
-        """Get analytics data."""
-        try:
-            # Check cached analytics if available (test hook)
-            cached = None
-            cache_key = None
-            getter = getattr(self._redis_service, "get_analytics", None)
-            if getter:
-                cache_key = self._build_analytics_cache_key(request)
-                cached = await getter(cache_key)
-            if cached:
-                analytics_cached = Analytics(
-                    analytics_id="cached",
-                    user_id=request.user_id,
-                    timeframe_start=datetime.now(UTC),
-                    timeframe_end=datetime.now(UTC),
-                )
-                analytics_cached.user_analytics = cached.get("user_analytics", {})
-                analytics_cached.system_analytics = cached.get("system_analytics", {})
-                analytics_cached.patterns = cached.get("patterns", {})
-                return analytics_cached
-
-            # Calculate timeframe
-            end_time = datetime.now(UTC)
-            start_time = end_time - timedelta(hours=request.timeframe_hours)
-
-            analytics = Analytics(
-                analytics_id=f"analytics_{request.user_id or 'global'}_{datetime.now(UTC).timestamp()}",
-                user_id=request.user_id,
-                timeframe_start=start_time,
-                timeframe_end=end_time,
-            )
-
-            # Gather analytics data (test-friendly hooks)
-            if hasattr(self, "_calculate_user_analytics"):
-                analytics.user_analytics = await self._calculate_user_analytics(
-                    request.user_id, start_time, end_time
-                )
-            if hasattr(self, "_calculate_system_analytics"):
-                analytics.system_analytics = await self._calculate_system_analytics(
-                    start_time, end_time
-                )
-            if hasattr(self, "_analyze_usage_patterns"):
-                analytics.patterns = await self._analyze_usage_patterns(analytics)
-
-            # If hook methods were not provided, fall back to detailed gathering
-            if not analytics.user_analytics and request.include_sessions:
-                await self._gather_session_analytics(
-                    analytics, start_time, end_time, request.user_id
-                )
-
-            if not analytics.user_analytics and request.include_memories:
-                await self._gather_memory_analytics(
-                    analytics, start_time, end_time, request.user_id
-                )
-
-            if not analytics.user_analytics and request.include_operations:
-                await self._gather_operation_analytics(
-                    analytics, start_time, end_time, request.user_id
-                )
-
-            if not analytics.patterns and request.include_patterns:
-                await self._gather_pattern_analytics(analytics, request.user_id)
-
-            if getter and cache_key:
-                cache_payload = {
-                    "user_analytics": getattr(analytics, "user_analytics", {}),
-                    "system_analytics": getattr(analytics, "system_analytics", {}),
-                    "patterns": getattr(analytics, "patterns", {}),
-                }
-                cache_ttl = getattr(self.config.cache, "analytics_ttl", 300)
-                storer = getattr(self._redis_service, "store_analytics", None)
-                if storer:
-                    try:
-                        await storer(cache_key, cache_payload, ttl=cache_ttl)
-                    except Exception as cache_exc:
-                        logger.debug("Analytics cache store skipped: %s", cache_exc)
-
-            return analytics
-
-        except Exception as e:
-            logger.exception("Error getting analytics: %s", e)
-            raise
-
-    async def _gather_session_analytics(
-        self,
-        analytics: Analytics,
-        start_time: datetime,
-        end_time: datetime,
-        _user_id: str | None,
-    ):
-        """Gather session analytics from Redis."""
-        try:
-            async with redis_manager.get_redis(REDIS_SESSION_STORE_DB) as conn:
-                # Get all session keys
-                session_keys = await conn.keys("session:*")
-
-                total_sessions = 0
-                active_sessions = 0
-                success_count = 0
-                total_operations = 0
-                session_durations: list[float] = []
-
-                for key in session_keys:
-                    try:
-                        key_str = key.decode() if isinstance(key, bytes) else key
-                        if key_str.startswith("session:index:"):
-                            continue
-
-                        # Check if session is active (TTL > 0)
-                        ttl = await conn.ttl(key)
-                        if ttl > 0:
-                            active_sessions += 1
-
-                        total_sessions += 1
-
-                        # Get session data to check timestamp range
-                        session_data_json = await conn.get(key)
-                        if not session_data_json:
-                            continue
-                        session_data = json.loads(session_data_json)
-                        if session_data:
-                            # Extract session_id from key
-                            session_id = key_str.replace("session:", "")
-
-                            # Track session duration for averages
-                            created_at_raw = session_data.get("created_at")
-                            last_accessed_raw = session_data.get("last_accessed")
-                            if created_at_raw and last_accessed_raw:
-                                try:
-                                    created_dt = datetime.fromisoformat(
-                                        created_at_raw.replace("Z", "+00:00")
-                                    )
-                                    last_dt = datetime.fromisoformat(
-                                        last_accessed_raw.replace("Z", "+00:00")
-                                    )
-                                    duration_min = max(
-                                        0.0,
-                                        (last_dt - created_dt).total_seconds() / 60,
-                                    )
-                                    session_durations.append(duration_min)
-                                except Exception as exc:
-                                    logger.debug(
-                                        "Failed to parse session duration for %s: %s",
-                                        session_id,
-                                        exc,
-                                    )
-
-                            # Check operations for this session
-                            ops_key = f"ops:{session_id}"
-                            async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as ops_conn:
-                                # Count operations in timeframe
-                                start_ts = start_time.timestamp() * 1000
-                                end_ts = end_time.timestamp() * 1000
-                                ops_in_range = await ops_conn.zcount(ops_key, start_ts, end_ts)
-                                total_operations += ops_in_range
-
-                                # Count successful operations
-                                if ops_in_range > 0:
-                                    ops = await ops_conn.zrangebyscore(
-                                        ops_key,
-                                        start_ts,
-                                        end_ts,
-                                        start=0,
-                                        num=ops_in_range,
-                                    )
-                                    for op_data in ops:
-                                        try:
-                                            if isinstance(op_data, bytes):
-                                                op_data = op_data.decode()
-                                            op = json.loads(op_data)
-                                            if op.get("status") == "success":
-                                                success_count += 1
-                                        except Exception:
-                                            continue
-                    except Exception as e:
-                        logger.warning(f"Error processing session key {key}: {e}")
-                        continue
-
-                # Calculate success rate
-                session_success_rate = (
-                    success_count / total_operations if total_operations > 0 else 0.0
-                )
-
-                analytics.total_sessions = total_sessions
-                analytics.active_sessions = active_sessions
-                analytics.session_success_rate = round(session_success_rate, 2)
-                if session_durations:
-                    analytics.average_session_duration = round(
-                        sum(session_durations) / len(session_durations), 2
-                    )
-
-                logger.info(
-                    f"Session analytics gathered: {total_sessions} total, "
-                    f"{active_sessions} active, {session_success_rate:.2%} success rate"
-                )
-
-        except Exception as e:
-            logger.exception(f"Error gathering session analytics: {e}")
-            # Fallback to zero values on error
-            analytics.total_sessions = 0
-            analytics.active_sessions = 0
-            analytics.session_success_rate = 0.0
-
-    async def _gather_memory_analytics(
-        self,
-        analytics: Analytics,
-        _start_time: datetime,
-        _end_time: datetime,
-        _user_id: str | None,
-    ):
-        """Gather memory analytics from Redis cache."""
-        try:
-            total_memories = 0
-            memories_by_session = {}
-
-            async with redis_manager.get_redis(REDIS_MEMORY_CACHE_DB) as conn:
-                # Scan for all memory cache keys
-                memory_pattern = "memory:*:payload"
-                cursor = 0
-
-                while True:
-                    cursor, keys = await conn.scan(cursor, match=memory_pattern, count=100)
-
-                    for key in keys:
-                        try:
-                            # Check if memory exists
-                            exists = await conn.exists(key)
-                            if exists:
-                                total_memories += 1
-
-                                # Get memory data to extract session_id
-                                memory_data = await conn.get(key)
-                                if memory_data:
-                                    if isinstance(memory_data, bytes):
-                                        memory_data = memory_data.decode()
-
-                                    memory_obj = json.loads(memory_data)
-                                    session_id = memory_obj.get("session_id")
-
-                                    if session_id:
-                                        memories_by_session[session_id] = (
-                                            memories_by_session.get(session_id, 0) + 1
-                                        )
-                        except Exception as e:
-                            logger.warning(f"Error processing memory key {key}: {e}")
-                            continue
-
-                    # Break if cursor is 0 (scan complete)
-                    if cursor == 0:
-                        break
-
-                # Calculate average memories per session
-                memories_per_session = (
-                    total_memories / len(memories_by_session) if memories_by_session else 0.0
-                )
-
-                analytics.total_memories = total_memories
-                analytics.memories_per_session = round(memories_per_session, 2)
-
-                logger.info(
-                    f"Memory analytics gathered: {total_memories} memories across "
-                    f"{len(memories_by_session)} sessions (avg {memories_per_session:.2f} per session)"
-                )
-
-        except Exception as e:
-            logger.exception(f"Error gathering memory analytics: {e}")
-            # Fallback to zero values on error
-            analytics.total_memories = 0
-            analytics.memories_per_session = 0.0
-
-    async def _gather_operation_analytics(
-        self,
-        analytics: Analytics,
-        start_time: datetime,
-        end_time: datetime,
-        _user_id: str | None,
-    ):
-        """Gather operation analytics from Redis operation tracking."""
-        try:
-            # Convert time window to milliseconds for Redis sorted set queries
-            start_ts = start_time.timestamp() * 1000
-            end_ts = end_time.timestamp() * 1000
-
-            # Track operations by type
-            operations_by_type: dict[str, list[dict]] = {}
-            tool_usage_counter: Counter[str] = Counter()
-            total_operations = 0
-            total_success = 0
-            total_duration_ms = 0
-
-            async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                # Get all session IDs from the operations index
-                session_ids = await conn.smembers("ops:index")
-
-                if not session_ids:
-                    logger.info("No operations found in analytics window")
-                    analytics.operation_success_rates = {}
-                    analytics.average_operation_duration = {}
-                    analytics.total_operations = 0
-                    return
-
-                # Query each session's operations
-                for session_id in session_ids:
-                    if isinstance(session_id, bytes):
-                        session_id = session_id.decode()
-
-                    ops_key = f"ops:{session_id}"
-
-                    # Get operations in time window
-                    ops_data = await conn.zrangebyscore(ops_key, start_ts, end_ts, withscores=False)
-
-                    for op_json in ops_data:
-                        try:
-                            if isinstance(op_json, bytes):
-                                op_json = op_json.decode()
-
-                            op = json.loads(op_json)
-                            op_type = op.get("type", "unknown")
-                            status = op.get("status", "unknown")
-                            duration_ms = op.get("duration_ms", 0)
-
-                            # Track by type
-                            if op_type not in operations_by_type:
-                                operations_by_type[op_type] = []
-                            operations_by_type[op_type].append(op)
-                            tool_usage_counter[op.get("tool_used", "unknown")] += 1
-
-                            # Track totals
-                            total_operations += 1
-                            if status in ["success", "ok"]:
-                                total_success += 1
-                            if duration_ms:
-                                total_duration_ms += duration_ms
-
-                        except Exception as e:
-                            logger.warning(f"Failed to parse operation: {e}")
-                            continue
-
-            # Calculate success rates and avg durations by type
-            success_rates = {}
-            avg_durations = {}
-
-            for op_type, ops in operations_by_type.items():
-                if not ops:
-                    continue
-
-                # Success rate
-                successes = sum(1 for op in ops if op.get("status") in ["success", "ok"])
-                success_rates[op_type] = round(successes / len(ops), 3) if ops else 0.0
-
-                # Average duration
-                durations = [op.get("duration_ms", 0) for op in ops if op.get("duration_ms")]
-                avg_durations[op_type] = (
-                    round(sum(durations) / len(durations), 2) if durations else 0.0
-                )
-
-            # Set analytics results
-            analytics.operation_success_rates = success_rates
-            analytics.average_operation_duration = avg_durations
-            analytics.total_operations = total_operations
-            analytics.operation_types = {
-                op_type: len(events) for op_type, events in operations_by_type.items()
-            }
-            analytics.tool_usage = dict(tool_usage_counter)
-
-            logger.info(
-                f"Operation analytics gathered: {total_operations} ops, "
-                f"{len(operations_by_type)} types, "
-                f"{total_success / total_operations:.2%} success rate"
-                if total_operations > 0
-                else "0 ops"
-            )
-
-        except Exception as e:
-            logger.exception(f"Error gathering operation analytics: {e}")
-            # Fallback to empty values
-            analytics.operation_success_rates = {}
-            analytics.average_operation_duration = {}
-            analytics.total_operations = 0
-
-    async def _gather_pattern_analytics(self, analytics: Analytics, _user_id: str | None):
-        """Gather pattern analytics from session and operation data."""
-        try:
-            patterns = []
-
-            # Configurable thresholds (could be moved to config)
-            LONG_SESSION_THRESHOLD_S = 1800  # 30 minutes
-            HIGH_ACTIVITY_OPS_PER_HOUR = 60
-
-            async with redis_manager.get_redis(REDIS_SESSION_STORE_DB) as sess_conn:
-                # Get all session keys
-                session_keys = await sess_conn.keys("session:*")
-
-                long_sessions_count = 0
-                high_activity_count = 0
-                activity_by_hour = [0] * 24  # 24 hours histogram
-
-                for key in session_keys:
-                    try:
-                        if isinstance(key, bytes):
-                            key = key.decode()
-                        if key.startswith("session:index:"):
-                            continue
-
-                        # Extract session_id from key
-                        session_id = key.replace("session:", "")
-
-                        # Get session data
-                        session_data = await sess_conn.get(key)
-                        if not session_data:
-                            continue
-
-                        if isinstance(session_data, bytes):
-                            session_data = session_data.decode()
-
-                        session_obj = json.loads(session_data)
-
-                        # Check for long sessions
-                        created_at_str = session_obj.get("created_at")
-                        last_accessed_str = session_obj.get("last_accessed")
-
-                        if created_at_str and last_accessed_str:
-                            try:
-                                created_at = datetime.fromisoformat(
-                                    created_at_str.replace("Z", "+00:00")
-                                )
-                                last_accessed = datetime.fromisoformat(
-                                    last_accessed_str.replace("Z", "+00:00")
-                                )
-                                duration_s = (last_accessed - created_at).total_seconds()
-
-                                if duration_s > LONG_SESSION_THRESHOLD_S:
-                                    long_sessions_count += 1
-                            except Exception as e:
-                                logger.warning(f"Error parsing session timestamps: {e}")
-
-                        # Check for high activity (via operation count)
-                        async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as ops_conn:
-                            ops_key = f"ops:{session_id}"
-                            ops_count = await ops_conn.zcard(ops_key)
-
-                            if ops_count > 0:
-                                # Get operation timestamps to calculate activity rate
-                                ops_data = await ops_conn.zrange(ops_key, 0, -1, withscores=True)
-
-                                if ops_data:
-                                    # Calculate time range of operations
-                                    timestamps = [score for _, score in ops_data]
-                                    if len(timestamps) > 1:
-                                        time_range_hours = (max(timestamps) - min(timestamps)) / (
-                                            1000 * 3600
-                                        )
-                                        if time_range_hours > 0:
-                                            ops_per_hour = ops_count / time_range_hours
-                                            if ops_per_hour > HIGH_ACTIVITY_OPS_PER_HOUR:
-                                                high_activity_count += 1
-
-                                    # Build activity by hour histogram
-                                    for _, ts_ms in ops_data:
-                                        try:
-                                            dt = datetime.fromtimestamp(ts_ms / 1000, UTC)
-                                            hour = dt.hour
-                                            activity_by_hour[hour] += 1
-                                        except Exception:
-                                            continue
-
-                    except Exception as e:
-                        logger.warning(f"Error processing session {key}: {e}")
-                        continue
-
-                # Compile detected patterns
-                if long_sessions_count > 0:
-                    patterns.append(
-                        f"long_sessions ({long_sessions_count} sessions > {LONG_SESSION_THRESHOLD_S / 60:.0f}m)"
-                    )
-
-                if high_activity_count > 0:
-                    patterns.append(
-                        f"high_activity ({high_activity_count} sessions > {HIGH_ACTIVITY_OPS_PER_HOUR} ops/hr)"
-                    )
-
-                # Detect peak activity hours
-                max_activity_hour = (
-                    activity_by_hour.index(max(activity_by_hour))
-                    if max(activity_by_hour) > 0
-                    else None
-                )
-                if max_activity_hour is not None:
-                    # Classify as morning/afternoon/evening
-                    if 6 <= max_activity_hour < 12:
-                        patterns.append(f"morning_routine (peak: {max_activity_hour}:00)")
-                    elif 12 <= max_activity_hour < 18:
-                        patterns.append(f"afternoon_activity (peak: {max_activity_hour}:00)")
-                    elif 18 <= max_activity_hour < 24:
-                        patterns.append(f"evening_work (peak: {max_activity_hour}:00)")
-                    else:
-                        patterns.append(f"late_night (peak: {max_activity_hour}:00)")
-
-                analytics.detected_patterns = patterns if patterns else ["no_significant_patterns"]
-
-                logger.info(
-                    f"Pattern analytics gathered: {len(patterns)} patterns detected, "
-                    f"peak hour: {max_activity_hour}:00"
-                    if max_activity_hour is not None
-                    else "no peak"
-                )
-
-        except Exception as e:
-            logger.exception(f"Error gathering pattern analytics: {e}")
-            analytics.detected_patterns = ["error_detecting_patterns"]
-
-    async def aggregate_analytics(
-        self,
-        timeframe_hours: int = 24,
-        scope: str = "global",
-        user_id: str | None = None,
-    ):
-        """Aggregate analytics data for dashboard with Redis caching."""
-        try:
-            # Generate cache key
-            cache_scope = f"user:{user_id}" if user_id else scope
-            window_hash = hashlib.md5(f"{timeframe_hours}".encode()).hexdigest()[:8]
-            cache_key = f"analytics:cache:aggregate:{cache_scope}:{window_hash}"
-            lock_key = f"analytics:lock:aggregate:{cache_scope}"
-
-            # Check cache first
-            try:
-                async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                    cached_data = await conn.get(cache_key)
-                    if cached_data:
-                        if isinstance(cached_data, bytes):
-                            cached_data = cached_data.decode()
-                        logger.info(
-                            f"Analytics cache hit for {cache_scope}, window={timeframe_hours}h"
-                        )
-                        return json.loads(cached_data)
-
-                    # Try to acquire lock to prevent thundering herd
-                    lock_acquired = await conn.setnx(lock_key, "1")
-                    if lock_acquired:
-                        await conn.expire(lock_key, 10)  # Lock expires after 10 seconds
-                    else:
-                        # Another process is computing, wait and retry cache
-                        await asyncio.sleep(0.5)
-                        cached_data = await conn.get(cache_key)
-                        if cached_data:
-                            if isinstance(cached_data, bytes):
-                                cached_data = cached_data.decode()
-                            return json.loads(cached_data)
-            except TypeError:
-                # In test environments redis_manager may be a MagicMock; skip caching
-                logger.debug(
-                    "analytics aggregation skipped Redis cache due to non-async client (test mode)"
-                )
-
-            try:
-                # Cache miss - compute analytics
-
-                # Create analytics request
-                analytics_request = AnalyticsRequest(
-                    user_id=user_id,
-                    timeframe_hours=timeframe_hours,
-                    include_sessions=True,
-                    include_memories=True,
-                    include_operations=True,
-                    include_patterns=True,
-                )
-
-                # Get analytics data
-                analytics = await self.get_analytics(analytics_request)
-
-                # Prepare response for caching
-                result = {
-                    "scope": cache_scope,
-                    "window_hours": timeframe_hours,
-                    "generated_at": datetime.now(UTC).isoformat(),
-                    "totals": {
-                        "sessions": analytics.total_sessions,
-                        "active_sessions": analytics.active_sessions,
-                        "memories": analytics.total_memories,
-                        "operations": analytics.total_operations,
-                        "session_success_rate": analytics.session_success_rate,
-                    },
-                    "by_operation": {
-                        "success_rates": analytics.operation_success_rates,
-                        "avg_durations_ms": analytics.average_operation_duration,
-                    },
-                    "patterns": analytics.detected_patterns,
-                    "memories_per_session": analytics.memories_per_session,
-                }
-
-                # Cache the result (TTL: 60 seconds default, configurable)
-                cache_ttl = (
-                    self.config.cache.analytics_ttl
-                    if hasattr(self.config.cache, "analytics_ttl")
-                    else 60
-                )
-                async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                    await conn.setex(cache_key, cache_ttl, json.dumps(result, default=str))
-
-                logger.info(
-                    f"Analytics aggregated and cached: {cache_scope}, "
-                    f"{analytics.total_operations} ops, {analytics.total_sessions} sessions"
-                )
-
-                return result
-
-            finally:
-                # Always release lock
-                with contextlib.suppress(Exception):
-                    async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                        await conn.delete(lock_key)
-
-        except Exception as e:
-            logger.exception("Error aggregating analytics: %s", e)
-            return {
-                "scope": scope,
-                "window_hours": timeframe_hours,
-                "error": str(e),
-                "totals": {},
-                "by_operation": {},
-                "patterns": [],
-            }
-
-    # ── Health Check ─────────────────────────────────────────────────────────
-
-    async def health_check(self) -> dict[str, Any]:
-        """Perform comprehensive health check.
-
-        Returns a dict for backward compatibility with existing tests and agents
-        (previously expected subscripting on the health payload).
-        """
-        try:
-            redis_health = await self._redis_service.health_check()
-            mem0_status = "connected" if self._mem0_client else "not_configured"
-
-            uptime_seconds = 0
-            if self._startup_time:
-                uptime_seconds = int((datetime.now(UTC) - self._startup_time).total_seconds())
-
-            cache_hit_rate = 0.0
-            response_time_ms = 0.0
-            try:
-                async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-                    hits = await conn.get("metrics:cache:hits")
-                    misses = await conn.get("metrics:cache:misses")
-                    if hits or misses:
-                        hits_count = int(hits) if hits else 0
-                        misses_count = int(misses) if misses else 0
-                        total = hits_count + misses_count
-                        cache_hit_rate = round(hits_count / total, 3) if total > 0 else 0.0
-
-                    resp_count = await conn.get("metrics:resp:count")
-                    resp_sum = await conn.get("metrics:resp:sum_ms")
-                    if resp_count and resp_sum:
-                        count = int(resp_count)
-                        sum_ms = float(resp_sum)
-                        response_time_ms = round(sum_ms / count, 2) if count > 0 else 0.0
-            except Exception as e:
-                logger.warning(f"Error fetching metrics from Redis: {e}")
-
-            redis_service_status = (
-                "connected"
-                if redis_health.get("status") == "healthy"
-                else redis_health.get("status", "unknown")
-            )
-            status = "healthy" if redis_service_status == "connected" else "degraded"
-
-            background_task_count = (
-                self._get_background_task_count_fn()
-                if self._get_background_task_count_fn is not None
-                else 0
-            )
-
-            return {
-                "status": {"overall": status},
-                "services": {
-                    "redis": {"status": redis_service_status},
-                    "mem0": {"status": mem0_status},
-                },
-                "checks": {
-                    "cache_hit_rate": cache_hit_rate,
-                    "response_time_ms": response_time_ms,
-                },
-                "components": {
-                    "redis": redis_health.get("status", "unknown"),
-                    "mem0": mem0_status,
-                    "background_tasks": background_task_count,
-                },
-                "uptime_seconds": uptime_seconds,
-                "metrics": {
-                    "active_sessions": redis_health.get("databases", {})
-                    .get("session_store", {})
-                    .get("connected_clients", 0),
-                    "cache_hit_rate": cache_hit_rate,
-                    "response_time_ms": response_time_ms,
-                },
-                "service_name": self.config.service.name,
-                "version": self.config.service.version,
-                "timestamp": datetime.now(UTC).isoformat(),
-            }
-
-        except Exception as e:
-            logger.exception("Error during health check: %s", e)
-            return {
-                "status": {"overall": "unhealthy"},
-                "services": {"redis": {"status": "error"}, "mem0": {"status": "error"}},
-                "checks": {},
-                "components": {"error": str(e)},
-                "uptime_seconds": 0,
-                "metrics": {},
-                "service_name": self.config.service.name,
-                "version": self.config.service.version,
-                "timestamp": datetime.now(UTC).isoformat(),
-            }