feat: add arms

Author: harvey_xiang

src/memos/api/exceptions.py

@@ -1,5 +1,6 @@
 import logging
 
+from fastapi.exceptions import HTTPException, RequestValidationError
 from fastapi.requests import Request
 from fastapi.responses import JSONResponse
 
@@ -10,9 +11,24 @@
 class APIExceptionHandler:
     """Centralized exception handling for MemOS APIs."""
 
+    @staticmethod
+    async def validation_error_handler(request: Request, exc: RequestValidationError):
+        """Handle request validation errors."""
+        logger.error(f"Validation error: {exc.errors()}")
+        return JSONResponse(
+            status_code=422,
+            content={
+                "code": 422,
+                "message": "Parameter validation error",
+                "detail": exc.errors(),
+                "data": None,
+            },
+        )
+
     @staticmethod
     async def value_error_handler(request: Request, exc: ValueError):
         """Handle ValueError exceptions globally."""
+        logger.error(f"ValueError: {exc}")
         return JSONResponse(
             status_code=400,
             content={"code": 400, "message": str(exc), "data": None},
@@ -21,8 +37,17 @@ async def value_error_handler(request: Request, exc: ValueError):
     @staticmethod
     async def global_exception_handler(request: Request, exc: Exception):
         """Handle all unhandled exceptions globally."""
-        logger.exception("Unhandled error:")
+        logger.error(f"Exception: {exc}")
         return JSONResponse(
             status_code=500,
             content={"code": 500, "message": str(exc), "data": None},
         )
+
+    @staticmethod
+    async def http_error_handler(request: Request, exc: HTTPException):
+        """Handle HTTP exceptions globally."""
+        logger.error(f"HTTP error {exc.status_code}: {exc.detail}")
+        return JSONResponse(
+            status_code=exc.status_code,
+            content={"code": exc.status_code, "message": str(exc.detail), "data": None},
+        )

src/memos/api/middleware/request_context.py

@@ -2,6 +2,9 @@
 Request context middleware for automatic trace_id injection.
 """
 
+import os
+import time
+
 from collections.abc import Callable
 
 from starlette.middleware.base import BaseHTTPMiddleware
@@ -15,6 +18,10 @@
 
 logger = memos.log.get_logger(__name__)
 
+print("ARMS_APP_NAME", os.environ["ARMS_APP_NAME"])
+print("ARMS_REGION_ID", os.environ["ARMS_REGION_ID"])
+print("ARMS_LICENSE_KEY", os.environ["ARMS_LICENSE_KEY"])
+
 
 def extract_trace_id_from_headers(request: Request) -> str | None:
     """Extract trace_id from various possible headers with priority: g-trace-id > x-trace-id > trace-id."""
@@ -38,6 +45,8 @@ async def dispatch(self, request: Request, call_next: Callable) -> Response:
         # Extract or generate trace_id
         trace_id = extract_trace_id_from_headers(request) or generate_trace_id()
 
+        start_time = time.time()
+
         # Create and set request context
         context = RequestContext(trace_id=trace_id, api_path=request.url.path)
         set_request_context(context)
@@ -49,15 +58,28 @@ async def dispatch(self, request: Request, call_next: Callable) -> Response:
         if request.query_params:
             params_log["query_params"] = dict(request.query_params)
 
-        logger.info(f"Request started: {request.method} {request.url.path}, {params_log}")
+        logger.info(f"Request started, params: {params_log}, headers: {request.headers}")
 
         # Process the request
-        response = await call_next(request)
-
-        # Log request completion with output
-        logger.info(f"Request completed: {request.url.path}, status: {response.status_code}")
-
-        # Add trace_id to response headers for debugging
-        response.headers["x-trace-id"] = trace_id
+        try:
+            response = await call_next(request)
+            end_time = time.time()
+            logger.info(f"response is: {response.body}")
+
+            # 记录请求状态
+            if response.status_code == 200:
+                logger.info(
+                    f"Request completed: {request.url.path}, status: {response.status_code}, cost: {(end_time - start_time) * 1000:.2f}ms"
+                )
+            else:
+                logger.error(
+                    f"Request Failed: {request.url.path}, status: {response.status_code}, cost: {(end_time - start_time) * 1000:.2f}ms"
+                )
+        except Exception as e:
+            end_time = time.time()
+            logger.error(
+                f"Request Exception Error: {e}, cost: {(end_time - start_time) * 1000:.2f}ms"
+            )
+            raise e
 
         return response

src/memos/api/routers/server_router.py

@@ -237,6 +237,8 @@ def search_memories(search_req: APISearchRequest):
         }
     )
 
+    logger.info(f"search_memories response is: {memories_result}")
+
     return SearchResponse(
         message="Search completed successfully",
         data=memories_result,
@@ -285,6 +287,9 @@ def add_memories(add_req: APIADDRequest):
         }
         for memory_id, memory in zip(mem_id_list, flattened_memories, strict=False)
     ]
+
+    logger.info(f"add_memories response is: {response_data}")
+
     return MemoryResponse(
         message="Memory added successfully",
         data=response_data,

src/memos/api/server_api.py

@@ -1,6 +1,7 @@
 import logging
 
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
+from fastapi.exceptions import RequestValidationError
 
 from memos.api.exceptions import APIExceptionHandler
 from memos.api.middleware.request_context import RequestContextMiddleware
@@ -21,8 +22,13 @@
 # Include routers
 app.include_router(server_router)
 
-# Exception handlers
+# Request validation failed
+app.exception_handler(RequestValidationError)(APIExceptionHandler.validation_error_handler)
+# Invalid business code parameters
 app.exception_handler(ValueError)(APIExceptionHandler.value_error_handler)
+# Business layer manual exception
+app.exception_handler(HTTPException)(APIExceptionHandler.http_error_handler)
+# Fallback for unknown errors
 app.exception_handler(Exception)(APIExceptionHandler.global_exception_handler)
 
 

src/memos/log.py

@@ -160,7 +160,7 @@ def close(self):
     },
     "handlers": {
         "console": {
-            "level": selected_log_level,
+            "level": "DEBUG",
             "class": "logging.StreamHandler",
             "stream": stdout,
             "formatter": "no_datetime",