node.js - library - Cómo capturar mensajes http de la biblioteca Request Node con Fiddler

node request post json

Question

Las solicitudes regulares iniciadas por el cliente al servidor de nodo se capturan bien en Fiddler. Sin embargo, las solicitudes enviadas desde el nodo a un servicio web no se capturan. No ayudó a pasar la configuración para el proxy (127.0.0.1:8888) al método de solicitud. ¿Cómo puedo enrutar los mensajes de solicitud a través de Fiddler?

var http = require(''http'');
var request = require(''request'');

request.get(webserviceURL, { "auth" : {"user": "user", "pass" = "pass", sendImmediately: true },
"proxy" : { "host" : "127.0.0.1", "port" : 8888 }},
function (error, response) { console.log( "response received" );
});

Solicitud de repo: https://github.com/mikeal/request

Answer 1

Fiddler trabaja configurando sus "Opciones de Internet" (desde el menú de inicio) "Conexiones"> "Configuración de LAN"> "Servidor Proxy" a su puerto, haciendo que todo el tráfico HTTP (clientes que obedecen esta configuración) lo atraviese.

Debería apuntar la biblioteca del cliente de node.js para usar un proxy, las configuraciones se escriben en ese diálogo de opciones después de iniciar Fiddler.

Answer 2

He estado esperando lo mismo ... un equivalente de la pestaña Network en Chrome DevTools, solo para Nodejs. Desafortunadamente, no parece que exista uno. No tengo Fiddler en macos, así que esta es la forma en que traté de aplastar los métodos require(''http'') para iniciar sesión y pasar. Dejando esto aquí en caso de que lo necesite de nuevo o si alguien más lo encuentra útil. Puede activarlo adjuntando un depurador y require(''filename'')() el archivo que contiene este script.

module.exports = () => {
    const http = require(''http'');
    http._request = http.request;

    global.DO_LOG_AJAX = true;
    const log = str => {
        if (global.DO_LOG_AJAX) {
            console.debug(str);
        }
    };

    const flushLog = (requestLines, responseLines) => {
        if (global.DO_LOG_AJAX) {
            log([
                ''----------------Begin Request-----------------------------------'',
                ...requestLines,
                ''----------------End Request / Begin Response--------------------'',
                ...responseLines,
                ''----------------End Reponse-------------------------------------'',
            ].join(''/n''));
        }
    };

    let write;
    let end;
    http.request = (...requestParams) => {
        const req = http._request(...requestParams);
        const { method, path, headers, host, port } = requestParams[0];
        const requestLogLines = [];
        requestLogLines.push(`${method} ${path}`);
        requestLogLines.push(`Host: ${host}:${port}`);
        for (const header of Object.keys(headers)) {
            requestLogLines.push(`${header}: ${headers[header]}`);
        }
        write = write || req.write;
        end = end || req.end;

        req.on(''error'', err => {
            log({ err });
        });

        req._write = write;
        req._end = end;
        const requestBody = [];
        req.write = (...writeParams) => {
            requestBody.push(writeParams[0].toString());
            return req._write(...writeParams);
        };
        req.end = (...endParams) => {
            if (endParams[0]) {
                requestBody.push(endParams[0].toString());
            }
            requestLogLines.push('''');
            requestLogLines.push(requestBody.join(''''));
            return req._end(...endParams);
        };

        const responseLogLines = [];
        req.once(''response'', response => {
            const responseBody = [];
            responseLogLines.push(`${response.statusCode} ${response.statusMessage}`);
            for (const header of Object.keys(response.headers)) {
                responseLogLines.push(`${header}: ${response.headers[header]}`);
            }
            const onData = chunk => {
                responseBody.push(chunk.toString());
            };
            const onClose = err => {
                responseLogLines.push('''');
                responseLogLines.push(responseBody.join(''''));
                responseLogLines.push('''');
                responseLogLines.push(`--- ERROR --- ${err.toString()}`);
                flushLog(requestLogLines, responseLogLines);
                req.removeListener(''data'', onData);
            };
            const onEnd = () => {
                responseLogLines.push('''');
                responseLogLines.push(responseBody.join(''''));
                flushLog(requestLogLines, responseLogLines);
                req.removeListener(''data'', onData);
            };
            response.on(''data'', onData);
            response.once(''close'', onClose);
            response.once(''end'', onEnd);
        });

        return req;
    };
};

Answer 3

Intenté hacerlo yo mismo (usando Fiddler y la biblioteca de solicitudes de npm). Así es como lo tengo funcionando:

process.env[''NODE_TLS_REJECT_UNAUTHORIZED''] = ''0''; // Ignore ''UNABLE_TO_VERIFY_LEAF_SIGNATURE'' authorization error

// Issue the request
request(
{
    method: "GET",
    uri: "https://secure.somewebsite.com/",
    proxy: "http://127.0.0.1:8888" // Note the fully-qualified path to Fiddler proxy. No "https" is required, even for https connections to outside.
},
function(err, response, body) {
    console.log("done");
});

Esto es con Fiddler2 utilizando las opciones de puerto y proxy predeterminadas (y sin autenticación de proxy).

Answer 4

La opción de proxy debe ser una url completa, como esta:

proxy : "http://127.0.0.1:8888"

Answer 5

Para hacer esto en una base ad-hoc, sin cambiar su código, puede usar variables de entorno.

Solicitud de respetos:

• HTTP_PROXY
• HTTPS_PROXY
• NO_PROXY

Por lo tanto, para establecer un proxy, simplemente configúrelos en su consola antes de ejecutar su proceso.

Por ejemplo, para configurar el uso de proxy http y https:

set HTTP_PROXY="http://127.0.0.1:8888"
set HTTPS_PROXY="http://127.0.0.1:8888"
set NODE_TLS_REJECT_UNAUTHORIZED=0

La última línea detiene los problemas con SSL a través del proxy fiddler.