volcengine-python-sdk 4.0.20__py2.py3-none-any.whl → 4.0.22__py2.py3-none-any.whl

volcenginesdkcore/auth/providers/sts_saml_provider.py

@@ -0,0 +1,100 @@
+import threading
+import time
+import uuid
+from datetime import datetime
+
+import dateutil.parser
+
+from volcenginesdkcore import UniversalApi, UniversalInfo, ApiClient, Configuration
+from .provider import Provider, CredentialValue
+import json
+
+
+class AssumeRoleSamlCredentials:
+    def __init__(self, ak, sk, session_token, current_time, expired_time):
+        self.ak = ak
+        self.sk = sk
+        self.session_token = session_token
+        self.current_time = current_time
+        self.expired_time = expired_time
+
+
+class StsSamlCredentialProvider(Provider):
+    def __init__(self, role_name, account_id, provider_name, saml_resp, duration_seconds=3600, scheme='https',
+                 host='sts.volcengineapi.com', region='cn-beijing', timeout=30, expired_buffer_seconds=60, policy=None):
+        # self.ak = ak
+        # self.sk = sk
+        self.role_name = role_name
+        self.account_id = account_id
+        self.provider_name = provider_name
+        self.saml_resp = saml_resp
+
+        self.timeout = timeout
+        self.duration_seconds = duration_seconds
+
+        self.host = host
+        self.region = region
+        self.scheme = scheme
+        self.policy = policy
+        self.expired_time = None
+        if expired_buffer_seconds > 600:
+            raise ValueError('expired_buffer_seconds must be less than or equal to 600')
+        self.expired_buffer_seconds = expired_buffer_seconds
+
+        self.credentials = None
+
+        self._lock = threading.Lock()
+
+    def retrieve(self):
+        return self.credentials
+
+    def is_expired(self):
+        return (self.credentials is None or
+                (self.expired_time and self.expired_time < time.time() + self.expired_buffer_seconds))
+
+    def refresh(self):
+        with self._lock:
+            if self.is_expired():
+                self._assume_role_saml()
+
+    def get_credentials(self):
+        self.refresh()
+        return self.credentials
+
+    def _assume_role_saml(self):
+        params = {
+            'DurationSeconds': self.duration_seconds,
+            'RoleSessionName': uuid.uuid4().hex,
+            'RoleTrn': 'trn:iam::' + self.account_id + ':role/' + self.role_name,
+            'SAMLProviderTrn': 'trn:iam::' + self.account_id + ':saml-provider/' + self.provider_name,
+            'SAMLResp': self.saml_resp,
+        }
+        if self.policy is not None:
+            params['Policy'] = self.policy
+        configuration = type.__call__(Configuration)
+
+        # configuration.ak = self.ak
+        # configuration.sk = self.sk
+        configuration.host = self.host
+        configuration.region = self.region
+        configuration.scheme = self.scheme
+        configuration.read_timeout = self.timeout
+        c = UniversalApi(ApiClient(configuration))
+        info = UniversalInfo(method='POST', service='sts', version='2018-01-01', action='AssumeRoleWithSAML',
+                             content_type='application/x-www-form-urlencoded')
+
+        resp, status_code, resp_header = c.do_call_with_http_info(info=info, body=params)
+        if 'Credentials' not in resp:
+            raise RuntimeError('failed to retrieve credentials from sts' + str(resp_header))
+        resp_cred = resp['Credentials']
+
+        # Parse the ISO string
+        dt = dateutil.parser.parse(resp_cred['Expiration'])
+
+        # Convert to timestamp (seconds since epoch)
+        self.expired_time = (dt - datetime(1970, 1, 1, tzinfo=dateutil.tz.tzutc())).total_seconds()
+
+        self.credentials = CredentialValue(ak=resp_cred['AccessKeyId'],
+                                           sk=resp_cred['SecretAccessKey'],
+                                           session_token=resp_cred['SessionToken'],
+                                           provider_name='StsSamlCredentialProvider')

volcenginesdkcore/configuration.py

@@ -12,6 +12,7 @@ import six
 from six.moves import http_client as httplib
 
 from volcenginesdkcore.endpoint import DefaultEndpointProvider
