added more tests to the event code, and fixed couple bugs

Author: DinisCruz

osbot_fast_api/api/Fast_API.py

@@ -155,11 +155,11 @@ def routes_paths_all(self):
         return self.routes_paths(include_default=True, expand_mounts=True)
 
 
-    def setup_middlewares(self):                 # overwrite to add more middlewares
-        self.setup_middleware__request_id       ()                                      # sets the 'fast-api-request-id' headers
+    def setup_middlewares(self):                 # overwrite to add more middlewares    (NOTE: the middleware execution is the reverse of the order they are added)
         self.setup_middleware__detect_disconnect()
         self.setup_middleware__cors             ()
         self.setup_middleware__api_key_check    ()
+        self.setup_middleware__request_id       ()                                      # sets the 'fast-api-request-id' headers
         return self
 
     def setup_routes     (self): return self     # overwrite to add rules

osbot_fast_api/api/events/Fast_API__Http_Event.py

@@ -26,7 +26,7 @@ class Fast_API__Http_Event(Type_Safe):
     http_event_request      : Fast_API__Http_Event__Request
     http_event_response     : Fast_API__Http_Event__Response
     http_event_traces       : Fast_API__Http_Event__Traces
-    event_id                : Random_Guid                           # todo: rename to http_event_id
+    event_id                : Random_Guid                                  # todo: rename to http_event_id
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -60,7 +60,6 @@ def messages(self):
         return messages
 
     def on_request(self, request: Request):
-
         # http_event_request
         self.http_event_request.headers      = dict(request.headers)
         self.http_event_request.host_name    = request.url.hostname
@@ -77,8 +76,6 @@ def on_request(self, request: Request):
         self.http_event_info.timestamp       = timestamp_utc_now()
         self.http_event_info.thread_id       = current_thread_id()
 
-        self.set_request_headers(request)
-
     def on_response(self, response: Response):
         # http_event_response
         self.http_event_response.end_time   = Decimal(time.time())
@@ -88,19 +85,12 @@ def on_response(self, response: Response):
         self.http_event_request.duration    = self.http_event_request.duration   .quantize(Decimal('0.001'))            #       (maybe a custom Decimal class)
 
         if response:
+            self.set_response_header_for_static_files_cache(response)
             self.http_event_response.content_type   = response.headers.get('content-type')
             self.http_event_response.content_length = response.headers.get('content-length')
             self.http_event_response.status_code    = response.status_code
-            self.set_response_headers(response)
             self.http_event_response.headers        = dict(response.headers)
 
-    def set_request_headers(self, request: Request):
-        request.headers._list.append((b'fast-api-request-id', str_to_bytes(self.event_id)))
-
-    def set_response_headers(self, response:Response):
-        response.headers[HEADER_NAME__FAST_API_REQUEST_ID] = self.event_id
-        self.set_response_header_for_static_files_cache(response)
-        return self
 
     def set_response_header_for_static_files_cache(self, response:Response):
         if self.http_event_response.content_type in HTTP_RESPONSE__CACHE_CONTENT_TYPES:

osbot_fast_api/api/events/Fast_API__Http_Events.py

@@ -1,17 +1,18 @@
 import types
 from collections                                    import deque
-from osbot_utils.type_safe.Type_Safe                import Type_Safe
-from osbot_utils.helpers.trace.Trace_Call__Config   import Trace_Call__Config
+from osbot_utils.type_safe.primitives.domains.identifiers.Random_Guid import Random_Guid
+from osbot_utils.type_safe.Type_Safe                                  import Type_Safe
+from osbot_utils.helpers.trace.Trace_Call__Config                     import Trace_Call__Config
 
 
 HTTP_EVENTS__MAX_REQUESTS_LOGGED = 50
 
 from typing import TYPE_CHECKING, Union
 
-if TYPE_CHECKING:
-    from fastapi                                    import Request
-    from starlette.responses                        import Response
-    from osbot_fast_api.api.events.Fast_API__Http_Event    import Fast_API__Http_Event
+# if TYPE_CHECKING:
+#     from fastapi                                    import Request
+#     from starlette.responses                        import Response
+from osbot_fast_api.api.events.Fast_API__Http_Event    import Fast_API__Http_Event
 
 class Fast_API__Http_Events(Type_Safe):
     #log_requests          : bool = False                           # todo: change this to save on S3 and disk
@@ -25,7 +26,6 @@ class Fast_API__Http_Events(Type_Safe):
     requests_order        : deque
     max_requests_logged   : int = HTTP_EVENTS__MAX_REQUESTS_LOGGED
     fast_api_name         : str
-    #add_header_request_id : bool = True
 
     def __init__(self,**kwargs):
         super().__init__(**kwargs)
@@ -75,9 +75,14 @@ def create_request_data(self, request):
         from osbot_fast_api.api.events.Fast_API__Http_Event       import Fast_API__Http_Event
         from osbot_fast_api.api.events.Fast_API__Http_Event__Info import Fast_API__Http_Event__Info
 
