Move error logging to DSKE exception __init__

Author: brunorijsman

client/http_client.py

@@ -87,7 +87,6 @@ async def get(
         try:
             response = await self._httpx_client.get(url, params=params, auth=auth)
         except httpx.HTTPError as exc:
-            LOGGER.error(f"Call GET {exc.request.url} exception {str(exc)}")
             raise exceptions.HTTPError(
                 method="GET",
                 url=url,
@@ -96,7 +95,6 @@ async def get(
                 exception=str(exc),
             ) from exc
         if response.status_code != 200:
-            LOGGER.error(f"Call GET {response.request.url} {response.status_code}")
             raise exceptions.HTTPError(
                 method="GET",
                 url=url,
@@ -169,7 +167,6 @@ async def _put_or_post(
             try:
                 response = await httpx_client.request(method, url, json=json, auth=auth)
             except httpx.HTTPError as exc:
-                LOGGER.error(f"Call {method} {url} exception {str(exc)}")
                 raise exceptions.HTTPError(
                     method=method,
                     url=url,
@@ -178,12 +175,6 @@ async def _put_or_post(
                     exception=str(exc),
                 ) from exc
             if response.status_code != 200:
-                message = ""
-                try:
-                    message = " " + response.json().get("message")
-                except Exception:  # pylint: disable=broad-except
-                    pass
-                LOGGER.error(f"Call {method} {url} {response.status_code}{message}")
                 raise exceptions.HTTPError(
                     method=method,
                     url=url,

common/block.py

@@ -8,7 +8,6 @@
 import pydantic
 from bitarray import bitarray
 from common.fragment import Fragment
-from common.logging import LOGGER
 from common.utils import bytes_to_str, str_to_bytes
 from common.exceptions import (
     InvalidBlockUUIDError,
@@ -149,13 +148,10 @@ def take_data(self, start: int, size: int) -> bytes:
         """
         end = start + size
         if start < 0:
-            LOGGER.error(f"Take data from blocK: invalid start index {start}")
             raise InvalidPSRDIndex(self._block_uuid, start)
         if end > self._size:
-            LOGGER.error(f"Take data from block: invalid end index {end}")
             raise InvalidPSRDIndex(self._block_uuid, end)
         if self._used[start:end].any():
-            LOGGER.error(f"Take data from block: already in use {start}:{end}")
             raise PSRDDataAlreadyUsedError(self._block_uuid, start, size)
         self._used[start:end] = True
         data = self._data[start:end]
@@ -191,12 +187,10 @@ def from_api(cls, api_block: APIBlock) -> "Block":
         try:
             block_uuid = UUID(api_block.block_uuid)
         except ValueError as exc:
-            LOGGER.error(f"Invalid block UUID in API block: {api_block.block_uuid}")
             raise InvalidBlockUUIDError(api_block.block_uuid) from exc
         try:
             data = str_to_bytes(api_block.data)
         except Exception as exc:
-            LOGGER.error(f"Invalid block data in API block: {api_block.data}")
             raise InvalidPSRDDataError from exc
         return Block(block_uuid, data)
 

common/exceptions.py

@@ -6,6 +6,7 @@
 from typing import List
 from uuid import UUID
 from fastapi import status
+from .logging import LOGGER
 
 
 class DSKEException(Exception):
@@ -18,6 +19,13 @@ def __init__(self, status_code: int, message: str, details: dict | None = None):
         self.status_code = status_code
         self.message = message
         self.details = details
+        try:
+            log_message = f"DSKEException raised: {message}"
+            if details is not None:
+                log_message += f" Details: {json.dumps(details)}"
+            LOGGER.error(log_message)
+        except Exception:  # pylint: disable=broad-except
+            pass
 
 
 class ClientNotRegisteredError(DSKEException):

common/fragment.py

@@ -5,7 +5,6 @@
 from uuid import UUID
 import pydantic
 from common.exceptions import InvalidBlockUUIDError, InvalidEncodedFragmentError
-from common.logging import LOGGER
 from . import utils
 
 
@@ -107,9 +106,6 @@ def from_api(
         try:
             block_uuid = UUID(api_fragment.block_uuid)
         except ValueError as exc:
-            LOGGER.error(
-                "Invalid block UUID in API fragment: %s", api_fragment.block_uuid
-            )
             raise InvalidBlockUUIDError(block_uuid=api_fragment.block_uuid) from exc
         block = pool.get_block(block_uuid)
         data = block.take_data(api_fragment.start, api_fragment.size)
@@ -139,35 +135,20 @@ def from_enc_str(
         """
         parts = enc_str.split(":")
         if len(parts) != 3:
-            LOGGER.error(
-                f"Invalid encoded fragment {enc_str} "
-                f"(expected three parts separated by :)"
-            )
             raise InvalidEncodedFragmentError(encoded_fragment=enc_str)
         block_uuid_str, start_byte_str, size_str = parts
         try:
             block_uuid = UUID(block_uuid_str)
         except ValueError as exc:
-            LOGGER.error(
-                f"Invalid encoded fragment {enc_str} "
-                f"(invalid block UUID {block_uuid_str})"
-            )
             raise InvalidBlockUUIDError(block_uuid=block_uuid_str) from exc
         block = pool.get_block(block_uuid)
         try:
             start = int(start_byte_str)
         except ValueError as exc:
-            LOGGER.error(
-                f"Invalid encoded fragment {enc_str} "
-                f"(invalid start byte {start_byte_str})"
-            )
             raise InvalidEncodedFragmentError(encoded_fragment=enc_str) from exc
         try:
             size = int(size_str)
         except ValueError as exc:
-            LOGGER.error(
-                f"Invalid encoded fragment {enc_str} " f"(invalid size {size_str})"
-            )
             raise InvalidEncodedFragmentError(encoded_fragment=enc_str) from exc
         data = block.take_data(start, size)
         return Fragment(block=block, start=start, size=size, data=data)

common/pool.py

@@ -7,7 +7,6 @@
 from .allocation import Allocation
 from .block import Block
 from .exceptions import OutOfPreSharedRandomDataError, InvalidBlockUUIDError
-from .logging import LOGGER
 from .owner import Owner
 
 
@@ -68,7 +67,6 @@ def get_block(self, block_uuid: UUID) -> Block:
         for block in self._blocks:
             if block.uuid == block_uuid:
                 return block
-        LOGGER.error(f"Block UUID not found in {str(self.owner)} pool: {block_uuid}")
         raise InvalidBlockUUIDError(block_uuid=str(block_uuid))
 
     def allocate(self, size: PositiveInt, purpose: str) -> Allocation:
@@ -79,10 +77,6 @@ def allocate(self, size: PositiveInt, purpose: str) -> Allocation:
         """
         available = self.nr_unused_bytes
         if available < size:
-            LOGGER.error(
-                f"PSRD allocation failed: pool={self._name} owner={self._owner} purpose={purpose} "
-                f"size={size} available={available}"
-            )
             raise OutOfPreSharedRandomDataError(
                 f"{self._name} {self._owner}", purpose, size, available
             )

common/share.py

@@ -4,7 +4,6 @@
 
 from uuid import UUID
 from .exceptions import WrongMasterSAEIDError, WrongSlaveSAEIDError
-from .logging import LOGGER
 from .utils import bytes_to_str
 
 
@@ -108,10 +107,6 @@ def check_master_sae(self, master_sae_id: str):
         """
         if self.master_sae_id != master_sae_id:
             key_id_str = str(self.user_key_id)
-            LOGGER.warning(
-                f"Requested master SAE ID {master_sae_id} does not match master SAE ID "
-                f"{self.master_sae_id} for key ID {key_id_str}"
-            )
             raise WrongMasterSAEIDError(master_sae_id, self.master_sae_id, key_id_str)
 
     def check_slave_sae(self, slave_sae_id: str):
@@ -121,8 +116,4 @@ def check_slave_sae(self, slave_sae_id: str):
         """
         if self.slave_sae_id != slave_sae_id:
             key_id_str = str(self.user_key_id)
-            LOGGER.warning(
-                f"Requested slave SAE ID {slave_sae_id} does not match slave SAE ID "
-                f"{self.slave_sae_id} for key ID {key_id_str}"
-            )
             raise WrongSlaveSAEIDError(slave_sae_id, self.slave_sae_id, key_id_str)

hub/hub.py

@@ -13,7 +13,6 @@
 from common.allocation import Allocation
 from common.block import Block
 from common.encryption_key import EncryptionKey
-from common.logging import LOGGER
 from common.owner import Owner
 from common.share import Share
 from common.share_api import APIGetShareResponse, APIPostShareRequest
@@ -119,7 +118,6 @@ def lookup_peer_client(self, client_name: str) -> PeerClient:
         Lookup a peer client by name.
         """
         if client_name not in self._peer_clients:
-            LOGGER.warning(f"Peer client {client_name} not found")
             raise exceptions.ClientNotRegisteredError(client_name)
         return self._peer_clients[client_name]
 
@@ -160,7 +158,6 @@ def get_share(self, key_id: UUID) -> Share:
         try:
             share = self._shares[key_id]
         except KeyError as exc:
-            LOGGER.warning(f"No share for key ID {key_id}")
             raise exceptions.UnknownKeyIDError(key_id) from exc
         return share
 

hub/peer_client.py

@@ -7,7 +7,6 @@
 from common.allocation import Allocation
 from common.block import Block
 from common.exceptions import InvalidSignatureError, EncryptorNotConnectedToClientError
-from common.logging import LOGGER
 from common.owner import Owner
 from common.pool import Pool
 from common.signature import Signature
@@ -96,9 +95,6 @@ def check_sae_is_connected(self, sae_id: str):
         Check whether a SAE is connected to a client. If not, raise an exception.
         """
         if sae_id not in self._encryptor_names:
-            LOGGER.warning(
-                f"Encryptor {sae_id} not connected to client {self._client_name}"
-            )
             raise EncryptorNotConnectedToClientError(self._client_name, sae_id)
 
     async def check_request_signature(self, raw_request: fastapi.Request):
@@ -119,9 +115,6 @@ async def check_request_signature(self, raw_request: fastapi.Request):
             # back to the pool. This is to prevent an attacker exhausting the pool (denial of
             # service) by sending lots of badly signed messages.
             allocation.give_back()
-            LOGGER.warning(
-                f"Invalid signature received from peer client '{self._client_name}'"
-            )
             raise InvalidSignatureError()
 
     def delete_fully_used_blocks(self) -> None: