HTTP Client
Introdução
Laravel fornece uma API expressiva e mínima em torno do client HTTP de Guzzle, permitindo que você faça rapidamente solicitações HTTP para se comunicar com outros aplicativos web. O wrapper do Laravel em Guzzle é focado em seus casos mais comuns de uso e uma excelente experiência de desenvolvedor.
Fazendo Pedidos
Para fazer requisições, você pode usar os métodos head
, get
, post
, put
, patch
e delete
fornecidos pela fachada Http
. Vamos começar examinando como fazer uma requisição básica GET
a outro URL.
use Illuminate\Support\Facades\Http;
$response = Http::get('http://example.com');
O método 'get' retorna uma instância de Illuminate\Http\Client\Response, que fornece um conjunto de métodos para inspecionar a resposta:
$response->body() : string;
$response->json($key = null, $default = null) : 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;
O objeto Illuminate\Http\Client\Response
também implementa a interface PHP ArrayAccess
, permitindo que você acesse dados de resposta JSON diretamente na resposta.
return Http::get('http://example.com/users/1')['name'];
Além dos métodos de resposta listados acima, os seguintes métodos podem ser usados para determinar se a resposta tem um determinado código de estado:
$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
URI Templates
O cliente HTTP também permite construir URLs de solicitação usando a especificação da especificação de modelo de URI. Para definir os parâmetros da URL que podem ser expandidos pelo seu modelo de URI, você pode usar o método withUrlParameters
:
Http::withUrlParameters([
'endpoint' => 'https://laravel.com',
'page' => 'docs',
'version' => '11.x',
'topic' => 'validation',
])->get('{+endpoint}/{page}/{version}/{topic}');
Pedidos de dumping
Se você gostaria de descartar o exemplo da solicitação que sai antes do envio e terminar a execução do script, você pode adicionar o método dd ao início da definição da sua solicitação:
return Http::dd()->get('http://example.com');
Solicitar dados
É claro que é comum ao realizar solicitações POST
, PUT
e PATCH
enviar dados adicionais com sua solicitação, então esses métodos aceitam uma matriz de dados como seu segundo argumento. Por padrão, os dados serão enviados usando o tipo de conteúdo application/json
:
use Illuminate\Support\Facades\Http;
$response = Http::post('http://example.com/users', [
'name' => 'Steve',
'role' => 'Network Administrator',
]);
Parâmetros de consulta de solicitação
Ao fazer solicitações GET, você pode anexar uma string de consulta diretamente para o URL ou passar um array de pares chave/valor como o segundo argumento do método get:
$response = Http::get('http://example.com/users', [
'name' => 'Taylor',
'page' => 1,
]);
Alternativamente, o método withQueryParams
pode ser usado:
Http::retry(3, 100)->withQueryParameters([
'name' => 'Taylor',
'page' => 1,
])->get('http://example.com/users')
Enviando Requisitos URL Codificados
Se você gostaria de enviar dados usando o tipo de conteúdo "application/x-www-form-urlencoded", você deve chamar o método "asForm" antes de fazer sua requisição.
$response = Http::asForm()->post('http://example.com/users', [
'name' => 'Sara',
'role' => 'Privacy Consultant',
]);
Enviando um corpo de requisição crua
Você pode usar o método 'withBody' se quiser fornecer um pedido de corpo bruto ao fazer um pedido. O tipo de conteúdo pode ser fornecido através do segundo argumento do método:
$response = Http::withBody(
base64_encode($photo), 'image/jpeg'
)->post('http://example.com/photo');
Pedidos de várias partes
Se você quiser enviar arquivos em requisições multipart, deverá chamar o método attach
antes de fazer sua requisição. Este método aceita o nome do arquivo e seu conteúdo. Se necessário, você pode fornecer um terceiro argumento que será considerado o nome do arquivo, enquanto um quarto argumento pode ser utilizado para fornecer cabeçalhos associados ao arquivo:
$response = Http::attach(
'attachment', file_get_contents('photo.jpg'), 'photo.jpg', ['Content-Type' => 'image/jpeg']
)->post('http://example.com/attachments');
Em vez de passar o conteúdo bruto de um arquivo, você pode passar um recurso de fluxo:
$photo = fopen('photo.jpg', 'r');
$response = Http::attach(
'attachment', $photo, 'photo.jpg'
)->post('http://example.com/attachments');
Cabeçalhos
Cabeçalhos podem ser adicionados a requisições usando o método withHeaders
. O método withHeaders
aceita um array de pares chave/valor:
$response = Http::withHeaders([
'X-First' => 'foo',
'X-Second' => 'bar'
])->post('http://example.com/users', [
'name' => 'Taylor',
]);
Você pode usar o método 'accept' para especificar o tipo de conteúdo que sua aplicação está esperando como resposta à sua requisição:
$response = Http::accept('application/json')->get('http://example.com/users');
Para conveniência, você pode usar o método acceptJson
para rapidamente especificar que seu aplicativo espera o tipo de conteúdo "application/json" na resposta à sua solicitação:
$response = Http::acceptJson()->get('http://example.com/users');
A withHeaders
mescla os cabeçalhos novos nos cabeçalhos existentes da requisição. Se necessário, você pode substituir todos os cabeçalhos totalmente usando o replaceHeaders
:
$response = Http::withHeaders([
'X-Original' => 'foo',
])->replaceHeaders([
'X-Replacement' => 'bar',
])->post('http://example.com/users', [
'name' => 'Taylor',
]);
Autenticação
Você pode especificar credenciais básicas de autenticação usando o método withBasicAuth
, e credenciais de autenticação de digest usando o método withDigestAuth
:
// Basic authentication...
$response = Http::withBasicAuth('taylor@laravel.com', 'secret')->post(/* ... */);
// Digest authentication...
$response = Http::withDigestAuth('taylor@laravel.com', 'secret')->post(/* ... */);
Tokens de portador
Se você gostaria de adicionar rapidamente um token de portador ao cabeçalho 'Autorização', você pode usar o método withToken
:
$response = Http::withToken('token')->post(/* ... */);
Tempo fora
O método "timeout" pode ser usado para especificar o número máximo de segundos à espera de uma resposta. Por padrão, o cliente HTTP será bloqueado após 30 segundos:
$response = Http::timeout(3)->get(/* ... */);
Se o tempo limite dado for excedido, uma exceção de Illuminate\Http\Client\ConnectionException
será lançada.
Você pode especificar o número máximo de segundos para esperar enquanto tenta se conectar a um servidor usando o método connectTimeout
:
$response = Http::connectTimeout(3)->get(/* ... */);
Retentativas
Se você gostaria que o cliente HTTP tentasse automaticamente a requisição caso ocorra algum erro de cliente ou servidor, você pode usar o método retry
. O método retry
aceita o número máximo de vezes que a requisição deve ser tentada e o número de milissegundos que Laravel deve esperar entre as tentativas:
$response = Http::retry(3, 100)->post(/* ... */);
Se você gostaria de calcular manualmente o número de milissegundos para dormir entre tentativas, você pode passar um fechamento como o segundo argumento para o método retry
:
use Exception;
$response = Http::retry(3, function (int $attempt, Exception $exception) {
return $attempt * 100;
})->post(/* ... */);
Para conveniência, você também pode fornecer uma matriz como o primeiro argumento para o método "retry". Esta matriz será usada para determinar quantos milissegundos dormir entre as tentativas subsequentes:
$response = Http::retry([100, 200])->post(/* ... */);
Se necessário, você pode passar um terceiro argumento para o método retry
. O terceiro argumento deve ser uma função que determina se as re-tentativas devem realmente ser feitas. Por exemplo, você pode querer fazer a requisição somente se a requisição inicial encontrar uma exceção ConnectionException
:
use Exception;
use Illuminate\Http\Client\PendingRequest;
$response = Http::retry(3, 100, function (Exception $exception, PendingRequest $request) {
return $exception instanceof ConnectionException;
})->post(/* ... */);
Se um pedido falhar, talvez queira fazer uma alteração no pedido antes de tentar novamente. Você pode fazer isso alterando o argumento do pedido fornecido ao chamar o método "retry". Por exemplo, você pode querer tentar novamente o pedido com um novo token de autorização se a primeira tentativa retornar um erro de autenticação:
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(/* ... */);
Se todas as solicitações falharem, uma instância de Illuminate\Http\Client\RequestException será lançada. Se você quiser desativar esse comportamento, você pode fornecer um argumento "throw" com o valor "false". Quando desativado, a última resposta recebida pelo cliente será retornada após todas as tentativas de novas tentativas:
$response = Http::retry(3, 100, throw: false)->post(/* ... */);
[!ALERTA] Se todas as solicitações falharem devido a um problema de conexão, ainda será lançada uma
Illuminate\Http\Client\ConnectionException
mesmo quando o argumentothrow
é definido comofalse
.
Tratamento de erros
Diferente do comportamento padrão de Guzzle, o wrapper HTTP do Laravel não lança exceções em erros do cliente ou do servidor (respostas com nível 400 e 500 dos servidores). Você pode determinar se um desses erros foi retornado usando os métodos successful
, clientError
ou serverError
:
// Determine if the status code is >= 200 and < 300...
$response->successful();
// Determine if the status code is >= 400...
$response->failed();
// Determine if the response has a 400 level status code...
$response->clientError();
// Determine if the response has a 500 level status code...
$response->serverError();
// Immediately execute the given callback if there was a client or server error...
$response->onError(callable $callback);
Throwing Exceptions
Se você tiver uma instância de resposta e quiser lançar um caso da classe Illuminate\Http\Client\RequestException
quando o código de estado da resposta indicar um erro de cliente ou servidor, você pode usar os métodos throw
ou throwIf
:
use Illuminate\Http\Client\Response;
$response = Http::post(/* ... */);
// Throw an exception if a client or server error occurred...
$response->throw();
// Throw an exception if an error occurred and the given condition is true...
$response->throwIf($condition);
// Throw an exception if an error occurred and the given closure resolves to true...
$response->throwIf(fn (Response $response) => true);
// Throw an exception if an error occurred and the given condition is false...
$response->throwUnless($condition);
// Throw an exception if an error occurred and the given closure resolves to false...
$response->throwUnless(fn (Response $response) => false);
// Throw an exception if the response has a specific status code...
$response->throwIfStatus(403);
// Throw an exception unless the response has a specific status code...
$response->throwUnlessStatus(200);
return $response['user']['id'];
A instância Illuminate\Http\Client\RequestException tem uma propriedade de acesso público chamada $response que permitirá inspecionar a resposta retornada.
O método 'throw' retorna a instância de resposta se não houver erro, permitindo que você encadeie outros métodos na função throw:
return Http::post(/* ... */)->throw()->json();
Se você quiser executar alguma lógica adicional antes da exceção ser lançada, você pode passar um fechamento para o método 'throw'. A exceção será lançada automaticamente após o fechamento ser invocado, então você não precisa de re-lançar a exceção do próprio fechamento:
use Illuminate\Http\Client\Response;
use Illuminate\Http\Client\RequestException;
return Http::post(/* ... */)->throw(function (Response $response, RequestException $e) {
// ...
})->json();
Middleware de engolida
Dado que o cliente HTTP do Laravel é alimentado pelo Guzzle, você pode aproveitar dos Guzzle Middleware para manipular a solicitação em saída ou inspecionar a resposta de entrada. Para manipular a solicitação em saída, registre um Guzzle middleware usando o 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');
Da mesma forma, você pode inspecionar a resposta HTTP de entrada registrando um middleware via o 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
Às vezes, você pode querer registrar um middleware que se aplica a cada solicitação de saída e resposta de entrada. Para fazer isso, você pode usar o método globalRequestMiddleware e o método globalResponseMiddleware. Geralmente, esses métodos devem ser chamados no método boot do seu AppServiceProvider
:
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()
));
Opções de engolir
Você pode especificar opções adicionais para uma solicitação de saída usando o método 'withOptions'. O método 'withOptions' aceita um array de pares chave-valor:
$response = Http::withOptions([
'debug' => true,
])->get('http://example.com/users');
Opções Globais
Para configurar as opções padrão para cada solicitação de saída, você pode utilizar o método 'globalOptions'. Normalmente, esse método deve ser invocado do método 'boot' do seu provedor de serviços AppServiceProvider.
use Illuminate\Support\Facades\Http;
/**
* Bootstrap any application services.
*/
public function boot(): void
{
Http::globalOptions([
'allow_redirects' => false,
]);
}
Pedidos Concorrentes
Às vezes você pode querer fazer vários pedidos HTTP simultaneamente. Em outras palavras, você quer que vários pedidos sejam enviados ao mesmo tempo em vez de emitir os pedidos sequencialmente. Isso pode levar a melhorias consideráveis de desempenho ao interagir com lentos APIs HTTP.
Por sorte você pode realizar isso usando o método 'pool'. O método 'pool' aceita uma função de retorno que recebe uma instância 'Illuminate\Http\Client\Pool', permitindo adicionar facilmente requisições no pool de requisições para envio:
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 você pode ver, cada instância de resposta pode ser acessada com base na ordem em que foi adicionada à piscina. Se você quiser, você pode nomear as solicitações usando o método 'como', que permite aceder as respostas correspondentes pelo nome:
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();
Personalizando Pedidos Concorrentes
O método 'pool' não pode ser encadeado com outros métodos de clientes HTTP como o 'withHeaders' ou o 'middleware'. Se você quiser aplicar cabeçalhos ou middleware personalizados para solicitações agrupadas, você deve configurar essas opções em cada solicitação no pool:
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
O cliente HTTP Laravel permite definir “macros”, que podem servir como um mecanismo expressivo e fluido para configurar caminhos de solicitação e cabeçalhos comuns ao interagir com serviços em sua aplicação. Para começar, você pode definir o macro dentro do método boot
da classe App\Providers\AppServiceProvider
do seu aplicativo:
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');
});
}
Uma vez que sua macro tenha sido configurada, você pode invocá-la de qualquer lugar em seu aplicativo para criar um pedido pendente com a configuração especificada:
$response = Http::github()->get('/');
Teste
Muitos serviços Laravel fornecem funcionalidades para ajudar você a escrever testes de forma fácil e expressiva, e o cliente HTTP do Laravel não é exceção. O método 'fake' da fachada 'Http' permite instruir o cliente HTTP a retornar respostas de teste/dummy quando as requisições são feitas.
Respostas Falso
Por exemplo, para instruir o cliente http a retornar respostas de código 200 vazias em cada solicitação, você pode chamar o método 'fake' sem argumentos:
use Illuminate\Support\Facades\Http;
Http::fake();
$response = Http::post(/* ... */);
Falso URLs Específicos
Alternativamente, você pode passar um array para o método 'fake'. As chaves do array devem representar os padrões de URL que você deseja fingir e suas respostas associadas. O caractere '*' pode ser usado como um caractere curinga. Qualquer solicitação feita para URLs que não foram fingidas realmente serão executadas. Você pode usar o método 'response' da fachada 'Http' para construir respostas fictícias / stub para esses pontos finais:
Http::fake([
// Stub a JSON response for GitHub endpoints...
'github.com/*' => Http::response(['foo' => 'bar'], 200, $headers),
// Stub a string response for Google endpoints...
'google.com/*' => Http::response('Hello World', 200, $headers),
]);
Se você gostaria de especificar um padrão de URL de fallback que fará todos os URLs sem correspondência, você pode usar apenas o caractere ' * ':
Http::fake([
// Stub a JSON response for GitHub endpoints...
'github.com/*' => Http::response(['foo' => 'bar'], 200, ['Headers']),
// Stub a string response for all other endpoints...
'*' => Http::response('Hello World', 200, ['Headers']),
]);
Sequências de Resposta Falsas
Às vezes você pode precisar especificar que um único URL deve retornar uma série de respostas falsas em um determinado pedido. Você pode fazer isso usando o método Http::sequence
para construir as respostas:
Http::fake([
// Stub a series of responses for GitHub endpoints...
'github.com/*' => Http::sequence()
->push('Hello World', 200)
->push(['foo' => 'bar'], 200)
->pushStatus(404),
]);
Quando todas as respostas em uma sequência de resposta são consumidas, qualquer solicitação adicional fará com que a sequência de resposta lance uma exceção. Se você gostaria de especificar uma resposta padrão que deverá ser retornada quando uma sequência estiver vazia, você pode usar o método whenEmpty
:
Http::fake([
// Stub a series of responses for GitHub endpoints...
'github.com/*' => Http::sequence()
->push('Hello World', 200)
->push(['foo' => 'bar'], 200)
->whenEmpty(Http::response()),
]);
Se quiser que uma sequência de respostas seja simulada, mas não precisar especificar um padrão de URL que deve ser falsificado, você pode usar o método Http::fakeSequence:
Http::fakeSequence()
->push('Hello World', 200)
->whenEmpty(Http::response());
Chamada falsa de retorno
Se você precisa de lógica mais complexa para determinar quais respostas retornar para determinados pontos finais, você pode passar uma função anônima ao método fake
. Esta função anônima receberá uma instância de Illuminate\Http\Client\Request
e deverá retornar uma instância de resposta. Dentro da sua função anônima, você pode realizar qualquer lógica necessária para determinar que tipo de resposta deve ser retornado:
use Illuminate\Http\Client\Request;
Http::fake(function (Request $request) {
return Http::response('Hello World', 200);
});
Prevenção de Solicitações não Autorizadas
Se você gostaria de garantir que todas as requisições enviadas pelo cliente HTTP estão fakes durante o seu teste individual ou suite de testes completo, você pode chamar o método preventStrayRequests
. Após chamar esse método, qualquer solicitação sem uma resposta correspondente irá gerar uma exceção em vez de fazer a solicitação real do HTTP:
use Illuminate\Support\Facades\Http;
Http::preventStrayRequests();
Http::fake([
'github.com/*' => Http::response('ok'),
]);
// An "ok" response is returned...
Http::get('https://github.com/laravel/framework');
// An exception is thrown...
Http::get('https://laravel.com');
Inspectando Pedidos
Ao simular respostas, você pode ocasionalmente querer inspecionar as solicitações que o cliente recebe para ter certeza de que seu aplicativo está enviando os dados ou cabeçalhos corretos. Você pode fazer isso chamando o método Http::assertSent
após chamar Http::fake
.
O método assertSent aceita um fechamento que receberá uma instância Illuminate\Http\Client\Request e deve retornar um valor booleano indicando se a solicitação corresponde às suas expectativas. Para o teste passar, pelo menos uma solicitação precisa ter sido emitida correspondendo às expectativas fornecidas:
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';
});
Se necessário, você pode afirmar que uma solicitação específica não foi enviada usando o 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';
});
Você pode usar o método assertSentCount
para verificar quantos requisições foram "enviadas" durante o teste:
Http::fake();
Http::assertSentCount(5);
Ou você pode usar o método assertNothingSent
para afirmar que nenhuma solicitação foi enviada durante o teste:
Http::fake();
Http::assertNothingSent();
Gerenciando Solicitações de Gravação
Você pode usar o método "recorded" para reunir todas as solicitações e suas respostas correspondentes. O método "recorded" retorna uma coleção de matrizes que contém instâncias de Illuminate\Http\Client\Request e 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];
Além disso, o método 'recorded' aceita um fechamento que receberá uma instância de 'Illuminate\Http\Client\Request' e 'Illuminate\Http\Client\Response' e pode ser usado para filtrar pares de solicitação / resposta com base em suas 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 três eventos durante o processo de envio de requisições HTTP. O evento "RequestSending" é disparado antes que uma requisição seja enviada, enquanto o evento "ResponseReceived" é disparado após o recebimento da resposta para uma determinada requisição. O evento "ConnectionFailed" é disparado se não houver recebimento de resposta para uma determinada requisição.
Os eventos RequestSending e ConnectionFailed contêm, respectivamente, as propriedades públicas $request e $response que podem ser usadas para inspecionar os objetos Illuminate\Http\Client\Request e Illuminate\Http\Client\Response. Você pode criar eventos de escuta para esses eventos dentro do seu aplicativo:
use Illuminate\Http\Client\Events\RequestSending;
class LogRequest
{
/**
* Handle the given event.
*/
public function handle(RequestSending $event): void
{
// $event->request ...
}
}