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

isar/apis/schedule/scheduling_controller.py

@@ -1,32 +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
-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,
@@ -34,54 +32,33 @@ 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(
-            ...,
             alias="id",
             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(
@@ -90,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)
@@ -130,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")
 
@@ -152,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}"
@@ -168,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}"
             )
@@ -185,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}"
             )
@@ -198,71 +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)
+        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,
+            )
 
-        pose: Pose = target_pose.to_alitra_pose()
-        step: DriveToPose = DriveToPose(pose=pose)
-        mission: Mission = Mission(tasks=[Task(steps=[step])])
+        self.scheduling_utilities.release_intervention_needed()
+        self.logger.info("Released intervention needed state successfully")
 
-        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)
+    @tracer.start_as_current_span("lockdown")
+    def lockdown(self) -> None:
+        self.logger.info("Received request to lockdown robot")
 
-    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")
+        state: States = self.scheduling_utilities.get_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,
+            )
+
+        self.scheduling_utilities.lock_down_robot()
+        self.logger.info("Lockdown started successfully")
+
+    @tracer.start_as_current_span("release_lockdown")
+    def release_lockdown(self) -> None:
+        self.logger.info("Received request to release robot lockdown")
 
         state: States = self.scheduling_utilities.get_state()
 
-        self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(state)
+        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.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.release_robot_lockdown()
+        self.logger.info("Released lockdown 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("maintenance_mode")
+    def set_maintenance_mode(self) -> None:
+        self.logger.info("Received request to set maintenance_mode")
 
-    def get_info(self):
-        return RobotInfoResponse(
-            robot_package=settings.ROBOT_PACKAGE,
-            isar_id=settings.ISAR_ID,
-            robot_name=settings.ROBOT_NAME,
-            robot_map_name=settings.DEFAULT_MAP,
-            robot_capabilities=robot_settings.CAPABILITIES,
-            plant_short_name=settings.STID_PLANT_NAME,
-        )
+        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.CONFLICT,
+                detail=message,
+            )
+
+        self.scheduling_utilities.set_maintenance_mode()
+        self.logger.info("Maintenance mode has been set")
+
+    @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")
+
+        state: States = self.scheduling_utilities.get_state()
+
+        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,
+            )
+
+        self.scheduling_utilities.release_maintenance_mode()
+        self.logger.info("Maintenance mode successfully released")
 
     def _api_response(self, mission: Mission) -> StartMissionResponse:
         return StartMissionResponse(
@@ -270,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,35 +1,35 @@
 -----BEGIN CERTIFICATE-----
-MIIGETCCA/mgAwIBAgIURlJMuiWItiyRuV8FbUKur8c4gJIwDQYJKoZIhvcNAQEL
-BQAwgZcxCzAJBgNVBAYTAk5PMQ8wDQYDVQQIDAZCZXJnZW4xDzANBgNVBAcMBkJl
+MIIGGzCCBAOgAwIBAgIUCVuS8tL7R2bdjRJznkk1NN0oUa8wDQYJKoZIhvcNAQEL
+BQAwgZwxCzAJBgNVBAYTAk5PMQ8wDQYDVQQIDAZCZXJnZW4xDzANBgNVBAcMBkJl
 cmdlbjEUMBIGA1UECgwLRXFfUm9ib3RpY3MxETAPBgNVBAsMCFJvYm90aWNzMRww
-GgYDVQQDDBNSb2JvdGljc19TZWxmU2lnbmVkMR8wHQYJKoZIhvcNAQkBFhB0bG5l
-QGVxdWlub3IuY29tMB4XDTIyMDkyNjEyMTMwM1oXDTIzMDkyNjEyMTMwM1owgZcx
-CzAJBgNVBAYTAk5PMQ8wDQYDVQQIDAZCZXJnZW4xDzANBgNVBAcMBkJlcmdlbjEU
-MBIGA1UECgwLRXFfUm9ib3RpY3MxETAPBgNVBAsMCFJvYm90aWNzMRwwGgYDVQQD
-DBNSb2JvdGljc19TZWxmU2lnbmVkMR8wHQYJKoZIhvcNAQkBFhB0bG5lQGVxdWlu
-b3IuY29tMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAupznI47mnZ+F
-An8El2zUs/xgqj/3FUjvmSAmrPtEXCcwSHDNqTr3qpUgsJdDXrBlcrbp555gSUwK
-n+TCgiIBOfSjv1kAcFVW9KMPixKsK1Jpe4zVxaQ+kxmrtRbJKVV9vV0ZyQJ15Fho
-vi1ChUmmRzmW22Junf9fyr3rLN7zIb0OBUAvFCSzulgYin8lrK1YorzhmKlcX2th
-F7KsMsmRwe4qSQn6B1CDcarcLoR/ubbbm7DgU976fUEKYpRipdcE64fli4iKM21E
-n/VSsCN+M2ragcGo5KM5ASjt/fMIeOXwYCcdQzxlKeRfDaNmBxfQiJwiTZR4aK5h
-iBafos1b+brJ36H6gllbHNni60BWwl4EtJBlYid9tqBMbk0Vaq5WJum2BuIhBycK
-lGL8xlQhXG+HlH9GvLFGuCOzmFoF8H5Ejo4iEK6SkyUDMm0RCRUoO456JPWgT35q
-YD15gdP1vcQwY+/TOL7JR475m5vCMVmLRsFyZJcUVXWGTTpBbdqbf44off2dy1M8
-LWxWnu6adDahM+LIGWtCFZozwigJrDOWF6KGYnPwB/Y8xBvF2v85gH6NEuBODPSE
-t1Lewbic4tnA8W5OP7rPlrtHDVYNOvhgoGDvrhmUKJOt4UqLkmNv0T0xGkCWNbOs
-Jxgdfm58VAiKP+1n0ql6ov7gxBoiKJkCAwEAAaNTMFEwHQYDVR0OBBYEFN0uZvIf
-vkSM7cjVCN+06Etok9XmMB8GA1UdIwQYMBaAFN0uZvIfvkSM7cjVCN+06Etok9Xm
-MA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggIBALcWBqFiBmqUabES
-YeeRlKckKKFagzEgKBA3avZdsKxqhX8gIRFhecu6x6xZ5Y8xVb7yp0mW9YGWl7w0
-i3g9YIOyy1NKbaGS67BKgg9w0d77DmR2TPtmxwC7PCJnnhRRTEt8c2i9bfZfICMK
-ro11VFsoLSgED2SwDjhGFvhi3PZ9vJvR2YwVNMETMzeUI3zWvU+oyInmfzPcOWho
-N0ZaQNR+8uKtQhfdj8+gCUi82CRntStoOiVThGvF2MZOroerQh8IB7d8HLlIE6qZ
-H+TN/UhEXZMTlLH/ecnZod9IjDGaBPy4IEP1pDXCy+xWEJXhkZlA36djNQvAIZAZ
-0AUpFu3BnnaNydZ6rnv4P3FFaJ2NDZA7CFVUC2NUhPiT3MAcZz/DGUWaPSNRGmhd
-8lDA3It2d76K87CORacJBbbqRWD7J6yird5URNT9gwZ1U9zW+bqbkaf/kKqjrwJj
-Svdwxjl+Lb3Ehac04ibFd8MSf2IVaq1lSc65E5tmN6Yn3hxUm2kJPGW57M7hKYYC
-L18LrQhpbPdMo4PsQMYSW+q88Awkwd+FDhx358pAioHt5GbgvGS2lsgoZLxR3X+O
-gcVO8Y3NP5ZUmElZGpwz6nIJvAiZNUQf7/mWDVLxwhZyjhodfvKJea8WR9rVP7Qm
-QgqJDiX8Md2BtpClLiOZLuSnwlHC
+GgYDVQQDDBNSb2JvdGljc19TZWxmU2lnbmVkMSQwIgYJKoZIhvcNAQkBFhVmZ19y
+b2JvdHNAZXF1aW5vci5jb20wHhcNMjQxMjExMDczNzAzWhcNMjUxMjExMDczNzAz
+WjCBnDELMAkGA1UEBhMCTk8xDzANBgNVBAgMBkJlcmdlbjEPMA0GA1UEBwwGQmVy
+Z2VuMRQwEgYDVQQKDAtFcV9Sb2JvdGljczERMA8GA1UECwwIUm9ib3RpY3MxHDAa
+BgNVBAMME1JvYm90aWNzX1NlbGZTaWduZWQxJDAiBgkqhkiG9w0BCQEWFWZnX3Jv
+Ym90c0BlcXVpbm9yLmNvbTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB
+ALVlT8EjA8UpXdARJM6YfhH+9DEyytb0SJYOEm9jWL7X0G5eMbNfKtfFj/BLQBBw
+GDqyvhFa8SO56zM3Yi1Lir41JkpOKf2zJpNaL1syPxOA87MAm43UN/p2Mo6QAYpC
+lJzmeNoagLFi/kIzGajeUwISOf//Zej0jK/9CpuvvNVHz4wRk4Ap9qtgrM9qhlNq
+rZL4ZQODnvDZ/nwAYwEh9O2sbRr73aiHFcbxNAU2XxtT5UwbZMHom2Xic2Dmubqn
+cWFU+C4upEqPvgYU/hxia/rkhHyicXmdXT6IzjVxPbrlPBHoKVodJOCQ3UoBQl5X
+caHCluKOblA/yX+vEhv2h/m8XOtWiq0Jxnx+6D7B1piZfQnnNVSBT0bOYASb2cpn
+8rJE3RBdBwiqjKTotVTZ8PAS/GY0Gz3GoMAUCvIGA02+/cO9ENls9D79/86lgiCQ
+UqyteNNmo+oMqKHBw9Jmeejw1kbpnJN1abc270+qCT17aeX8yiMza5CyUTQTtgFI
+62xIYaHWhN7GrxOvoMU8X0G1HINwjS5heIhu5bND/26dLZqV3aBUWwb4ql5QIce2
+q5BQKmMqQLZF6J0aFL9dKJv5u3ioPFmiYPsPiRlwusPOoOFCiMt2kqZE3h3wxu6V
+cXWdj0sH+dgxuGYTxrLuoSru4Xv/HPXh15mVY0/eI+u/AgMBAAGjUzBRMB0GA1Ud
+DgQWBBQW2Ms6M3iadKVLOnraMlx6Exm8KjAfBgNVHSMEGDAWgBQW2Ms6M3iadKVL
+OnraMlx6Exm8KjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4ICAQB0
+XorfCLmVUN3aQWBouwG0fXHBqi3d4RA0vPsi8w+R/dOuHnLBLlHAiOkCMqW23bLs
+ir2UVqpGXcp5keKGeCTj+bmdqhnS/B9eoaeA8np/zDPH834v+Qv7JA5ch50gYrL7
+llF/02e5m0egP2xx9V7k90Du8OBm7xQgfbyrUcB2laC+loPyQiHMF24CU4ESfC4K
+DBXOZm8Kd6+fvzEs8XDLKwjNb9MocHIJikysZTncxfhgVPaU5KCqF3afHkCkZGzn
+Z+yMBfWbZ2WtM3lfwmM7z5NCTSqSFucW5+kw/OnzS3nQLyz2Q4nh4ApojsI3v+FH
+xz8aCITPbVwKAHGYO9jbk9x8LlkzDPCCzBH7dGKLKaQSCoD+IOwig1cI7pM77WeI
+BNC0g2ZCuLdb7c37/kT/1xGrIGUrpDsO34ZWW7E2X8kQPkAgqMNp0uXcnvIoNHO1
+eVL08Om+7WbwK7wS3te5IWDq4rRWVW4Jv709w8z6porr3W8ipdtUoYqbgZI8jOiW
+osY4UVcRwQ4S1oF5pNRzXlZAPwAnaDipglxHBiy9/ARS6HKpOCbmUHbj+goXYNyZ
+ps8TcYc9LFOq4HBE4KKbV971jf/wQy1nVcm2qSbOJ9MPHM5BG22m1iVhSYbLPgE2
+SBZvCS+voD8MqpBB1tPcvVqlPb1pFxf1lOc5QV3uOA==
 -----END CERTIFICATE-----

isar/config/keyvault/keyvault_service.py

@@ -1,5 +1,4 @@
 import logging
-import traceback
 from typing import Union
 
 from azure.core.exceptions import (
@@ -66,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,63 +1,71 @@
-import importlib.resources as pkg_resources
 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
-    with pkg_resources.path("isar.config", "logging.conf") as path:
-        log_config = yaml.safe_load(open(path))
+
+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:
-    handler = logging.StreamHandler()
-    handler.setLevel(log_config["root"]["level"])
-    handler.setFormatter(
-        ColourizedFormatter(
-            log_config["formatters"]["colourized"]["format"],
-            style="{",
-            use_colors=True,
-        )
-    )
-    return 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_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}'."
-        print(f"\n{message} \n")
-        raise ConfigurationError(message)
 
-    handler = AzureLogHandler(connection_string=connection_string)
+def configure_console_handler(log_config: dict, settings: Settings) -> logging.Handler:
+    handler = logging.StreamHandler()
     handler.setLevel(log_config["root"]["level"])
+    if settings.DEBUG_LOG_FORMATTER:
+        handler.setFormatter(
+            ColourizedFormatter(
+                log_config["formatters"]["debug-formatter"]["format"],
+                style="{",
+                use_colors=True,
+            )
+        )
+    else:
+        handler.setFormatter(
+            ColourizedFormatter(
+                log_config["formatters"]["colourized"]["format"],
+                style="{",
+                use_colors=True,
+            )
+        )
     return handler