bentools/guzzle-throttle-middleware

A GuzzleHTTP Middleware that can delay requests before sending them.

, _(*1)

Guzzle Throttle Middleware

This middleware adds throttling capabilities to your Guzzle client., _(*2)

This can be useful when some hosts limits your number of requests per second / per minute., _(*3)

Installation

composer require bentools/guzzle-throttle-middleware, _(*4)

Counter storage

By default, request counters are stored in an array., _(*5)

But you can use the PSR6Adapter to store your counters within a psr/cache implementation, such as symfony/cache, and use shared storages like Redis, APCu, Memcached, ..., _(*6)

Usage

For this middleware to work, you need to register some configurations., _(*7)

A configuration is composed of: * A Request matcher (to trigger or not the throttler, depending on the request content) * A maximum number of requests * The period, in seconds, during which the maximum number of requests apply. * A storage key., _(*8)

You can register as many configurations as you need. The 1st request matcher wins., _(*9)

Example

namespace App\RequestMatcher;

use BenTools\Psr7\RequestMatcherInterface;
use Psr\Http\Message\RequestInterface;

class ExampleOrgRequestMatcher implements RequestMatcherInterface
{
    /**
     * @inheritDoc
     */
    public function matchRequest(RequestInterface $request)
    {
        return false !== strpos($request->getUri()->getHost(), 'example.org');
    }
}

use App\RequestMatcher\ExampleOrgRequestMatcher;
use BenTools\GuzzleHttp\Middleware\Storage\Adapter\ArrayAdapter;
use BenTools\GuzzleHttp\Middleware\ThrottleConfiguration;
use BenTools\GuzzleHttp\Middleware\ThrottleMiddleware;
use GuzzleHttp\Client;
use GuzzleHttp\HandlerStack;

require_once __DIR__ . '/vendor/autoload.php';

$stack = HandlerStack::create();
$middleware = new ThrottleMiddleware(new ArrayAdapter());

// Max 1 request per second
$maxRequests = 1;
$durationInSeconds = 1;
$middleware->registerConfiguration(
    new ThrottleConfiguration(new ExampleOrgRequestMatcher(), $maxRequests, $durationInSeconds, 'example')
);

$stack->push($middleware, 'throttle');
$client = new Client([
    'handler' => $stack,
]);

$client->get('http://www.example.org'); // Will be executed immediately
$client->get('http://www.example.org'); // Will be executed in 1 second

Tests

./vendor/bin/phpunit, _(*10)

Known issues

Due to PHP's synchronous behaviour, remember that throttling means calling sleep() or usleep() functions, which will delay your entire script, and not only the current request., _(*11)

This means throttling will also block Guzzle's asynchronous requests when using CurlMultiHandler., _(*12)

To prevent this, you may have a look at bentools/guzzle-queue-handler, a handler that delegates asynchronous requests to PHP workers (Beanstalk, RabbitMQ, Redis, ...)., _(*13)

You can then enable throttling only on workers., _(*14)

See also

• bentools/guzzle-queue-handler - A queue handler to process Guzzle 6+ requests within a work queue.
• kevinrob/guzzle-cache-middleware - A HTTP Cache for Guzzle 6. It's a simple Middleware to be added in the HandlerStack.
• bentools/guzzle-duration-middleware - A Guzzle 6+ Middleware that adds a X-Request-Duration header to all responses to monitor response times.