अजगर-अनुरोध मॉड्यूल से सभी अनुरोधों को लॉग इन करें

Question 1

मैं अजगर अनुरोधों का उपयोग कर रहा हूं । मुझे कुछ OAuthगतिविधि को डीबग करने की आवश्यकता है , और इसके लिए मैं चाहूंगा कि सभी अनुरोधों को लॉग किया जाए। मुझे इसकी जानकारी मिल सकती है ngrep, लेकिन दुर्भाग्यवश https कनेक्शन को टालना संभव नहीं है (जिसकी आवश्यकता है OAuth)

मैं Requestsएक्सेस करने वाले सभी URL (+ पैरामीटर) को कैसे सक्रिय कर सकता हूं ?

Question 2

अंतर्निहित urllib3लाइब्रेरी loggingमॉड्यूल के साथ सभी नए कनेक्शन और URL लॉग करती है , लेकिन POSTनिकाय नहीं । के लिए GETअनुरोध यह पर्याप्त होना चाहिए:

import logging

logging.basicConfig(level=logging.DEBUG)

जो आपको सबसे वर्बोज़ लॉगिंग विकल्प देता है; देख लॉगिंग विधिपत्र कैसे प्रवेश करने के स्तर और स्थलों को कॉन्फ़िगर करने के बारे में अधिक जानकारी के लिए।

लघु डेमो:

>>> import requests
>>> import logging
>>> logging.basicConfig(level=logging.DEBUG)
>>> r = requests.get('http://httpbin.org/get?foo=bar&baz=python')
DEBUG:urllib3.connectionpool:Starting new HTTP connection (1): httpbin.org:80
DEBUG:urllib3.connectionpool:http://httpbin.org:80 "GET /get?foo=bar&baz=python HTTP/1.1" 200 366

Urllib3 के सटीक संस्करण के आधार पर, निम्न संदेश लॉग किए गए हैं:

INFO: पुनर्निर्देश
WARN: कनेक्शन पूल भरा हुआ है (यदि ऐसा होता है तो अक्सर कनेक्शन पूल का आकार बढ़ जाता है)
WARN: हेडर्स पार्स करने में विफल (अमान्य हेडर के साथ प्रतिक्रिया हेडर)
WARN: कनेक्शन को फिर से लेना
WARN: प्रमाणपत्र अपेक्षित होस्टनाम से मेल नहीं खाता था
WARN: कंटेंट-लेंथ और ट्रांसफ़र-एन्कोडिंग दोनों के साथ प्रतिक्रिया मिली, जब एक chunked प्रतिक्रिया को संसाधित किया गया
DEBUG: नए कनेक्शन (HTTP या HTTPS)
DEBUG: गिरा हुआ कनेक्शन
DEBUG: कनेक्शन विवरण: विधि, पथ, HTTP संस्करण, स्थिति कोड और प्रतिक्रिया लंबाई
DEBUG: पुन: गणना वेतन वृद्धि

इसमें शीर्षलेख या निकाय शामिल नहीं हैं। ग्रंट-वर्क करने के लिए क्लास urllib3का उपयोग करता है http.client.HTTPConnection, लेकिन वह क्लास लॉगिंग का समर्थन नहीं करता है, इसे आमतौर पर केवल प्रिंटआउट में प्रिंट करने के लिए कॉन्फ़िगर किया जा सकता है । हालाँकि, आप printउस मॉड्यूल में एक वैकल्पिक नाम शुरू करने के बजाय लॉगिंग के लिए सभी डिबग जानकारी भेजने के लिए इसे रिग कर सकते हैं :

import logging
import http.client

httpclient_logger = logging.getLogger("http.client")

def httpclient_logging_patch(level=logging.DEBUG):
    """Enable HTTPConnection debug logging to the logging framework"""

    def httpclient_log(*args):
        httpclient_logger.log(level, " ".join(args))

    # mask the print() built-in in the http.client module to use
    # logging instead
    http.client.print = httpclient_log
    # enable debugging
    http.client.HTTPConnection.debuglevel = 1

सभी डिबग सूचना को एक मानक लकड़हारे तक पहुँचाने के लिए कनेक्शन कॉलिंग का httpclient_logging_patch()कारण बनता है http.client, और इसलिए इसके द्वारा उठाया जाता है logging.basicConfig():

