isar 1.11.0__tar.gz → 1.12.0__tar.gz

{isar-1.11.0 → isar-1.12.0}/.github/workflows/pythonpackage.yml

@@ -17,10 +17,10 @@ jobs:
         python-version: ["3.8", "3.9", "3.10"]
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v3
         with:
           python-version: ${{ matrix.python-version }}
 

{isar-1.11.0 → isar-1.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: isar
-Version: 1.11.0
+Version: 1.12.0
 Summary: Integration and Supervisory control of Autonomous Robots
 Home-page: https://github.com/equinor/isar
 Author: Equinor ASA

{isar-1.11.0 → isar-1.12.0}/main.py

@@ -7,7 +7,8 @@ from dotenv import load_dotenv
 from injector import Injector
 
 from isar.apis.api import API
-from isar.config.log import setup_logger
+from isar.config.keyvault.keyvault_service import Keyvault
+from isar.config.log import setup_loggers
 from isar.config.settings import settings
 from isar.models.communication.queues.queues import Queues
 from isar.modules import get_injector
@@ -26,11 +27,12 @@ from robot_interface.robot_interface import RobotInterface
 if __name__ == "__main__":
     load_dotenv()
 
-    setup_logger()
-    logger: Logger = logging.getLogger("main")
-
     injector: Injector = get_injector()
 
+    keyvault_client = injector.get(Keyvault)
+    setup_loggers(keyvault=keyvault_client)
+    logger: Logger = logging.getLogger("main")
+
     state_machine: StateMachine = injector.get(StateMachine)
     robot: RobotInterface = injector.get(RobotInterface)
     queues: Queues = injector.get(Queues)

{isar-1.11.0 → isar-1.12.0}/setup.py

@@ -36,6 +36,9 @@ setup(
         "fastapi-azure-auth",
         "fastapi",
         "injector",
+        "opencensus-ext-logging",
+        "opencensus-ext-requests",
+        "opencensus-ext-azure",
         "numpy",
         "paho-mqtt",
         "pydantic",

{isar-1.11.0 → isar-1.12.0}/src/isar/apis/api.py

@@ -1,21 +1,34 @@
 import logging
 from http import HTTPStatus
 from logging import Logger
+import os
 from typing import List, Union
 
 import click
 import uvicorn
-from fastapi import FastAPI, Security
+from fastapi import FastAPI, Security, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.routing import APIRouter
 from injector import inject
 from pydantic import AnyHttpUrl
 
+from opencensus.ext.azure.trace_exporter import AzureExporter
+from opencensus.trace.samplers import ProbabilitySampler
+from opencensus.trace.tracer import Tracer
+from opencensus.trace.span import SpanKind
+from opencensus.trace.attributes_helper import COMMON_ATTRIBUTES
+
 from isar.apis.models.models import ControlMissionResponse, StartMissionResponse
 from isar.apis.schedule.scheduling_controller import SchedulingController
 from isar.apis.security.authentication import Authenticator
+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
 
+HTTP_URL = COMMON_ATTRIBUTES["HTTP_URL"]
+HTTP_STATUS_CODE = COMMON_ATTRIBUTES["HTTP_STATUS_CODE"]
+
 
 class API:
     @inject
@@ -23,12 +36,16 @@ class API:
         self,
         authenticator: Authenticator,
         scheduling_controller: SchedulingController,
+        keyvault_client: Keyvault,
         port: int = settings.API_PORT,
+        azure_ai_logging_enabled: bool = settings.LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED,
     ) -> None:
         self.authenticator: Authenticator = authenticator
         self.scheduling_controller: SchedulingController = scheduling_controller
+        self.keyvault_client: Keyvault = keyvault_client
         self.host: str = "0.0.0.0"  # Locking uvicorn to use 0.0.0.0
         self.port: int = port
+        self.azure_ai_logging_enabled: bool = azure_ai_logging_enabled
 
         self.logger: Logger = logging.getLogger("api")
 
@@ -76,6 +93,9 @@ class API:
                 allow_headers=["*"],
             )
 
+        if self.azure_ai_logging_enabled:
+            self._add_request_logging_middleware(app)
+
         app.include_router(router=self._create_scheduler_router())
 
         app.include_router(router=self._create_info_router())
