#Introducción
Laravel proporciona una API expresiva y mínima alrededor del cliente HTTP Guzzle, que le permite realizar rápidamente solicitudes HTTP salientes para comunicarse con otras aplicaciones web. El envoltorio de Laravel alrededor de Guzzle está enfocado en sus casos de uso más comunes y en una experiencia de desarrollo excelente.
Antes de comenzar, debe asegurarse de haber instalado el paquete Guzzle como una dependencia de su aplicación. Por defecto, Laravel incluye automáticamente esta dependencia. Sin embargo, si previamente eliminó el paquete, puede instalarlo nuevamente mediante Composer:
composer require guzzlehttp/guzzle
#Realizar solicitudes
Para realizar solicitudes, puede usar los métodos head, get, post, put, patch y delete proporcionados por el facade Http. Primero, veamos cómo hacer una solicitud básica GET a otra URL:
use Illuminate\Support\Facades\Http;
$response = Http::get('http://example.com');
El método get devuelve una instancia de Illuminate\Http\Client\Response, que proporciona una variedad de métodos que pueden usarse para inspeccionar la respuesta:
$response->body() : string;
$response->json($key = null, $default = null) : array|mixed;
$response->object() : object;
$response->collect($key = null) : Illuminate\Support\Collection;
$response->status() : int;
$response->successful() : bool;
$response->redirect(): bool;
$response->failed() : bool;
$response->clientError() : bool;
$response->header($header) : string;
$response->headers() : array;
El objeto Illuminate\Http\Client\Response también implementa la interfaz PHP ArrayAccess, lo que le permite acceder directamente a los datos JSON de la respuesta:
return Http::get('http://example.com/users/1')['name'];
Además de los métodos de respuesta listados arriba, los siguientes métodos pueden usarse para determinar si la respuesta tiene un código de estado dado:
$response->ok() : bool; // 200 OK
$response->created() : bool; // 201 Created
$response->accepted() : bool; // 202 Accepted
$response->noContent() : bool; // 204 No Content
$response->movedPermanently() : bool; // 301 Moved Permanently
$response->found() : bool; // 302 Found
$response->badRequest() : bool; // 400 Bad Request
$response->unauthorized() : bool; // 401 Unauthorized
$response->paymentRequired() : bool; // 402 Payment Required
$response->forbidden() : bool; // 403 Forbidden
$response->notFound() : bool; // 404 Not Found
$response->requestTimeout() : bool; // 408 Request Timeout
$response->conflict() : bool; // 409 Conflict
$response->unprocessableEntity() : bool; // 422 Unprocessable Entity
$response->tooManyRequests() : bool; // 429 Too Many Requests
$response->serverError() : bool; // 500 Internal Server Error
#Plantillas URI
El cliente HTTP también le permite construir URLs de solicitud usando la especificación de plantillas URI. Para definir los parámetros de URL que pueden expandirse mediante su plantilla URI, puede usar el método withUrlParameters:
Http::withUrlParameters([
'endpoint' => 'https://laravel.com',
'page' => 'docs',
'version' => '9.x',
'topic' => 'validation',
])->get('{+endpoint}/{page}/{version}/{topic}');
#Volcado de solicitudes
Si desea volcar la instancia de la solicitud saliente antes de que se envíe y terminar la ejecución del script, puede agregar el método dd al inicio de la definición de su solicitud:
return Http::dd()->get('http://example.com');
#Datos de la solicitud
Por supuesto, es común al hacer solicitudes POST, PUT y PATCH enviar datos adicionales con su solicitud, por lo que estos métodos aceptan un array de datos como segundo argumento. Por defecto, los datos se enviarán usando el tipo de contenido application/json:
use Illuminate\Support\Facades\Http;
$response = Http::post('http://example.com/users', [
'name' => 'Steve',
'role' => 'Network Administrator',
]);
#Parámetros de consulta en solicitudes GET
Al hacer solicitudes GET, puede anexar una cadena de consulta directamente a la URL o pasar un array de pares clave / valor como segundo argumento al método get:
$response = Http::get('http://example.com/users', [
'name' => 'Taylor',
'page' => 1,
]);
Alternativamente, puede usar el método withQueryParameters:
Http::retry(3, 100)->withQueryParameters([
'name' => 'Taylor',
'page' => 1,
])->get('http://example.com/users')
#Enviar solicitudes con codificación Form URL Encoded
Si desea enviar datos usando el tipo de contenido application/x-www-form-urlencoded, debe llamar al método asForm antes de hacer su solicitud:
$response = Http::asForm()->post('http://example.com/users', [
'name' => 'Sara',
'role' => 'Privacy Consultant',
]);
#Enviar un cuerpo de solicitud en bruto
Puede usar el método withBody si desea proporcionar un cuerpo de solicitud en bruto al hacer una solicitud. El tipo de contenido puede proporcionarse mediante el segundo argumento del método:
$response = Http::withBody(
base64_encode($photo), 'image/jpeg'
)->post('http://example.com/photo');
#Solicitudes multipartes
Si desea enviar archivos como solicitudes multipartes, debe llamar al método attach antes de hacer su solicitud. Este método acepta el nombre del archivo y su contenido. Si es necesario, puede proporcionar un tercer argumento que será considerado como el nombre del archivo, mientras que un cuarto argumento puede usarse para proporcionar encabezados asociados con el archivo:
$response = Http::attach(
'attachment', file_get_contents('photo.jpg'), 'photo.jpg', ['Content-Type' => 'image/jpeg']
)->post('http://example.com/attachments');
En lugar de pasar el contenido en bruto de un archivo, puede pasar un recurso de flujo:
$photo = fopen('photo.jpg', 'r');
$response = Http::attach(
'attachment', $photo, 'photo.jpg'
)->post('http://example.com/attachments');
#Encabezados
Se pueden agregar encabezados a las solicitudes usando el método withHeaders. Este método withHeaders acepta un array de pares clave/valor:
$response = Http::withHeaders([
'X-First' => 'foo',
'X-Second' => 'bar'
])->post('http://example.com/users', [
'name' => 'Taylor',
]);
Puede usar el método accept para especificar el tipo de contenido que su aplicación espera en respuesta a su solicitud:
$response = Http::accept('application/json')->get('http://example.com/users');
Para mayor comodidad, puede usar el método acceptJson para especificar rápidamente que su aplicación espera el tipo de contenido application/json en respuesta a su solicitud:
$response = Http::acceptJson()->get('http://example.com/users');
El método withHeaders fusiona nuevos encabezados con los encabezados existentes de la solicitud. Si es necesario, puede reemplazar todos los encabezados completamente usando el método replaceHeaders:
$response = Http::withHeaders([
'X-Original' => 'foo',
])->replaceHeaders([
'X-Replacement' => 'bar',
])->post('http://example.com/users', [
'name' => 'Taylor',
]);
#Autenticación
Puede especificar credenciales de autenticación básica y digest usando los métodos withBasicAuth y withDigestAuth, respectivamente:
// Autenticación básica...
$response = Http::withBasicAuth('taylor@laravel.com', 'secret')->post(/* ... */);
// Autenticación digest...
$response = Http::withDigestAuth('taylor@laravel.com', 'secret')->post(/* ... */);
#Tokens Bearer
Si desea agregar rápidamente un token bearer al encabezado Authorization de la solicitud, puede usar el método withToken:
$response = Http::withToken('token')->post(/* ... */);
#Tiempo de espera
El método timeout puede usarse para especificar el número máximo de segundos para esperar una respuesta. Por defecto, el cliente HTTP esperará un máximo de 30 segundos:
$response = Http::timeout(3)->get(/* ... */);
Si se excede el tiempo de espera dado, se lanzará una instancia de Illuminate\Http\Client\ConnectionException.
Puede especificar el número máximo de segundos para esperar mientras se intenta conectar a un servidor usando el método connectTimeout:
$response = Http::connectTimeout(3)->get(/* ... */);
#Reintentos
Si desea que el cliente HTTP reintente automáticamente la solicitud si ocurre un error de cliente o servidor, puede usar el método retry. El método retry acepta el número máximo de veces que se debe intentar la solicitud y el número de milisegundos que Laravel debe esperar entre intentos:
$response = Http::retry(3, 100)->post(/* ... */);
Si desea calcular manualmente el número de milisegundos para esperar entre intentos, puede pasar un closure como segundo argumento al método retry:
use Exception;
$response = Http::retry(3, function (int $attempt, Exception $exception) {
return $attempt * 100;
})->post(/* ... */);
Para mayor comodidad, también puede proporcionar un array como primer argumento al método retry. Este array se usará para determinar cuántos milisegundos esperar entre intentos sucesivos:
$response = Http::retry([100, 200])->post(/* ... */);
Si es necesario, puede pasar un tercer argumento al método retry. El tercer argumento debe ser un callable que determine si realmente se deben intentar los reintentos. Por ejemplo, puede querer reintentar la solicitud solo si la solicitud inicial encuentra una ConnectionException:
use Exception;
use Illuminate\Http\Client\PendingRequest;
$response = Http::retry(3, 100, function (Exception $exception, PendingRequest $request) {
return $exception instanceof ConnectionException;
})->post(/* ... */);
Si un intento de solicitud falla, puede querer hacer un cambio en la solicitud antes de que se realice un nuevo intento. Puede lograr esto modificando el argumento de solicitud proporcionado al callable que pasó al método retry. Por ejemplo, podría querer reintentar la solicitud con un nuevo token de autorización si el primer intento devolvió un error de autenticación:
use Exception;
use Illuminate\Http\Client\PendingRequest;
use Illuminate\Http\Client\RequestException;
$response = Http::withToken($this->getToken())->retry(2, 0, function (Exception $exception, PendingRequest $request) {
if (! $exception instanceof RequestException || $exception->response->status() !== 401) {
return false;
}
$request->withToken($this->getNewToken());
return true;
})->post(/* ... */);
Si todas las solicitudes fallan, se lanzará una instancia de Illuminate\Http\Client\RequestException. Si desea deshabilitar este comportamiento, puede proporcionar un argumento throw con valor false. Cuando está deshabilitado, se devolverá la última respuesta recibida por el cliente después de que se hayan intentado todos los reintentos:
$response = Http::retry(3, 100, throw: false)->post(/* ... */);
Si todas las solicitudes fallan debido a un problema de conexión, se seguirá lanzando una Illuminate\Http\Client\ConnectionException incluso cuando el argumento throw esté establecido en false.
#Manejo de errores
A diferencia del comportamiento predeterminado de Guzzle, el envoltorio del cliente HTTP de Laravel no lanza excepciones en errores de cliente o servidor (respuestas con códigos 400 y 500 del servidor). Puede determinar si se devolvió uno de estos errores usando los métodos successful, clientError o serverError:
// Determinar si el código de estado es >= 200 y < 300...
$response->successful();
// Determinar si el código de estado es >= 400...
$response->failed();
// Determinar si la respuesta tiene un código de estado de nivel 400...
$response->clientError();
// Determinar si la respuesta tiene un código de estado de nivel 500...
$response->serverError();
// Ejecutar inmediatamente el callback dado si hubo un error de cliente o servidor...
$response->onError(callable $callback);
#Lanzar excepciones
Si tiene una instancia de respuesta y desea lanzar una instancia de Illuminate\Http\Client\RequestException si el código de estado de la respuesta indica un error de cliente o servidor, puede usar los métodos throw o throwIf:
use Illuminate\Http\Client\Response;
$response = Http::post(/* ... */);
// Lanzar una excepción si ocurrió un error de cliente o servidor...
$response->throw();
// Lanzar una excepción si ocurrió un error y la condición dada es verdadera...
$response->throwIf($condition);
// Lanzar una excepción si ocurrió un error y el closure dado devuelve true...
$response->throwIf(fn (Response $response) => true);
// Lanzar una excepción si ocurrió un error y la condición dada es falsa...
$response->throwUnless($condition);
// Lanzar una excepción si ocurrió un error y el closure dado devuelve false...
$response->throwUnless(fn (Response $response) => false);
// Lanzar una excepción si la respuesta tiene un código de estado específico...
$response->throwIfStatus(403);
// Lanzar una excepción a menos que la respuesta tenga un código de estado específico...
$response->throwUnlessStatus(200);
return $response['user']['id'];
La instancia Illuminate\Http\Client\RequestException tiene una propiedad pública $response que le permitirá inspeccionar la respuesta devuelta.
El método throw devuelve la instancia de respuesta si no ocurrió ningún error, permitiéndole encadenar otras operaciones al método throw:
return Http::post(/* ... */)->throw()->json();
Si desea realizar alguna lógica adicional antes de que se lance la excepción, puede pasar un closure al método throw. La excepción se lanzará automáticamente después de que se invoque el closure, por lo que no necesita volver a lanzar la excepción desde dentro del closure:
use Illuminate\Http\Client\Response;
use Illuminate\Http\Client\RequestException;
return Http::post(/* ... */)->throw(function (Response $response, RequestException $e) {
// ...
})->json();
#Middleware de Guzzle
Dado que el cliente HTTP de Laravel está potenciado por Guzzle, puede aprovechar el Middleware de Guzzle para manipular la solicitud saliente o inspeccionar la respuesta entrante. Para manipular la solicitud saliente, registre un middleware de Guzzle mediante el método withRequestMiddleware:
use Illuminate\Support\Facades\Http;
use Psr\Http\Message\RequestInterface;
$response = Http::withRequestMiddleware(
function (RequestInterface $request) {
return $request->withHeader('X-Example', 'Value');
}
)->get('http://example.com');
De igual forma, puede inspeccionar la respuesta HTTP entrante registrando un middleware mediante el método withResponseMiddleware:
use Illuminate\Support\Facades\Http;
use Psr\Http\Message\ResponseInterface;
$response = Http::withResponseMiddleware(
function (ResponseInterface $response) {
$header = $response->getHeader('X-Example');
// ...
return $response;
}
)->get('http://example.com');
#Middleware global
A veces, puede querer registrar un middleware que se aplique a cada solicitud saliente y respuesta entrante. Para lograr esto, puede usar los métodos globalRequestMiddleware y globalResponseMiddleware. Normalmente, estos métodos deben invocarse en el método boot del AppServiceProvider de su aplicación:
use Illuminate\Support\Facades\Http;
Http::globalRequestMiddleware(fn ($request) => $request->withHeader(
'User-Agent', 'Example Application/1.0'
));
Http::globalResponseMiddleware(fn ($response) => $response->withHeader(
'X-Finished-At', now()->toDateTimeString()
));
#Opciones de Guzzle
Puede especificar opciones adicionales de opciones de solicitud de Guzzle usando el método withOptions. El método withOptions acepta un array de pares clave/valor:
$response = Http::withOptions([
'debug' => true,
])->get('http://example.com/users');
#Solicitudes concurrentes
A veces, puede querer realizar múltiples solicitudes HTTP concurrentemente. En otras palabras, desea que varias solicitudes se envíen al mismo tiempo en lugar de emitirlas secuencialmente. Esto puede llevar a mejoras sustanciales en el rendimiento al interactuar con APIs HTTP lentas.
Afortunadamente, puede lograr esto usando el método pool. El método pool acepta una función anónima que recibe una instancia de Illuminate\Http\Client\Pool, lo que le permite añadir fácilmente solicitudes al grupo de solicitudes para su envío:
use Illuminate\Http\Client\Pool;
use Illuminate\Support\Facades\Http;
$responses = Http::pool(fn (Pool $pool) => [
$pool->get('http://localhost/first'),
$pool->get('http://localhost/second'),
$pool->get('http://localhost/third'),
]);
return $responses[0]->ok() &&
$responses[1]->ok() &&
$responses[2]->ok();
Como puede ver, cada instancia de respuesta puede accederse según el orden en que fue agregada al grupo. Si lo desea, puede nombrar las solicitudes usando el método as, lo que le permite acceder a las respuestas correspondientes por nombre:
use Illuminate\Http\Client\Pool;
use Illuminate\Support\Facades\Http;
$responses = Http::pool(fn (Pool $pool) => [
$pool->as('first')->get('http://localhost/first'),
$pool->as('second')->get('http://localhost/second'),
$pool->as('third')->get('http://localhost/third'),
]);
return $responses['first']->ok();
#Personalización de solicitudes concurrentes
El método pool no puede encadenarse con otros métodos del cliente HTTP como withHeaders o middleware. Si desea aplicar encabezados personalizados o middleware a las solicitudes agrupadas, debe configurar esas opciones en cada solicitud dentro del grupo:
use Illuminate\Http\Client\Pool;
use Illuminate\Support\Facades\Http;
$headers = [
'X-Example' => 'example',
];
$responses = Http::pool(fn (Pool $pool) => [
$pool->withHeaders($headers)->get('http://laravel.test/test'),
$pool->withHeaders($headers)->get('http://laravel.test/test'),
$pool->withHeaders($headers)->get('http://laravel.test/test'),
]);
#Macros
El cliente HTTP de Laravel le permite definir "macros", que pueden servir como un mecanismo fluido y expresivo para configurar rutas y encabezados comunes al interactuar con servicios en toda su aplicación. Para comenzar, puede definir la macro dentro del método boot de la clase App\Providers\AppServiceProvider de su aplicación:
use Illuminate\Support\Facades\Http;
/**
* Bootstrap any application services.
*/
public function boot(): void
{
Http::macro('github', function () {
return Http::withHeaders([
'X-Example' => 'example',
])->baseUrl('https://github.com');
});
}
Una vez que su macro ha sido configurada, puede invocarla desde cualquier lugar en su aplicación para crear una solicitud pendiente con la configuración especificada:
$response = Http::github()->get('/');
#Pruebas
Muchos servicios de Laravel proporcionan funcionalidades para ayudarle a escribir pruebas de manera fácil y expresiva, y el cliente HTTP de Laravel no es la excepción. El método fake del facade Http le permite instruir al cliente HTTP para que devuelva respuestas simuladas / ficticias cuando se realicen solicitudes.
#Simulación de respuestas
Por ejemplo, para instruir al cliente HTTP para que devuelva respuestas vacías con código de estado 200 para cada solicitud, puede llamar al método fake sin argumentos:
use Illuminate\Support\Facades\Http;
Http::fake();
$response = Http::post(/* ... */);
#Simulación de URLs específicas
Alternativamente, puede pasar un array al método fake. Las claves del array deben representar patrones de URL que desea simular y sus respuestas asociadas. El carácter * puede usarse como comodín. Cualquier solicitud realizada a URLs que no hayan sido simuladas se ejecutará realmente. Puede usar el método response del facade Http para construir respuestas simuladas para estos endpoints:
Http::fake([
// Simular una respuesta JSON para endpoints de GitHub...
'github.com/*' => Http::response(['foo' => 'bar'], 200, $headers),
// Simular una respuesta de cadena para endpoints de Google...
'google.com/*' => Http::response('Hello World', 200, $headers),
]);
Si desea especificar un patrón de URL de reserva que simule todas las URLs no coincidentes, puede usar un solo carácter *:
Http::fake([
// Simular una respuesta JSON para endpoints de GitHub...
'github.com/*' => Http::response(['foo' => 'bar'], 200, ['Headers']),
// Simular una respuesta de cadena para todos los demás endpoints...
'*' => Http::response('Hello World', 200, ['Headers']),
]);
#Simulación de secuencias de respuestas
A veces puede necesitar especificar que una sola URL debe devolver una serie de respuestas simuladas en un orden específico. Puede lograr esto usando el método Http::sequence para construir las respuestas:
Http::fake([
// Simular una serie de respuestas para endpoints de GitHub...
'github.com/*' => Http::sequence()
->push('Hello World', 200)
->push(['foo' => 'bar'], 200)
->pushStatus(404),
]);
Cuando todas las respuestas en una secuencia de respuestas han sido consumidas, cualquier solicitud adicional hará que la secuencia lance una excepción. Si desea especificar una respuesta predeterminada que se debe devolver cuando una secuencia esté vacía, puede usar el método whenEmpty:
Http::fake([
// Simular una serie de respuestas para endpoints de GitHub...
'github.com/*' => Http::sequence()
->push('Hello World', 200)
->push(['foo' => 'bar'], 200)
->whenEmpty(Http::response()),
]);
Si desea simular una secuencia de respuestas pero no necesita especificar un patrón de URL específico que debe simularse, puede usar el método Http::fakeSequence:
Http::fakeSequence()
->push('Hello World', 200)
->whenEmpty(Http::response());
#Callback de simulación
Si requiere una lógica más complicada para determinar qué respuestas devolver para ciertos endpoints, puede pasar un closure al método fake. Este closure recibirá una instancia de Illuminate\Http\Client\Request así como un array de opciones. El closure debe devolver una instancia de respuesta. Dentro de su closure, puede realizar la lógica necesaria para determinar qué tipo de respuesta devolver:
use Illuminate\Http\Client\Request;
Http::fake(function (Request $request, array $options) {
return Http::response('Hello World', 200);
});
#Prevención de solicitudes no deseadas
Si desea asegurarse de que todas las solicitudes enviadas a través del cliente HTTP hayan sido simuladas durante su prueba individual o suite completa de pruebas, puede llamar al método preventStrayRequests. Después de llamar a este método, cualquier solicitud que no tenga una respuesta simulada correspondiente lanzará una excepción en lugar de realizar la solicitud HTTP real:
use Illuminate\Support\Facades\Http;
Http::preventStrayRequests();
Http::fake([
'github.com/*' => Http::response('ok'),
]);
// Se devuelve una respuesta "ok"...
Http::get('https://github.com/laravel/framework');
// Se lanza una excepción...
Http::get('https://laravel.com');
#Inspección de solicitudes
Al simular respuestas, puede que ocasionalmente desee inspeccionar las solicitudes que el cliente recibe para asegurarse de que su aplicación está enviando los datos o encabezados correctos. Puede lograr esto llamando al método Http::assertSent después de llamar a Http::fake.
El método assertSent acepta un closure que recibirá una instancia de Illuminate\Http\Client\Request y debe devolver un valor booleano que indique si la solicitud coincide con sus expectativas. Para que la prueba pase, al menos una solicitud debe haberse emitido que coincida con las expectativas dadas:
use Illuminate\Http\Client\Request;
use Illuminate\Support\Facades\Http;
Http::fake();
Http::withHeaders([
'X-First' => 'foo',
])->post('http://example.com/users', [
'name' => 'Taylor',
'role' => 'Developer',
]);
Http::assertSent(function (Request $request) {
return $request->hasHeader('X-First', 'foo') &&
$request->url() == 'http://example.com/users' &&
$request['name'] == 'Taylor' &&
$request['role'] == 'Developer';
});
Si es necesario, puede afirmar que una solicitud específica no fue enviada usando el método assertNotSent:
use Illuminate\Http\Client\Request;
use Illuminate\Support\Facades\Http;
Http::fake();
Http::post('http://example.com/users', [
'name' => 'Taylor',
'role' => 'Developer',
]);
Http::assertNotSent(function (Request $request) {
return $request->url() === 'http://example.com/posts';
});
Puede usar el método assertSentCount para afirmar cuántas solicitudes fueron "enviadas" durante la prueba:
Http::fake();
Http::assertSentCount(5);
O puede usar el método assertNothingSent para afirmar que no se enviaron solicitudes durante la prueba:
Http::fake();
Http::assertNothingSent();
#Registro de solicitudes / respuestas
Puede usar el método recorded para recopilar todas las solicitudes y sus respuestas correspondientes. El método recorded devuelve una colección de arrays que contiene instancias de Illuminate\Http\Client\Request y Illuminate\Http\Client\Response:
Http::fake([
'https://laravel.com' => Http::response(status: 500),
'https://nova.laravel.com/' => Http::response(),
]);
Http::get('https://laravel.com');
Http::get('https://nova.laravel.com/');
$recorded = Http::recorded();
[$request, $response] = $recorded[0];
Además, el método recorded acepta un closure que recibirá una instancia de Illuminate\Http\Client\Request y Illuminate\Http\Client\Response y puede usarse para filtrar pares solicitud / respuesta según sus expectativas:
use Illuminate\Http\Client\Request;
use Illuminate\Http\Client\Response;
Http::fake([
'https://laravel.com' => Http::response(status: 500),
'https://nova.laravel.com/' => Http::response(),
]);
Http::get('https://laravel.com');
Http::get('https://nova.laravel.com/');
$recorded = Http::recorded(function (Request $request, Response $response) {
return $request->url() !== 'https://laravel.com' &&
$response->successful();
});
#Eventos
Laravel dispara tres eventos durante el proceso de envío de solicitudes HTTP. El evento RequestSending se dispara antes de que se envíe una solicitud, mientras que el evento ResponseReceived se dispara después de que se recibe una respuesta para una solicitud dada. El evento ConnectionFailed se dispara si no se recibe respuesta para una solicitud dada.
Los eventos RequestSending y ConnectionFailed contienen una propiedad pública $request que puede usar para inspeccionar la instancia Illuminate\Http\Client\Request. De igual forma, el evento ResponseReceived contiene una propiedad $request así como una propiedad $response que puede usarse para inspeccionar la instancia Illuminate\Http\Client\Response. Puede registrar escuchas de eventos para este evento en su proveedor de servicios App\Providers\EventServiceProvider:
/**
* The event listener mappings for the application.
*
* @var array
*/
protected $listen = [
'Illuminate\Http\Client\Events\RequestSending' => [
'App\Listeners\LogRequestSending',
],
'Illuminate\Http\Client\Events\ResponseReceived' => [
'App\Listeners\LogResponseReceived',
],
'Illuminate\Http\Client\Events\ConnectionFailed' => [
'App\Listeners\LogConnectionFailed',
],
];