修改了requests，所有requests的地方将自动打印日志，前提要给custom_request添加handlers

import requests

from app.utils.utils_ydf import LogManager

logger = LogManager('custom_request').get_logger_without_handlers()

class CustomSession(requests.Session):

    def request(self, method, url,

                params=None, data=None, headers=None, cookies=None, files=None,

                auth=None, timeout=None, allow_redirects=True, proxies=None,

                hooks=None, stream=None, verify=None, cert=None, json=None):

        """Constructs a :class:`Request <Request>`, prepares it and sends it.

        Returns :class:`Response <Response>` object.

        :param method: method for the new :class:`Request` object.

        :param url: URL for the new :class:`Request` object.

        :param params: (optional) Dictionary or bytes to be sent in the query

            string for the :class:`Request`.

        :param data: (optional) Dictionary, bytes, or file-like object to send

            in the body of the :class:`Request`.

        :param json: (optional) json to send in the body of the

            :class:`Request`.

        :param headers: (optional) Dictionary of HTTP Headers to send with the

            :class:`Request`.

        :param cookies: (optional) Dict or CookieJar object to send with the

            :class:`Request`.

        :param files: (optional) Dictionary of ``'filename': file-like-objects``

            for multipart encoding upload.

        :param auth: (optional) Auth tuple or callable to enable

            Basic/Digest/Custom HTTP Auth.

        :param timeout: (optional) How long to wait for the server to send

            data before giving up, as a float, or a :ref:`(connect timeout,

            read timeout) <timeouts>` tuple.

        :type timeout: float or tuple

        :param allow_redirects: (optional) Set to True by default.

        :type allow_redirects: bool

        :param proxies: (optional) Dictionary mapping protocol or protocol and

            hostname to the URL of the proxy.

        :param stream: (optional) whether to immediately download the response

            content. Defaults to ``False``.

        :param verify: (optional) Either a boolean, in which case it controls whether we verify

            the server's TLS certificate, or a string, in which case it must be a path

            to a CA bundle to use. Defaults to ``True``.

        :param cert: (optional) if String, path to ssl client cert file (.pem).

            If Tuple, ('cert', 'key') pair.

        :rtype: requests.Response

        """

        # Create the Request.

        req = requests.Request(

            method=method.upper(),

            url=url,

            headers=headers,

            files=files,

            data=data or {},

            json=json,

            params=params or {},

            auth=auth,

            cookies=cookies,

            hooks=hooks,

        )

        logger.debug('start {} this url -->  {} '.format(method, url))

        prep = self.prepare_request(req)

        proxies = proxies or {}

        settings = self.merge_environment_settings(

            prep.url, proxies, stream, verify, cert

        )

        # Send the request.

        send_kwargs = {

            'timeout': timeout,

            'allow_redirects': allow_redirects,

        }

        send_kwargs.update(settings)

        resp = self.send(prep, **send_kwargs)

        logger.debug('{}  {}  {}  {}  {}  {}'.format(method, resp.url, resp.status_code, resp.elapsed.total_seconds(), resp.is_redirect, resp.text.__len__()))

        return resp

def custom_request(method, url, **kwargs):

    with CustomSession() as session:

        return session.request(method=method, url=url, **kwargs)

def patch_request():

    LogManager('custom_request').get_logger_and_add_handlers()

    requests.api.request = custom_request

if __name__ == '__main__':

    patch_request()

    resp = requests.get('http://www.sina.com.cn')

    requests.get('https://www.baidu.com')