@@ -241,3 +261,36 @@ class API:
             self.port,
             extra={"color_message": color_message},
         )
+
+    def _add_request_logging_middleware(self, app: FastAPI) -> None:
+        connection_string: str
+        try:
+            connection_string = self.keyvault_client.get_secret(
+                "application-insights-connection-string"
+            ).value
+        except KeyvaultError:
+            message: str = (
+                "Missing connection string for Application Insights in key vault. "
+            )
+            self.logger.critical(message)
+            raise ConfigurationError(message)
+
+        @app.middleware("http")
+        async def middlewareOpencensus(request: Request, call_next):
+            tracer = Tracer(
+                exporter=AzureExporter(connection_string=connection_string),
+                sampler=ProbabilitySampler(1.0),
+            )
+            with tracer.span("main") as span:
+                span.span_kind = SpanKind.SERVER
+
+                response = await call_next(request)
+
+                tracer.add_attribute_to_current_span(
+                    attribute_key=HTTP_STATUS_CODE, attribute_value=response.status_code
+                )
+                tracer.add_attribute_to_current_span(
+                    attribute_key=HTTP_URL, attribute_value=str(request.url)
+                )
+
+            return response

{isar-1.11.0 → isar-1.12.0}/src/isar/apis/models/start_mission_definition.py

@@ -1,4 +1,5 @@
-from typing import List, Optional, Type
+from enum import Enum
+from typing import List, Optional
 
 from alitra import Position
 from pydantic import BaseModel, Field
@@ -9,29 +10,32 @@ from isar.models.mission.mission import Mission, Task
 from robot_interface.models.mission.step import (
     STEPS,
     DriveToPose,
-    InspectionStep,
     TakeImage,
     TakeThermalImage,
     TakeThermalVideo,
     TakeVideo,
 )
 
-inspection_step_types: List[Type[InspectionStep]] = [
-    TakeImage,
-    TakeThermalImage,
-    TakeVideo,
-    TakeThermalVideo,
-]
+
+class InspectionTypes(str, Enum):
+    image = "Image"
+    thermal_image = "ThermalImage"
+    video = "Video"
+    thermal_video = "ThermalVideo"
+
+
+class StartMissionInspectionDefinition(BaseModel):
+    type: InspectionTypes = Field(default=InspectionTypes.image)
+    inspection_target: InputPosition
+    analysis_types: Optional[List]
+    duration: Optional[float]
+    metadata: Optional[dict]
 
 
 class StartMissionTaskDefinition(BaseModel):
     pose: InputPose
     tag: Optional[str]
-    inspection_target: InputPosition
-    inspection_types: List[str] = Field(
-        default=[step.get_inspection_type().__name__ for step in inspection_step_types]
-    )
-    video_duration: Optional[float] = Field(default=10)
+    inspections: List[StartMissionInspectionDefinition]
 
 
 class StartMissionDefinition(BaseModel):
@@ -47,12 +51,14 @@ def to_isar_mission(mission_definition: StartMissionDefinition) -> Mission:
             drive_step: DriveToPose = DriveToPose(pose=task.pose.to_alitra_pose())
             inspection_steps: List[STEPS] = [
                 create_inspection_step(
-                    inspection_type=inspection_type,
-                    duration=task.video_duration,
-                    target=task.inspection_target.to_alitra_position(),
+                    inspection_type=inspection.type,
+                    duration=inspection.duration,
+                    target=inspection.inspection_target.to_alitra_position(),
                     tag_id=tag_id,
+                    analysis=inspection.analysis_types,
+                    metadata=inspection.metadata,
                 )
-                for inspection_type in task.inspection_types
+                for inspection in task.inspections
             ]
         except ValueError as e:
             raise MissionPlannerError(f"Failed to create task: {str(e)}")
@@ -68,27 +74,30 @@ def to_isar_mission(mission_definition: StartMissionDefinition) -> Mission:
 
 
 def create_inspection_step(
-    inspection_type: str, duration: float, target: Position, tag_id: Optional[str]
+    inspection_type: InspectionTypes,
+    duration: float,
+    target: Position,
+    analysis: Optional[List],
+    tag_id: Optional[str],
+    metadata: Optional[dict],
 ) -> STEPS:
     inspection_step: STEPS
