global settings;auth add logger; retry add logger

modify retry_condition.py

modify logger infomations

modify lint

Author: wallisyan

aliyun-python-sdk-core/aliyunsdkcore/__init__.py

@@ -1,2 +1,4 @@
 __version__ = "2.12.1"
 
+import logging
+logging.getLogger('aliyunsdkcore').addHandler(logging.NullHandler())

aliyun-python-sdk-core/aliyunsdkcore/auth/signers/access_key_signer.py

@@ -19,14 +19,18 @@
 # specific language governing permissions and limitations
 # under the License.
 
+import logging
 from aliyunsdkcore.auth.signers.signer import Signer
 
+logger = logging.getLogger(__name__)
+
 
 class AccessKeySigner(Signer):
     def __init__(self, access_key_credential):
         self._credential = access_key_credential
 
     def sign(self, region_id, request):
+        logger.debug("Calculating signature using AccessKey.")
         cred = self._credential
         header = request.get_signed_header(region_id, cred.access_key_id, cred.access_key_secret)
         url = request.get_url(region_id, cred.access_key_id, cred.access_key_secret)

aliyun-python-sdk-core/aliyunsdkcore/auth/signers/ecs_ram_role_signer.py

@@ -20,14 +20,14 @@
 # under the License.
 
 import time
-
+import logging
+import json
 
 from aliyunsdkcore.vendored.six.moves.urllib.request import urlopen
-
 from aliyunsdkcore.auth.signers.signer import Signer
 from aliyunsdkcore.acs_exception.exceptions import ServerException
 
-import json
+logger = logging.getLogger(__name__)
 
 
 class EcsRamRoleSigner(Signer):
@@ -39,6 +39,7 @@ def __init__(self, ecs_ram_role_credential):
         self._expiration = 0
 
     def sign(self, region_id, request):
+        logger.debug("Calculating signature using EcsRamRole.")
         self._check_session_credential()
         session_ak, session_sk, token = self._session_credential
         if request.get_style() == 'RPC':

aliyun-python-sdk-core/aliyunsdkcore/auth/signers/ram_role_arn_signer.py

@@ -21,6 +21,7 @@
 
 import time
 import json
+import logging
 
 from aliyunsdkcore.auth.signers.signer import Signer
 from aliyunsdkcore.auth.signers.access_key_signer import AccessKeySigner
@@ -31,6 +32,8 @@
 from aliyunsdkcore.request import CommonRequest
 from aliyunsdkcore.compat import ensure_string
 
+logger = logging.getLogger(__name__)
+
 
 class RamRoleArnSigner(Signer):
     _SESSION_PERIOD = 3600
@@ -47,6 +50,7 @@ def __init__(self, credential, do_action_api):
                 self._credential.session_role_name = "aliyun-python-sdk-" + str(time.time())
 
     def sign(self, region_id, request):
+        logger.debug("Calculating signature using RamRoleArn.")
         self._check_session_credential()
         session_ak, session_sk, token = self._session_credential
         if request.get_style() == 'RPC':

aliyun-python-sdk-core/aliyunsdkcore/auth/signers/rsa_key_pair_signer.py

@@ -11,6 +11,8 @@
 from aliyunsdkcore.request import RpcRequest
 from aliyunsdkcore.auth.algorithm import sha_hmac256
 
+logger = logging.getLogger(__name__)
+
 
 class RsaKeyPairSigner(Signer):
     _MIN_SESSION_PERIOD = 900
@@ -37,6 +39,7 @@ def __init__(self, credential, region_id, debug=False):
         self._session_credential = None
 
     def sign(self, region_id, request):
+        logger.debug("Calculating signature using RsaKeyPair.")
         self._check_session_credential()
         session_ak, session_sk = self._session_credential
         header = request.get_signed_header(region_id, session_ak, session_sk)

aliyun-python-sdk-core/aliyunsdkcore/auth/signers/sts_token_signer.py

@@ -19,14 +19,19 @@
 # specific language governing permissions and limitations
 # under the License.
 
+import logging
+
 from aliyunsdkcore.auth.signers.signer import Signer
 
+logger = logging.getLogger(__name__)
+
 
 class StsTokenSigner(Signer):
     def __init__(self, sts_credential):
         self._credential = sts_credential
 
     def sign(self, region_id, request):
+        logger.debug("Calculating signature using StsToken.")
         sts_cred = self._credential
         if request.get_style() == 'RPC':
             request.add_query_param("SecurityToken", sts_cred.sts_token)

aliyun-python-sdk-core/aliyunsdkcore/client.py

@@ -21,8 +21,10 @@
 import time
 import warnings
 import json
-import aliyunsdkcore
+import logging
 import jmespath
