Guzzle est un client HTTP PHP populaire qui facilite l'envoi de requêtes HTTP et la création de bibliothèques de services Web. Les frameworks PHP les plus populaires fournissent un service client HTTP interne, et ils constituent simplement une implémentation personnalisée du client HTTP Guzzle :

• Client HTTP Laravel
• Client HTTP Symfony
• Client HTTP Laminas (anciennement Zend Framework)

Guzzle est largement utilisé pour deux raisons principales :

1) Personnalisation et flexibilité

Pour les fans de design patterns, Guzzle est ouvert aux extensions. Cela signifie que vous pouvez facilement implémenter de nouvelles fonctionnalités dans Guzzle en étendant ses composants principaux (client HTTP, requête, réponse, Milddeware, etc.).

2) Prise en charge du middleware

Le système middleware Guzzle permet aux développeurs d'interagir avec une demande avant qu'elle ne soit envoyée et avec une réponse avant qu'elles ne soient traitées. Il peut activer des fonctionnalités avancées telles que la journalisation, l'authentification et la gestion des erreurs.

Introduction au client HTTP Guzzle

Dans ce didacticiel, je vais vous guider tout au long du processus de création d'un client HTTP Guzzle personnalisé pour faciliter la surveillance de chaque demande effectuée à partir de votre application par rapport à des services externes.

Je vais également vous montrer comment injecter cette implémentation dans le conteneur IoC (ou Services Container) pour rendre cette implémentation disponible dans toute votre application.

Nous couvrirons les bases, les options de personnalisation et fournirons de vrais exemples de code.

Installer Guzzle

Assurez-vous que Guzzle est installé. Sinon, installez-le à l'aide de Composer :

composer require guzzlehttp/guzzle

Personnalisation de base

Commençons par créer un client HTTP Guzzle personnalisé de base :

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);
    }
}

Dans cet exemple, nous étendons la classe Guzzle Http Client et personnalisons le constructeur pour ajouter un en-tête personnalisé à toutes les requêtes effectuées par ce client.

Surveiller les requêtes HTTP de Guzzle

Guzzle fournit des méthodes de raccourci pour exécuter des requêtes HTTP :

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

Toutes ces méthodes utilisent la méthode de requête générique à l'intérieur. La capture d'écran ci-dessous a été prise à partir du code du client Guzzle :

Vous pouvez remplacer la méthode de requête pour personnaliser la gestion des appels HTTP effectués par votre application vers des services externes.

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}");
    }
}

Dans cet exemple, j'ajoute simplement un nouvel élément dans la chronologie de la transaction pour chaque demande. Vous pouvez maintenant voir les appels API effectués par Guzzle dans votre vue de surveillance :

Si vous êtes nouveau sur Inspector, vous pouvez suivre ce tutoriel pour commencer :

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

Vous pouvez également injecter le paramètre Segment dans le rappel pour interagir avec l'élément ou ajouter plus d'informations :

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");
    }
}

Utilisez le client HTTP personnalisé

Vous pouvez désormais utiliser votre client personnalisé dans votre application. Étant donné que l'extension n'introduit aucun changement dans le comportement du client HTTP Guzzle standard, vous pouvez créer une instance de la classe personnalisée et l'utiliser comme d'habitude :

// 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');

Liez le client Guzzle Http dans le conteneur

Je vais utiliser Laravel dans cet exemple, mais le concept de base est le même pour les frameworks PHP les plus populaires mentionnés au début de l'article. Tous fonctionnent avec un conteneur de services.

Nous créons une liaison singleton dans le conteneur pour la classe Guzzle Http Client. Ainsi, chaque service demandant cette classe recevra une instance de notre client personnalisé prenant en charge la surveillance en temps réel.

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

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

Vous pouvez maintenant essayer d'injecter la classe Guzzle Http Client dans une commande Artisan et exécuter un appel Http juste à des fins de test :

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;
    }
}

Exécutez la commande pour vérifier si l'appel HTTP sera visible dans la chronologie de la transaction :

php artisan try

Nouveau parmi les inspecteurs ? Surveillez votre candidature gratuitement

Inspector est un outil de surveillance de l'exécution de code spécialement conçu pour les développeurs de logiciels. Vous n'avez pas besoin d'installer quoi que ce soit dans votre infrastructure cloud ou vos serveurs, installez simplement le package composer et vous êtes prêt à partir.

Contrairement à d'autres plates-formes complexes tout-en-un, Inspector est extrêmement simple et compatible avec PHP. Vous pouvez essayer notre package Laravel ou Symfony.

Si vous recherchez une automatisation efficace, des informations approfondies et la possibilité de transférer des alertes et des notifications dans votre environnement de messagerie, essayez Inspector gratuitement. Enregistrez votre compte.

Ou apprenez-en plus sur le site : https://inspector.dev