-
-    if inspection_type == TakeImage.get_inspection_type().__name__:
+    if inspection_type == InspectionTypes.image.value:
         inspection_step = TakeImage(target=target)
-        if tag_id:
-            inspection_step.tag_id = tag_id
-    elif inspection_type == TakeVideo.get_inspection_type().__name__:
+    elif inspection_type == InspectionTypes.video.value:
         inspection_step = TakeVideo(target=target, duration=duration)
-        if tag_id:
-            inspection_step.tag_id = tag_id
-    elif inspection_type == TakeThermalImage.get_inspection_type().__name__:
+    elif inspection_type == InspectionTypes.thermal_image.value:
         inspection_step = TakeThermalImage(target=target)
-        if tag_id:
-            inspection_step.tag_id = tag_id
-    elif inspection_type == TakeThermalVideo.get_inspection_type().__name__:
+    elif inspection_type == InspectionTypes.thermal_video.value:
         inspection_step = TakeThermalVideo(target=target, duration=duration)
-        if tag_id:
-            inspection_step.tag_id = tag_id
     else:
         raise ValueError(f"Inspection type '{inspection_type}' not supported")
 
+    if tag_id:
+        inspection_step.tag_id = tag_id
+    if analysis:
+        inspection_step.analysis = analysis
+    if metadata:
+        inspection_step.metadata = metadata
+
     return inspection_step

{isar-1.11.0 → isar-1.12.0}/src/isar/apis/security/authentication.py

@@ -31,8 +31,8 @@ azure_scheme = SingleTenantAzureAuthorizationCodeBearer(
 
 async def validate_has_role(user: User = Depends(azure_scheme)) -> None:
     """
-    Validate that a user has the `role` role in order to access the API.
-    Raises a 401 authentication error if not.
+    Validate if the user has the required role in order to access the API.
+    Raises a 401 authorization error if not.
     """
     if settings.REQUIRED_ROLE not in user.roles:
         raise InvalidAuth(

{isar-1.11.0 → isar-1.12.0}/src/isar/config/keyvault/keyvault_service.py

@@ -21,25 +21,33 @@ class Keyvault:
         client_secret: str = None,
         tenant_id: str = None,
     ):
+        self.name = keyvault_name
         self.url = "https://" + keyvault_name + ".vault.azure.net"
         self.client_id = client_id
         self.client_secret = client_secret
         self.tenant_id = tenant_id
         self.logger = logging.getLogger("API")
+        self.client: SecretClient = None
 
     def get_secret(self, secret_name: str) -> KeyVaultSecret:
         secret_client: SecretClient = self.get_secret_client()
         try:
             secret: KeyVaultSecret = secret_client.get_secret(name=secret_name)
         except ResourceNotFoundError:
-            self.logger.error("Secret was not found in keyvault.")
-            traceback.print_exc()
+            self.logger.error(
+                "Secret '%s' was not found in keyvault '%s'.",
+                secret_name,
+                self.name,
+                exc_info=True,
+            )
             raise KeyvaultError  # type: ignore
         except HttpResponseError:
             self.logger.error(
-                "An error occurred while retrieving a secret from keyvault."
+                "An error occurred while retrieving the secret '%s' from keyvault '%s'.",
+                secret_name,
+                self.name,
+                exc_info=True,
             )
-            traceback.print_exc()
             raise KeyvaultError  # type: ignore
 
         return secret
@@ -49,25 +57,32 @@ class Keyvault:
         try:
             secret_client.set_secret(name=secret_name, value=secret_value)
         except HttpResponseError:
-            self.logger.error("An error occurred while setting a secret in keyvault.")
-            traceback.print_exc()
+            self.logger.error(
+                "An error occurred while setting secret '%s' in keyvault '%s'.",
+                secret_name,
+                self.name,
+                exc_info=True,
+            )
             raise KeyvaultError  # type: ignore
 
     def get_secret_client(self) -> SecretClient:
-        try:
-            credential: Union[ClientSecretCredential, DefaultAzureCredential]
-            if self.client_id and self.client_secret and self.tenant_id:
-                credential = ClientSecretCredential(
-                    tenant_id=self.tenant_id,
-                    client_id=self.client_id,
-                    client_secret=self.client_secret,
+        if self.client == None:
+            try:
+                credential: Union[ClientSecretCredential, DefaultAzureCredential]
+                if self.client_id and self.client_secret and self.tenant_id:
+                    credential = ClientSecretCredential(
+                        tenant_id=self.tenant_id,
+                        client_id=self.client_id,
+                        client_secret=self.client_secret,
+                    )
+                else:
+                    credential = DefaultAzureCredential()
+            except ClientAuthenticationError:
+                self.logger.error(
+                    "Failed to authenticate to Azure while connecting to KeyVault",
+                    exc_info=True,
                 )
-            else:
-                credential = DefaultAzureCredential()
-        except ClientAuthenticationError:
-            self.logger.error("Failed to authenticate to Azure.")
-            traceback.print_exc()
-            raise KeyvaultError
+                raise KeyvaultError
 
-        secret_client = SecretClient(vault_url=self.url, credential=credential)
-        return secret_client
+            self.client = SecretClient(vault_url=self.url, credential=credential)
+        return self.client

isar-1.12.0/src/isar/config/log.py

@@ -0,0 +1,61 @@
+import importlib.resources as pkg_resources
+import logging
+import logging.config
+import yaml
+from uvicorn.logging import ColourizedFormatter
+from opencensus.ext.azure.log_exporter import AzureLogHandler
+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
+
+
+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))
+
+    logging.config.dictConfig(log_config)
+
+    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)
+        )
+
+    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)
+
+
+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 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)
+    handler.setLevel(log_config["root"]["level"])
+    return handler