+
+import aliyunsdkcore
 from aliyunsdkcore.vendored.six.moves.urllib.parse import urlencode
 from aliyunsdkcore.vendored.requests import codes
 
@@ -53,8 +55,11 @@
 # TODO: replace it with TimeoutHandler
 _api_timeout_config_data = aliyunsdkcore.utils._load_json_from_data_dir("timeout_config.json")
 
+logger = logging.getLogger(__name__)
+
 
 class AcsClient:
+    LOG_FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
 
     def __init__(
             self,
@@ -253,7 +258,6 @@ def _handle_retry_and_timeout(self, endpoint, request, signer):
 
         request_timeout = self._get_request_timeout(request)
 
-        retryable = RetryCondition.SHOULD_RETRY
         retries = 0
 
         while True:
@@ -266,8 +270,10 @@ def _handle_retry_and_timeout(self, endpoint, request, signer):
             retryable = self._retry_policy.should_retry(retry_policy_context)
             if retryable & RetryCondition.NO_RETRY:
                 break
+            logger.debug("Retry needed, request is: %s", request.get_action_name())
             retry_policy_context.retryable = retryable
             time_to_sleep = self._retry_policy.compute_delay_before_next_retry(retry_policy_context)
+            logger.debug('Retry %s times', retries)
             time.sleep(time_to_sleep / 1000.0)
             retries += 1
 
@@ -278,20 +284,18 @@ def _handle_retry_and_timeout(self, endpoint, request, signer):
 
     def _handle_single_request(self, endpoint, request, timeout, signer):
         http_response = self._make_http_response(endpoint, request, timeout, signer)
-
-        exception = None
+        params = request.get_query_params()
+        params.pop('AccessKeyId', None)
+        logger.debug('The request params are %s', str(params))
 
         # Do the actual network thing
         try:
             status, headers, body = http_response.get_response_object()
         except IOError as e:
             error_message = str(e)
             error_message += "\nEndpoint: " + endpoint
-            error_message += "\nProduct: " + str(request.get_product())
-            error_message += "\nSdkCoreVersion: " + aliyunsdkcore.__version__
-            error_message += "\nHttpUrl: " + str(http_response.get_url())
-            error_message += "\nHttpHeaders: " + \
-                str(http_response.get_headers())
+            logger.error('Catch a HttpError when connect to %s, current sdk version is %s',
+                         endpoint, aliyunsdkcore.__version__, exc_info=True)
 
             exception = ClientException(error_code.SDK_HTTP_ERROR, error_message)
             return None, None, None, exception
@@ -312,7 +316,7 @@ def _parse_error_info_from_response_body(response_body):
                 error_message_to_return = body_obj['Message']
         except ValueError:
             # failed to parse body as json format
-            pass
+            logger.warning('failed to parse response body as json format')
 
         return error_code_to_return, error_message_to_return
 
@@ -325,7 +329,7 @@ def _get_server_exception(self, http_status, response_body):
         except (ValueError, TypeError, AttributeError):
             # in case the response body is not a json string, return the raw
             # data instead
-            pass
+            logger.warning('failed to parse response body as json format')
 
         if http_status < codes.OK or http_status >= codes.MULTIPLE_CHOICES:
 
@@ -372,3 +376,25 @@ def get_response(self, acs_request):
     def add_endpoint(self, region_id, product_code, endpoint):
         self._endpoint_resolver.put_endpoint_entry(
             region_id, product_code, endpoint)
+
+    def set_stream_logger(self, log_level=logging.INFO, logger_name='aliyunsdkcore', stream=None,
+                          format_string=None):
+        log = logging.getLogger(logger_name)
+        log.setLevel(log_level)
+        ch = logging.StreamHandler(stream)
+        ch.setLevel(log_level)
+        if format_string is None:
+            format_string = self.LOG_FORMAT
+        formatter = logging.Formatter(format_string)
+        ch.setFormatter(formatter)
+        log.addHandler(ch)
+
+    def set_file_logger(self, path, log_level=logging.INFO, logger_name='aliyunsdkcore'):
+        log = logging.getLogger(logger_name)
+        log.setLevel(log_level)
+        fh = logging.FileHandler(path)
+        fh.setLevel(log_level)
+        formatter = logging.Formatter(self.LOG_FORMAT)
+        fh.setFormatter(formatter)
+        log.addHandler(fh)
+

aliyun-python-sdk-core/aliyunsdkcore/retry/retry_condition.py

@@ -13,12 +13,15 @@
 # limitations under the License.
 
 import jmespath
+import logging
 
 import aliyunsdkcore.utils
 import aliyunsdkcore.utils.validation as validation
 from aliyunsdkcore.acs_exception.exceptions import ClientException, ServerException
 import aliyunsdkcore.acs_exception.error_code as error_code
 
+logger = logging.getLogger(__name__)
+
 
 def _find_data_in_retry_config(key_name, request, retry_config):
     if request.get_product() is None:
@@ -55,9 +58,12 @@ def __init__(self, max_retry_times):
         self.max_retry_times = max_retry_times
 
     def should_retry(self, retry_policy_context):
+
         if retry_policy_context.retries_attempted < self.max_retry_times:
             return RetryCondition.SHOULD_RETRY
         else:
+            logger.debug("Reached the maximum number of retry "
+                         "attempts: %s", retry_policy_context.retries_attempted)
             return RetryCondition.NO_RETRY
 
 
@@ -72,6 +78,8 @@ def should_retry(self, retry_policy_context):
 
         if isinstance(exception, ClientException):
             if exception.get_error_code() == error_code.SDK_HTTP_ERROR:
+                logger.debug("Retry needed, retryable ClientException caught: %s",
+                             exception, exc_info=True)
                 return RetryCondition.SHOULD_RETRY
 
         if isinstance(exception, ServerException):
@@ -80,14 +88,18 @@ def should_retry(self, retry_policy_context):
                                                        request,
                                                        self.retry_config)
             if isinstance(normal_errors, list) and error_code_ in normal_errors:
