feat(configurable-logger): logging support in the core library

README.md

@@ -67,10 +67,21 @@ pip install apimatic-core
 | [`ApiResponse`](apimatic_core/http/response/api_response.py)                                | A wrapper class for Api Response                            |
 | [`HttpResponse`](apimatic_core/http/response/http_response.py)                              | A class which contains information about the HTTP Response  |
 
+## Logging Configuration
+| Name                                                                                                 | Description                                                 |
+|------------------------------------------------------------------------------------------------------|-------------------------------------------------------------|
+| [`ApiLoggingConfiguration`](apimatic_core/logger/configuration/api_logging_configuration.py)         | Holds overall logging configuration for logging an API call |
+| [`ApiRequestLoggingConfiguration`](apimatic_core/logger/configuration/api_logging_configuration.py)  | Holds logging configuration for API request                 |
+| [`ApiResponseLoggingConfiguration`](apimatic_core/logger/configuration/api_logging_configuration.py) | Holds logging configuration for API response                |
+
+
 ## Logger
-| Name                                                             | Description                                         |
-|------------------------------------------------------------------|-----------------------------------------------------|
-| [`EndpointLogger`](apimatic_core/logger/endpoint_logger.py)      | A class to provide logging for an HTTP request      |
+| Name                                                      | Description                                                                                                                                                       |
+|-----------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`SdkLogger`](apimatic_core/logger/sdk_logger.py)         | Responsible for logging the request and response of an API call, it represents the default implementation of ApiLogger when there exist any logging configuration |
+| [`NoneSdkLogger`](apimatic_core/logger/sdk_logger.py)     | Represents the default implementation for ApiLogger when no logging configuration is provided                                                                     |
+| [`ConsoleLogger`](apimatic_core/logger/default_logger.py) | Represents the default implementation for Logger when no custom implementation is provided                                                                        |
+| [`LoggerFactory`](apimatic_core/logger/sdk_logger.py)     | Responsible for providing the ApiLogger implementation (`SdkLogger` \| `NoneSdkLogger`) based on the logging configuration                                        |
 
 ## Types
 | Name                                                                          | Description                                                                  |

apimatic_core/__init__.py

@@ -10,5 +10,6 @@
     'factories',
     'types',
     'logger',
-    'exceptions'
+    'exceptions',
+    'constants'
 ]

apimatic_core/api_call.py

@@ -1,26 +1,25 @@
 from apimatic_core.configurations.endpoint_configuration import EndpointConfiguration
 from apimatic_core.configurations.global_configuration import GlobalConfiguration
-from apimatic_core.logger.endpoint_logger import EndpointLogger
+from apimatic_core.logger.sdk_logger import LoggerFactory
 from apimatic_core.response_handler import ResponseHandler
 
 
 class ApiCall:
 
     @property
     def new_builder(self):
-        return ApiCall(self._global_configuration, logger=self._endpoint_logger.logger)
+        return ApiCall(self._global_configuration)
 
     def __init__(
             self,
-            global_configuration=GlobalConfiguration(),
-            logger=None
+            global_configuration=GlobalConfiguration()
     ):
         self._global_configuration = global_configuration
         self._request_builder = None
         self._response_handler = ResponseHandler()
         self._endpoint_configuration = EndpointConfiguration()
-        self._endpoint_logger = EndpointLogger(logger)
-        self._endpoint_name_for_logging = None
+        self._api_logger = LoggerFactory.get_api_logger(self._global_configuration.get_http_client_configuration()
+                                                        .logging_configuration)
 
     def request(self, request_builder):
         self._request_builder = request_builder
@@ -34,52 +33,32 @@ def endpoint_configuration(self, endpoint_configuration):
         self._endpoint_configuration = endpoint_configuration
         return self
 
-    def endpoint_name_for_logging(self, endpoint_name_for_logging):
-        self._endpoint_name_for_logging = endpoint_name_for_logging
-        return self
-
     def execute(self):
-        try:
-            _http_client_configuration = self._global_configuration.get_http_client_configuration()
-
-            if _http_client_configuration.http_client is None:
-                raise ValueError("An HTTP client instance is required to execute an Api call.")
-
-            _http_request = self._request_builder \
-                .endpoint_logger(self._endpoint_logger) \
-                .endpoint_name_for_logging(self._endpoint_name_for_logging) \
-                .build(self._global_configuration)
+        _http_client_configuration = self._global_configuration.get_http_client_configuration()
 
-            _http_callback = _http_client_configuration.http_callback
+        if _http_client_configuration.http_client is None:
+            raise ValueError("An HTTP client instance is required to execute an Api call.")
 
-            self.update_http_callback(_http_callback,
-                                      _http_callback.on_before_request if _http_callback is not None else None,
-                                      _http_request, "Calling the on_before_request method of http_call_back for {}.")
+        _http_request = self._request_builder.build(self._global_configuration)
 
-            self._endpoint_logger.debug("Raw request for {} is: {}".format(
-                self._endpoint_name_for_logging, vars(_http_request)))
+        # Logging the request
+        self._api_logger.log_request(_http_request)
 
-            _http_response = _http_client_configuration.http_client.execute(
-                _http_request, self._endpoint_configuration)
+        _http_callback = _http_client_configuration.http_callback
 
