PHPackages                             zwirek/reactphp-limiter - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Queues & Workers](/categories/queues)
4. /
5. zwirek/reactphp-limiter

ActiveLibrary[Queues & Workers](/categories/queues)

zwirek/reactphp-limiter
=======================

Set of classes for limiting concurrent job execution using ReactPHP

v0.1.0(2y ago)0177↓100%MITPHPPHP >=8.1

Since Jan 4Pushed 2y ago1 watchersCompare

[ Source](https://github.com/zwirek/reactphp-limiter)[ Packagist](https://packagist.org/packages/zwirek/reactphp-limiter)[ RSS](/packages/zwirek-reactphp-limiter/feed)WikiDiscussions main Synced 1mo ago

READMEChangelog (1)Dependencies (4)Versions (2)Used By (0)

zwirek/reactphp-limiter
=======================

[](#zwirekreactphp-limiter)

Set of limiters designed to use with [ReactPHP](https://github.com/reactphp)

Table of content
----------------

[](#table-of-content)

1. [Introduction](#introduction)
2. [Usage](#usage)
    - [RateLimiter](#ratelimiter)
    - [TimeWindowLimiter](#timewindowlimiter)
    - [MutationLimiter](#mutationlimiter)
3. [Limiter Interface](#limiter-interface)

Introduction
------------

[](#introduction)

This repository contains several limiter classes designed for use with ReactPHP. Each limiter must have a registered handler (callable) that will be called immediately for each request before the limit is reached. Any additional request over the limit will be queued. There are different limiters for different purposes:

- RateLimiter: Limits simultaneous handler execution for a given limit
- TimeWindowLimiter: For time window, limit handler execution to the specified limit.
- MutationLimiter: Limits handler execution against a resource.

Usage
-----

[](#usage)

### RateLimiter

[](#ratelimiter)

Limit concurrent handler execution to given limit

```
$loop = \React\EventLoop\Loop::get();

$limiter = new \Zwirek\Limiter\RateLimiter(2, function($counter) use ($loop) {
    $deferred = new \React\Promise\Deferred();

    echo 'execute for ', $counter, PHP_EOL;

    $loop->addTimer(2, function() use ($deferred, $counter) {
        $deferred->resolve('return ' . $counter . PHP_EOL);
    });

    return $deferred->promise();
});

for ($i = 1; $i handle($i)->then(function($resolve) { echo $resolve; });
}

$loop->run();
```

Handler will only be fired twice at the same time.

It is possible to limit the number of jobs waiting to be executed by setting an overflow limit

```
$loop = \React\EventLoop\Loop::get();

$limiter = new \Zwirek\Limiter\RateLimiter(2, function($counter) use ($loop) {
    $deferred = new \React\Promise\Deferred();

    echo 'execute for ', $counter, PHP_EOL;

    $loop->addTimer(2, function() use ($deferred, $counter) {
        $deferred->resolve('return ' . $counter . PHP_EOL);
    });

    return $deferred->promise();
}, 5);

for ($i = 1; $i handle($i)
        ->then(
            function ($resolve) {
                echo $resolve;
            },
            function (OverflowException $exception) use ($i) {
                echo 'Overflow limit reached for call ', $i, PHP_EOL;
            }
        );
}

$loop->run();
```

Calls above the limit are immediately rejected.

### TimeWindowLimiter

[](#timewindowlimiter)

This limiter is responsible for limiting handler execution under a given limit within a time window. For example it is possible to limit a job execution to 100 times every 1 minute.

```
$loop = \React\EventLoop\Loop::get();

$limiter = new \Zwirek\Limiter\TimeWindowLimiter(2, 500, function($counter) use ($loop) {
    $deferred = new \React\Promise\Deferred();

    echo 'execute for ', $counter, PHP_EOL;

    $loop->addTimer(1, function() use ($deferred, $counter) {
        $deferred->resolve('return ' . $counter . PHP_EOL);
    });

    return $deferred->promise();
});

for ($i = 1; $i handle($i)->then(function($resolve) { echo $resolve; });
}

$loop->run();
```

For this example, the handler is called twice every half second. The next calls will start immediately when the next window starts, even if jobs from the previous window are in pending state.

It is possible to limit the number of jobs waiting to be executed by setting an overflow limit.

```
$loop = \React\EventLoop\Loop::get();

$limiter = new \Zwirek\Limiter\TimeWindowLimiter(2, 500, function($counter) use ($loop) {
    $deferred = new \React\Promise\Deferred();

    echo 'execute for ', $counter, PHP_EOL;

    $loop->addTimer(1, function() use ($deferred, $counter) {
        $deferred->resolve('return ' . $counter . PHP_EOL);
    });

    return $deferred->promise();
}, 5);

for ($i = 1; $i handle($i)
        ->then(
            function ($resolve) {
                echo $resolve;
            },
            function (OverflowException $exception) use ($i) {
                echo 'Overflow limit reached for call ', $i, PHP_EOL;
            }
        );
}

$loop->run();
```

### MutationLimiter

[](#mutationlimiter)

This limiter can limit concurrent job calls for specific resource. Resource can be anything like file, connection, row in database because limiter needs additional callback that returns resource id. Resource id must be string or int or float.

```
$loop = \React\EventLoop\Loop::get();

$limiter = new \Zwirek\Limiter\MutationLimiter(
    function($counter, $resource) use ($loop) {
        $deferred = new \React\Promise\Deferred();

        echo 'execute counter ', $counter, ' for resource ', $resource, PHP_EOL;

        $loop->addTimer(1, function() use ($deferred, $counter) {
            $deferred->resolve('return ' . $counter . PHP_EOL);
        });

        return $deferred->promise();
    },
    function($counter, $resource) {
        return $resource;
    }
);

$successCallback = function ($resolve) {
    echo $resolve;
};

for ($i = 1; $i handle($i, 1)->then($successCallback);
    $limiter->handle($i, 2)->then($successCallback);
    $limiter->handle($i, 3)->then($successCallback);
}

$loop->run();
```

Second callback is responsible for providing resource id. It gets the same data as argument as handler callback. In this way it is possible to resolve resource id based on given data.

It is possible to limit the number of jobs waiting to be executed per resource by setting an overflow limit.

```
$loop = \React\EventLoop\Loop::get();

$limiter = new \Zwirek\Limiter\MutationLimiter(
    function($counter, $resource) use ($loop) {
        $deferred = new \React\Promise\Deferred();

        echo 'execute counter ', $counter, ' for resource ', $resource, PHP_EOL;

        $loop->addTimer(1, function() use ($deferred, $counter) {
            $deferred->resolve('return ' . $counter . PHP_EOL);
        });

        return $deferred->promise();
    },
    function($counter, $resource) {
        return $resource;
    },
    4
);

$successCallback = function ($resolve) {
    echo $resolve;
};
$failureCallback = function (OverflowException $exception) {
    echo $exception->getMessage(), PHP_EOL;
};

for ($i = 1; $i handle($i, 1)->then($successCallback, $failureCallback);
    $limiter->handle($i, 2)->then($successCallback, $failureCallback);
    $limiter->handle($i, 3)->then($successCallback, $failureCallback);
}

$loop->run();
```

Limiter Interface
-----------------

[](#limiter-interface)

Every limiter class implement `\Zwirek\Limiter\Limiter` interface. Limiter interface have only one public method.

```
\Zwirek\Limiter\Limiter::handle(mixed ...$arguments): \React\Promise\Promise
```

The handler can be called with zero or more arguments. It is important to call `::handle` with at least the number of arguments as a registered handler callback.

###  Health Score

22

—

LowBetter than 22% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity13

Limited adoption so far

Community7

Small or concentrated contributor base

Maturity40

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Unknown

Total

1

Last Release

859d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/20dc0d745ba97e3a11c00e27ad4c7af2884644ccc845d838748732e5969fd06c?d=identicon)[zwirek](/maintainers/zwirek)

---

Top Contributors

[![zwirek](https://avatars.githubusercontent.com/u/7045479?v=4)](https://github.com/zwirek "zwirek (3 commits)")

---

Tags

asynchronousreactphpqueuelimiterrate limitlicky buckettime windowtime box

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/zwirek-reactphp-limiter/health.svg)

```
[![Health](https://phpackages.com/badges/zwirek-reactphp-limiter/health.svg)](https://phpackages.com/packages/zwirek-reactphp-limiter)
```

###  Alternatives

[bunny/bunny

Performant pure-PHP AMQP (RabbitMQ) non-blocking ReactPHP library

7426.5M37](/packages/bunny-bunny)[react/socket

Async, streaming plaintext TCP/IP and secure TLS socket server and client connections for ReactPHP

1.3k116.9M402](/packages/react-socket)[react/dns

Async DNS resolver for ReactPHP

535114.1M100](/packages/react-dns)[clue/mq-react

Mini Queue, the lightweight in-memory message queue to concurrently do many (but not too many) things at once, built on top of ReactPHP

144691.7k4](/packages/clue-mq-react)[react/promise-timer

A trivial implementation of timeouts for Promises, built on top of ReactPHP.

34141.9M96](/packages/react-promise-timer)[react/async

Async utilities and fibers for ReactPHP

2238.8M171](/packages/react-async)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)