+                logger.debug("Retry needed, retryable ServerException caught: %s",
+                             exception, exc_info=True)
                 return RetryCondition.SHOULD_RETRY
 
             throttling_errors = _find_data_in_retry_config("RetryableThrottlingErrors",
                                                            request,
                                                            self.retry_config)
             if isinstance(throttling_errors, list) and error_code_ in throttling_errors:
+                logger.debug("Retry needed, retryable ThrottlingError caught: %s",
+                             exception, exc_info=True)
                 return RetryCondition.SHOULD_RETRY | \
-                       RetryCondition.SHOULD_RETRY_WITH_THROTTLING_BACKOFF
+                    RetryCondition.SHOULD_RETRY_WITH_THROTTLING_BACKOFF
 
         return RetryCondition.NO_RETRY
 
@@ -106,6 +118,9 @@ def __init__(self, retryable_http_status_list=None):
 
     def should_retry(self, retry_policy_context):
         if retry_policy_context.http_status_code in self.retryable_http_status_list:
+            logger.debug(
+                "Retry needed: retryable HTTP status code received: %s",
+                retry_policy_context.http_status_code)
             return RetryCondition.SHOULD_RETRY
         else:
             return RetryCondition.NO_RETRY

python-sdk-functional-test/credentials_test.py

@@ -78,7 +78,7 @@ def test_call_roa_request_with_sts_token(self):
     def test_ecs_ram_role(self):
         # push ecs
         from aliyunsdkcore.auth.credentials import EcsRamRoleCredential
-        ecs_ram_role_credential = EcsRamRoleCredential("TestRole")
+        ecs_ram_role_credential = EcsRamRoleCredential("EcsRamRoleTest")
         acs_client = AcsClient(region_id="cn-hangzhou", credential=ecs_ram_role_credential)
         request = DescribeRegionsRequest()
         response = acs_client.do_action_with_exception(request)

python-sdk-functional-test/error_handle_test.py

@@ -36,10 +36,6 @@ def test_server_timeout(self):
             self.assertEqual("SDK.HttpError", e.error_code)
             head_message, attributes = self._parse_complex_error_message(e.get_error_msg())
             self.assertEqual("ecs-cn-hangzhou.aliyuncs.com", attributes.get("Endpoint"))
-            self.assertEqual("Ecs", attributes.get("Product"))
-            self.assertTrue("SdkCoreVersion" in attributes)
-            self.assertTrue("HttpUrl" in attributes)
-            self.assertTrue("HttpHeaders" in attributes)
 
     def test_server_unreachable(self):
         from aliyunsdkcore.request import CommonRequest
@@ -52,10 +48,6 @@ def test_server_unreachable(self):
             self.assertEqual("SDK.HttpError", e.error_code)
             head_message, attributes = self._parse_complex_error_message(e.get_error_msg())
             self.assertEqual("www.aliyun-hangzhou.com", attributes.get("Endpoint"))
-            self.assertEqual("None", attributes.get("Product"))
-            self.assertTrue("SdkCoreVersion" in attributes)
-            self.assertTrue("HttpUrl" in attributes)
-            self.assertTrue("HttpHeaders" in attributes)
 
     def test_server_error_normal(self):
         from aliyunsdkecs.request.v20140526.DeleteInstanceRequest import DeleteInstanceRequest