create protected_task function

Author: GabrielSalla

src/main.py

@@ -3,8 +3,6 @@
 import asyncio
 import logging
 import sys
-import traceback
-from typing import Coroutine
 
 import uvloop
 
@@ -19,18 +17,11 @@
 import registry as registry
 import utils.app as app
 import utils.log as log
+from utils.exception_handling import protected_task
 
 _logger = logging.getLogger("main")
 
 
-async def protected_task(task: Coroutine[None, None, None]) -> None:
-    try:
-        await task
-    except Exception:
-        _logger.error(f"Exception with task '{task}'")
-        _logger.error(traceback.format_exc().strip())
-
-
 async def init_plugins_services(controller_enabled: bool, executor_enabled: bool) -> None:
     """Initialize the plugins services"""
     for plugin_name, plugin in plugins.loaded_plugins.items():
@@ -86,11 +77,11 @@ async def stop_plugins_services() -> None:
 
 async def finish() -> None:
     """Finish the application, making sure any exception won't impact other closing tasks"""
-    await protected_task(http_server.wait_stop())
-    await protected_task(monitors_loader.wait_stop())
-    await protected_task(databases.close())
-    await protected_task(internal_database.close())
-    await protected_task(stop_plugins_services())
+    await protected_task(_logger, http_server.wait_stop())
+    await protected_task(_logger, monitors_loader.wait_stop())
+    await protected_task(_logger, databases.close())
+    await protected_task(_logger, internal_database.close())
+    await protected_task(_logger, plugins.services.stop())
 
 
 async def main() -> None:

src/utils/exception_handling.py

@@ -2,7 +2,7 @@
 import logging
 import traceback
 from contextlib import contextmanager
-from typing import Generator
+from typing import Coroutine, Generator
 
 from base_exception import BaseSentinelaException
 
@@ -29,3 +29,11 @@ def catch_exceptions(
         if error_message:
             logger.error(error_message)
         logger.info("Exception caught successfully, going on")
+
+
+async def protected_task(logger: logging.Logger, task: Coroutine[None, None, None]) -> None:
+    try:
+        await task
+    except Exception:
+        logger.error(f"Exception with task '{task}'")
+        logger.error(traceback.format_exc().strip())

tests/utils/test_exception_handling.py

@@ -6,7 +6,7 @@
 
 from base_exception import BaseSentinelaException
 from tests.test_utils import assert_message_in_log, assert_message_not_in_log
-from utils.exception_handling import catch_exceptions
+from utils.exception_handling import catch_exceptions, protected_task
 
 pytestmark = pytest.mark.asyncio(loop_scope="session")
 
@@ -78,3 +78,33 @@ async def error() -> None:
         assert logger_error_spy.call_count == 2
         logger_error_spy.assert_called_with("error function raised exception")
         logger_info_spy.assert_called_once_with("Exception caught successfully, going on")
+
+
+async def test_protected_task(caplog, mocker):
+    """'protected_task' should do nothing if the execution doesn't raise any errors"""
+    logger = logging.getLogger("test_protected_task")
+    logger_error_spy: MagicMock = mocker.spy(logger, "error")
+
+    async def no_error() -> None:
+        pass
+
+    await protected_task(logger, no_error())
+
+    assert_message_not_in_log(caplog, "Exception with task")
+    logger_error_spy.assert_not_called()
+
+
+async def test_protected_task_error(caplog, mocker):
+    """'protected_task' should log the exception message if an exception is raised"""
+    logger = logging.getLogger("test_protected_task")
+    logger_error_spy: MagicMock = mocker.spy(logger, "error")
+
+    async def error() -> None:
+        raise ValueError("should be raised")
+
+    await protected_task(logger, error())
+
+    assert_message_in_log(caplog, "Exception with task")
+    assert_message_in_log(caplog, "ValueError: should be raised")
+
+    assert logger_error_spy.call_count == 2