PHPackages                             padosoft/laravel-super-cache - 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. [Caching](/categories/caching)
4. /
5. padosoft/laravel-super-cache

ActiveLibrary[Caching](/categories/caching)

padosoft/laravel-super-cache
============================

A Laravel package for advanced caching with tags and namespaces in Redis.

v2.1.3(3mo ago)27.7k↓43.9%2[1 PRs](https://github.com/padosoft/laravel-super-cache/pulls)MITPHPPHP ^8.0CI failing

Since Oct 4Pushed 1mo ago1 watchersCompare

[ Source](https://github.com/padosoft/laravel-super-cache)[ Packagist](https://packagist.org/packages/padosoft/laravel-super-cache)[ Docs](https://github.com/padosoft/laravel-super-cache)[ RSS](/packages/padosoft-laravel-super-cache/feed)WikiDiscussions main Synced 1mo ago

READMEChangelog (10)Dependencies (17)Versions (43)Used By (0)

Laravel Super Cache
===================

[](#laravel-super-cache)

[![Laravel Super Cache](./resources/images/laravel-super-cache-logo.webp)](./resources/images/laravel-super-cache-logo.webp)

A powerful caching solution for Laravel that uses Redis with Lua scripting, batch processing, and optimized tag management to handle high volumes of keys efficiently.

[![Latest Version on Packagist](https://camo.githubusercontent.com/53a97e42ee9b7b3a5136452ea8b36271248bc0116ed350bce0bbc97e5296df9c/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f7061646f736f66742f6c61726176656c2d73757065722d63616368652e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/padosoft/laravel-super-cache)[![Software License](https://camo.githubusercontent.com/55c0218c8f8009f06ad4ddae837ddd05301481fcf0dff8e0ed9dadda8780713e/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c6963656e73652d4d49542d627269676874677265656e2e7376673f7374796c653d666c61742d737175617265)](LICENSE.md)[![CircleCI](https://camo.githubusercontent.com/2281e7e5542d05168f8e65d5b9fee18f84a9891693bee46f09fa2e68a8598220/68747470733a2f2f636972636c6563692e636f6d2f67682f7061646f736f66742f6c61726176656c2d73757065722d63616368652e7376673f7374796c653d736869656c64)](https://circleci.com/gh/padosoft/laravel-super-cache)[![Quality Score](https://camo.githubusercontent.com/b3dcda05376a7a286841553fab40b5d6e4f1b202d4206b7f32a20144cc61b5d0/68747470733a2f2f696d672e736869656c64732e696f2f7363727574696e697a65722f672f7061646f736f66742f6c61726176656c2d73757065722d63616368652e7376673f7374796c653d666c61742d737175617265)](https://scrutinizer-ci.com/g/padosoft/laravel-super-cache)[![Total Downloads](https://camo.githubusercontent.com/58c90ad9b12f22a5c5e83f09ced717021437ae7f1d9e8790cfbeed715bc8198f/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f64742f7061646f736f66742f6c61726176656c2d73757065722d63616368652e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/padosoft/laravel-super-cache)

Table of Contents
-----------------

[](#table-of-contents)

- [Purpose](#purpose)
- [Why Use This Package?](#why-use-this-package)
- [Features](#features)
- [Requires](#requires)
- [Installation and Configuration](#installation-and-configuration)
    - [Activating the Listener for Expiry Notifications](#activating-the-listener-for-expiry-notifications)
- [Usage Examples](#usage-examples)
- [Architecture Overview](#architecture-overview)
- [Design Decisions and Performance](#design-decisions-and-performance)
    - [Key and Tag Organization](#key-and-tag-organization)
    - [Sharding for Efficient Tag Management](#sharding-for-efficient-tag-management)
    - [Locks for Concurrency Control](#locks-for-concurrency-control)
    - [Handling Expire Correctly with TTLs](#handling-expire-correctly-with-ttls)
    - [Namespace Suffix for Parallel Processing](#namespace-suffix-for-parallel-processing)
    - [Scheduled Command for Orphaned Key Cleanup](#scheduled-command-for-orphaned-key-cleanup)

Purpose
-------

[](#purpose)

`laravel-super-cache` is designed to provide a high-performance, reliable, and scalable caching solution for Laravel applications that require efficient tag-based cache invalidation. By leveraging Redis's native capabilities and optimizing the way tags are managed, this package addresses limitations in Laravel's built-in cache tag system, making it suitable for large-scale enterprise applications.

Why Use This Package?
---------------------

[](#why-use-this-package)

Laravel's native caching mechanism has an implementation for tag-based cache management; however, it faces limitations, especially when dealing with high volumes of cache keys and frequent invalidations. Some of the issues include:

1. **Inconsistency with Tag Invalidation**: Laravel uses a versioned tag strategy, which can lead to keys not being properly invalidated when associated tags change, particularly in highly concurrent environments.
2. **Performance Overhead**: The default implementation in Laravel relies on a "soft invalidate" mechanism that increments tag versions instead of directly removing keys, which can lead to slower cache operations and memory growth (memory leaks).
3. **Scalability Issues**: The handling of large volumes of tags and keys is not optimized for performance, making it difficult to maintain consistency and speed in enterprise-level applications.

`laravel-super-cache` addresses these limitations by providing an efficient, high-performance caching layer optimized for Redis, leveraging Lua scripting, and batch processing techniques.

Features
--------

[](#features)

- **Architecture for High Volume**: Designed to handle thousands of cache keys with rapid creation and deletion, without performance degradation.
- **Enterprise-Level Performance**: Uses Redis's native capabilities and optimizes cache storage and retrieval for high-speed operations.
- **Use of Lua Scripting for Efficiency**: Employs Lua scripts for atomic operations, reducing network round-trips and improving consistency.
- **Batch Processing and Pipelining**: Processes cache operations in batches, reducing overhead and maximizing throughput.
- **Parallel Processing with Namespaces**: Enables parallel processing of expiry notifications by using namespace suffixing and configurable listeners.

Requires
--------

[](#requires)

- php: >=8.0
- illuminate/database: ^9.0|^10.0|^11.0
- illuminate/support: ^9.0|^10.0|^11.0

Installation and Configuration
------------------------------

[](#installation-and-configuration)

To install `laravel-super-cache`, use Composer:

```
composer require padosoft/laravel-super-cache
```

After installing the package, add to in the config/app.php file of your main project

```
'providers' => [
        /*
         * Laravel Framework Service Providers...
         */
        Illuminate\Auth\AuthServiceProvider::class,
        ...
        /*
         * Super Cache
         */
        Padosoft\SuperCache\SuperCacheServiceProvider::class,
    ],
```

and then publish the configuration file:

```
php artisan vendor:publish --provider="Padosoft\SuperCache\SuperCacheServiceProvider"
```

The configuration file allows you to set:

- `prefix`: The prefix for all cache keys, preventing conflicts when using the same Redis instance.
- `connection`: The Redis connection to use, as defined in your `config/database.php`.
- `SUPERCACHE_NUM_SHARDS`: The number of shards to optimize performance for tag management.
- `retry_max`, `batch_size`, and `time_threshold`: Parameters to optimize batch processing and retries.

### Activating the Listener for Expiry Notifications

[](#activating-the-listener-for-expiry-notifications)

The listener is responsible for handling expired cache keys and cleaning up associated tags. To activate it, add the following command to your `supervisor` configuration:

```
[program:supercache_listener]
command=php artisan supercache:listener {namespace}
numprocs=5
```

You can run multiple processes in parallel by setting different {namespace} values. This allows the listener to handle notifications in parallel for optimal performance.

### Enabling Redis Expiry Notifications (required for listener)

[](#enabling-redis-expiry-notifications-required-for-listener)

To enable the expiry notifications required by `laravel-super-cache`, you need to configure Redis (or AWS ElastiCache) to send `EXPIRED` events. Here's how you can do it:

#### For a Standard Redis Instance

[](#for-a-standard-redis-instance)

1. **Edit Redis Configuration**: Open the `redis.conf` file and set the `notify-keyspace-events` parameter to enable expiry notifications.

    ```
    notify-keyspace-events Ex

    ```

    This configuration enables notifications for key expirations (Ex), which is required for the listener to function correctly.
2. **Using Redis CLI**: Alternatively, you can use the Redis CLI to set the configuration without editing the file directly.

    ```
    redis-cli config set notify-keyspace-events Ex
    ```

This command will apply the changes immediately without needing a Redis restart.

#### For AWS ElastiCache Redis

[](#for-aws-elasticache-redis)

If you are using Redis on AWS ElastiCache, follow these steps to enable expiry notifications:

1. **Access the AWS ElastiCache Console:**

    - Go to the ElastiCache dashboard on your AWS account.
2. **Locate Your Redis Cluster:**

    - Find your cluster or replication group that you want to configure.
3. **Modify the Parameter Group:**

    - Go to the **Parameter Groups** section.
    - Find the parameter group associated with your cluster, or create a new one.
    - Search for the `notify-keyspace-events` parameter and set its value to `Ex`.
    - Save changes to the parameter group.
4. **Attach the Parameter Group to Your Redis Cluster:**

    - Attach the modified parameter group to your Redis cluster.
    - A **cluster reboot** may be required for the changes to take effect.

After configuring the `notify-keyspace-events` parameter, Redis will publish `EXPIRED` events when keys expire, allowing the `laravel-super-cache` listener to process these events correctly.

Assicurarsi che php abbia questo parametro, altrimenti dopo 60 secondo il comando esce perchè la connessione viene interrotta

```
default_socket_timeout = -1

```

### Scheduled Command for Orphaned Key Cleanup (Optionally but recommended)

[](#scheduled-command-for-orphaned-key-cleanup-optionally-but-recommended)

Optionally but recommended, a scheduled command can be configured to periodically clean up any orphaned keys or sets left due to unexpected interruptions or errors. This adds an additional safety net to maintain consistency across cache keys and tags.

```
php artisan supercache:clean
```

This can be scheduled using Laravel's scheduler to run at appropriate intervals, ensuring your cache remains clean and optimized.

Usage Examples
--------------

[](#usage-examples)

Below are examples of using the `SuperCacheManager` and its facade `SuperCache`:

```
use SuperCache\Facades\SuperCache;

// Store an item in cache
SuperCache::put('user:1', $user);

// Store an item in cache with tags
SuperCache::putWithTags('product:1', $product, ['products', 'featured']);

// Retrieve an item from cache
$product = SuperCache::get('product:1');

// Check if a key exists
$exists = SuperCache::has('user:1');

// Increment a counter
SuperCache::increment('views:product:1');

// Decrement a counter
SuperCache::decrement('stock:product:1', 5);

// Get all keys matching a pattern
$keys = SuperCache::getKeys(['product:*']);

// Flush all cache
SuperCache::flush();
```

For all options see `SuperCacheManager` class.

Architecture Overview
---------------------

[](#architecture-overview)

[![the-architecture.webp](resources%2Fimages%2Fthe-architecture.webp)](resources%2Fimages%2Fthe-architecture.webp)

Design Decisions and Performance
--------------------------------

[](#design-decisions-and-performance)

### Key and Tag Organization

[](#key-and-tag-organization)

[![add key.webp](resources%2Fimages%2Fadd%20key.webp)](resources%2Fimages%2Fadd%20key.webp)[![remove key.webp](resources%2Fimages%2Fremove%20key.webp)](resources%2Fimages%2Fremove%20key.webp)Each cache key is stored with an associated set of tags. These tags allow efficient invalidation when certain categories of keys need to be cleared. The structure ensures that any cache invalidation affects only the necessary keys without touching unrelated data.

Tag-Based Cache Architecture
----------------------------

[](#tag-based-cache-architecture)

To efficiently handle cache keys and their associated tags, `laravel-super-cache` employs a well-defined architecture using Redis data structures. This ensures high performance for lookups, tag invalidations, and efficient management of keys. Below is a breakdown of how the package manages and stores these data structures in Redis.

### 3 Main Structures in Redis

[](#3-main-structures-in-redis)

1. **Key-Value Storage**:

    - Each cache entry is stored as a key-value pair in Redis.
    - **Naming Convention**: The cache key is prefixed for the package (e.g., `supercache:key:`), ensuring no conflicts with other Redis data.
2. **Set for Each Tag (Tag-Key Sets)**:

    - For every tag associated with a key, a Redis set is created to hold all the keys associated with that tag.
    - **Naming Convention**: Each set is named with a pattern like `supercache:tag::shard:`, where `` is the tag name and `` is determined by the sharding algorithm.
    - These sets allow quick retrieval of all keys associated with a tag, facilitating efficient cache invalidation by tag.
3. **Set for Each Key (Key-Tag Sets)**:

    - Each cache key has a set that holds all the tags associated with that key.
    - **Naming Convention**: The set is named as `supercache:tags:`, where `` is the actual cache key.
    - This structure allows quick identification of which tags are associated with a key, ensuring efficient clean-up when a key expires.

### Sharding for Efficient Tag Management

[](#sharding-for-efficient-tag-management)

To optimize performance when dealing with potentially large sets of keys associated with a single tag, `laravel-super-cache` employs a **sharding strategy**:

- **Why Sharding?**: A single tag might be associated with a large number of keys. If all keys for a tag were stored in a single set, this could degrade performance. Sharding splits these keys across multiple smaller sets, distributing the load.
- **How Sharding Works**: When a key is added to a tag, a fast hash function (e.g., `crc32`) is used to compute a shard index. The key is then stored in the appropriate shard for that tag.
    - **Naming Convention for Sharded Sets**: Each set for a tag is named as `supercache:tag::shard:`.
    - The number of shards is configurable through the `SUPERCACHE_NUM_SHARDS` setting, allowing you to balance between performance and memory usage.

### Example: Creating a Cache Key with Tags

[](#example-creating-a-cache-key-with-tags)

When you create a cache key with associated tags, here's what happens:

1. **Key-Value Pair**: A key-value pair is stored in Redis, prefixed as `supercache:key:`.
2. **Tag-Key Sets**: For each tag associated with the key:
    - A shard is determined using a hash function.
    - The key is added to the corresponding sharded set for the tag, named as `supercache:tag::shard:`.
3. **Key-Tag Set**: A set is created to associate the key with its tags, named as `supercache:tags:`.

This structure allows efficient lookup, tagging, and invalidation of cache entries.

#### Example

[](#example)

Suppose you cache a key `product:123` with tags `electronics` and `featured`. The following structures would be created in Redis:

- **Key-Value Pair**:

    - `supercache:key:product:123` -> ``
- **Tag-Key Sets**:

    - Assuming `SUPERCACHE_NUM_SHARDS` is set to 256, and `product:123` hashes to shard `42` for `electronics` and shard `85` for `featured`:
        - `supercache:tag:electronics:shard:42` -> contains `supercache:key:product:123`
        - `supercache:tag:featured:shard:85` -> contains `supercache:key:product:123`
- **Key-Tag Set**:

    - `supercache:tags:product:123` -> contains `electronics`, `featured`

### Benefits of This Architecture

[](#benefits-of-this-architecture)

- **Efficient Lookups and Invalidation**: Using sets for both tags and keys enables quick lookups and invalidation of cache entries when necessary.
- **Scalable Performance**: The sharding strategy distributes the keys associated with tags across multiple sets, ensuring performance remains high even when a tag has a large number of keys.
- **Atomic Operations**: When a cache key is added or removed, all necessary operations (like updating sets and shards) are executed atomically, ensuring data consistency.

By following this architecture, `laravel-super-cache` is designed to handle high-volume cache operations efficiently while maintaining the flexibility and scalability needed for large enterprise applications.

### Sharding for Efficient Tag Management

[](#sharding-for-efficient-tag-management-1)

[![sharding.webp](resources%2Fimages%2Fsharding.webp)](resources%2Fimages%2Fsharding.webp)Tags are distributed across multiple shards to optimize performance. When a key is associated with a tag, it is added to a specific shard determined by a fast hashing function (crc32). This sharding reduces the performance bottleneck by preventing single large sets from slowing down the cache operations.

### Locks for Concurrency Control

[](#locks-for-concurrency-control)

[![locks.webp](resources%2Fimages%2Flocks.webp)](resources%2Fimages%2Flocks.webp)When a key is processed for expiration, an optimistic lock is acquired to prevent race conditions, ensuring that no concurrent process attempts to alter the same key simultaneously. The lock has a short TTL to ensure it is quickly released after processing.

### Namespace Suffix for Parallel Processing

[](#namespace-suffix-for-parallel-processing)

To handle high volumes of expiry notifications efficiently, the listener processes them in parallel by suffixing namespaces to keys. Each process handles notifications for a specific namespace, allowing for scalable parallel processing. The listener uses batch processing with Lua scripting to optimize performance.

### Redis Expiry Notifications and Listener System

[](#redis-expiry-notifications-and-listener-system)

#### Handling Expire Correctly with TTLs

[](#handling-expire-correctly-with-ttls)

[![expires.webp](resources%2Fimages%2Fexpires.webp)](resources%2Fimages%2Fexpires.webp)To ensure keys are deleted from Redis when they expire, a combination of TTL and expiry notifications is used. If a key expires naturally, the listener is notified to clean up any associated tag sets. This ensures no "orphan" references are left in the cache.

#### Listener for Expiry Notifications

[](#listener-for-expiry-notifications)

[![listener.webp](resources%2Fimages%2Flistener.webp)](resources%2Fimages%2Flistener.webp)The listener is responsible for handling expired cache keys and cleaning up associated tags efficently by using mixed technics LUA script + batch processing + pipeline. You can run multiple processes in parallel by setting different {namespace} values. This allows the listener to handle notifications in parallel for optimal performance.

To ensure that keys are cleaned up efficiently upon expiration, `laravel-super-cache` uses Redis expiry notifications in combination with a dedicated listener process. This section explains how the notification system works, how the listener consumes these events, and the benefits of using batching, pipelines, and Lua scripts for performance optimization.

#### Redis Expiry Notifications: How They Work

[](#redis-expiry-notifications-how-they-work)

Redis has a mechanism to publish notifications when certain events occur. One of these events is the expiration of keys (`EXPIRED`). The `laravel-super-cache` package uses these expiry notifications to clean up the tag associations whenever a cache key expires.

**Enabling Expiry Notifications in Redis**:

- Redis must be configured to send `EXPIRED` notifications. This is done by setting the `notify-keyspace-events` parameter to include `Ex` (for expired events).
- When a key in Redis reaches its TTL (Time-To-Live) and expires, an `EXPIRED` event is published to the Redis notification channel.

#### The Listener: Consuming Expiry Events

[](#the-listener-consuming-expiry-events)

The `supercache:listener` command is a long-running process that listens for these `EXPIRED` events and performs clean-up tasks when they are detected. Specifically, it:

1. **Subscribes to Redis Notifications**: The listener subscribes to the `EXPIRED` events, filtered by a specific namespace to avoid processing unrelated keys.
2. **Accumulates Expired Keys in Batches**: When a key expires, the listener adds it to an in-memory batch. This allows for processing multiple keys at once rather than handling each key individually.
3. **Processes Batches Using Pipelines and Lua Scripts**: Once a batch reaches a size or time threshold, it is processed in bulk using Redis pipelines or Lua scripts for maximum efficiency.

### Performance Benefits: Batching, Pipeline, and Lua Scripts

[](#performance-benefits-batching-pipeline-and-lua-scripts)

1. **Batching in Memory**:

    - **What is it?** Instead of processing each expired key as soon as it is detected, the listener accumulates keys in a batch.
    - **Benefits**: Reduces the overhead of individual operations, as multiple keys are processed together, reducing the number of calls to Redis.
2. **Using Redis Pipelines**:

    - **What is it?** A pipeline in Redis allows multiple commands to be sent to the server in one go, reducing the number of network round-trips.
    - **Benefits**: Processing a batch of keys in a single pipeline operation is much faster than processing each key individually, as it minimizes network latency.
3. **Executing Batch Operations with Lua Scripts**:

    - **What is it?** Lua scripts allow you to execute multiple Redis commands atomically, ensuring that all operations on a batch of keys are processed as a single unit within Redis.
    - **Benefits**:
        - **Atomicity**: Ensures that all related operations (e.g., removing a key and cleaning up its associated tags) happen together without interference from other processes.
        - **Performance**: Running a Lua script directly on the Redis server is faster than issuing multiple commands from an external client, as it reduces the need for multiple network calls and leverages Redis’s internal processing speed.

### Parallel Processing with Namespaces

[](#parallel-processing-with-namespaces)

To improve scalability, the listener allows processing multiple namespaces in parallel. Each listener process is assigned to handle a specific namespace, ensuring that the processing load is distributed evenly across multiple processes.

- **Benefit**: Parallel processing enables your system to handle high volumes of expired keys efficiently, without creating a performance bottleneck.

#### Example Workflow: Handling Key Expiry

[](#example-workflow-handling-key-expiry)

1. **Key Expiration Event**: A cache key `product:123` reaches its TTL and expires. Redis publishes an `EXPIRED` event for this key.
2. **Listener Accumulates Key**: The listener process receives the event and adds `product:123` to an in-memory batch.
3. **Batch Processing Triggered**: Once the batch reaches a size threshold (e.g., 100 keys) or a time threshold (e.g., 1 second), the listener triggers the batch processing.
4. **Batch Processing with Lua Script**:
    - A Lua script is executed on Redis to:
        - Verify if the key is actually expired (prevent race conditions).
        - Remove the key from all associated tag sets.
        - Delete the key-tag association set.
    - This entire process is handled atomically by the Lua script for consistency and performance.

### Why This Approach Optimizes Performance

[](#why-this-approach-optimizes-performance)

By combining batching, pipelining, and Lua scripts, the package ensures:

- **Reduced Network Overhead**: Fewer round-trips between your application and Redis.
- **Atomic Operations**: Lua scripts guarantee that all necessary operations for a key's expiry are handled in a single atomic block.
- **Efficient Resource Utilization**: Memory batching allows for efficient use of system resources, processing large numbers of keys quickly.
- **Parallel Scalability**: By using multiple listeners across namespaces, your system can handle large volumes of expirations without creating performance bottlenecks. This approach provides a robust, scalable, and highly performant cache management system for enterprise-grade Laravel applications.

### Scheduled Command for Orphaned Key Cleanup

[](#scheduled-command-for-orphaned-key-cleanup)

Optionally, a scheduled command can be configured to periodically clean up any orphaned keys or sets left due to unexpected interruptions or errors. This adds an additional safety net to maintain consistency across cache keys and tags.

```
php artisan supercache:clean
```

This can be scheduled using Laravel's scheduler to run at appropriate intervals, ensuring your cache remains clean and optimized.

Conclusion
----------

[](#conclusion)

With laravel-super-cache, your Laravel application can achieve enterprise-grade caching performance with robust tag management, efficient key invalidation, and seamless parallel processing. Enjoy a faster, more reliable cache that scales effortlessly with your application's needs.

Change log
----------

[](#change-log)

Please see [CHANGELOG](CHANGELOG.md) for more information what has changed recently.

Testing
-------

[](#testing)

```
composer test
```

Contributing
------------

[](#contributing)

Please see [CONTRIBUTING](CONTRIBUTING.md) for details.

Security
--------

[](#security)

If you discover any security related issues, please email instead of using the issue tracker.

Credits
-------

[](#credits)

- [Lorenzo Padovani](https://github.com/lopadova)
- [All Contributors](../../contributors)

About Padosoft
--------------

[](#about-padosoft)

Padosoft () is a software house based in Florence, Italy. Specialized in E-commerce and web sites.

License
-------

[](#license)

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

###  Health Score

49

—

FairBetter than 95% of packages

Maintenance84

Actively maintained with recent releases

Popularity29

Limited adoption so far

Community14

Small or concentrated contributor base

Maturity56

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 69% 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

Every ~14 days

Recently: every ~90 days

Total

35

Last Release

113d ago

Major Versions

v1.0.8 → v2.0-beta.62024-11-28

v1.1.2 → v2.0-beta.72024-12-09

### Community

Maintainers

![](https://www.gravatar.com/avatar/9fabb1f16f7a29a235494893175d25d51628fe2a6c9052834e35abe0666c9a8e?d=identicon)[lopadova](/maintainers/lopadova)

---

Top Contributors

[![januabisconti](https://avatars.githubusercontent.com/u/171591409?v=4)](https://github.com/januabisconti "januabisconti (49 commits)")[![lopadova](https://avatars.githubusercontent.com/u/10467699?v=4)](https://github.com/lopadova "lopadova (11 commits)")[![Copilot](https://avatars.githubusercontent.com/in/1143301?v=4)](https://github.com/Copilot "Copilot (7 commits)")[![EduardoMateos](https://avatars.githubusercontent.com/u/11529050?v=4)](https://github.com/EduardoMateos "EduardoMateos (3 commits)")[![leopado](https://avatars.githubusercontent.com/u/20923180?v=4)](https://github.com/leopado "leopado (1 commits)")

---

Tags

cachelaravelredisredis-cacherediscacheredis-cachepadosoftlaravel-super-cache

###  Code Quality

TestsPHPUnit

Static AnalysisPHPStan

Code StyleLaravel Pint

### Embed Badge

![Health badge](/badges/padosoft-laravel-super-cache/health.svg)

```
[![Health](https://phpackages.com/badges/padosoft-laravel-super-cache/health.svg)](https://phpackages.com/packages/padosoft-laravel-super-cache)
```

###  Alternatives

[awssat/laravel-visits

Laravel Redis visits counter for Eloquent models

975163.6k2](/packages/awssat-laravel-visits)[swayok/alternative-laravel-cache

Replacements for Laravel's redis and file cache stores that properly implement tagging idea. Powered by cache pool implementations provided by http://www.php-cache.com/

202541.1k6](/packages/swayok-alternative-laravel-cache)[rtcamp/nginx-helper

Cleans nginx's fastcgi/proxy cache or redis-cache whenever a post is edited/published. Also provides cloudflare edge cache purging with Cache-Tags.

23517.0k1](/packages/rtcamp-nginx-helper)[cache/predis-adapter

A PSR-6 cache implementation using Redis (Predis). This implementation supports tags

272.6M13](/packages/cache-predis-adapter)[contributte/redis

Redis client integration into Nette framework

181.6M2](/packages/contributte-redis)[byerikas/cache-tags

Allows for Redis/Valkey cache flushing multiple tagged items by a single tag.

1413.9k](/packages/byerikas-cache-tags)

PHPackages © 2026

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