-            self._endpoint_logger.debug("Raw response for {} is: {}".format(
-                self._endpoint_name_for_logging, vars(_http_response)))
+        # Applying the on before sending HTTP request callback
+        if _http_callback is not None:
+            _http_callback.on_before_request(_http_request)
 
-            self.update_http_callback(_http_callback,
-                                      _http_callback.on_after_response if _http_callback is not None else None,
-                                      _http_response, "Calling on_after_response method of http_call_back for {}.")
+        # Executing the HTTP call
+        _http_response = _http_client_configuration.http_client.execute(
+            _http_request, self._endpoint_configuration)
 
-            return self._response_handler.endpoint_logger(self._endpoint_logger) \
-                .endpoint_name_for_logging(self._endpoint_name_for_logging) \
-                .handle(_http_response, self._global_configuration.get_global_errors())
-        except Exception as e:
-            self._endpoint_logger.error(e)
-            raise
+        # Logging the response
+        self._api_logger.log_response(_http_response)
 
-    def update_http_callback(self, http_callback, func, argument, log_message):
-        if http_callback is None:
-            return
+        # Applying the after receiving HTTP response callback
+        if _http_callback is not None:
+            _http_callback.on_after_response(_http_response)
 
-        self._endpoint_logger.info(log_message.format(
-            self._endpoint_name_for_logging))
-        func(argument)
+        return self._response_handler.handle(_http_response, self._global_configuration.get_global_errors())

apimatic_core/constants/__init__.py

@@ -0,0 +1,3 @@
+__all__ = [
+    'logger_constants'
+]

apimatic_core/constants/logger_constants.py

@@ -0,0 +1,44 @@
+
+class LoggerConstants:
+    METHOD = "method"
+    """Key representing the method of the HTTP request."""
+
+    URL = "url"
+    """Key representing the URL of the HTTP request."""
+
+    QUERY_PARAMETER = "query_parameter"
+    """Key representing the query parameters of the HTTP request."""
+
+    HEADERS = "headers"
+    """Key representing the headers of the HTTP request or response."""
+
+    BODY = "body"
+    """Key representing the body of the HTTP request or response."""
+
+    STATUS_CODE = "status_code"
+    """Key representing the status code of the HTTP response."""
+
+    CONTENT_LENGTH = "content_length"
+    """Key representing the content length of the HTTP response."""
+
+    CONTENT_TYPE = "content_type"
+    """Key representing the content type of the HTTP response."""
+
+    CONTENT_LENGTH_HEADER = "content-length"
+    """Key representing the content length header."""
+
+    CONTENT_TYPE_HEADER = "content-type"
+    """Key representing the content type header."""
+
+    NON_SENSITIVE_HEADERS = tuple(map(lambda x: x.lower(), [
+        "Accept", "Accept-Charset", "Accept-Encoding", "Accept-Language",
+        "Access-Control-Allow-Origin", "Cache-Control", "Connection",
+        "Content-Encoding", "Content-Language", "Content-Length", "Content-Location",
+        "Content-MD5", "Content-Range", "Content-Type", "Date", "ETag", "Expect",
+        "Expires", "From", "Host", "If-Match", "If-Modified-Since", "If-None-Match",
+        "If-Range", "If-Unmodified-Since", "Keep-Alive", "Last-Modified", "Location",
+        "Max-Forwards", "Pragma", "Range", "Referer", "Retry-After", "Server",
+        "Trailer", "Transfer-Encoding", "Upgrade", "User-Agent", "Vary", "Via",
+        "Warning", "X-Forwarded-For", "X-Requested-With", "X-Powered-By"
+    ]))
+    """List of sensitive headers that need to be filtered."""

apimatic_core/http/configurations/http_client_configuration.py

@@ -46,13 +46,20 @@ def retry_statuses(self):
     def retry_methods(self):
         return self._retry_methods
 
-    def __init__(
-            self, http_client_instance=None,
-            override_http_client_configuration=False, http_call_back=None,
-            timeout=60, max_retries=0, backoff_factor=2,
-            retry_statuses=[408, 413, 429, 500, 502, 503, 504, 521, 522, 524],
-            retry_methods=['GET', 'PUT']
-    ):
+    @property
+    def logging_configuration(self):
+        return self._logging_configuration
+
+    def __init__(self, http_client_instance=None,
+                 override_http_client_configuration=False, http_call_back=None,
+                 timeout=60, max_retries=0, backoff_factor=2,
+                 retry_statuses=None, retry_methods=None, logging_configuration=None):
+        if retry_statuses is None:
+            retry_statuses = [408, 413, 429, 500, 502, 503, 504, 521, 522, 524]
+
+        if retry_methods is None:
+            retry_methods = ['GET', 'PUT']
+
         self._http_response_factory = HttpResponseFactory()
 
         # The Http Client passed from the sdk user for making requests
@@ -84,5 +91,7 @@ def __init__(
         # The Http Client to use for making requests.
         self._http_client = None
 
+        self._logging_configuration = logging_configuration
+
     def set_http_client(self, http_client):
         self._http_client = http_client

apimatic_core/logger/__init__.py

@@ -1,3 +1,5 @@
 __all__ = [
-    'endpoint_logger'
-]
+    'default_logger',
+    'sdk_logger',
+    'configuration'
+]

apimatic_core/logger/configuration/__init__.py

@@ -0,0 +1,3 @@
+__all__ = [
+    "api_logging_configuration",
+]