+        if hasattr(request.state, 'request_id'):                            # Use existing request_id if available (from Middleware__Request_ID)
+            event_id = request.state.request_id
+        else:
+            event_id = Random_Guid()                                        # Fallback if middleware not present
+
         kwargs                         = dict(fast_api_name = self.fast_api_name)
         http_event_info                = Fast_API__Http_Event__Info(**kwargs)
-        http_event                     = Fast_API__Http_Event(http_event_info=http_event_info)
+        http_event                     = Fast_API__Http_Event(http_event_info=http_event_info, event_id=event_id)
         event_id                       = http_event.event_id                # get the random request_id/guid that was created in the ctor of Fast_API__Request_Data
         request.state.http_events      = self                               # store a copy of this object in the request (so that it is available durant the request handling)
         request.state.request_id       = event_id                           # store request_id in request.state
@@ -103,8 +108,13 @@ def event_id(self, request):
         return self.request_data(request).event_id
 
     def request_messages(self, request):
-        event_id = self.event_id(request)
-        return self.requests_data.get(event_id, {}).get('messages', [])
+        event_id   = self.event_id(request)
+        http_event = self.requests_data.get(event_id)#.get('messages', [])
+        if type(http_event) is Fast_API__Http_Event:
+            return http_event.messages()
+        if type(http_event) is dict:
+            return http_event.get('messages', [])
+        return []
 
     def request_trace_start(self, request):
         from osbot_utils.helpers.trace.Trace_Call import Trace_Call

osbot_fast_api/events/Fast_API__With_Events.py

@@ -9,9 +9,10 @@ def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.http_events.fast_api_name = self.config.name                     # Wire up the name
 
-    def setup_middlewares(self):                                              # Add event middleware
+    def setup_middlewares(self):                                              # Add event middleware    (NOTE: the middleware execution is the reverse of the order they are added)
+        self.setup_middleware__http_events()                                  # This will make this middleware to be the last one executed
         super().setup_middlewares()                                           # Call parent middlewares first
-        self.setup_middleware__http_events()                                  # Then add events
+
         return self
 
     def setup_middleware__http_events(self):                                  # Moved from base class

tests/unit/api/events/test_Fast_API__Http_Events.py

@@ -107,10 +107,10 @@ def test_on_http_response(self):
             #assert _.log_requests  is False
             assert _.requests_data == {self.event_id : self.request_data}
 
-            assert self.response.headers == MutableHeaders({'content-length': '0', 'fast-api-request-id': self.event_id})
-
+            #assert self.response.headers == MutableHeaders({'content-length': '0', 'fast-api-request-id': self.event_id})  # this is now set on Middleware__Request_ID
 
 
+            duration     =  self.request_data.http_event_request.duration
             expected_data = { 'http_event_info'         : { 'client_city'     : None                                            ,
                                                             'client_country'  : None                                            ,
                                                             'client_ip'       : 'pytest'                                        ,
@@ -121,7 +121,7 @@ def test_on_http_response(self):
                                                             'thread_id'       : self.request_data.http_event_info.thread_id     ,
                                                             'timestamp'       : self.request_data.http_event_info.timestamp     ,
                                                             'log_messages'    : []                                              },
-                              'http_event_request'       : { 'duration'       : Decimal('0.001')                                ,
+                              'http_event_request'       : { 'duration'       : duration                                        ,
                                                              'host_name'      : None                                            ,
                                                              'headers'        : {}                                              ,
                                                              'event_id'        : self.request_data.event_id                     ,
@@ -143,7 +143,7 @@ def test_on_http_response(self):
                                                              'traces_count'   : 0                                                 ,
                                                              'traces_id'      : self.request_data.http_event_traces.traces_id     }}
 
-            assert self.request_data.http_event_request.duration == Decimal(0.001).quantize(Decimal('0.001'))
+            assert self.request_data.http_event_request.duration >= Decimal(0.001).quantize(Decimal('0.001'))
             assert self.request_data.json()                      == expected_data
 
 

tests/unit/api/test_Fast_API.py

@@ -103,8 +103,8 @@ def test_setup_routes(self):
         assert self.fast_api.setup_routes() == self.fast_api
 
     def test_user_middleware(self):
-        assert self.fast_api.user_middlewares() == [{'function_name': None, 'params': {}, 'type': 'Middleware__Detect_Disconnect'},
-                                                    {'function_name': None, 'params': {}, 'type': 'Middleware__Request_ID'       }]
+        assert self.fast_api.user_middlewares() == [{'function_name': None, 'params': {}, 'type': 'Middleware__Request_ID'       },
+                                                    {'function_name': None, 'params': {}, 'type': 'Middleware__Detect_Disconnect'}]
 
     def test__verify__title_description_version(self):
         app = self.fast_api.app()