isar-1.12.0/src/isar/config/predefined_mission_definition/default_mission.json

@@ -0,0 +1,98 @@
+{
+    "mission_definition": {
+        "tasks": [
+            {
+                "pose": {
+                    "position": {
+                        "x": 0,
+                        "y": 0,
+                        "z": 0,
+                        "frame_name": "robot"
+                    },
+                    "orientation": {
+                        "x": 0,
+                        "y": 0,
+                        "z": 0,
+                        "w": 1,
+                        "frame_name": "robot"
+                    },
+                    "frame_name": "robot"
+                },
+                "tag": "1-A",
+                "inspections": [
+                    {
+                        "type": "Image",
+                        "inspection_target": {
+                            "x": 0,
+                            "y": 0,
+                            "z": 0,
+                            "frame_name": "robot"
+                        },
+                        "analysis_types": [
+                            "CarSeal",
+                            "Rust"
+                        ],
+                        "metadata": {
+                            "zoom": "2x"
+                        }
+                    },
+                    {
+                        "type": "ThermalVideo",
+                        "inspection_target": {
+                            "x": 0,
+                            "y": 0,
+                            "z": 0,
+                            "frame_name": "robot"
+                        },
+                        "analysis_types": [
+                            "GasDetection"
+                        ],
+                        "duration": 10
+                    }
+                ]
+            },
+            {
+                "pose": {
+                    "position": {
+                        "x": 1,
+                        "y": 1,
+                        "z": 1,
+                        "frame_name": "robot"
+                    },
+                    "orientation": {
+                        "x": 0,
+                        "y": 0,
+                        "z": 0,
+                        "w": 1,
+                        "frame_name": "robot"
+                    },
+                    "frame_name": "robot"
+                },
+                "inspections": [
+                    {
+                        "type": "ThermalImage",
+                        "inspection_target": {
+                            "x": 0,
+                            "y": 0,
+                            "z": 0,
+                            "frame_name": "robot"
+                        },
+                        "analysis_types": [
+                            "ColdSpot",
+                            "HotSpot"
+                        ]
+                    },
+                    {
+                        "type": "Video",
+                        "inspection_target": {
+                            "x": 0,
+                            "y": 0,
+                            "z": 0,
+                            "frame_name": "robot"
+                        }
+                    }
+                ]
+            }
+        ]
+    }
+}