>>> httpclient_logging_patch()
>>> r = requests.get('http://httpbin.org/get?foo=bar&baz=python')
DEBUG:urllib3.connectionpool:Starting new HTTP connection (1): httpbin.org:80
DEBUG:http.client:send: b'GET /get?foo=bar&baz=python HTTP/1.1\r\nHost: httpbin.org\r\nUser-Agent: python-requests/2.22.0\r\nAccept-Encoding: gzip, deflate\r\nAccept: */*\r\nConnection: keep-alive\r\n\r\n'
DEBUG:http.client:reply: 'HTTP/1.1 200 OK\r\n'
DEBUG:http.client:header: Date: Tue, 04 Feb 2020 13:36:53 GMT
DEBUG:http.client:header: Content-Type: application/json
DEBUG:http.client:header: Content-Length: 366
DEBUG:http.client:header: Connection: keep-alive
DEBUG:http.client:header: Server: gunicorn/19.9.0
DEBUG:http.client:header: Access-Control-Allow-Origin: *
DEBUG:http.client:header: Access-Control-Allow-Credentials: true
DEBUG:urllib3.connectionpool:http://httpbin.org:80 "GET /get?foo=bar&baz=python HTTP/1.1" 200 366

Question 3

आपको डिबगिंग को httplibस्तर पर सक्षम करने की आवश्यकता है ( requests→ urllib3→ httplib)।

यहाँ कुछ कार्यों को टॉगल ( ..._on()और ..._off()) या अस्थायी रूप से करने के लिए किया गया है:

import logging
import contextlib
try:
    from http.client import HTTPConnection # py3
except ImportError:
    from httplib import HTTPConnection # py2

def debug_requests_on():
    '''Switches on logging of the requests module.'''
    HTTPConnection.debuglevel = 1

    logging.basicConfig()
    logging.getLogger().setLevel(logging.DEBUG)
    requests_log = logging.getLogger("requests.packages.urllib3")
    requests_log.setLevel(logging.DEBUG)
    requests_log.propagate = True

def debug_requests_off():
    '''Switches off logging of the requests module, might be some side-effects'''
    HTTPConnection.debuglevel = 0

    root_logger = logging.getLogger()
    root_logger.setLevel(logging.WARNING)
    root_logger.handlers = []
    requests_log = logging.getLogger("requests.packages.urllib3")
    requests_log.setLevel(logging.WARNING)
    requests_log.propagate = False

@contextlib.contextmanager
def debug_requests():
    '''Use with 'with'!'''
    debug_requests_on()
    yield
    debug_requests_off()

डेमो उपयोग:

>>> requests.get('http://httpbin.org/')
<Response [200]>

