Middleware de débogage / surveillance pour les applications python wsgi

Question

Je recherche un middleware wsgi qui me permet de contourner une application wsgi et qui me permet de surveiller les requêtes http entrantes et sortantes et les champs d'en-tête.

Quelque chose comme les en-têtes live de Firefox, mais côté serveur.

Answer 1

Le middleware

from wsgiref.util import request_uri
import sys

def logging_middleware(application, stream=sys.stdout):
    def _logger(environ, start_response):
        stream.write('REQUEST\n')
        stream.write('%s %s\n' %(
            environ['REQUEST_METHOD'],
            request_uri(environ),
        ))

        for name, value in environ.items():
            if name.startswith('HTTP_'):
                stream.write('    %s: %s\n' %(
                    name[5:].title().replace('_', '-'),
                    value,
                ))
        stream.flush()
        def _start_response(code, headers):
            stream.write('RESPONSE\n')
            stream.write('%s\n' % code)
            for data in headers:
                stream.write('    %s: %s\n' % data)
            stream.flush()
            start_response(code, headers)
        return application(environ, _start_response)
    return _logger

Le test

def application(environ, start_response):
    start_response('200 OK', [
        ('Content-Type', 'text/html')
    ])
    return ['Hello World']

if __name__ == '__main__':
    logger = logging_middleware(application)
    from wsgiref.simple_server import make_server
    httpd = make_server('', 1234, logger)
    httpd.serve_forever()

Voir aussi le débogueur de werkzeug , écrit Armin, utile pour le débogage interactif.

Answer 2

Cela ne devrait pas être trop difficile de vous écrire tant que vous n’avez besoin que des en-têtes. Essayez ça:

import sys

def log_headers(app, stream=None):
    if stream is None:
        stream = sys.stdout
    def proxy(environ, start_response):
        for key, value in environ.iteritems():
            if key.startswith('HTTP_'):
                stream.write('%s: %s\n' % (key[5:].title().replace('_', '-'), value))
        return app(environ, start_response)
    return proxy

Answer 3

Si vous souhaitez des journaux de style Apache, essayez paste.translogger

Mais pour quelque chose de plus complet, mais pas dans un emplacement très pratique ou stable (peut-être copiez-le dans votre source) est wsgifilter.proxyapp.DebugHeaders

Et en écrire un en utilisant WebOb :

import webob, sys
class LogHeaders(object):
    def __init__(self, app, stream=sys.stderr):
        self.app = app
        self.stream = stream
    def __call__(self, environ, start_response):
        req = webob.Request(environ)
        resp = req.get_response(self.app)
        print >> self.stream, 'Request:\n%s\n\nResponse:\n%s\n\n\n' % (req, resp)
        return resp(environ, start_response)

Answer 4

La documentation de mod_wsgi fournit divers conseils sur le débogage qui s'appliquent à tout mécanisme d'hébergement WSGI et pas seulement à mod_wsgi. Voir:

http://code.google.com/p/modwsgi/wiki/DebuggingTechniques

Ceci inclut un exemple de middleware WSGI qui capture la demande et la réponse.

Answer 5

Mon projet WebCore contient un peu de middleware qui enregistre l'intégralité de l'environnement WSGI (donc les sessions Beaker, les en-têtes, etc.) de la demande entrante, les en-têtes des réponses sortantes, ainsi que les informations de performances dans une base de données MongoDB. Les frais généraux moyens sont d’environ 4 ms.

Le module a été supprimé du package principal, mais n’a pas encore été intégré. La version actuelle de cette réponse est disponible dans l'historique Git:

http://github.com /blob/cd1d6dcbd081323869968c51a78eceb1a32007d8/web/extras/cprofile.py