Merge pull request #21 from donbowman/add-connexion

feat: add support for connexion framework

Author: bobbui

README.md

@@ -126,6 +126,27 @@ if __name__ == "__main__":
     app.run(host='0.0.0.0', port=int(5000), use_reloader=False, loop=loop)
 ```
 
+### Connexion
+
+```python
+import datetime, logging, sys, json_logging, connexion
+
+app = connexion.FlaskApp(__name__)
+json_logging.ENABLE_JSON_LOGGING = True
+json_logging.init(framework_name='connexion', specification_dir='openapi/')
+json_logging.init_request_instrument(app)
+
+app.add_api('api.yaml')
+
+# init the logger as usual
+logger = logging.getLogger("test-logger")
+logger.setLevel(logging.DEBUG)
+logger.addHandler(logging.StreamHandler(sys.stdout))
+
+if __name__ == "__main__":
+    app.run()
+```
+
 ## 2.3 Get current correlation-id
 Current request correlation-id can be retrieved and pass to downstream services call as follow:
 

example/connexion-example/hello.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+
+import connexion
+import json_logging
+
+
+def post_greeting(name: str) -> str:
+    return 'Hello {name}'.format(name=name)
+
+def create()
+    app = connexion.FlaskApp(__name__, port=9090, specification_dir='openapi/')
+    json_logging.ENABLE_JSON_LOGGING = True
+    json_logging.init(framework_name='connexion')
+    json_logging.init_request_instrument(app)
+
+    app.add_api('helloworld-api.yaml', arguments={'title': 'Hello World Example'})
+    return app
+
+if __name__ == '__main__':
+
+    app = create()
+    app.run()

example/connexion-example/openapi/helloworld-api.yaml

@@ -0,0 +1,30 @@
+openapi: "3.0.0"
+
+info:
+  title: Hello World
+  version: "1.0"
+servers:
+  - url: http://localhost:9090/v1.0
+
+paths:
+  /greeting/{name}:
+    post:
+      summary: Generate greeting
+      description: Generates a greeting message.
+      operationId: hello.post_greeting
+      responses:
+        200:
+          description: greeting response
+          content:
+            text/plain:
+              schema:
+                type: string
+                example: "hello dave!"
+      parameters:
+        - name: name
+          in: path
+          description: Name of the person to greet.
+          required: true
+          schema:
+            type: string
+            example: "dave"

json_logging/__init__.py

@@ -344,3 +344,11 @@ def format(self, record):
 register_framework_support('quart', None, quart_support.QuartAppRequestInstrumentationConfigurator,
                         quart_support.QuartRequestAdapter,
                         quart_support.QuartResponseAdapter)
+
+# register connexion support
+# noinspection PyPep8
+import json_logging.framework.connexion as connexion_support
+
+register_framework_support('connexion', None, connexion_support.ConnexionAppRequestInstrumentationConfigurator,
+                        connexion_support.ConnexionRequestAdapter,
+                        connexion_support.ConnexionResponseAdapter)

json_logging/framework/connexion/__init__.py

@@ -0,0 +1,123 @@
+# coding=utf-8
+import logging
+import sys
+
+import json_logging
+import json_logging.framework
+from json_logging import JSONLogWebFormatter
+from json_logging.framework_base import AppRequestInstrumentationConfigurator, RequestAdapter, ResponseAdapter
+
+
+def is_connexion_present():
+    # noinspection PyPep8,PyBroadException
+    try:
+        import connexion
+        return True
+    except:
+        return False
+
+
+if is_connexion_present():
+    from connexion import request as request_obj
+    import connexion as connexion
+    from flask import g
+
+    _current_request = request_obj
+    _connexion = connexion
+    _connexion.g = g
+
+
+class ConnexionAppRequestInstrumentationConfigurator(AppRequestInstrumentationConfigurator):
+    def config(self, app):
+        if not is_connexion_present():
+            raise RuntimeError("connexion is not available in system runtime")
+        from flask.app import Flask
+        if not isinstance(app.app, Flask):
+            raise RuntimeError("app is not a valid connexion.app.Connexion app instance")
+
+        # Disable standard logging
+        logging.getLogger('werkzeug').disabled = True
+
+        json_logging.util.update_formatter_for_loggers([logging.getLogger('werkzeug')], JSONLogWebFormatter)
+
+        # noinspection PyAttributeOutsideInit
+        self.request_logger = logging.getLogger('connexion-request-logger')
+        self.request_logger.setLevel(logging.DEBUG)
+        self.request_logger.addHandler(logging.StreamHandler(sys.stdout))
+
+        from flask import g
+
+        @app.app.before_request
+        def before_request():
+            g.request_info = json_logging.RequestInfo(_current_request)
+
+        @app.app.after_request
+        def after_request(response):
+            request_info = g.request_info
+            request_info.update_response_status(response)
+            # TODO:handle to print out request instrumentation in non-JSON mode
+            self.request_logger.info("", extra={'request_info': request_info})
+            return response
+
+
+class ConnexionRequestAdapter(RequestAdapter):
+    @staticmethod
+    def get_request_class_type():
+        raise NotImplementedError
+
+    @staticmethod
+    def support_global_request_object():
+        return True
+
+    @staticmethod
+    def get_current_request():
+        return _current_request
+
+    def get_remote_user(self, request):
+        if request.authorization is not None:
+            return request.authorization.username
+        else:
+            return json_logging.EMPTY_VALUE
+
+    def is_in_request_context(self, request_):
+        return _connexion.has_request_context()
+
+    def get_http_header(self, request, header_name, default=None):
+        if header_name in request.headers:
+            return request.headers.get(header_name)
+        return default
+
+    def set_correlation_id(self, request_, value):
+        _connexion.g.correlation_id = value
+
+    def get_correlation_id_in_request_context(self, request):
+        return _connexion.g.get('correlation_id', None)
+
+    def get_protocol(self, request):
+        return request.environ.get('SERVER_PROTOCOL')
+
+    def get_path(self, request):
+        return request.path
+
+    def get_content_length(self, request):
+        return request.content_length
+
+    def get_method(self, request):
+        return request.method
+
+    def get_remote_ip(self, request):
+        return request.remote_addr
+
+    def get_remote_port(self, request):
+        return request.environ.get('REMOTE_PORT')
+
+
+class ConnexionResponseAdapter(ResponseAdapter):
+    def get_status_code(self, response):
+        return response.status_code
+
+    def get_response_size(self, response):
+        return response.calculate_content_length()
+
+    def get_content_type(self, response):
+        return response.content_type