Guzzle é um cliente PHP HTTP popular que facilita o envio de solicitações HTTP e a criação de bibliotecas de serviços da web. As estruturas PHP mais populares fornecem um serviço de cliente Http interno e são simplesmente uma implementação personalizada do cliente Guzzle Http:

• Cliente Http Laravel
• Cliente HTTP Symfony
• Laminas (anteriormente Zend Framework) Cliente Http

Guzzle é amplamente utilizado por dois motivos principais:

1) Personalização e Flexibilidade

Para os fãs de padrões de design, o Guzzle está aberto a extensões. Significa que você pode implementar facilmente novas funcionalidades no Guzzle estendendo seus componentes principais (cliente HTTP, solicitação, resposta, Milddeware, etc).

2) Suporte para Middleware

O sistema de middleware Guzzle permite que os desenvolvedores interajam com uma solicitação antes de ser enviada e com uma resposta antes de serem processadas. Ele pode ativar recursos avançados como registro, autenticação e tratamento de erros.

Introdução ao cliente HTTP Guzzle

Neste tutorial, orientarei você no processo de criação de um cliente Guzzle Http personalizado para facilitar o monitoramento de cada solicitação feita em seu aplicativo em relação a serviços externos.

Também mostrarei como injetar essa implementação no contêiner IoC (ou contêiner de serviços) para disponibilizar essa implementação em todo o seu aplicativo.

Abordaremos o básico, opções de personalização e forneceremos exemplos de código reais.

Instalar o Guzzle

Certifique-se de ter o Guzzle instalado. Caso contrário, instale-o usando o Composer:

composer require guzzlehttp/guzzle

Personalização Básica

Vamos começar criando um cliente Http Guzzle personalizado básico:

namespace App\Extensions\Guzzle;

use GuzzleHttp\Client;

class CustomGuzzleClient extends Client 
{
    public function __construct(array $config = []) 
    {
        $config['headers']['Custom-Header'] = 'Custom-Value';
        parent::__construct($config);
    }
}

Neste exemplo, estendemos a classe Guzzle Http Client e personalizamos o construtor para adicionar um cabeçalho personalizado a todas as solicitações feitas por este cliente.

Monitore solicitações HTTP do Guzzle

Guzzle fornece métodos de atalho para executar solicitações HTTP:

$client->get('/endpoint');
$client->post('/endpoint');
$client->put('/endpoint');

Todos esses métodos usam o método de solicitação genérico interno. A captura de tela abaixo foi tirada do código do cliente Guzzle:

Você pode substituir o método de solicitação para personalizar o gerenciamento de chamadas HTTP feitas pelo seu aplicativo para serviços externos.

namespace App\Extensions\Guzzle;

use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;


class CustomGuzzleClient extends Client 
{
    public function request($method, $uri, array $options = []) 
    {
        return inspector()->addSegment(function () use ($method, $uri, $options) {

            return parent::request($method, $uri, $options);

        }, "http", "{$method} {$uri}");
    }
}

Neste exemplo, apenas adiciono um novo item na linha do tempo da transação para cada solicitação. Agora você pode ver as chamadas de API feitas pelo Guzzle em sua visualização de monitoramento:

Se você é novo no Inspector, pode seguir este tutorial sobre como começar:

https://inspector.dev/laravel-real-time-performance-monitoring-using-inspector-part-1/

Você também pode injetar o parâmetro Segment no callback para interagir com o item ou adicionar mais informações:

namespace App\Extensions\Guzzle;

use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;
use Inspector\Models\Segment;

class CustomGuzzleClient extends Client 
{
    public function request($method, $uri, array $options = []) 
    {
        return inspector()->addSegment(function (Segment $segment) use ($method, $uri, $options) {

            $response = parent::request($method, $uri, $options);
            $segment->label = "{$response->getStatusCode()} {$method} {$uri}";
            return $response;

        }, "http");
    }
}

Use o cliente HTTP personalizado

Agora, você pode usar seu cliente personalizado em seu aplicativo. Como a extensão não introduz nenhuma alteração no comportamento do Guzzle Http Client padrão, você pode criar uma instância da classe personalizada e usá-la normalmente:

// Create an instance of the custom client
$client = new CustomGuzzleClient(['base_uri' => 'https://api.example.com']);

// Make an API request. It will be automatically monitored by Inspector.
$response = $client->get('/endpoint');

Vincule o cliente Guzzle Http ao contêiner

Vou usar o Laravel neste exemplo, mas o conceito básico é o mesmo para os frameworks PHP mais populares mencionados no início do artigo. Todos eles trabalham com um Service Container.

Criamos uma ligação singleton no contêiner para a classe Guzzle Http Client. Assim, todo serviço que solicitar esta classe receberá uma instância do nosso cliente customizado que suporta monitoramento em tempo real.

use GuzzleHttp\Client;
use App\Extensions\Guzzle\CustomGuzzleClient;
use Illuminate\Contracts\Foundation\Application;

$this->app->singleton(Client::class, function (Application $app) {
    return new CustomGuzzleClient();
});

Agora você pode tentar injetar a classe Guzzle Http Client em um Artisan Command e executar uma chamada Http apenas para teste:

namespace App\Console\Commands;


use Illuminate\Console\Command;
use GuzzleHttp\Client;

class TryCommand extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'try';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Test Guzzle Http Client monitoring.';

    /**
     * Inject the Guzzle Http Client class into the constructor.
     * The CustomGuzzleClient will be the concrete class.
     */
    public function __construct(protected Client $client)
    {
        parent::__construct();
    }

    /**
     * Handle the command execution.
     */
    public function handle()
    {
        $this->line($this->description);

        $this->line("Concrete class: ".get_class($this->client));

        $this->client->get('https://google.com');

        return Command::SUCCESS;
    }
}

Execute o comando para verificar se a Chamada Http estará visível na timeline da transação:

php artisan try

Novo no Inspetor? Monitore seu aplicativo gratuitamente

Inspector é uma ferramenta de monitoramento de execução de código projetada especificamente para desenvolvedores de software. Você não precisa instalar nada em sua infraestrutura de nuvem ou servidores, basta instalar o pacote compositor e você está pronto para começar.

Ao contrário de outras plataformas complexas e completas, o Inspector é super fácil e compatível com PHP. Você pode experimentar nosso pacote Laravel ou Symfony.

Se você procura automação eficaz, insights profundos e a capacidade de encaminhar alertas e notificações para seu ambiente de mensagens, experimente o Inspector gratuitamente. Registre sua conta.

Ou saiba mais no site: https://inspector.dev