Merge pull request #137 from avadev/AS-147

PR : AS-147 : Added logging to Python V2 SDK

Author: svc-developer

src/avalara/ava_logger.py

@@ -0,0 +1,89 @@
+import functools
+import logging
+import json
+import time
+
+import requests
+
+from . import client
+
+
+
+def ava_log(func):
+    """
+    Function decorator for implementation of logging
+    @param func: function where logging needs to be implemented
+    @return: function
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        logger = logging.getLogger()
+        is_log_req_resp_allowed = False
+        ava_log_entry = {}
+        is_error_log = False
+
+        # Logic :
+        # 1) Check if decorator is called for function in AvaTaxClient class
+        # 2) If logger is set then use it else use new instance of logger (this property is useful when SDK consumer
+        #    wants to use specific configuration)
+        # 3) Execute actual method and create log entry in case of http response only
+        # 4) In case of exception though log error
+        execution_start_time = time.perf_counter()
+        try:
+            if isinstance(args[0], client.AvataxClient):
+                if hasattr(args[0], "logger") and (args[0].__getattribute__("logger") is not None):
+                    logger = args[0].__getattribute__("logger")
+                if hasattr(args[0], "is_log_req_resp_allowed"):
+                    is_log_req_resp_allowed = args[0].__getattribute__("is_log_req_resp_allowed")
+            result = func(*args, **kwargs)
+            if result is not None and isinstance(result, requests.models.Response):
+                ava_log_entry = get_ava_log_entry(result, is_log_req_resp_allowed)
+            return result
+        except Exception as e:
+            is_error_log = True
+            ava_log_entry["error"] = str(e)
+            raise e
+        finally:
+            total_execution_time = time.perf_counter() - execution_start_time
+            if ava_log_entry["execution_time"] is None:
+                ava_log_entry["execution_time"] = total_execution_time * 1000
+            json_data = json.dumps(ava_log_entry, indent=4)
+            if is_error_log:
+                logger.error(json_data)
+            else:
+                logger.info(json_data)
+
+    return wrapper
+
+
+def get_ava_log_entry(result: requests.Response, is_log_req_resp_allowed: bool) -> dict:
+    log_entry = {}
+    log_entry["execution_time"] = result.elapsed.total_seconds() * 1000
+    log_entry["x-correlation-id"] = result.headers["x-correlation-id"]
+    log_entry["status_code"] = result.status_code
+    log_entry["request_url"] = result.url
+    log_entry["method"] = result.request.method
+    if is_log_req_resp_allowed:
+        log_entry["request"] = str(result.request.body)
+        log_entry["response"] = result.text
+
+    return log_entry
+
+
+def decorate_all_methods(decorator, exclude=["__init__", "add_credentials"]):
+    """
+    Decorator to be applied at class level. This decorator decorates all methods in class with
+    supplied decorator in parameter.
+    @param decorator: decorator to be applied to all methods in class
+    @param exclude: list of methods to exclude from being decorated.
+    @return: class with decorated methods
+    """
+
+    def decorate(cls):
+        for attr in cls.__dict__:
+            if callable(getattr(cls, attr)) and attr not in exclude:
+                setattr(cls, attr, decorator(getattr(cls, attr)))
+        return cls
+
+    return decorate

src/avalara/client.py

@@ -24,17 +24,26 @@
 @version    TBD
 @link       https://github.com/avadev/AvaTax-REST-V2-Python-SDK
 """
+import  logging
 from requests.auth import HTTPBasicAuth
-from ._str_version import str_type
+
 from . import client_methods
-import os
+from ._str_version import str_type
 
 
 class AvataxClient(client_methods.Mixin):
     """Class for our Avatax client."""
 
-    def __init__(self, app_name=None, app_version=None, machine_name=None,
-                 environment=None, timeout_limit=None):
+    def __init__(
+            self,
+            app_name=None,
+            app_version=None,
+            machine_name=None,
+            environment=None,
+            timeout_limit=None,
+            is_log_req_resp_allowed=False,
+            logger=None
+    ):
         """
         Initialize the sandbox client.
 
@@ -47,11 +56,13 @@ def __init__(self, app_name=None, app_version=None, machine_name=None,
             :param  string  environment: Default environment is production,
                 input sandbox, for the sandbox API
             :param  int/float The timeout limit for every call made by this client instance. (default: 10 sec)
+            :param  bool is_log_req_resp_allowed: is logging request and response is allowed (default: False)
         :return: object
         """
-        if not all(isinstance(i, str_type) for i in [app_name,
-                                                     machine_name,
-                                                     environment]):
+        if not all(
+                isinstance(i, str_type)
+                for i in [app_name, machine_name, environment]
+        ):
             raise ValueError('Input(s) must be string or none type object')
         self.base_url = 'https://rest.avatax.com'
         if environment:
@@ -63,11 +74,15 @@ def __init__(self, app_name=None, app_version=None, machine_name=None,
         self.app_name = app_name
         self.app_version = app_version
         self.machine_name = machine_name
-        self.client_id = '{}; {}; Python SDK; API_VERSION; {};'.format(app_name,
-                                                                app_version,
-                                                                machine_name)
+        self.client_id = '{}; {}; Python SDK; API_VERSION; {};'.format(
+            app_name, app_version, machine_name
+        )
         self.client_header = {'X-Avalara-Client': self.client_id}
-        self.timeout_limit = timeout_limit 
+        self.timeout_limit = timeout_limit
+        self.is_log_req_resp_allowed = is_log_req_resp_allowed
+        self.logger = logger
+        # if self.logger is set, logging is done using supplied logger configuration
+
 
     def add_credentials(self, username=None, password=None):
         """