+from volcenginesdkcore.observability.debugger import sdk_core_logger
 from volcenginesdkcore.retryer.retryer import DEFAULT_RETRYER
 
 
@@ -87,7 +88,7 @@ class Configuration(six.with_metaclass(TypeWithDefault, object)):
 
         # Logging Settings
         self.logger = {}
-        self.logger["package_logger"] = logging.getLogger("volcenginesdkcore")
+        self.logger["package_logger"] = sdk_core_logger
         self.logger["urllib3_logger"] = logging.getLogger("urllib3")
         # Log format
         self.logger_format = '%(asctime)s %(levelname)s %(message)s'
@@ -137,6 +138,7 @@ class Configuration(six.with_metaclass(TypeWithDefault, object)):
         self.client_side_validation = True
 
         self.endpoint_provider = DefaultEndpointProvider()
+        self.credential_provider = None
 
         self.auto_retry = True
         self.__retryer = DEFAULT_RETRYER
@@ -208,14 +210,14 @@ class Configuration(six.with_metaclass(TypeWithDefault, object)):
             for _, logger in six.iteritems(self.logger):
                 logger.setLevel(logging.DEBUG)
             # turn on httplib debug
-            httplib.HTTPConnection.debuglevel = 1
+            #httplib.HTTPConnection.debuglevel = 1
         else:
             # if debug status is False, turn off debug logging,
             # setting log level to default `logging.WARNING`
             for _, logger in six.iteritems(self.logger):
                 logger.setLevel(logging.WARNING)
             # turn off httplib debug
-            httplib.HTTPConnection.debuglevel = 0
+            #httplib.HTTPConnection.debuglevel = 0
 
     @property
     def logger_format(self):
@@ -239,6 +241,9 @@ class Configuration(six.with_metaclass(TypeWithDefault, object)):
         """
         self.__logger_format = value
         self.logger_formatter = logging.Formatter(self.__logger_format)
+        for _, lg in six.iteritems(self.logger):
+            for h in lg.handlers:
+                h.setFormatter(self.logger_formatter)
 
     def get_api_key_with_prefix(self, identifier):
         """Gets API key (with prefix if set).
@@ -267,7 +272,7 @@ class Configuration(six.with_metaclass(TypeWithDefault, object)):
                "OS: {env}\n" \
                "Python Version: {pyversion}\n" \
                "Version of the API: 0.1.0\n" \
-               "SDK Package Version: 4.0.20".\
+               "SDK Package Version: 4.0.22".\
             format(env=sys.platform, pyversion=sys.version)
 
     @property
@@ -334,3 +339,11 @@ class Configuration(six.with_metaclass(TypeWithDefault, object)):
     @property
     def retryer(self):
         return self.__retryer
+
+    @property
+    def log_level(self):
+        return sdk_core_logger.get_log_level()
+
+    @log_level.setter
+    def log_level(self, value):
+        sdk_core_logger.set_log_level(value)

volcenginesdkcore/endpoint/providers/default_provider.py

@@ -3,6 +3,7 @@ import os
 import warnings
 
 from volcenginesdkcore.endpoint.endpoint_provider import EndpointProvider, ResolvedEndpoint
+from volcenginesdkcore.observability.debugger import sdk_core_logger
 
 open_prefix = 'open'
 endpoint_suffix = '.volcengineapi.com'
@@ -29,14 +30,36 @@ class ServiceEndpointInfo:
         return self.service.lower().replace('_', '-')
 
     def get_endpoint_for(self, region, suffix=endpoint_suffix):
+        sdk_core_logger.debug_endpoint(
+            "get_endpoint_for start: service=%s, region=%s, suffix=%s",
+            self.service, region, suffix
+        )
         if self.is_global:
             if self.global_endpoint:
+                sdk_core_logger.debug_endpoint(
+                    "use global endpoint: service=%s, endpoint=%s",
+                    self.service, self.global_endpoint
+                )
                 return self.global_endpoint
-            return self.__standardize_domain_service_code + suffix
+
+            endpoint = self.__standardize_domain_service_code + suffix
+            sdk_core_logger.debug_endpoint(
+                "build global endpoint from service code: %s", endpoint
+            )
+            return endpoint
         if region in self.region_endpoint_map:
-            return self.region_endpoint_map[region]
+            endpoint = self.region_endpoint_map[region]
+            sdk_core_logger.debug_endpoint(
+                "use region endpoint from map: service=%s, region=%s, endpoint=%s",
+                self.service, region, endpoint
+            )
+            return endpoint
 
-        return self.__standardize_domain_service_code + '.' + region + suffix
+        endpoint = self.__standardize_domain_service_code + '.' + region + suffix
+        sdk_core_logger.debug_endpoint(
+            "build region endpoint by default rule: %s", endpoint
+        )
+        return endpoint
 
 
 default_endpoint = {
@@ -483,9 +506,21 @@ class DefaultEndpointProvider(EndpointProvider):
         self.custom_endpoints = custom_endpoints or {}
 
     def get_default_endpoint(self, service, region, suffix=endpoint_suffix):
+        sdk_core_logger.debug_endpoint(
+            "get_default_endpoint: service=%s, region=%s, suffix=%s",
+            service, region, suffix
+        )
         if service in default_endpoint:
             e = default_endpoint[service]
-            return e.get_endpoint_for(region, suffix)
+            endpoint = e.get_endpoint_for(region, suffix)
+            sdk_core_logger.debug_endpoint(
+                "resolved default endpoint: service=%s, endpoint=%s",
+                service, endpoint
+            )
+            return endpoint
+        sdk_core_logger.debug_endpoint(
+            "service not found in default_endpoint, use fallback=%s", fallback_endpoint
+        )
         return fallback_endpoint
 
     def __in_bootstrap_region_list(self, region, custom_bootstrap_region):
@@ -525,20 +560,36 @@ class DefaultEndpointProvider(EndpointProvider):
         return use_dual_stack
 
     def endpoint_for(self, service, region, custom_bootstrap_region=None, use_dual_stack=None, **kwargs):
+        sdk_core_logger.debug_endpoint(
+            "endpoint_for called: service=%s, region=%s, custom_bootstrap_region=%s, use_dual_stack=%s",
+            service, region, custom_bootstrap_region, use_dual_stack
+        )
         if service in self.custom_endpoints:
             conf = self.custom_endpoints[service]
             host = conf.get_endpoint_for(region)
+            sdk_core_logger.debug_endpoint(
+                "use custom endpoint: service=%s, region=%s, host=%s",
+                service, region, host
+            )
             return ResolvedEndpoint(host)
 
         if custom_bootstrap_region is None:
             custom_bootstrap_region = {}
 
         if not self.__in_bootstrap_region_list(region, custom_bootstrap_region):
+            sdk_core_logger.debug_endpoint(
+                "region=%s not in bootstrap list, fallback=%s",
+                region, fallback_endpoint
+            )
             return ResolvedEndpoint(fallback_endpoint)
 
         suffix = dualstack_endpoint_suffix if self.__has_enabled_dualstack(use_dual_stack) else endpoint_suffix
         host = self.get_default_endpoint(service=service, region=region, suffix=suffix)
 
+        sdk_core_logger.debug_endpoint(
+            "final resolved endpoint: service=%s, region=%s, host=%s",
+            service, region, host
+        )
         return ResolvedEndpoint(host)
 
 
@@ -547,4 +598,8 @@ class HostEndpointProvider(EndpointProvider):
         self.host = host
 
     def endpoint_for(self, service, region, **kwargs):
+        sdk_core_logger.debug_endpoint(
+            "HostEndpointProvider.endpoint_for: service=%s, region=%s, host=%s",
+            service, region, self.host
+        )
         return ResolvedEndpoint(self.host)

volcenginesdkcore/interceptor/interceptors/request.py

@@ -61,6 +61,7 @@ class Request(object):
         # retryer setting, default use global configration if value not set
         self.auto_retry = configuration.auto_retry
         self.retryer = configuration.retryer
+        self.credential_provider = configuration.credential_provider
 
         self.runtime_options = None
         if hasattr(body, '_configuration') and isinstance(body._configuration, RuntimeOption):

volcenginesdkcore/interceptor/interceptors/sign_request_interceptor.py

@@ -10,6 +10,13 @@ class SignRequestInterceptor(RequestInterceptor):
         return 'volcengine-sign-request-interceptor'
 
     def intercept(self, context):
+        # 新增代码。处理assume_role和assume_role_oidc和assume_role_saml
+        if context.request.credential_provider is not None:
+            credentials = context.request.credential_provider.get_credentials() # 这会调用 _assume_role_oidc() 方法获取临时凭证
+            context.request.ak = credentials.ak
+            context.request.sk = credentials.sk
+            context.request.session_token = credentials.session_token
+
         self.update_params_for_auth(host=context.request.host, path=context.request.true_path,
                                     method=context.request.method,
                                     headers=context.request.header_params,

volcenginesdkcore/observability/debugger.py

@@ -0,0 +1,235 @@
+# coding: utf-8
+
+from __future__ import print_function
+
+import logging
+
+# Try using Enum (which comes with Py3 / you can pip install enum34 for Py2)
+try:
+    from enum import Enum
+except Exception:
+    Enum = None
+
+SDK_DEBUGGER_LOG_NAME = "com.volcengine.sdkcore"
+
+
+if Enum is not None:
+    # ========== Implementation based on Enum (preferred) ==========
+    class LogLevel(Enum):
+        # Base bit (starting from low bit 0)
+        LOG_DEBUG_OFF = (0,)
+        LOG_DEBUG_WITH_REQUEST = (1,)
+        LOG_DEBUG_WITH_REQUEST_BODY = (2, 'LOG_DEBUG_WITH_REQUEST')
+        LOG_DEBUG_WITH_REQUEST_ID = (3, 'LOG_DEBUG_WITH_REQUEST')
+        LOG_DEBUG_WITH_RESPONSE = (4, 'LOG_DEBUG_WITH_REQUEST')
+        LOG_DEBUG_WITH_RESPONSE_BODY = (5, 'LOG_DEBUG_WITH_RESPONSE')
+        LOG_DEBUG_WITH_SIGNING = (6, 'LOG_DEBUG_WITH_REQUEST')
+        LOG_DEBUG_WITH_ENDPOINT = (7, 'LOG_DEBUG_WITH_REQUEST')
+        LOG_DEBUG_WITH_REQUEST_RETRIES = (8, 'LOG_DEBUG_WITH_REQUEST')
+        LOG_DEBUG_WITH_CONFIG = (9, 'LOG_DEBUG_WITH_REQUEST')
+        # Special: represents "include all debug items", mask will be assigned dynamically after class definition
+        LOG_DEBUG_ALL = (-1,)
+
+        def __init__(self, bit_index, *parents):
+            # Record bit index
+            object.__setattr__(self, 'bit_index', bit_index)
+
+            # Calculate mask; ALL uses -1 as a placeholder, assigned later
+            if bit_index >= 0:
+                m = 1 << bit_index
+                cls = type(self)  # Key: do not directly use class name, compatible during enum construction
+                for p in parents:
+                    parent = p if isinstance(p, cls) else cls[p]
+                    m |= parent.mask
+                object.__setattr__(self, 'mask', m)
+            else:
+                object.__setattr__(self, 'mask', 0)
+
+        @classmethod
+        def combine(cls, *modes):
+            """Combine multiple modes into flags"""
+            if not modes:
+                return cls.LOG_DEBUG_OFF.mask
+            f = 0
+            for m in modes:
+                f |= m.mask
+            return f
+
+        def matches(self, flags):
+            """Check whether the current mode is contained in flags"""
+            return (flags & self.mask) == self.mask
+
+    # Calculate mask for LOG_DEBUG_ALL after class loading
+    _all = 0
+    for lv in LogLevel:
+        if lv not in (LogLevel.LOG_DEBUG_OFF, LogLevel.LOG_DEBUG_ALL):
+            _all |= lv.mask
+    object.__setattr__(LogLevel.LOG_DEBUG_ALL, 'mask', _all)
+
+else:
+    # ========== Pure Python fallback implementation when Enum is not available ==========
+    class _Level(object):
+        __slots__ = ('name', 'bit_index', 'mask')
+
+        def __init__(self, name, bit_index, parents=None):
+            self.name = name
+            self.bit_index = bit_index
+            if bit_index >= 0:
+                m = 1 << bit_index
+                if parents:
+                    for p in parents:
+                        m |= p.mask
+                self.mask = m
+            else:
+                self.mask = 0  # Placeholder, ALL will be assigned later by OR-ing all masks
+
+        def matches(self, flags):
+            return (flags & self.mask) == self.mask
+
+        def __repr__(self):
+            return '<LogLevel {0} mask=0x{1:X}>'.format(self.name, self.mask)
+
+    class LogLevel(object):
+        """Enum fallback container: provides the same constants and API as Enum"""
+        # Define base and parent levels first
+        LOG_DEBUG_OFF = _Level('LOG_DEBUG_OFF', 0)
+        LOG_DEBUG_WITH_REQUEST = _Level('LOG_DEBUG_WITH_REQUEST', 1)
+
+        LOG_DEBUG_WITH_RESPONSE = _Level('LOG_DEBUG_WITH_RESPONSE', 4, [LOG_DEBUG_WITH_REQUEST])
+
+        # Levels dependent on parents
+        LOG_DEBUG_WITH_REQUEST_BODY = _Level('LOG_DEBUG_WITH_REQUEST_BODY', 2, [LOG_DEBUG_WITH_REQUEST])
+        LOG_DEBUG_WITH_REQUEST_ID = _Level('LOG_DEBUG_WITH_REQUEST_ID', 3, [LOG_DEBUG_WITH_REQUEST])
+        LOG_DEBUG_WITH_RESPONSE_BODY = _Level('LOG_DEBUG_WITH_RESPONSE_BODY', 5, [LOG_DEBUG_WITH_RESPONSE])
+        LOG_DEBUG_WITH_SIGNING = _Level('LOG_DEBUG_WITH_SIGNING', 6, [LOG_DEBUG_WITH_REQUEST])
+        LOG_DEBUG_WITH_ENDPOINT = _Level('LOG_DEBUG_WITH_ENDPOINT', 7, [LOG_DEBUG_WITH_REQUEST])
+        LOG_DEBUG_WITH_REQUEST_RETRIES = _Level('LOG_DEBUG_WITH_REQUEST_RETRIES', 8, [LOG_DEBUG_WITH_REQUEST])
+        LOG_DEBUG_WITH_CONFIG = _Level('LOG_DEBUG_WITH_CONFIG', 9, [LOG_DEBUG_WITH_REQUEST])
+
+        LOG_DEBUG_ALL = _Level('LOG_DEBUG_ALL', -1)  # Placeholder, will be OR-ed later
+
+        @classmethod
+        def _all_levels(cls):
+            # Used for internal aggregation
+            return [
+                cls.LOG_DEBUG_OFF,
+                cls.LOG_DEBUG_WITH_REQUEST,
+                cls.LOG_DEBUG_WITH_REQUEST_BODY,
+                cls.LOG_DEBUG_WITH_REQUEST_ID,
+                cls.LOG_DEBUG_WITH_RESPONSE,
+                cls.LOG_DEBUG_WITH_RESPONSE_BODY,
+                cls.LOG_DEBUG_WITH_SIGNING,
+                cls.LOG_DEBUG_WITH_ENDPOINT,
+                cls.LOG_DEBUG_WITH_REQUEST_RETRIES,
+                cls.LOG_DEBUG_WITH_CONFIG,
+                cls.LOG_DEBUG_ALL,
+            ]
+
+        @classmethod
+        def combine(cls, *modes):
+            if not modes:
+                return cls.LOG_DEBUG_OFF.mask
+            f = 0
+            for m in modes:
+                f |= m.mask
+            return f
+
+    # Calculate mask for LOG_DEBUG_ALL
+    _all_mask = 0
+    for _lv in LogLevel._all_levels():
+        if _lv.name not in ('LOG_DEBUG_OFF', 'LOG_DEBUG_ALL'):
+            _all_mask |= _lv.mask
+    LogLevel.LOG_DEBUG_ALL.mask = _all_mask
+
+
+class SdkCoreLogger(logging.Logger):
+
+    def __init__(self, name, debug=False, log_level=0):
+        # In Python 2.7, must explicitly call parent __init__
+        if debug:
+            logging.Logger.__init__(self, name, logging.DEBUG)
+        else:
+            logging.Logger.__init__(self, name, logging.WARNING)
+        self._log_level = int(log_level)
+
+    # ---- Custom bit control ----
+    def set_log_level(self, log_level):
+        self._log_level = int(log_level)
+
+    def get_log_level(self):
+        return self._log_level
+
+    def is_enabled_for_loglevel(self, level_enum):
+        # Does not change logging's native level semantics, only adds an extra bit filter
+        return level_enum.matches(self._log_level)
+
+    @staticmethod
+    def get_sdk_logger(name,
+                       debug=False,
+                       log_level=0,
+                       fmt="%(asctime)s [%(threadName)s] %(levelname)s %(name)s:%(lineno)d - %(message)s",
+                       datefmt="%Y-%m-%d %H:%M:%S"):
+        """
+        Create an SdkLogger with Handler.
+        - base_level: standard logging minimum level
+        - log_flags: your custom LogLevel bitmask
+        """
+        # No global pollution: only subclass used for the returned logger
+        # If you want to globally setLoggerClass, call logging.setLoggerClass(SdkLogger) at module init
+        logger = SdkCoreLogger(name, debug=debug, log_level=log_level)
+
+        if not logger.handlers:
+            h = logging.StreamHandler()
+            if debug:
+                h.setLevel(logging.DEBUG)
+            else:
+                h.setLevel(logging.WARNING)
+            try:
+                formatter = logging.Formatter(fmt=fmt, datefmt=datefmt)
+            except TypeError:
+                # Compatibility with very old logging versions (almost never used)
+                formatter = logging.Formatter(fmt)
+            h.setFormatter(formatter)
+            logger.addHandler(h)
+
+        logger.propagate = False  # Avoid bubbling up to root logger
+        return logger
+
+    # ---- New API: debug with "function bit" ----
+    def debugx(self, curr_log_level_enum, msg, *args, **kwargs):
+        """
+        Debug with "function bit".
+        Conditions:
+          1) Standard logging level allowed (Logger.level / Handler.level)
+          2) Custom bit included (self._log_level)
+        Only then will it output.
+        """
+        if self.isEnabledFor(logging.DEBUG) and self.is_enabled_for_loglevel(curr_log_level_enum):
+            # Keep consistent with logging convention, parameters use % placeholder, formatted in Handler/Formatter
+            self.debug(msg, *args, **kwargs)
+
+    def debug_sign(self, msg, *args, **kwargs):
+        self.debugx(LogLevel.LOG_DEBUG_WITH_SIGNING, "[Sign] " + msg, *args, **kwargs)
+
+    def debug_endpoint(self, msg, *args, **kwargs):
+        self.debugx(LogLevel.LOG_DEBUG_WITH_ENDPOINT, "[Endpoint] " + msg, *args, **kwargs)
+
+    def debug_retry(self, msg, *args, **kwargs):
+        self.debugx(LogLevel.LOG_DEBUG_WITH_REQUEST, "[Retry] " + msg, *args, **kwargs)
+
+    def debug_config(self, msg, *args, **kwargs):
+        self.debugx(LogLevel.LOG_DEBUG_WITH_CONFIG, "[Config] " + msg, *args, **kwargs)
+
+    def debug_request(self, msg, *args, is_body=False, **kwargs):
+        if is_body:
+            self.debugx(LogLevel.LOG_DEBUG_WITH_REQUEST_BODY, "[Request] " + msg, *args, **kwargs)
+        else:
+            self.debugx(LogLevel.LOG_DEBUG_WITH_REQUEST, "[Request] " + msg, *args, **kwargs)
+
+    def debug_response(self, msg, *args, is_body=False, **kwargs):
+        if is_body:
+            self.debugx(LogLevel.LOG_DEBUG_WITH_RESPONSE_BODY, "[Response] " + msg, *args, **kwargs)
+        else:
+            self.debugx(LogLevel.LOG_DEBUG_WITH_RESPONSE, "[Response] " + msg, *args, **kwargs)
+
+sdk_core_logger =   SdkCoreLogger.get_sdk_logger(SDK_DEBUGGER_LOG_NAME, debug=False, log_level=LogLevel.LOG_DEBUG_ALL.mask)

volcenginesdkcore/rest.py

@@ -15,6 +15,8 @@ import six
 from six.moves.urllib.parse import urlencode
 from urllib3 import Retry
 
+from volcenginesdkcore.observability.debugger import sdk_core_logger, LogLevel
+
 try:
     import urllib3
 except ImportError:
@@ -39,6 +41,68 @@ class RESTResponse(io.IOBase):
         """Returns a given response header."""
         return self.urllib3_response.getheader(name, default)
 
+
+def log_request(method, url, query_params, headers, body, post_params, request_time_out):
+    sdk_core_logger.debug_request("request url: %s %s", method, url)
+    if request_time_out:
+        sdk_core_logger.debug_request("request timeout: %s", request_time_out)
+
+    if query_params:
+        sdk_core_logger.debug_request("query params: %s", query_params)
+
+    if headers:
+        sdk_core_logger.debug_request("headers:")
+        for k, v in headers.items():
+            sdk_core_logger.debug_request("    %s: %s", k, v)
+
+    if post_params:
+        sdk_core_logger.debug_request("post params: %s", post_params)
+
+    if body:
+        # body may be bytes and needs to be decoded
+        if isinstance(body, bytes):
+            try:
+                body = body.decode("utf-8")
+            except Exception:
+                body = str(body)
+        sdk_core_logger.debug_request("body: %s", body, is_body=True)
+
+
+def log_response(r, _preload_content):
+    sdk_core_logger.debugx(LogLevel.LOG_DEBUG_WITH_REQUEST_ID, "[Response] request id: %s", r.getheader("X-Tt-Logid"))
+    sdk_core_logger.debug_response("status: %s", r.status)
+    sdk_core_logger.debug_response("reason: %s", r.reason)
+    sdk_core_logger.debug_response("headers:")
+    for k, v in r.getheaders().items():
+        sdk_core_logger.debug_response("    %s: %s", k, v)
+    if _preload_content:
+        sdk_core_logger.debug_response("body: %s", r.data, is_body=True)
+    else:
+        preview_len = 2048
+        # Stream not preloaded: avoid consuming the stream, just do a "peek"
+        preview_bytes = b""
+        try:
+            # urllib3.HTTPResponse.peek(n) is usually available and does not advance the read pointer
+            if hasattr(r, "peek"):
+                preview_bytes = r.peek(preview_len) or b""
+            else:
+                # Some implementations may cache r.data (not read the underlying stream again)
+                cached = getattr(r, "data", b"")
+                if cached:
+                    preview_bytes = cached[:preview_len]
+        except Exception:
+            preview_bytes = b""
+
+        if preview_bytes:
+            try:
+                preview_text = preview_bytes.decode("utf-8", errors="replace")
+            except Exception:
+                preview_text = repr(preview_bytes)
+            sdk_core_logger.debug_response("response body (preview, %d bytes): %s", len(preview_bytes), preview_text, is_body=True)
+        else:
+            sdk_core_logger.debug_response("response body (preview): <streaming, not read>", is_body=True)
+
+
 class RESTClientObject(object):
 
     def __init__(self, configuration, pools_size=4, maxsize=None):
@@ -175,6 +239,8 @@ class RESTClientObject(object):
         if 'Content-Type' not in headers:
             headers['Content-Type'] = 'application/json'
 
+        log_request(method, url, query_params, headers, body, post_params, timeout)
+
         try:
             # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
             if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
@@ -248,7 +314,7 @@ class RESTClientObject(object):
 
             # log response body
             logger.debug("response body: %s", r.data)
-
+        log_response(r, _preload_content)
         if not 200 <= r.status <= 299:
             raise ApiException(http_resp=r)