Set response content-type application/vnd.spring-boot.actuator.v2+json

Responses sent by Pyctuator should set content-type to
`application/vnd.spring-boot.actuator.v2+json` - the existing mechanism
was invoked *after* requests were intercepted so the content-type was
missing tom "HTTP Traces" in SBA.

Author: michael.yak

pyctuator/httptrace/fastapi_http_tracer.py

@@ -0,0 +1 @@
+SBA_V2_CONTENT_TYPE = "application/vnd.spring-boot.actuator.v2+json;charset=UTF-8"

pyctuator/httptrace/flask_http_tracer.py

@@ -1,19 +1,24 @@
+from collections import defaultdict
+from datetime import datetime
 from http import HTTPStatus
-from typing import Optional, Dict, Callable, Awaitable
+from typing import Mapping, List, Callable
+from typing import Optional, Dict, Awaitable
 
 from fastapi import APIRouter, FastAPI, Header
 from pydantic import BaseModel
+from starlette.datastructures import Headers
 from starlette.requests import Request
 from starlette.responses import Response
 
 from pyctuator.environment.environment_provider import EnvironmentData
 from pyctuator.health.health_provider import HealthSummary
-from pyctuator.httptrace.fastapi_http_tracer import FastApiHttpTracer
+from pyctuator.httptrace import TraceRecord, TraceRequest, TraceResponse
 from pyctuator.httptrace.http_tracer import Traces
-from pyctuator.logging.pyctuator_logging import LoggersData, LoggerLevels
-from pyctuator.metrics.metrics_provider import Metric, MetricNames
+from pyctuator.impl import SBA_V2_CONTENT_TYPE
 from pyctuator.impl.pyctuator_impl import PyctuatorImpl, AppInfo
 from pyctuator.impl.pyctuator_router import PyctuatorRouter, EndpointsData
+from pyctuator.logging.pyctuator_logging import LoggersData, LoggerLevels
+from pyctuator.metrics.metrics_provider import Metric, MetricNames
 from pyctuator.threads.thread_dump_provider import ThreadDump
 
 
@@ -24,6 +29,7 @@ class FastApiLoggerItem(BaseModel):
 # pylint: disable=too-many-locals
 class FastApiPyctuator(PyctuatorRouter):
 
