Merge pull request #352 from DNO-inc/improve_auth_logs

Improve auth logs

burrito/apps/auth/views.py

@@ -59,7 +59,6 @@ async def auth__password_login(
                     Password login:
                         * user_id: {user.user_id}
                         * login: {user_login_data.login}
-                        * tokens: {tokens}
 
                 """
             )
@@ -115,7 +114,6 @@ async def auth__key_login(
                 Key login:
                     * user_id: {user.user_id}
                     * name: {user.firstname} {user.lastname}
-                    * tokens: {tokens}
 
             """
         )

burrito/models/user_model.py

@@ -19,7 +19,7 @@ class Users(BurritoBasicModel):
     firstname = CharField(60)
     lastname = CharField(60)
 
-    login = CharField(25, unique=True)
+    login = CharField(40, unique=True)
 
     faculty = ForeignKeyField(
         Faculties,

burrito/utils/app_util.py

@@ -3,8 +3,14 @@
 
 from fastapi import FastAPI, APIRouter
 from fastapi.middleware.cors import CORSMiddleware
-
-from .singleton_pattern import singleton
+from pymongo.errors import ServerSelectionTimeoutError
+import peewee
+
+from burrito.utils.exceptions import (
+    DBConnectionError,
+    db_connection_error_handler
+)
+from burrito.utils.singleton_pattern import singleton
 from burrito.utils.task_manager import get_task_manager
 from burrito import CURRENT_TIME_ZONE
 
@@ -29,8 +35,20 @@ def get_current_app(*, docs_url="/docs", openapi_url="/openapi.json") -> Burrito
         BurritoApi: current application object
     """
 
-    app = BurritoApi(docs_url=docs_url, openapi_url=openapi_url)
+    app: FastAPI = BurritoApi(docs_url=docs_url, openapi_url=openapi_url)
 
+    app.add_exception_handler(
+        DBConnectionError,
+        db_connection_error_handler
+    )
+    app.add_exception_handler(
+        ServerSelectionTimeoutError,
+        db_connection_error_handler
+    )
+    app.add_exception_handler(
+        peewee.OperationalError,
+        db_connection_error_handler
+    )
     app.add_event_handler("startup", startup_event)
     app.add_middleware(
         CORSMiddleware,

burrito/utils/auth.py

@@ -145,7 +145,6 @@ def create_refresh_token(token_data: AuthTokenPayload) -> str:
     get_logger().info(
         f"""
             Generate new token:
-                * token: {_token}
                 * redis key: {_token_redis_key}
                 * payload:  {token_data.dict()}
 

burrito/utils/db_cursor_object.py

@@ -2,9 +2,11 @@
 from playhouse.shortcuts import ReconnectMixin
 
 from pymysql import connect as pymysql_conn
+from pymysql.err import OperationalError
 
 from burrito.utils.singleton_pattern import singleton
 from burrito.utils.config_reader import get_config
+from burrito.utils.exceptions import MySQLConnectionError, DBConnectionError
 
 
 @singleton
@@ -27,11 +29,18 @@ def get_database_cursor() -> BurritoDatabaseCursor:
         BurritoDatabaseCursor: current database cursor
     """
 
-    return BurritoDatabaseCursor(
-        get_config().BURRITO_DB_NAME,
-        user=get_config().BURRITO_DB_USER,
-        password=get_config().BURRITO_DB_PASSWORD,
-        host=get_config().BURRITO_DB_HOST,
-        port=int(get_config().BURRITO_DB_PORT),
-        charset="utf8mb4"
-    )
+    try:
+        return BurritoDatabaseCursor(
+            get_config().BURRITO_DB_NAME,
+            user=get_config().BURRITO_DB_USER,
+            password=get_config().BURRITO_DB_PASSWORD,
+            host=get_config().BURRITO_DB_HOST,
+            port=int(get_config().BURRITO_DB_PORT),
+            charset="utf8mb4"
+        )
+
+    except OperationalError as exc:
+        raise MySQLConnectionError(str(exc)) from exc
+
+    except Exception as exc:
+        raise DBConnectionError(str(exc)) from exc

burrito/utils/exceptions.py

@@ -0,0 +1,35 @@
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import HTTPException
+
+from burrito.utils.logger import get_logger
+
+
+class DBConnectionError(HTTPException):
+    def __init__(self, detail: str = "One of dbs is unreachable") -> None:
+        super().__init__(500, detail)
+
+    def __str__(self) -> str:
+        return super().__repr__()
+
+
+class MySQLConnectionError(DBConnectionError):
+    def __init__(self, detail: str = "Can't connect to MySQL") -> None:
+        super().__init__(detail)
+
+
+class RedisConnectionError(DBConnectionError):
+    def __init__(self, detail: str = "Can't connect to Redis") -> None:
+        super().__init__(detail)
+
+
+class MongoConnectionError(DBConnectionError):
+    def __init__(self, detail: str = "Can't connect to Mongo") -> None:
+        super().__init__(detail)
+
+
+def db_connection_error_handler(request, exc) -> JSONResponse:
+    get_logger().critical(str(exc))
+    return JSONResponse(
+        content={"detail": "Some internal services is unreachable"},
+        status_code=500
+    )

burrito/utils/logger.py

@@ -12,7 +12,7 @@ class BurritoFormatter(logging.Formatter):
     red = "\x1b[31;20m"
     magenta = "\u001b[35m"
     reset = "\x1b[0m"
-    _format = "[ %(asctime)s ] | %(name)s (%(process)d) | %(levelname)s: %(message)s (%(filename)s:%(lineno)d)"
+    _format = "[ %(asctime)s ] | %(name)s (%(process)d) | %(levelname)s: %(message)s (%(pathname)s:%(lineno)d)"
 
     # Defining formats
     FORMATS = {
@@ -61,7 +61,7 @@ def __init__(self, name: str, level: int) -> None:
         self.addHandler(ch)
 
 
-def get_logger(level: int = logging.DEBUG) -> BurritoLogger:
+def get_logger(level: int = logging.DEBUG) -> logging.Logger:
     """_summary_
 
     Args:

burrito/utils/mongo_util.py

@@ -7,9 +7,9 @@
 from pymongo.errors import ServerSelectionTimeoutError
 import gridfs
 
+from burrito.utils.exceptions import MongoConnectionError, DBConnectionError
 from burrito.utils.singleton_pattern import singleton
 from burrito.utils.config_reader import get_config
-from burrito.utils.logger import get_logger
 
 from burrito.models.m_basic_model import MongoBaseModel
 from burrito.models.m_ticket_files import TicketFiles
@@ -39,26 +39,27 @@ def get_mongo_cursor():
 
     try:
         mongo_cursor.admin.command("ping")
+
     except ServerSelectionTimeoutError as exc:
-        get_logger().critical("Mongo server is unavailable")
-        raise HTTPException(
-            status_code=500,
-            detail="Some of the services is unavailable, please try late"
-        ) from exc
+        raise MongoConnectionError(str(exc)) from exc
+
+    except Exception as exc:
+        raise DBConnectionError(str(exc)) from exc
 
     return mongo_cursor
 
 
-_MONGO_CURSOR = get_mongo_cursor()
 _MONGO_DB_NAME = get_config().BURRITO_MONGO_DB
-_MONGO_GRIDFS: gridfs.GridFS = gridfs.GridFS(getattr(_MONGO_CURSOR, _MONGO_DB_NAME))
+_MONGO_GRIDFS: gridfs.GridFS = gridfs.GridFS(
+    getattr(get_mongo_cursor(), _MONGO_DB_NAME)
+)
 
 
 def mongo_init_ttl_indexes(models: list[MongoBaseModel]):
     """Create indexes to use TTL ability of MongoDB"""
 
     for model in models:
-        _MONGO_CURSOR[_MONGO_DB_NAME][model.Meta.table_name].create_index(
+        get_mongo_cursor()[_MONGO_DB_NAME][model.Meta.table_name].create_index(
             "obj_creation_time",  # index name
             expireAfterSeconds=300
         )
@@ -74,7 +75,7 @@ def mongo_insert(model: MongoBaseModel):
     Returns:
         The id of the newly inserted record
     """
-    return str(_MONGO_CURSOR[_MONGO_DB_NAME][model.Meta.table_name].insert_one(model.dict()).inserted_id)
+    return str(get_mongo_cursor()[_MONGO_DB_NAME][model.Meta.table_name].insert_one(model.dict()).inserted_id)
 
 
 def mongo_select(
@@ -105,7 +106,7 @@ def mongo_select(
 
     if sort_by:
         return list(
-            _MONGO_CURSOR[_MONGO_DB_NAME][model.Meta.table_name].find(filters).skip(
+            get_mongo_cursor()[_MONGO_DB_NAME][model.Meta.table_name].find(filters).skip(
                 (start_page - 1) * items_count
             ).limit(items_count).sort(
                 sort_by,
@@ -114,7 +115,7 @@ def mongo_select(
         )
 
     return list(
-        _MONGO_CURSOR[_MONGO_DB_NAME][model.Meta.table_name].find(filters).skip(
+        get_mongo_cursor()[_MONGO_DB_NAME][model.Meta.table_name].find(filters).skip(
             (start_page - 1) * items_count
         ).limit(items_count)
     )
@@ -131,7 +132,7 @@ def mongo_update(model: MongoBaseModel, **filters) -> list[object]:
     if item_id and isinstance(item_id, str):
         filters["_id"] = ObjectId(item_id)
 
-    _MONGO_CURSOR[_MONGO_DB_NAME][model.Meta.table_name].update_many(
+    get_mongo_cursor()[_MONGO_DB_NAME][model.Meta.table_name].update_many(
         filters, {"$set": model.dict()}
     )
 
@@ -147,7 +148,7 @@ def mongo_delete(model: MongoBaseModel, **filters) -> None:
     if item_id and isinstance(item_id, str):
         filters["_id"] = ObjectId(item_id)
 
-    _MONGO_CURSOR[_MONGO_DB_NAME][model.Meta.table_name].delete_many(filters)
+    get_mongo_cursor()[_MONGO_DB_NAME][model.Meta.table_name].delete_many(filters)
 
 
 def mongo_page_count(
@@ -171,7 +172,7 @@ def mongo_page_count(
     if item_id and isinstance(item_id, str):
         filters["_id"] = ObjectId(item_id)
 
-    return math.ceil(_MONGO_CURSOR[_MONGO_DB_NAME][model.Meta.table_name].count_documents(filters) / items_count)
+    return math.ceil(get_mongo_cursor()[_MONGO_DB_NAME][model.Meta.table_name].count_documents(filters) / items_count)
 
 
 def mongo_items_count(model: MongoBaseModel, **filters) -> int:
@@ -188,7 +189,7 @@ def mongo_items_count(model: MongoBaseModel, **filters) -> int:
     if item_id and isinstance(item_id, str):
         filters["_id"] = ObjectId(item_id)
 
-    return math.ceil(_MONGO_CURSOR[_MONGO_DB_NAME][model.Meta.table_name].count_documents(filters))
+    return math.ceil(get_mongo_cursor()[_MONGO_DB_NAME][model.Meta.table_name].count_documents(filters))
 
 
 def mongo_save_file(ticket_id: int, file_owner_id: int, file_name: str, file: bytes, content_type: str | None) -> str:

burrito/utils/redis_utils.py

@@ -1,10 +1,8 @@
 import redis
-from fastapi import HTTPException
 
 from burrito.utils.singleton_pattern import singleton
 from burrito.utils.config_reader import get_config
-from burrito.utils.logger import get_logger
-
+from burrito.utils.exceptions import RedisConnectionError, DBConnectionError
 
 @singleton
 class RedisConnector(redis.Redis):
@@ -31,11 +29,11 @@ def get_redis_connector() -> redis.Redis:
 
     try:
         _redis_object.ping()
+
     except (redis.exceptions.ConnectionError, ConnectionRefusedError) as exc:
-        get_logger().critical("Redis server is unavailable")
-        raise HTTPException(
-            status_code=500,
-            detail="Some of the services is unavailable, please try late"
-        ) from exc
+        raise RedisConnectionError(str(exc)) from exc
+
+    except Exception as exc:
+        raise DBConnectionError(str(exc)) from exc
 
     return _redis_object

burrito/utils/validators.py

@@ -16,7 +16,7 @@ def is_valid_login(login: str) -> bool:
     if not isinstance(login, str):
         return False
 
-    if len(login) < 3 or len(login) > 20:
+    if len(login) < 3 or len(login) > 40:
         return False
 
     pattern = r"^[\w_]*$"