feat: Logging is working, and we can search through the data

Author: Robin-Van-de-Merghel

diracx-client/src/diracx/client/_generated/aio/operations/_operations.py

@@ -59,9 +59,9 @@
     build_pilots_clear_pilots_request,
     build_pilots_create_pilot_secrets_request,
     build_pilots_delete_pilots_request,
-    build_pilots_get_logs_request,
     build_pilots_pilot_login_request,
     build_pilots_refresh_pilot_tokens_request,
+    build_pilots_search_logs_request,
     build_pilots_search_request,
     build_pilots_send_message_request,
     build_pilots_update_pilot_fields_request,
@@ -3480,7 +3480,7 @@ async def send_message(
         *,
         content_type: str = "application/json",
         **kwargs: Any,
-    ) -> int:
+    ) -> None:
         """Send Message.
 
         Send Message.
@@ -3490,15 +3490,15 @@ async def send_message(
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :return: int
-        :rtype: int
+        :return: None
+        :rtype: None
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
     @overload
     async def send_message(
         self, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
-    ) -> int:
+    ) -> None:
         """Send Message.
 
         Send Message.
@@ -3508,23 +3508,23 @@ async def send_message(
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :return: int
-        :rtype: int
+        :return: None
+        :rtype: None
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
     @distributed_trace_async
     async def send_message(
         self, body: Union[_models.LogMessage, IO[bytes]], **kwargs: Any
-    ) -> int:
+    ) -> None:
         """Send Message.
 
         Send Message.
 
         :param body: Is either a LogMessage type or a IO[bytes] type. Required.
         :type body: ~_generated.models.LogMessage or IO[bytes]
-        :return: int
-        :rtype: int
+        :return: None
+        :rtype: None
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map: MutableMapping = {
@@ -3541,7 +3541,7 @@ async def send_message(
         content_type: Optional[str] = kwargs.pop(
             "content_type", _headers.pop("Content-Type", None)
         )
-        cls: ClsType[int] = kwargs.pop("cls", None)
+        cls: ClsType[None] = kwargs.pop("cls", None)
 
         content_type = content_type or "application/json"
         _json = None
@@ -3569,27 +3569,90 @@ async def send_message(
 
         response = pipeline_response.http_response
 
-        if response.status_code not in [200]:
+        if response.status_code not in [204]:
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("int", pipeline_response.http_response)
-
         if cls:
-            return cls(pipeline_response, deserialized, {})  # type: ignore
+            return cls(pipeline_response, None, {})  # type: ignore
 
-        return deserialized  # type: ignore
+    @overload
+    async def search_logs(
+        self,
+        body: Optional[_models.SearchParams] = None,
+        *,
+        page: int = 1,
+        per_page: int = 100,
+        content_type: str = "application/json",
+        **kwargs: Any,
+    ) -> List[Dict[str, Any]]:
+        """Search Logs.
+
+        Search Logs.
+
+        :param body: Default value is None.
+        :type body: ~_generated.models.SearchParams
+        :keyword page: Default value is 1.
+        :paramtype page: int
+        :keyword per_page: Default value is 100.
+        :paramtype per_page: int
+        :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: list of dict mapping str to any
+        :rtype: list[dict[str, any]]
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+
+    @overload
+    async def search_logs(
+        self,
+        body: Optional[IO[bytes]] = None,
+        *,
+        page: int = 1,
+        per_page: int = 100,
+        content_type: str = "application/json",
+        **kwargs: Any,
+    ) -> List[Dict[str, Any]]:
+        """Search Logs.
+
+        Search Logs.
+
+        :param body: Default value is None.
+        :type body: IO[bytes]
+        :keyword page: Default value is 1.
+        :paramtype page: int
+        :keyword per_page: Default value is 100.
+        :paramtype per_page: int
+        :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
+         Default value is "application/json".
+        :paramtype content_type: str
+        :return: list of dict mapping str to any
+        :rtype: list[dict[str, any]]
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
 
     @distributed_trace_async
-    async def get_logs(self, *, pilot_id: int, **kwargs: Any) -> List[Dict[str, Any]]:
-        """Get Logs.
+    async def search_logs(
+        self,
+        body: Optional[Union[_models.SearchParams, IO[bytes]]] = None,
+        *,
+        page: int = 1,
+        per_page: int = 100,
+        **kwargs: Any,
+    ) -> List[Dict[str, Any]]:
+        """Search Logs.
 
-        Get Logs.
+        Search Logs.
 
-        :keyword pilot_id: Required.
-        :paramtype pilot_id: int
+        :param body: Is either a SearchParams type or a IO[bytes] type. Default value is None.
+        :type body: ~_generated.models.SearchParams or IO[bytes]
+        :keyword page: Default value is 1.
+        :paramtype page: int
+        :keyword per_page: Default value is 100.
+        :paramtype per_page: int
         :return: list of dict mapping str to any
         :rtype: list[dict[str, any]]
         :raises ~azure.core.exceptions.HttpResponseError:
@@ -3602,13 +3665,31 @@ async def get_logs(self, *, pilot_id: int, **kwargs: Any) -> List[Dict[str, Any]
         }
         error_map.update(kwargs.pop("error_map", {}) or {})
 
-        _headers = kwargs.pop("headers", {}) or {}
+        _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
         _params = kwargs.pop("params", {}) or {}
 
+        content_type: Optional[str] = kwargs.pop(
+            "content_type", _headers.pop("Content-Type", None)
+        )
         cls: ClsType[List[Dict[str, Any]]] = kwargs.pop("cls", None)
 
-        _request = build_pilots_get_logs_request(
-            pilot_id=pilot_id,
+        content_type = content_type or "application/json"
+        _json = None
+        _content = None
+        if isinstance(body, (IOBase, bytes)):
+            _content = body
+        else:
+            if body is not None:
+                _json = self._serialize.body(body, "SearchParams")
+            else:
+                _json = None
+
+        _request = build_pilots_search_logs_request(
+            page=page,
+            per_page=per_page,
+            content_type=content_type,
+            json=_json,
+            content=_content,
             headers=_headers,
             params=_params,
         )

diracx-client/src/diracx/client/_generated/models/_models.py

@@ -767,32 +767,48 @@ class LogLine(_serialization.Model):
 
     All required parameters must be populated in order to send to server.
 
-    :ivar line_no: Line No. Required.
-    :vartype line_no: int
-    :ivar line: Line. Required.
-    :vartype line: str
+    :ivar timestamp: Timestamp. Required.
+    :vartype timestamp: str
+    :ivar severity: Severity. Required.
+    :vartype severity: str
+    :ivar message: Message. Required.
+    :vartype message: str
+    :ivar scope: Scope. Required.
+    :vartype scope: str
     """
 
     _validation = {
-        "line_no": {"required": True},
-        "line": {"required": True},
+        "timestamp": {"required": True},
+        "severity": {"required": True},
+        "message": {"required": True},
+        "scope": {"required": True},
     }
 
     _attribute_map = {
-        "line_no": {"key": "line_no", "type": "int"},
-        "line": {"key": "line", "type": "str"},
+        "timestamp": {"key": "timestamp", "type": "str"},
+        "severity": {"key": "severity", "type": "str"},
+        "message": {"key": "message", "type": "str"},
+        "scope": {"key": "scope", "type": "str"},
     }
 
