isar 1.20.2__py3-none-any.whl → 1.34.9__py3-none-any.whl

isar/apis/schedule/scheduling_controller.py

@@ -1,37 +1,30 @@
 import logging
 from http import HTTPStatus
-from typing import List, Optional
 
-from alitra import Pose
 from fastapi import Body, HTTPException, Path
-from injector import inject
+from opentelemetry import trace
 
-from isar.apis.models import InputPose, StartMissionResponse
 from isar.apis.models.models import (
     ControlMissionResponse,
-    RobotInfoResponse,
+    StartMissionResponse,
     TaskResponse,
 )
 from isar.apis.models.start_mission_definition import (
     StartMissionDefinition,
+    StopMissionDefinition,
     to_isar_mission,
 )
-from isar.config.settings import robot_settings, settings
+from isar.config.settings import robot_settings
 from isar.mission_planner.mission_planner_interface import MissionPlannerError
 from isar.services.utilities.scheduling_utilities import SchedulingUtilities
 from isar.state_machine.states_enum import States
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.step import (
-    DriveToPose,
-    Localize,
-    MoveArm,
-    ReturnToHome,
-)
-from robot_interface.models.mission.task import Task
+from robot_interface.models.mission.task import TASKS, InspectionTask
+
+tracer = trace.get_tracer(__name__)
 
 
 class SchedulingController:
-    @inject
     def __init__(
         self,
         scheduling_utilities: SchedulingUtilities,
@@ -39,6 +32,7 @@ class SchedulingController:
         self.scheduling_utilities: SchedulingUtilities = scheduling_utilities
         self.logger = logging.getLogger("api")
 
+    @tracer.start_as_current_span("start_mission_by_id")
     def start_mission_by_id(
         self,
         mission_id: str = Path(
@@ -46,46 +40,25 @@ class SchedulingController:
             title="Mission ID",
             description="ID-number for predefined mission",
         ),
-        initial_pose: Optional[InputPose] = Body(
-            default=None,
-            description="The starting point of the mission. Used for initial "
-            "localization of robot",
-            embed=True,
-        ),
-        return_pose: Optional[InputPose] = Body(
-            default=None,
-            description="End pose of the mission. The robot return to the specified "
-            "pose after finishing all inspections",
-            embed=True,
-        ),
     ) -> StartMissionResponse:
-        self.logger.info(f"Received request to start mission with id {mission_id}")
+        self.logger.info("Received request to start mission with id %s", mission_id)
 
         state: States = self.scheduling_utilities.get_state()
         self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(state)
 
         mission: Mission = self.scheduling_utilities.get_mission(mission_id)
-        if return_pose:
-            pose: Pose = return_pose.to_alitra_pose()
-            step: DriveToPose = DriveToPose(pose=pose)
-            mission.tasks.append(Task(steps=[step]))
 
         self.scheduling_utilities.verify_robot_capable_of_mission(
             mission=mission, robot_capabilities=robot_settings.CAPABILITIES
         )
 
-        initial_pose_alitra: Optional[Pose] = (
-            initial_pose.to_alitra_pose() if initial_pose else None
-        )
+        self.logger.info("Starting mission with ISAR Mission ID: '%s'", mission.id)
 
-        self.logger.info(f"Starting mission with ISAR Mission ID: '{mission.id}'")
-
-        self.scheduling_utilities.start_mission(
-            mission=mission, initial_pose=initial_pose_alitra
-        )
+        self.scheduling_utilities.start_mission(mission=mission)
 
         return self._api_response(mission)
 
+    @tracer.start_as_current_span("start_mission")
     def start_mission(
         self,
         mission_definition: StartMissionDefinition = Body(
@@ -94,35 +67,26 @@ class SchedulingController:
             title="Mission Definition",
             description="Description of the mission in json format",
         ),
-        initial_pose: Optional[InputPose] = Body(
-            default=None,
-            description="The starting point of the mission. Used for initial "
-            "localization of robot",
-            embed=True,
-        ),
-        return_pose: Optional[InputPose] = Body(
-            default=None,
-            description="End pose of the mission. The robot return to the specified "
-            "pose after finishing all inspections",
-            embed=True,
-        ),
     ) -> StartMissionResponse:
         self.logger.info("Received request to start new mission")
 
         if not mission_definition:
-            error_message: str = (
+            error_message_no_mission_definition: str = (
                 "Unprocessable entity - 'mission_definition' empty or invalid"
             )
-            self.logger.error(error_message)
+            self.logger.error(error_message_no_mission_definition)
             raise HTTPException(
-                status_code=HTTPStatus.UNPROCESSABLE_ENTITY, detail=error_message
+                status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                detail=error_message_no_mission_definition,
             )
 
         state: States = self.scheduling_utilities.get_state()
         self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(state)
 
         try:
-            mission: Mission = to_isar_mission(mission_definition)
+            mission: Mission = to_isar_mission(
+                start_mission_definition=mission_definition
+            )
         except MissionPlannerError as e:
             error_message = f"Bad Request - Cannot create ISAR mission: {e}"
             self.logger.warning(error_message)
@@ -134,21 +98,23 @@ class SchedulingController:
         self.scheduling_utilities.verify_robot_capable_of_mission(
             mission=mission, robot_capabilities=robot_settings.CAPABILITIES
         )
-        if return_pose:
-            pose: Pose = return_pose.to_alitra_pose()
-            step: DriveToPose = DriveToPose(pose=pose)
-            mission.tasks.append(Task(steps=[step]))
 
-        initial_pose_alitra: Optional[Pose] = (
-            initial_pose.to_alitra_pose() if initial_pose else None
-        )
+        self.logger.info("Starting mission: %s", mission.id)
+        self.scheduling_utilities.start_mission(mission=mission)
+        return self._api_response(mission)
+
+    @tracer.start_as_current_span("return_home")
+    def return_home(self) -> None:
+        self.logger.info("Received request to return home")
 
-        self.logger.info(f"Starting mission: {mission.id}")
-        self.scheduling_utilities.start_mission(
-            mission=mission, initial_pose=initial_pose_alitra
+        state: States = self.scheduling_utilities.get_state()
+        self.scheduling_utilities.verify_state_machine_ready_to_receive_return_home_mission(
+            state
         )
-        return self._api_response(mission)
 
+        self.scheduling_utilities.return_home()
+
+    @tracer.start_as_current_span("pause_mission")
     def pause_mission(self) -> ControlMissionResponse:
         self.logger.info("Received request to pause current mission")
 
@@ -156,7 +122,7 @@ class SchedulingController:
 
         if state not in [
             States.Monitor,
-            States.Initiate,
+            States.ReturningHome,
         ]:
             error_message = (
                 f"Conflict - Pause command received in invalid state - State: {state}"
@@ -172,12 +138,13 @@ class SchedulingController:
         )
         return pause_mission_response
 
+    @tracer.start_as_current_span("resume_mission")
     def resume_mission(self) -> ControlMissionResponse:
         self.logger.info("Received request to resume current mission")
 
         state: States = self.scheduling_utilities.get_state()
 
-        if state != States.Paused:
+        if state not in [States.Paused, States.ReturnHomePaused]:
             error_message = (
                 f"Conflict - Resume command received in invalid state - State: {state}"
             )
@@ -189,12 +156,29 @@ class SchedulingController:
         )
         return resume_mission_response
 
-    def stop_mission(self) -> ControlMissionResponse:
+    @tracer.start_as_current_span("stop_mission")
+    def stop_mission(
+        self,
+        mission_id: StopMissionDefinition = Body(
+            default=None,
+            embed=True,
+            title="Mission ID to stop",
+            description="The mission ID of the mission being stopped, in json format",
+        ),
+    ) -> ControlMissionResponse:
+
         self.logger.info("Received request to stop current mission")
 
         state: States = self.scheduling_utilities.get_state()
 
-        if state in [States.Off, States.Idle]:
+        if (
+            state == States.UnknownStatus
+            or state == States.Stopping
+            or state == States.BlockedProtectiveStop
+            or state == States.Offline
+            or state == States.Home
+            or state == States.ReturningHome
+        ):
             error_message = (
                 f"Conflict - Stop command received in invalid state - State: {state}"
             )
@@ -202,119 +186,94 @@ class SchedulingController:
             raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
 
         stop_mission_response: ControlMissionResponse = (
-            self.scheduling_utilities.stop_mission()
+            self.scheduling_utilities.stop_mission(mission_id.mission_id)
         )
         return stop_mission_response
 
-    def drive_to(
-        self,
-        target_pose: InputPose = Body(
-            default=None,
-            title="Target Pose",
-            description="The target pose for the drive_to step",
-        ),
-    ) -> StartMissionResponse:
-        self.logger.info("Received request to start new drive-to mission")
+    @tracer.start_as_current_span("release_intervention_needed")
+    def release_intervention_needed(self) -> None:
+        self.logger.info("Received request to release intervention needed state")
 
         state: States = self.scheduling_utilities.get_state()
 
-        self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(state)
-
-        pose: Pose = target_pose.to_alitra_pose()
-        step: DriveToPose = DriveToPose(pose=pose)
-        mission: Mission = Mission(tasks=[Task(steps=[step])])
+        if state != States.InterventionNeeded:
+            error_message = f"Conflict - Release intervention needed command received in invalid state - State: {state}"
+            self.logger.warning(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.CONFLICT,
+                detail=error_message,
+            )
 
-        self.logger.info(
-            f"Starting drive to mission with ISAR Mission ID: '{mission.id}'"
-        )
-        self.scheduling_utilities.start_mission(mission=mission, initial_pose=None)
-        return self._api_response(mission)
+        self.scheduling_utilities.release_intervention_needed()
+        self.logger.info("Released intervention needed state successfully")
 
-    def start_localization_mission(
-        self,
-        localization_pose: InputPose = Body(
-            default=None,
-            embed=True,
-            title="Localization Pose",
-            description="The current position of the robot",
-        ),
-    ) -> StartMissionResponse:
-        self.logger.info("Received request to start new localization mission")
+    @tracer.start_as_current_span("lockdown")
+    def lockdown(self) -> None:
+        self.logger.info("Received request to lockdown robot")
 
         state: States = self.scheduling_utilities.get_state()
 
-        self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(state)
+        if state == States.Lockdown:
+            error_message = "Conflict - Lockdown command received in lockdown state"
+            self.logger.warning(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.CONFLICT,
+                detail=error_message,
+            )
 
-        pose: Pose = localization_pose.to_alitra_pose()
-        step: Localize = Localize(localization_pose=pose)
-        mission: Mission = Mission(tasks=[Task(steps=[step])])
+        self.scheduling_utilities.lock_down_robot()
+        self.logger.info("Lockdown started successfully")
 
-        self.logger.info(
-            f"Starting localization mission with ISAR Mission ID: '{mission.id}'"
-        )
-        self.scheduling_utilities.start_mission(
-            mission=mission,
-            initial_pose=None,
-        )
-        return self._api_response(mission)
+    @tracer.start_as_current_span("release_lockdown")
+    def release_lockdown(self) -> None:
+        self.logger.info("Received request to release robot lockdown")
 
-    def start_move_arm_mission(
-        self,
-        arm_pose_literal: str = Path(
-            ...,
-            alias="arm_pose_literal",
-            title="Arm pose literal",
-            description="Arm pose as a literal",
-        ),
-    ) -> StartMissionResponse:
-        self.logger.info("Received request to start new move arm mission")
+        state: States = self.scheduling_utilities.get_state()
 
-        if not robot_settings.VALID_ARM_POSES:
-            error_message: str = (
-                f"Received a request to move the arm but the robot "
-                f"{settings.ROBOT_NAME} does not support moving an arm"
-            )
+        if state != States.Lockdown:
+            error_message = f"Conflict - Release lockdown command received in invalid state - State: {state}"
             self.logger.warning(error_message)
             raise HTTPException(
-                status_code=HTTPStatus.BAD_REQUEST, detail=error_message
+                status_code=HTTPStatus.CONFLICT,
+                detail=error_message,
             )
 
-        if arm_pose_literal not in robot_settings.VALID_ARM_POSES:
-            error_message = (
-                f"Received a request to move the arm but the arm pose "
-                f"{arm_pose_literal} is not supported by the robot "
-                f"{settings.ROBOT_NAME}"
-            )
-            self.logger.warning(error_message)
+        self.scheduling_utilities.release_robot_lockdown()
+        self.logger.info("Released lockdown successfully")
+
+    @tracer.start_as_current_span("maintenance_mode")
+    def set_maintenance_mode(self) -> None:
+        self.logger.info("Received request to set maintenance_mode")
+
+        state: States = self.scheduling_utilities.get_state()
+
+        if state == States.Maintenance or state == States.StoppingDueToMaintenance:
+            message = f"Conflict - Call to set maintenance mode was given while in state {state}."
+            self.logger.info(message)
             raise HTTPException(
-                status_code=HTTPStatus.BAD_REQUEST, detail=error_message
+                status_code=HTTPStatus.CONFLICT,
+                detail=message,
             )
 
-        state: States = self.scheduling_utilities.get_state()
+        self.scheduling_utilities.set_maintenance_mode()
+        self.logger.info("Maintenance mode has been set")
 
-        self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(state)
+    @tracer.start_as_current_span("release_maintenance_mode")
+    def release_maintenance_mode(self) -> None:
+        self.logger.info("Received request to release robot from maintenance mode")
 
-        step: MoveArm = MoveArm(arm_pose=arm_pose_literal)
-        mission: Mission = Mission(tasks=[Task(steps=[step])])
+        state: States = self.scheduling_utilities.get_state()
 
-        self.logger.info(
-            f"Starting move arm mission with ISAR Mission ID: '{mission.id}'"
-        )
-        self.scheduling_utilities.start_mission(
-            mission=mission,
-            initial_pose=None,
-        )
-        return self._api_response(mission)
+        if state != States.Maintenance:
+            message = f"Conflict - Release maintenance mode command received in invalid state - State: {state}"
+            self.logger.info(message)
+            raise HTTPException(
+                status_code=HTTPStatus.CONFLICT,
+                detail=message,
+            )
 
-    def get_info(self):
-        return RobotInfoResponse(
-            robot_package=settings.ROBOT_PACKAGE,
-            isar_id=settings.ISAR_ID,
-            robot_name=settings.ROBOT_NAME,
-            robot_capabilities=robot_settings.CAPABILITIES,
-            robot_map_name=settings.DEFAULT_MAP,
-            plant_short_name=settings.PLANT_SHORT_NAME,
-        )
+        self.scheduling_utilities.release_maintenance_mode()
+        self.logger.info("Maintenance mode successfully released")
 
     def _api_response(self, mission: Mission) -> StartMissionResponse:
         return StartMissionResponse(
@@ -322,9 +281,12 @@ class SchedulingController:
             tasks=[self._task_api_response(task) for task in mission.tasks],
         )
 
-    def _task_api_response(self, task: Task) -> TaskResponse:
-        steps: List[dict] = []
-        for step in task.steps:
-            steps.append({"id": step.id, "type": step.__class__.__name__})
+    def _task_api_response(self, task: TASKS) -> TaskResponse:
+        if isinstance(task, InspectionTask):
+            inspection_id = task.inspection_id
+        else:
+            inspection_id = None
 
-        return TaskResponse(id=task.id, tag_id=task.tag_id, steps=steps)
+        return TaskResponse(
+            id=task.id, tag_id=task.tag_id, inspection_id=inspection_id, type=task.type
+        )

isar/apis/security/authentication.py

@@ -3,7 +3,7 @@ import logging
 from fastapi import Depends
 from fastapi.security.base import SecurityBase
 from fastapi_azure_auth import SingleTenantAzureAuthorizationCodeBearer
-from fastapi_azure_auth.exceptions import InvalidAuth
+from fastapi_azure_auth.exceptions import InvalidAuthHttp
 from fastapi_azure_auth.user import User
 from pydantic import BaseModel
 
@@ -35,7 +35,7 @@ async def validate_has_role(user: User = Depends(azure_scheme)) -> None:
     Raises a 403 authorization error if not.
     """
     if settings.REQUIRED_ROLE not in user.roles:
-        raise InvalidAuth(
+        raise InvalidAuthHttp(
             "Current user does not possess the required role for this endpoint"
         )
 
@@ -48,9 +48,9 @@ class Authenticator:
         self.logger = logging.getLogger("api")
         self.authentication_enabled: bool = authentication_enabled
         enabled_string = "enabled" if self.authentication_enabled else "disabled"
-        self.logger.info(f"API authentication is {enabled_string}")
+        self.logger.info("API authentication is %s", enabled_string)
 
-    def should_authenticate(self):
+    def should_authenticate(self) -> bool:
         return self.authentication_enabled
 
     def get_scheme(self):
@@ -58,7 +58,7 @@ class Authenticator:
             return validate_has_role
         return NoSecurity
 
-    async def load_config(self):
+    async def load_config(self) -> None:
         """
         Load OpenID config on startup.
         """

isar/config/certs/ca-cert.pem

@@ -1,33 +1,35 @@
 -----BEGIN CERTIFICATE-----
-MIIFrDCCA5QCCQDxWBtOiKrXyDANBgkqhkiG9w0BAQsFADCBlzELMAkGA1UEBhMC
-Tk8xDzANBgNVBAgMBkJlcmdlbjEPMA0GA1UEBwwGQmVyZ2VuMRQwEgYDVQQKDAtF
-cV9Sb2JvdGljczERMA8GA1UECwwIUm9ib3RpY3MxHDAaBgNVBAMME1JvYm90aWNz
-X1NlbGZTaWduZWQxHzAdBgkqhkiG9w0BCQEWEHRsbmVAZXF1aW5vci5jb20wHhcN
-MjMwOTI4MTIwMjU0WhcNMjQwOTI3MTIwMjU0WjCBlzELMAkGA1UEBhMCTk8xDzAN
-BgNVBAgMBkJlcmdlbjEPMA0GA1UEBwwGQmVyZ2VuMRQwEgYDVQQKDAtFcV9Sb2Jv
-dGljczERMA8GA1UECwwIUm9ib3RpY3MxHDAaBgNVBAMME1JvYm90aWNzX1NlbGZT
-aWduZWQxHzAdBgkqhkiG9w0BCQEWEHRsbmVAZXF1aW5vci5jb20wggIiMA0GCSqG
-SIb3DQEBAQUAA4ICDwAwggIKAoICAQDlId+Y8n3aQDx49siw+2iuJL+QPcr2W/Li
-XLKzKDaJ39oB7cIAfvX17c5tOgpTx+u/lsQBDfNhweclrPB4oCcJdDPFGWsTuI1H
-PE/6ytVpinBFub/RpIHY049LlGRPvDEIc+qWiwZBkwG38KO8Ly/4oU3vW28L0YF/
-LUDnsmZ/kZV/dBXe/z+1FqG7nqQC1kl0LmbQtIJT+yW9ybK/Olu1uMhGpy10cBca
-k+lZDZWhi1Y76jTqxlVR9bCsP0XWR9czbU26R29JzSAChm2gAy+ekAqO+ol0xbhG
-msVNn640zTPjIcsouHB/QjZEwJ/amGMS8o+wfQc+rOUQozRl1gEhFTby9Vn66IsE
-WRkXkI8AgGcxrnwOnVjgRaJPtgNWfL35EYEZxw5+mIKEhvEcApoTEcr7LUv8E10n
-afpZhEzjgBZGRLMw0myn21+PgsJwG/jDQHd/oDXyWRcDu53humJZN3b+WIZa2BXy
-98H0ZNKyP78uvG3mrqG2kW3tgws4XOqRuBEEj5PJuddShtkhpUJtobwksTH5vDt7
-L5JiVKDEYvXT9xt9FW8cDC1ZO4RRbfbMLv9xs1CXrbS75Wz0TyAqUkAPFAwfFgR5
-etES5ZeI4oPFW+zxgTkqLvT2PZh6I39OHE+Gi8P7aKZfnb7QqT4GkckJ1JWXuPee
-urkiGIrvowIDAQABMA0GCSqGSIb3DQEBCwUAA4ICAQAAAjrgEWNnR2fEAMYtR/RK
-VLgycBph2b1l6I3kwfDHF+HNwlrAihvP8M8xjCmbTODHOZ9ZaHMqnAoODpZpxgdg
-J3lEo3NuzTqYBQ+hXO0PLhVl5jaolX6vD/i7zqzK4mnQ34zKQb8LaJlEeCwuVhyN
-Mjwc84JreVD+VOaXIydVZ4vVmfylv79JsM6j7e4YsNofpvEiCAk/R/apDGXnOCkD
-WwoTxRFGl9HMqYigHg5TTfszfC765njRxwsrgLWN5cFPNai28ueBG0473pdUGlgN
-tT8NtXClr7R3avJ+v1pM4MlJXbyvl7ADsl9Bj+iHQusZgKEq/rARk8yzh6vH8Pwa
-QrsbgQ0OLcMMQrDSsl8BrwzV7boO+KHM6ypBsxJWBIJPCTdTq5cGHMLL+5+vfmE+
-jXqdrrO7b+xiiFPszMBjmyGo8/55Pr63YYz7pyXKQtjyev91yO7+niCQ4+MkR5XQ
-NTQdcfdd/LZwLhO7BS6U08Ytcg0ZMr3tb/hxCHD8vx+XS6gSxXVHqDqMZlmEcLOo
-cOQy73tOFX4Htpge0vQKhnH0TIDPb8um2IivdWdMz8wAoNGwj+A/aP3Eh9qqVZ5w
-1t/Erqpxw+FIiAjqRJ1yE9I7I3buhostxj0y4ry7g+faNtgu8hrrILz84kJw4YdC
-qtASXmP/Nm1dAHV2UjM33A==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 -----END CERTIFICATE-----

isar/config/keyvault/keyvault_service.py

@@ -65,7 +65,7 @@ class Keyvault:
             raise KeyvaultError  # type: ignore
 
     def get_secret_client(self) -> SecretClient:
-        if self.client == None:
+        if self.client is None:
             try:
                 credential: Union[ClientSecretCredential, DefaultAzureCredential]
                 if self.client_id and self.client_secret and self.tenant_id:

isar/config/log.py

@@ -1,66 +1,71 @@
 import logging
 import logging.config
+import os
 from importlib.resources import as_file, files
 
 import yaml
-from opencensus.ext.azure.log_exporter import AzureLogHandler
 from uvicorn.logging import ColourizedFormatter
 
-from isar.config.configuration_error import ConfigurationError
-from isar.config.keyvault.keyvault_error import KeyvaultError
-from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
 
+from .settings import Settings
 
-def setup_loggers(keyvault: Keyvault) -> None:
-    log_levels: dict = settings.LOG_LEVELS
-    source = files("isar").joinpath("config").joinpath("logging.conf")
-    with as_file(source) as f:
-        log_config = yaml.safe_load(open(f))
+
+def setup_loggers() -> None:
+    log_config = load_log_config()
 
     logging.config.dictConfig(log_config)
 
+    env_log_levels = {}
+    for env_var, value in os.environ.items():
+        if env_var.endswith("_LOG_LEVEL"):
+            log_name = env_var.split("_LOG_LEVEL")[0].lower()
+            env_log_levels[log_name] = value.upper()
+
     handlers = []
     if settings.LOG_HANDLER_LOCAL_ENABLED:
-        handlers.append(configure_console_handler(log_config=log_config))
-    if settings.LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED:
         handlers.append(
-            configure_azure_handler(log_config=log_config, keyvault=keyvault)
+            configure_console_handler(log_config=log_config, settings=settings)
         )
 
     for log_handler in handlers:
-        for loggers in log_config["loggers"].keys():
-            logging.getLogger(loggers).addHandler(log_handler)
-            logging.getLogger(loggers).setLevel(log_levels[loggers])
-        logging.getLogger().addHandler(log_handler)
+        for logger_name, logger_config in log_config["loggers"].items():
+            logger = logging.getLogger(logger_name)
+            logger.addHandler(log_handler)
+            if "level" in logger_config:
+                logger.setLevel(logger_config["level"])
+            if logger_name in env_log_levels:
+                logger.setLevel(env_log_levels[logger_name])
+        root_logger = logging.getLogger()
+        root_logger.addHandler(log_handler)
+        if "level" in log_config.get("root", {}):
+            root_logger.setLevel(log_config["root"]["level"])
 
 
-def configure_console_handler(log_config: dict) -> logging.Handler:
+def load_log_config():
+    source = files("isar").joinpath("config").joinpath("logging.conf")
+    with as_file(source) as f:
+        log_config = yaml.safe_load(open(f))
+    return log_config
+
+
+def configure_console_handler(log_config: dict, settings: Settings) -> logging.Handler:
     handler = logging.StreamHandler()
     handler.setLevel(log_config["root"]["level"])
-    handler.setFormatter(
-        ColourizedFormatter(
-            log_config["formatters"]["colourized"]["format"],
-            style="{",
-            use_colors=True,
+    if settings.DEBUG_LOG_FORMATTER:
+        handler.setFormatter(
+            ColourizedFormatter(
+                log_config["formatters"]["debug-formatter"]["format"],
+                style="{",
+                use_colors=True,
+            )
         )
-    )
-    return handler
-
-
-def configure_azure_handler(log_config: dict, keyvault: Keyvault) -> logging.Handler:
-    connection_string: str
-    try:
-        connection_string = keyvault.get_secret(
-            "application-insights-connection-string"
-        ).value
-    except KeyvaultError:
-        message: str = (
-            f"CRITICAL ERROR: Missing connection string for Application Insights in key vault '{keyvault.name}'."
+    else:
+        handler.setFormatter(
+            ColourizedFormatter(
+                log_config["formatters"]["colourized"]["format"],
+                style="{",
+                use_colors=True,
+            )
         )
-        print(f"\n{message} \n")
-        raise ConfigurationError(message)
-
-    handler = AzureLogHandler(connection_string=connection_string)
-    handler.setLevel(log_config["root"]["level"])
     return handler