Feature/logging system

app/config.py.example

@@ -22,3 +22,17 @@ email_conf = ConnectionConfig(
     MAIL_SSL=False,
     USE_CREDENTIALS=True,
 )
+
+# LOGGER
+LOGGER = {
+    "logger": {
+        "path": "./var/log",
+        "filename": "calendar.log",
+        "level": "error",
+        "rotation": "20 days",
+        "retention": "1 month",
+        "format": ("<level>{level: <8}</level> <green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green>"
+                   " - <cyan>{name}</cyan>:<cyan>{function}</cyan>"
+                   " - <level>{message}</level>")
+    }
+}

app/internal/logger_customizer.py

@@ -0,0 +1,111 @@
+import json
+import sys
+from typing import Union
+
+from pathlib import Path
+from loguru import logger, _Logger as Logger
+
+
+class LoggerConfigError(Exception):
+    pass
+
+
+class LoggerCustomizer:
+
+    @classmethod
+    def make_logger(cls, config_file_or_dict: Union[Path, dict],
+                    logger_name: str) -> Logger:
+        """Creates a loguru logger from given configuration path or dict.
+
+        Args:
+            config_file_or_dict (Union[Path, dict]): Path to logger
+            configuration file or dictionary of configuration
+            logger_name (str): Logger instance created from configuration
+
+        Raises:
+            LoggerConfigError: Error raised when the configuration is invalid
+
+        Returns:
+            Logger: Loguru logger instance
+        """
+
+        config = cls.load_logging_config(config_file_or_dict)
+
+        try:
+            logging_config = config.get(logger_name)
+            logs_path = logging_config.get('path')
+            log_file_path = logging_config.get('filename')
+
+            logger = cls.customize_logging(
+                file_path=Path(logs_path) / Path(log_file_path),
+                level=logging_config.get('level'),
+                retention=logging_config.get('retention'),
+                rotation=logging_config.get('rotation'),
+                format=logging_config.get('format')
+            )
+        except (TypeError, ValueError) as err:
+            raise LoggerConfigError(
+                f"You have an issue with the logger configuration: {err!r}, "
+                "fix it please")
+
+        return logger
+
+    @classmethod
+    def customize_logging(cls,
+                          file_path: Path,
+                          level: str,
+                          rotation: str,
+                          retention: str,
+                          format: str
+                          ) -> Logger:
+        """Used to customize the logger instance
+
+        Args:
+            file_path (Path): Path where the log file is located
+            level (str): The level wanted to start logging from
+            rotation (str): Every how long the logs would be
+                rotated(creation of new file)
+            retention (str): Amount of time in words defining how
+                long a log is kept
+            format (str): The logging format
+
+        Returns:
+            Logger: Instance of a logger mechanism
+        """
+        logger.remove()
+        logger.add(
+            sys.stdout,
+            enqueue=True,
+            backtrace=True,
+            level=level.upper(),
+            format=format
+        )
+        logger.add(
+            str(file_path),
+            rotation=rotation,
+            retention=retention,
+            enqueue=True,
+            backtrace=True,
+            level=level.upper(),
+            format=format
+        )
+
+        return logger
+
+    @classmethod
+    def load_logging_config(cls, config: Union[Path, dict]) -> dict:
+        """Loads logging configuration from file or dict
+
+        Args:
+            config (Union[Path, dict]): Path to logging configuration file
+
+        Returns:
+            dict: Configuration parsed as dictionary
+        """
+        if isinstance(config, Path):
+            with open(config) as config_file:
+                used_config = json.load(config_file)
+        else:
+            used_config = config
+
+        return used_config

app/main.py

@@ -7,20 +7,29 @@
     MEDIA_PATH, STATIC_PATH, templates)
 from app.routers import agenda, event, profile, email
 
+from app.internal.logger_customizer import LoggerCustomizer
+
+from app import config
 
 models.Base.metadata.create_all(bind=engine)
 
 app = FastAPI()
 app.mount("/static", StaticFiles(directory=STATIC_PATH), name="static")
 app.mount("/media", StaticFiles(directory=MEDIA_PATH), name="media")
 
+# Configure logger
+logger = LoggerCustomizer.make_logger(config.LOGGER, "logger")
+app.logger = logger
+
+
 app.include_router(profile.router)
 app.include_router(event.router)
 app.include_router(agenda.router)
 app.include_router(email.router)
 
 
 @app.get("/")
+@app.logger.catch()
 async def home(request: Request):
     return templates.TemplateResponse("home.html", {
         "request": request,

requirements.txt

@@ -8,9 +8,6 @@ click==7.1.2
 colorama==0.4.4
 coverage==5.3.1
 fastapi==0.63.0
-fastapi_mail==0.3.3.1
-faker==5.6.2
-smtpdfix==0.2.6
 h11==0.12.0
 h2==4.0.0
 hpack==4.0.0
@@ -19,6 +16,7 @@ idna==2.10
 importlib-metadata==3.3.0
 iniconfig==1.1.1
 Jinja2==2.11.2
+loguru==0.5.3
 MarkupSafe==1.1.1
 packaging==20.8
 Pillow==8.1.0
@@ -45,3 +43,6 @@ watchgod==0.6
 websockets==8.1
 wsproto==1.0.0
 zipp==3.4.0
+fastapi_mail==0.3.3.1
+faker==5.6.2
+smtpdfix==0.2.6

tests/conftest.py

@@ -1,14 +1,23 @@
 import datetime
+import logging
 
 import pytest
+from _pytest.logging import caplog as _caplog  # noqa: F401
+from loguru import logger
+from faker import Faker
+
 from app.database.database import Base, SessionLocal, engine
 from app.database.models import Event, User
+from app.internal.logger_customizer import LoggerCustomizer
 from app.main import app
 from app.routers import profile
-from faker import Faker
+from app import config
+
 from fastapi.testclient import TestClient
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
+
+
 pytest_plugins = "smtpdfix"
 
 SQLALCHEMY_TEST_DATABASE_URL = "sqlite:///./test.db"
@@ -29,6 +38,15 @@ def client():
     return TestClient(app)
 
 
+@pytest.fixture(scope='module')
+def client_with_logger():
+    logger = LoggerCustomizer.make_logger(config.LOGGER, "logger")
+
+    client = TestClient(app)
+    client.logger = logger
+    return client
+
+
 @pytest.fixture
 def session():
     Base.metadata.create_all(bind=engine)
@@ -82,3 +100,14 @@ def profile_test_client():
     with TestClient(app) as client:
         yield client
     app.dependency_overrides = {}
+
+
+@pytest.fixture
+def caplog(_caplog):  # noqa: F811
+    class PropagateHandler(logging.Handler):
+        def emit(self, record):
+            logging.getLogger(record.name).handle(record)
+
+    handler_id = logger.add(PropagateHandler(), format="{message} {extra}")
+    yield _caplog
+    logger.remove(handler_id)

tests/test_logger.py

@@ -0,0 +1,49 @@
+import logging
+
+import pytest
+
+from app.internal.logger_customizer import LoggerCustomizer, LoggerConfigError
+
+
+class TestLogger:
+    @staticmethod
+    def test_log_debug(caplog, client_with_logger):
+        with caplog.at_level(logging.DEBUG):
+            client_with_logger.logger.debug('Is it debugging now?')
+            assert 'Is it debugging now?' in caplog.text
+
+    @staticmethod
+    def test_log_info(caplog, client_with_logger):
+        with caplog.at_level(logging.INFO):
+            client_with_logger.logger.info('App started')
+            assert 'App started' in caplog.text
+
+    @staticmethod
+    def test_log_error(caplog, client_with_logger):
+        with caplog.at_level(logging.ERROR):
+            client_with_logger.logger.error('Something bad happened!')
+            assert 'Something bad happened!' in caplog.text
+
+    @staticmethod
+    def test_log_critical(caplog, client_with_logger):
+        with caplog.at_level(logging.CRITICAL):
+            client_with_logger.logger.critical("WE'RE DOOMED!")
+            assert "WE'RE DOOMED!" in caplog.text
+
+    @staticmethod
+    def test_bad_configuration():
+        bad_config = {
+            "logger": {
+                "path": "./var/log",
+                "filename": "calendar.log",
+                "level": "eror",
+                "rotation": "20 days",
+                "retention": "1 month",
+                "format": ("<level>{level: <8}</level> "
+                           "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green>"
+                           "- <cyan>{name}</cyan>:<cyan>{function}</cyan>"
+                           " - <level>{message}</level>")
+            }
+        }
+        with pytest.raises(LoggerConfigError):
+            LoggerCustomizer.make_logger(bad_config, 'logger')