-    def __init__(self, *, line_no: int, line: str, **kwargs: Any) -> None:
+    def __init__(
+        self, *, timestamp: str, severity: str, message: str, scope: str, **kwargs: Any
+    ) -> None:
         """
-        :keyword line_no: Line No. Required.
-        :paramtype line_no: int
-        :keyword line: Line. Required.
-        :paramtype line: str
+        :keyword timestamp: Timestamp. Required.
+        :paramtype timestamp: str
+        :keyword severity: Severity. Required.
+        :paramtype severity: str
+        :keyword message: Message. Required.
+        :paramtype message: str
+        :keyword scope: Scope. Required.
+        :paramtype scope: str
         """
         super().__init__(**kwargs)
-        self.line_no = line_no
-        self.line = line
+        self.timestamp = timestamp
+        self.severity = severity
+        self.message = message
+        self.scope = scope
 
 
 class LogMessage(_serialization.Model):
@@ -804,42 +820,30 @@ class LogMessage(_serialization.Model):
     :vartype pilot_stamp: str
     :ivar lines: Lines. Required.
     :vartype lines: list[~_generated.models.LogLine]
-    :ivar vo: Vo. Required.
-    :vartype vo: str
     """
 
     _validation = {
         "pilot_stamp": {"required": True},
         "lines": {"required": True},
-        "vo": {"required": True},
     }
 
     _attribute_map = {
         "pilot_stamp": {"key": "pilot_stamp", "type": "str"},
         "lines": {"key": "lines", "type": "[LogLine]"},
-        "vo": {"key": "vo", "type": "str"},
     }
 
     def __init__(
-        self,
-        *,
-        pilot_stamp: str,
-        lines: List["_models.LogLine"],
-        vo: str,
-        **kwargs: Any,
+        self, *, pilot_stamp: str, lines: List["_models.LogLine"], **kwargs: Any
     ) -> None:
         """
         :keyword pilot_stamp: Pilot Stamp. Required.
         :paramtype pilot_stamp: str
         :keyword lines: Lines. Required.
         :paramtype lines: list[~_generated.models.LogLine]
-        :keyword vo: Vo. Required.
-        :paramtype vo: str
         """
         super().__init__(**kwargs)
         self.pilot_stamp = pilot_stamp
         self.lines = lines
-        self.vo = vo
 
 
 class Metadata(_serialization.Model):