RedisProxy

Execute commands in a pipeline.

Execute commands in a transaction.

Create a new Redis proxy instance.

Get the connection name.

Determine if this connection uses Redis Cluster.

Register a custom Redis connection macro.

Macros persist for the worker lifetime and affect every Redis connection.

Mix another object into the Redis connection.

Registered macros persist for the worker lifetime and affect every Redis connection.

Determine if a Redis connection macro is registered.

Flush the registered Redis connection macros.

Concurrent coroutines may resolve different methods during a flush.

Scan keys matching a pattern.

Scan hash fields matching a pattern.

Scan sorted set members matching a pattern.

Scan set members matching a pattern.

Pass dynamic method calls to a pooled Redis connection.

Release the connection stored in coroutine context.

Discard the connection stored in coroutine context.

Handle subscribe/psubscribe using the coroutine-native subscriber.

Creates a dedicated socket connection (not from the pool) and bridges the channel-based subscriber to the Laravel-style callback API.

Determine which commands must reuse the same connection.

Get a connection from coroutine context, or from redis connection pool.

The key to identify the connection object in coroutine context.

Execute callback with a pinned connection from the pool.

Use this for operations requiring multiple commands on the same connection (e.g., evalSha + getLastError, multi-step Lua operations). The connection is automatically returned to the pool after the callback completes.

If a connection is already stored in coroutine context (e.g., from an active multi/pipeline), that connection is reused and not released.

Pin a pool connection in coroutine context for the duration of a callback.

All Redis operations inside the callback will reuse the same connection, avoiding multiple pool checkouts. Re-entrant: if a connection is already pinned, the callback runs on it without re-pinning.

Execute a callback with serialization and compression temporarily disabled.

Pins a pool connection and disables phpredis serialization and compression for the duration of the callback, then restores settings and releases.

This is needed for rate limiter counters which must be stored as raw integers — phpredis serialization (e.g., igbinary) would corrupt them.

Create a coroutine-native Redis subscriber.

Returns a Subscriber with its own dedicated socket connection (not from the pool). Use for the channel-based pub/sub API:

$sub = Redis::subscriber();
$sub->subscribe('channel');
while ($message = $sub->channel()->pop()) { ... }
$sub->close();

Register a Redis command listener with the connection.

The listener persists on the singleton event dispatcher for the worker lifetime and runs for every subsequent Redis command event.

Register a Redis command failure listener with the connection.

The listener persists on the singleton event dispatcher for the worker lifetime and runs for every subsequent Redis failure event.

Subscribe to a set of given channels for messages.

Subscribe to a set of given channels with wildcards.

Run a command against the Redis database.

Throttle a callback for a maximum number of executions over a given duration.

Funnel a callback for a maximum number of simultaneous executions.

Flush (delete) all Redis keys matching a pattern.

Use this for standalone/one-off flush operations. It handles the connection lifecycle automatically (get from pool, flush, release). Uses the default connection, or specify one via Redis::connection($name)->flushByPattern().

If you already have a raw connection from withConnection(..., transform: false), call $connection->flushByPattern() directly to avoid redundant pool operations.

Uses SCAN to iterate keys efficiently and deletes them in batches. Correctly handles OPT_PREFIX to avoid the double-prefixing bug.

No description