Guzzle es un popular cliente PHP HTTP que facilita el envío de solicitudes HTTP y la creación de bibliotecas de servicios web. Los frameworks PHP más populares proporcionan un servicio de Cliente Http interno y son simplemente una implementación personalizada del Cliente Http de Guzzle:

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

Guzzle se usa ampliamente por dos razones principales:

1) Personalización y flexibilidad

Para los fanáticos de los patrones de diseño, Guzzle está abierto a extensiones. Significa que puede implementar fácilmente nuevas funcionalidades en Guzzle ampliando sus componentes principales (Cliente Http, Solicitud, Respuesta, Milddeware, etc.).

2) Soporte para middleware

El sistema de middleware Guzzle permite a los desarrolladores interactuar con una Solicitud antes de enviarla y una Respuesta antes de procesarla. Puede habilitar funciones avanzadas como registro, autenticación y manejo de errores.

Introducción al cliente HTTP Guzzle

En este tutorial, lo guiaré a través del proceso de creación de un Cliente Http Guzzle personalizado para facilitar el monitoreo de cada solicitud realizada desde su aplicación frente a servicios externos.

También le mostraré cómo inyectar esta implementación en el contenedor de IoC (o contenedor de servicios) para que esta implementación esté disponible en toda su aplicación.

Cubriremos los conceptos básicos, las opciones de personalización y proporcionaremos ejemplos de código reales.

Instalar Guzzle

Asegúrate de tener Guzzle instalado. Si no, instálalo usando Composer:

composer require guzzlehttp/guzzle

Personalización básica

Comencemos creando un 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);
    }
}

En este ejemplo, ampliamos la clase Guzzle Http Client y personalizamos el constructor para agregar un encabezado personalizado a todas las solicitudes realizadas por este cliente.

Supervisar las solicitudes HTTP de Guzzle

Guzzle proporciona métodos abreviados para ejecutar solicitudes Http:

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

Todos estos métodos utilizan el método de solicitud genérico en su interior. La siguiente captura de pantalla fue tomada del código del cliente Guzzle:

Puedes anular el método de solicitud para personalizar la gestión de las llamadas HTTP realizadas por tu aplicación a servicios 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}");
    }
}

En este ejemplo, simplemente agrego un nuevo elemento en el cronograma de la transacción para cada solicitud. Ahora puedes ver las llamadas API realizadas por Guzzle en tu vista de monitoreo:

Si eres nuevo en Inspector, puedes seguir este tutorial sobre cómo empezar:

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

También puedes inyectar el parámetro Segmento en la devolución de llamada para interactuar con el elemento o agregar más información:

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

Utilice el cliente Http personalizado

Ahora puedes usar tu cliente personalizado en tu aplicación. Dado que la extensión no introduce ningún cambio en el comportamiento del Cliente Http estándar de Guzzle, puedes crear una instancia de la clase personalizada y usarla como de costumbre:

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

Vincula el cliente Guzzle Http al contenedor

Voy a usar Laravel en este ejemplo, pero el concepto básico es el mismo para los frameworks PHP más populares mencionados al principio del artículo. Todos ellos funcionan con un Service Container.

Creamos un enlace singleton en el contenedor para la clase Guzzle Http Client. Entonces, cada servicio que solicite esta clase recibirá una instancia de nuestro cliente personalizado que admite monitoreo en tiempo 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();
});

Ahora puedes intentar inyectar la clase Guzzle Http Client en un Artisan Command y ejecutar una llamada Http solo para probar:

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

Ejecute el comando para verificar si la llamada Http será visible en la línea de tiempo de la transacción:

php artisan try

¿Nuevo en el inspector? Monitoriza tu aplicación gratis

Inspector es una herramienta de monitoreo de ejecución de código diseñada específicamente para desarrolladores de software. No necesita instalar nada en su infraestructura o servidores en la nube, simplemente instale el paquete Composer y estará listo para comenzar.

A diferencia de otras plataformas complejas todo en uno, Inspector es súper sencillo y compatible con PHP. Puedes probar nuestro paquete Laravel o Symfony.

Si busca una automatización eficaz, conocimientos profundos y la capacidad de reenviar alertas y notificaciones a su entorno de mensajería, pruebe Inspector de forma gratuita. Registre su cuenta.

O obtenga más información en el sitio web: https://inspector.dev