>>> debug_requests_on()
>>> requests.get('http://httpbin.org/')
INFO:requests.packages.urllib3.connectionpool:Starting new HTTP connection (1): httpbin.org
DEBUG:requests.packages.urllib3.connectionpool:"GET / HTTP/1.1" 200 12150
send: 'GET / HTTP/1.1\r\nHost: httpbin.org\r\nConnection: keep-alive\r\nAccept-
Encoding: gzip, deflate\r\nAccept: */*\r\nUser-Agent: python-requests/2.11.1\r\n\r\n'
reply: 'HTTP/1.1 200 OK\r\n'
header: Server: nginx
...
<Response [200]>

>>> debug_requests_off()
>>> requests.get('http://httpbin.org/')
<Response [200]>

>>> with debug_requests():
...     requests.get('http://httpbin.org/')
INFO:requests.packages.urllib3.connectionpool:Starting new HTTP connection (1): httpbin.org
...
<Response [200]>

आप READEST देखेंगे, जिसमें HEADERS और DATA शामिल हैं, और RESADONSE HEADERS के साथ लेकिन DATA के बिना। केवल एक चीज गायब है जो प्रतिक्रिया होगी। जो लॉग नहीं किया गया है।

स्रोत

Question 4

अजगर 3+ का उपयोग करने वालों के लिए

import requests
import logging
import http.client

http.client.HTTPConnection.debuglevel = 1

logging.basicConfig()
logging.getLogger().setLevel(logging.DEBUG)
requests_log = logging.getLogger("requests.packages.urllib3")
requests_log.setLevel(logging.DEBUG)
requests_log.propagate = True

Question 5

import loggingनिम्न स्तर के डीबग लॉग संदेशों को निकालने के लिए पायथन लॉगिंग सिस्टम ( ) प्राप्त करने का प्रयास करते समय, इसने मुझे इस बात की खोज करने के लिए प्रेरित किया:

requests --> urllib3 --> http.client.HTTPConnection

केवल वही urllib3वास्तव में पायथन loggingप्रणाली का उपयोग करता है:

requests नहीं
http.client.HTTPConnection नहीं
urllib3 हाँ

निश्चित रूप से, आप HTTPConnectionसेटिंग से डीबग संदेश निकाल सकते हैं :

HTTPConnection.debuglevel = 1

लेकिन ये आउटपुट केवल printकथन के माध्यम से उत्सर्जित होते हैं । इसे साबित करने के लिए, बस Python 3.7 client.pyस्रोत कोड को प्रिंट करें और प्रिंट स्टेटमेंट्स को स्वयं देखें (धन्यवाद @Yohann):

curl https://raw.githubusercontent.com/python/cpython/3.7/Lib/http/client.py |grep -A1 debuglevel`

संभवतया किसी तरह से पुनर्निर्देशित करने का तरीका, लॉग-इन सिस्टम में जूता-हॉर्न स्टडआउट के लिए काम कर सकता है और संभवतः एक लॉग फ़ाइल जैसे कैप्चर करने के लिए।

' `urllib3`' लकड़हारा नहीं ' `requests.packages.urllib3`' चुनें

urllib3पायथन 3 loggingसिस्टम के माध्यम से डिबग जानकारी को कैप्चर करने के लिए , इंटरनेट पर बहुत सलाह के विपरीत, और जैसा कि @MikeSmith बताता है, आपके पास बहुत अधिक अवरोधन नहीं होंगे:

log = logging.getLogger('requests.packages.urllib3')

इसके बजाय आपको जरूरत है:

log = logging.getLogger('urllib3')

`urllib3`लॉग फ़ाइल में डीबग करना

यहाँ कुछ कोड है जो urllib3पायथन loggingसिस्टम का उपयोग करके लॉगिंग फ़ाइल में कार्य करता है:

import requests
import logging
from http.client import HTTPConnection  # py3

# log = logging.getLogger('requests.packages.urllib3')  # useless
log = logging.getLogger('urllib3')  # works

log.setLevel(logging.DEBUG)  # needed
fh = logging.FileHandler("requests.log")
log.addHandler(fh)

requests.get('http://httpbin.org/')

परिणाम:

Starting new HTTP connection (1): httpbin.org:80
http://httpbin.org:80 "GET / HTTP/1.1" 200 3168

`HTTPConnection.debuglevel`प्रिंट () स्टेटमेंट को सक्षम करना

यदि आप सेट करते हैं HTTPConnection.debuglevel = 1

from http.client import HTTPConnection  # py3
HTTPConnection.debuglevel = 1
requests.get('http://httpbin.org/')

आपको अतिरिक्त रसीले निम्न स्तर की जानकारी का प्रिंट स्टेटमेंट आउटपुट मिलेगा :

send: b'GET / HTTP/1.1\r\nHost: httpbin.org\r\nUser-Agent: python- 
requests/2.22.0\r\nAccept-Encoding: gzip, deflate\r\nAccept: */*\r\nConnection: keep-alive\r\n\r\n'
reply: 'HTTP/1.1 200 OK\r\n'
header: Access-Control-Allow-Credentials header: Access-Control-Allow-Origin 
header: Content-Encoding header: Content-Type header: Date header: ...

याद रखें कि यह आउटपुट printपायथन loggingसिस्टम का उपयोग करता है और न कि , और इस तरह एक पारंपरिक loggingस्ट्रीम या फ़ाइल हैंडलर का उपयोग करके इसे कैप्चर नहीं किया जा सकता है (हालाँकि यह स्टडआउट को रीडायरेक्ट करके फ़ाइल में आउटपुट कैप्चर करना संभव हो सकता है) ।

उपरोक्त दोनों को मिलाएं - कंसोल में सभी संभव लॉगिंग को अधिकतम करें

सभी संभव लॉगिंग को अधिकतम करने के लिए, आपको इसके साथ कंसोल / स्टडआउट आउटपुट के लिए व्यवस्थित होना चाहिए:

import requests
import logging
from http.client import HTTPConnection  # py3

log = logging.getLogger('urllib3')
log.setLevel(logging.DEBUG)

# logging from urllib3 to console
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
log.addHandler(ch)