+    # pylint: disable=unused-variable
     def __init__(
             self,
             app: FastAPI,
@@ -32,10 +38,8 @@ def __init__(
     ) -> None:
         super().__init__(app, pyctuator_impl)
         router = APIRouter()
-        self.fastapi_http_tracer = FastApiHttpTracer(pyctuator_impl.http_tracer)
 
         @router.get("/", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
-        # pylint: disable=unused-variable
         def get_endpoints() -> EndpointsData:
             return self.get_endpoints_data()
 
@@ -49,7 +53,6 @@ def get_endpoints() -> EndpointsData:
         @router.options("/logfile", include_in_schema=include_in_openapi_schema)
         @router.options("/trace", include_in_schema=include_in_openapi_schema)
         @router.options("/httptrace", include_in_schema=include_in_openapi_schema)
-        # pylint: disable=unused-variable
         def options() -> None:
             """
             Spring boot admin, after registration, issues multiple OPTIONS request to the monitored application in order
@@ -60,55 +63,45 @@ def options() -> None:
             """
 
         @router.get("/env", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
-        # pylint: disable=unused-variable
         def get_environment() -> EnvironmentData:
             return pyctuator_impl.get_environment()
 
         @router.get("/info", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
-        # pylint: disable=unused-variable
         def get_info() -> AppInfo:
             return pyctuator_impl.app_info
 
         @router.get("/health", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
-        # pylint: disable=unused-variable
         def get_health() -> HealthSummary:
             return pyctuator_impl.get_health()
 
         @router.get("/metrics", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
-        # pylint: disable=unused-variable
         def get_metric_names() -> MetricNames:
             return pyctuator_impl.get_metric_names()
 
         @router.get("/metrics/{metric_name}", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
-        # pylint: disable=unused-variable
         def get_metric_measurement(metric_name: str) -> Metric:
             return pyctuator_impl.get_metric_measurement(metric_name)
 
         # Retrieving All Loggers
         @router.get("/loggers", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
-        # pylint: disable=unused-variable
         def get_loggers() -> LoggersData:
             return pyctuator_impl.logging.get_loggers()
 
         @router.post("/loggers/{logger_name}", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
-        # pylint: disable=unused-variable
         def set_logger_level(item: FastApiLoggerItem, logger_name: str) -> Dict:
             pyctuator_impl.logging.set_logger_level(logger_name, item.configuredLevel)
             return {}
 
         @router.get("/loggers/{logger_name}", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
-        # pylint: disable=unused-variable
         def get_logger(logger_name: str) -> LoggerLevels:
             return pyctuator_impl.logging.get_logger(logger_name)
 
         @router.get("/dump", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
         @router.get("/threaddump", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
-        # pylint: disable=unused-variable
         def get_thread_dump() -> ThreadDump:
             return pyctuator_impl.get_thread_dump()
 
         @router.get("/logfile", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
-        # pylint: disable=unused-variable
         def get_logfile(range_header: str = Header(default=None,
                                                    alias="range")) -> Response:  # pylint: disable=redefined-builtin
             if not range_header:
@@ -129,23 +122,50 @@ def get_logfile(range_header: str = Header(default=None,
 
         @router.get("/trace", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
         @router.get("/httptrace", include_in_schema=include_in_openapi_schema, tags=["pyctuator"])
-        # pylint: disable=unused-variable
         def get_httptrace() -> Traces:
             return pyctuator_impl.http_tracer.get_httptrace()
 
         @app.middleware("http")
-        # pylint: disable=unused-variable
-        async def record_httptrace(
+        async def intercept_requests_and_responses(
                 request: Request,
-                call_next: Callable[[Request], Awaitable[Response]]) -> Response:
-            return await self.fastapi_http_tracer.record_httptrace(request, call_next)
-
-        @app.middleware("http")
-        # pylint: disable=unused-variable
-        async def add_sba2_support(request: Request, call_next: Callable) -> Response:
+                call_next: Callable[[Request], Awaitable[Response]]
+        ) -> Response:
+            request_time = datetime.now()
             response: Response = await call_next(request)
-            if request.url.path.startswith(pyctuator_impl.pyctuator_endpoint_path_prefix):
-                response.headers["Content-Type"] = pyctuator_impl.sba_v2_content_type
+            response_time = datetime.now()
+
+            # Set the SBA-V2 content type for responses from Pyctuator
+            if request.url.path.startswith(self.pyctuator_impl.pyctuator_endpoint_path_prefix):
+                response.headers["Content-Type"] = SBA_V2_CONTENT_TYPE
+
+            # Record the request and response
+            new_record = self._create_record(request, response, request_time, response_time)
+            self.pyctuator_impl.http_tracer.add_record(record=new_record)
+
             return response
 
-        app.include_router(router, prefix=(pyctuator_impl.pyctuator_endpoint_path_prefix))
+        app.include_router(router, prefix=pyctuator_impl.pyctuator_endpoint_path_prefix)
+
+    def _create_headers_dictionary(self, headers: Headers) -> Mapping[str, List[str]]:
+        headers_dict: Mapping[str, List[str]] = defaultdict(list)
+        for (key, value) in headers.items():
+            headers_dict[key].append(value)
+        return headers_dict
+
+    def _create_record(
+            self,
+            request: Request,
+            response: Response,
+            request_time: datetime,
+            response_time: datetime,
+    ) -> TraceRecord:
+        response_delta_time = response_time - request_time
+        new_record: TraceRecord = TraceRecord(
+            request_time,
+            None,
+            None,
+            TraceRequest(request.method, str(request.url), self._create_headers_dictionary(request.headers)),
+            TraceResponse(response.status_code, self._create_headers_dictionary(response.headers)),
+            int(response_delta_time.microseconds / 1000),
+        )
+        return new_record