FastAPI backend including tests

Author: chr1st1ank

example/fastapi_sample_app.py

@@ -0,0 +1,55 @@
+import logging
+
+import fastapi
+
+import json_logging
+
+app = fastapi.FastAPI()
+
+# init the logger as usual
+logger = logging.getLogger(__name__)
+
+@app.get('/')
+async def home():
+    logger.info("test log statement")
+    logger.info("test log statement with extra props", extra={'props': {"extra_property": 'extra_value'}})
+    correlation_id = json_logging.get_correlation_id()
+    return "hello world" \
+           "\ncorrelation_id                    : " + correlation_id
+
+
+@app.get('/exception')
+def exception():
+    try:
+        raise RuntimeError
+    except BaseException as e:
+        logger.error("Error occurred", exc_info=e)
+        logger.exception("Error occurred", exc_info=e)
+    return "Error occurred, check log for detail"
+
+
+@app.get('/exclude_from_request_instrumentation')
+def exclude_from_request_instrumentation():
+    return "this request wont log request instrumentation information"
+
+
+if __name__ == "__main__":
+    import uvicorn
+    logging_config = {
+        'version': 1,
+        'disable_existing_loggers': False,
+        'handlers': {
+            'default_handler': {
+                'class': 'logging.StreamHandler',
+                'level': 'DEBUG',
+            },
+        },
+        'loggers': {
+            '': {
+                'handlers': ['default_handler'],
+            }
+        }
+    }
+    json_logging.init_fastapi(enable_json=True)
+    json_logging.init_request_instrument(app, exclude_url_patterns=[r'^/exclude_from_request_instrumentation'])
+    uvicorn.run(app, host='0.0.0.0', port=5000, log_level="debug", log_config=logging_config)

json_logging/__init__.py

@@ -395,3 +395,15 @@ def init_quart(custom_formatter=None, enable_json=False):
 
 def init_connexion(custom_formatter=None, enable_json=False):
     __init(framework_name='connexion', custom_formatter=custom_formatter, enable_json=enable_json)
+
+
+# register FastAPI support
+import json_logging.framework.fastapi as fastapi_support
+
+register_framework_support('fastapi', app_configurator=None,
+                           app_request_instrumentation_configurator=fastapi_support.FastAPIAppRequestInstrumentationConfigurator,
+                           request_adapter_class=fastapi_support.FastAPIRequestAdapter,
+                           response_adapter_class=fastapi_support.FastAPIResponseAdapter)
+
+def init_fastapi(custom_formatter=None, enable_json=False):
+    __init(framework_name='fastapi', custom_formatter=custom_formatter, enable_json=enable_json)

json_logging/framework/fastapi/__init__.py

@@ -0,0 +1,137 @@
+# coding=utf-8
+import logging
+
+from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+from starlette.requests import Request
+from starlette.responses import Response
+from starlette.types import ASGIApp
+
+import json_logging
+import json_logging.framework
+from json_logging.framework_base import AppRequestInstrumentationConfigurator, RequestAdapter, ResponseAdapter
+
+from json_logging.util import is_not_match_any_pattern
+
+
+def is_fastapi_present():
+    # noinspection PyPep8,PyBroadException
+    try:
+        import fastapi
+        import starlette
+        return True
+    except:
+        return False
+
+
+if is_fastapi_present():
+    import fastapi
+    import starlette.requests
+    import starlette.responses
+
+
+class JSONLoggingASGIMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app: ASGIApp, exclude_url_patterns=tuple()) -> None:
+        super().__init__(app)
+        self.request_logger = logging.getLogger('fastapi-request-logger')
+        self.exclude_url_patterns = exclude_url_patterns
+        logging.getLogger("uvicorn.access").propagate = False
+
+    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
+        log_request = is_not_match_any_pattern(request.url.path, self.exclude_url_patterns)
+
+        if not log_request:
+            return await call_next(request)
+
+        request_info = json_logging.RequestInfo(request)
+        response = await call_next(request)
+        request_info.update_response_status(response)
+        self.request_logger.info(
+            "", extra={"request_info": request_info, "type": "request"}
+        )
+        return response
+
+
+class FastAPIAppRequestInstrumentationConfigurator(AppRequestInstrumentationConfigurator):
+    def config(self, app, exclude_url_patterns=tuple()):
+        if not is_fastapi_present():
+            raise RuntimeError("fastapi is not available in system runtime")
+        if not isinstance(app, fastapi.FastAPI):
+            raise RuntimeError("app is not a valid fastapi.FastAPI instance")
+
+        # Disable standard logging
+        logging.getLogger('uvicorn.access').disabled = True
+
+        # noinspection PyAttributeOutsideInit
+        self.request_logger = logging.getLogger('fastapi-request-logger')
+
+        app.add_middleware(JSONLoggingASGIMiddleware, exclude_url_patterns=exclude_url_patterns)
+
+
+class FastAPIRequestAdapter(RequestAdapter):
+    @staticmethod
+    def get_request_class_type():
+        return starlette.requests.Request
+
+    @staticmethod
+    def support_global_request_object():
+        return False
+
+    @staticmethod
+    def get_current_request():
+        raise NotImplementedError
+
+    def get_remote_user(self, request: starlette.requests.Request):
+        try:
+            return request.user
+        except AssertionError:
+            return json_logging.EMPTY_VALUE
+
+    def get_http_header(self, request: starlette.requests.Request, header_name, default=None):
+        try:
+            if header_name in request.headers:
+                return request.headers.get(header_name)
+        except:
+            pass
+        return default
+
+    def set_correlation_id(self, request_, value):
+        request_.state.correlation_id = value
+
+    def get_correlation_id_in_request_context(self, request: starlette.requests.Request):
+        try:
+            return request.state.correlation_id
+        except AttributeError:
+            return None
+
+    def get_protocol(self, request: starlette.requests.Request):
+        protocol = str(request.scope.get('type', ''))
+        http_version = str(request.scope.get('http_version', ''))
+        if protocol.lower() == 'http' and http_version:
+            return protocol.upper() + "/" + http_version
+        return json_logging.EMPTY_VALUE
+
+    def get_path(self, request: starlette.requests.Request):
+        return request.url.path
+
+    def get_content_length(self, request: starlette.requests.Request):
+        return request.headers.get('content-length', json_logging.EMPTY_VALUE)
+
+    def get_method(self, request: starlette.requests.Request):
+        return request.method
+
+    def get_remote_ip(self, request: starlette.requests.Request):
+        return request.client.host
+
+    def get_remote_port(self, request: starlette.requests.Request):
+        return request.client.port
+
+
+class FastAPIResponseAdapter(ResponseAdapter):
+    def get_status_code(self, response: starlette.responses.Response):
+        return response.status_code
+
+    def get_response_size(self, response: starlette.responses.Response):
+        return response.headers.get('content-length', json_logging.EMPTY_VALUE)
+
+    def get_content_type(self, response: starlette.responses.Response):
+        return response.headers.get('content-type', json_logging.EMPTY_VALUE)

test-requirements.txt

@@ -3,6 +3,9 @@ flask
 connexion[swagger-ui]
 quart
 sanic
+fastapi
+uvicorn
+requests
 flake8
 pytest
 -e .