# print statements from `http.client.HTTPConnection` to console/stdout
HTTPConnection.debuglevel = 1

requests.get('http://httpbin.org/')

उत्पादन की पूरी श्रृंखला दे रहा है:

Starting new HTTP connection (1): httpbin.org:80
send: b'GET / HTTP/1.1\r\nHost: httpbin.org\r\nUser-Agent: python-requests/2.22.0\r\nAccept-Encoding: gzip, deflate\r\nAccept: */*\r\nConnection: keep-alive\r\n\r\n'
reply: 'HTTP/1.1 200 OK\r\n'
http://httpbin.org:80 "GET / HTTP/1.1" 200 3168
header: Access-Control-Allow-Credentials header: Access-Control-Allow-Origin 
header: Content-Encoding header: ...

Question 6

मैं अजगर 3.4 का उपयोग कर रहा हूं, 2.19.1 अनुरोध

'urllib3' अब प्राप्त करने के लिए लकड़हारा है (अब 'request.packages.urllib3') नहीं है। बुनियादी लॉगिंग अभी भी http.client.HTTPConnection.debuglevel को सेट किए बिना होगी

Question 7

नेटवर्क प्रोटोकॉल डिबगिंग के लिए एक स्क्रिप्ट या किसी एप्लिकेशन का सबसिस्टम होने के बाद, यह देखने के लिए वांछित है कि क्या अनुरोध-प्रतिक्रिया जोड़े वास्तव में प्रभावी URL, हेडर, पेलोड और स्थिति सहित हैं। और यह आम तौर पर सभी स्थानों पर व्यक्तिगत अनुरोधों को लागू करने के लिए अव्यावहारिक है। एक ही समय में प्रदर्शन के विचार हैं जो एकल (या कुछ विशेष) का उपयोग करने का सुझाव देते हैं requests.Session, इसलिए निम्नलिखित मानते हैं कि सुझाव का पालन किया जाता है।

requestsतथाकथित ईवेंट हुक का समर्थन करता है (2.23 के रूप में वास्तव में केवल responseहुक है)। यह मूल रूप से एक घटना श्रोता है, और इस घटना को नियंत्रण से लौटने से पहले उत्सर्जित किया जाता है requests.request। इस समय अनुरोध और प्रतिक्रिया दोनों पूरी तरह से परिभाषित हैं, इसलिए लॉग इन किया जा सकता है।

import logging

import requests


logger = logging.getLogger('httplogger')

def logRoundtrip(response, *args, **kwargs):
    extra = {'req': response.request, 'res': response}
    logger.debug('HTTP roundtrip', extra=extra)

session = requests.Session()
session.hooks['response'].append(logRoundtrip)

यह मूल रूप से सत्र के सभी HTTP राउंड-ट्रिप को लॉग करने का तरीका है।

HTTP राउंड-ट्रिप लॉग रिकॉर्ड्स फ़ॉर्मेट करना

ऊपर लॉगिंग उपयोगी होने के लिए लॉगिंग रिकॉर्ड्स पर समझने और एक्स्ट्रा करने वाले विशेष लॉगिंग फॉर्मेटर हो सकते हैं । यह इस तरह दिख सकता है:reqres

import textwrap

class HttpFormatter(logging.Formatter):   

    def _formatHeaders(self, d):
        return '\n'.join(f'{k}: {v}' for k, v in d.items())

    def formatMessage(self, record):
        result = super().formatMessage(record)
        if record.name == 'httplogger':
            result += textwrap.dedent('''
                ---------------- request ----------------
                {req.method} {req.url}
                {reqhdrs}

                {req.body}
                ---------------- response ----------------
                {res.status_code} {res.reason} {res.url}
                {reshdrs}

                {res.text}
            ''').format(
                req=record.req,
                res=record.res,
                reqhdrs=self._formatHeaders(record.req.headers),
                reshdrs=self._formatHeaders(record.res.headers),
            )

        return result

formatter = HttpFormatter('{asctime} {levelname} {name} {message}', style='{')
handler = logging.StreamHandler()
handler.setFormatter(formatter)
logging.basicConfig(level=logging.DEBUG, handlers=[handler])

अब यदि आप कुछ अनुरोधों का उपयोग करते हैं session, जैसे:

session.get('https://httpbin.org/user-agent')
session.get('https://httpbin.org/status/200')

आउटपुट stderrनिम्नानुसार दिखेगा।

