How to monitor Guzzle Http Client – PHP Fast tips

Valerio Barbera

Guzzle is a popular PHP HTTP client that makes it easy to send HTTP requests and create web service libraries. The most popular PHP frameworks provides an internal Http Client service, and they are simply a customized implementation of the Guzzle Http Client:

Guzzle is widely used for two main reasons:

Customization and Flexibility

For the fans of design patterns Guzzle is open to extensions. Means that you can easily implement new functionalities into Guzzle by extending its core components (Http Client, Request, Response, Milddeware, etc).

Support for Middleware

The Guzzle middleware system allows developers to interact with a Request before it is sent, and Response before they are processed. It can enable advanced features like logging, authentication, and error handling.

Introduction

In this tutorial, I will guide you through the process of creating a custom Guzzle Http Client to make it easy to monitor every request made from your application against external services. 

I will also show you how to inject this implementation into the IoC container (or Services Container) to make this implementation available throughout your application.

We will cover the basics, customization options, and provide real code examples.

Install Guzzle

Ensure you have Guzzle installed. If not, install it using Composer:

composer require guzzlehttp/guzzle

Basic Customization

Let’s start by creating a basic custom Guzzle Http Client:

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

In this example, we extend the Guzzle Http Client class and customize the constructor to add a custom header to all requests made by this client.

Monitor Guzzle Http Requests

Guzzle provides shortcut methods to run Http requests:

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

All of these methods use the generic request method inside. The screenshot below was taken from the Guzzle Client code:

You can override the request method to customize the management of HTTP calls made by your application to external services.

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

In this example I just add a new item in the transaction’s timeline for every request. Now you can see the API calls made by Guzzle in your monitoring view:

If you are new to Inspector you can follow this tutorial on how to get started:

You can also inject the Segment parameter in the callback to interact with the item or add more information:

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 the custom Http Client

Now, you can use your custom client in your application. Since the extension doesn’t introduce any change to the behavior of the standard Guzzle Http Client, you can make an instance of the custom class and use it as usual:

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

Bind the Guzzle Http Client into the container

I’m going to use Laravel in this example, but the basic concept is the same for the most popular PHP frameworks mentioned at the beginning of the article. All of them work with a Service Container.

We create a singleton binding into the container for the Guzzle Http Client class. So every service that ask for this class will receive an instance of our custom client that supports real-time monitoring.

use GuzzleHttp\Client;
use App\Extensions\Guzzle\CustomGuzzleClient;
use Illuminate\Contracts\Foundation\Application;
 
$this->app->singleton(Client::class, function (Application $app) {
    return new CustomGuzzleClient();
});

Now you can try to inject the Guzzle Http Client class in an Artisan Command and run an Http call just for testing:

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

Run the command to verify if the Http Call will be visible in the transaction’s timeline:

php artisan try

New to Inspector? Try it for free now

Are you responsible for software development in your company? Consider trying my product Inspector to find out bugs and bottlenecks in your code automatically. Before your customers stumble onto the problem.

Inspector is usable by any IT leader who doesn’t need anything complicated. If you want effective automation, deep insights, and the ability to forward alerts and notifications into your messaging environment try Inspector for free. Register your account.

Or learn more on the website: https://inspector.dev

Related Posts

Application Monitoring Essentials unlock software success

In this video I explore the essentials of application monitoring in software development. You can learn the best practices from Inspector Academy to ensure uptime, satisfy users, and drive sustainable company growth. The idea of application monitoring has been around for a while, but it has never been as indispensable as today. Despite its importance

Create a query for histogram charts with MySQL – Tutorial

To create a statistical query to build a histogram chart with MySQL, you can use the COUNT() function along with GROUP BY to count occurrences of values within a specified range or category created by the grouping constraint.  Especially for time series data there are a lot of use cases for histograms like monitoring the

Try the new Google Chat notification channel

Hi, I’m happy to announce that Google Chat is now available as a notification channel for your application. Now you can receive all important notifications of what happens in your application in your Google Chat environment in real time. Inspector Notification Channels allow you to create an automated and  informed workplace, helping your collaborators to