2020-05-14 22:10:13,224 DEBUG urllib3.connectionpool Starting new HTTPS connection (1): httpbin.org:443
2020-05-14 22:10:13,695 DEBUG urllib3.connectionpool https://httpbin.org:443 "GET /user-agent HTTP/1.1" 200 45
2020-05-14 22:10:13,698 DEBUG httplogger HTTP roundtrip
---------------- request ----------------
GET https://httpbin.org/user-agent
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive

None
---------------- response ----------------
200 OK https://httpbin.org/user-agent
Date: Thu, 14 May 2020 20:10:13 GMT
Content-Type: application/json
Content-Length: 45
Connection: keep-alive
Server: gunicorn/19.9.0
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true

{
  "user-agent": "python-requests/2.23.0"
}


2020-05-14 22:10:13,814 DEBUG urllib3.connectionpool https://httpbin.org:443 "GET /status/200 HTTP/1.1" 200 0
2020-05-14 22:10:13,818 DEBUG httplogger HTTP roundtrip
---------------- request ----------------
GET https://httpbin.org/status/200
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive

None
---------------- response ----------------
200 OK https://httpbin.org/status/200
Date: Thu, 14 May 2020 20:10:13 GMT
Content-Type: text/html; charset=utf-8
Content-Length: 0
Connection: keep-alive
Server: gunicorn/19.9.0
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true

एक जीयूआई रास्ता

जब आपके पास बहुत सारी क्वेरीज़ होती हैं, तो एक साधारण UI और रिकॉर्ड्स को फ़िल्टर करने का एक तरीका काम में आता है। मैं उसके लिए क्रोनोलोगर (जो मैं लेखक हूं) का उपयोग करके दिखाऊंगा ।

सबसे पहले, हुक को उन रिकॉर्ड का उत्पादन करने के लिए फिर से लिखा loggingगया है जो तार पर भेजते समय धारावाहिक कर सकते हैं। यह इस तरह दिख सकता है:

def logRoundtrip(response, *args, **kwargs): 
    extra = {
        'req': {
            'method': response.request.method,
            'url': response.request.url,
            'headers': response.request.headers,
            'body': response.request.body,
        }, 
        'res': {
            'code': response.status_code,
            'reason': response.reason,
            'url': response.url,
            'headers': response.headers,
            'body': response.text
        },
    }
    logger.debug('HTTP roundtrip', extra=extra)

session = requests.Session()
session.hooks['response'].append(logRoundtrip)

दूसरा, लॉगिंग कॉन्फ़िगरेशन को उपयोग करने के लिए अनुकूलित किया जाना है logging.handlers.HTTPHandler(जिसे क्रोनोलॉजर समझता है)।

import logging.handlers

chrono = logging.handlers.HTTPHandler(
  'localhost:8080', '/api/v1/record', 'POST', credentials=('logger', ''))
handlers = [logging.StreamHandler(), chrono]
logging.basicConfig(level=logging.DEBUG, handlers=handlers)

अंत में, क्रोनोलॉजर उदाहरण चलाएं। जैसे डॉकर का उपयोग करना:

docker run --rm -it -p 8080:8080 -v /tmp/db \
    -e CHRONOLOGER_STORAGE_DSN=sqlite:////tmp/db/chrono.sqlite \
    -e CHRONOLOGER_SECRET=example \
    -e CHRONOLOGER_ROLES="basic-reader query-reader writer" \
    saaj/chronologer \
    python -m chronologer -e production serve -u www-data -g www-data -m

और फिर से अनुरोध करें:

session.get('https://httpbin.org/user-agent')
session.get('https://httpbin.org/status/200')

स्ट्रीम हैंडलर उत्पादन करेगा:

DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): httpbin.org:443
DEBUG:urllib3.connectionpool:https://httpbin.org:443 "GET /user-agent HTTP/1.1" 200 45
DEBUG:httplogger:HTTP roundtrip
DEBUG:urllib3.connectionpool:https://httpbin.org:443 "GET /status/200 HTTP/1.1" 200 0
DEBUG:httplogger:HTTP roundtrip

अब यदि आप http: // localhost: 8080 / (यूज़रनेम के लिए "लकड़हारा" और बेसिक कोरपॉप पॉपअप के लिए पासवर्ड का उपयोग करते हैं) खोलें और "ओपन" बटन पर क्लिक करें, आपको कुछ इस तरह देखना चाहिए: