Cache slam defense using a semaphore to prevent dogpile effect.

Przemek Sobstel

Last update: Sep 28, 2022

Related tags

Overview

metaphore

PHP cache slam defense using a semaphore to prevent dogpile effect (aka clobbering updates, stampending herd or Slashdot effect).

Problem: too many requests hit your website at the same time while it tries to regenerate same content slamming your database, eg. when cache expired.

Solution: first request generates new content while all the subsequent requests get (stale) content from cache until it's refreshed by the first request.

Read http://www.sobstel.org/blog/preventing-dogpile-effect/ for more details.

Installation

In composer.json file:

"require": {
  "sobstel/metaphore": "1.2.*"
}

or just composer require sobstel/metaphore

Usage

use Metaphore\Cache;
use Metaphore\Store\MemcachedStore;

// initialize $memcached object (new Memcached())

$cache = new Cache(new MemcachedStore($memcached));
$cache->cache('key', function() {
    // generate content
}, 30);

Public API (methods)

__construct(ValueStoreInterface $valueStore, LockManager $lockManager = null)
cache($key, callable $callable, [$ttl, [$onNoStaleCacheCallable]]) - returns result
delete($key)
getValue($key) - returns Value object
setResult($key, $result, Ttl $ttl) - sets result (without anti-dogpile-effect mechanism)
onNoStaleCache($callable)
getValueStore()
getLockManager()

Value store vs lock store

Cache values and locks can be handled by different stores.

$valueStore = new Metaphore\MemcachedStore($memcached);

$lockStore = new Your\Custom\MySQLLockStore($connection);
$lockManager = new Metaphore\LockManager($lockStore);

$cache = new Metaphore\Cache($valueStore, $lockManager);

By default - if no 2nd argument passed to Cache constructor - value store is used as a lock store.

Sample use case might be to have custom MySQL GET_LOCK/RELEASE_LOCK for locks and still use in-built Memcached store for storing values.

Time-to-live

You can pass simple integer value...

$cache->cache('key', callback, 30); // cache for 30 secs

.. or use more advanced Metaphore\TTl object, which gives you control over grace period and lock ttl.

// $ttl, $grace_ttl, $lock_ttl
$ttl = new Ttl(30, 60, 15);

$cache->cache('key', callback, $ttl);

$ttl - regular cache time (in seconds)
$grace_ttl - grace period, how long to allow to serve stale content while new one is being generated (in seconds), similar to HTTP's stale-while-revalidate, default is 60s
$lock_ttl - lock time, how long to prevent other request(s) from generating same content, default is 5s

Ttl value is added to current timestamp (time() + $ttl).

No stale cache

In rare situations, when cache gets expired and there's no stale (generated earlier) content available, all requests will start generating new content.

You can add listener to catch this:

$cache->onNoStaleCache(function (NoStaleCacheEvent $event) {
    Logger::log(sprintf('no stale cache detected for key %s', $event->getKey()));
});

You can also affect value that is returned:

$cache->onNoStaleCache(function (NoStaleCacheEvent $event) {
    $event->setResult('new custom result');
});

Tests

Run all tests: phpunit.

If no memcached or/and redis installed: phpunit --exclude-group=notisolated or phpunit --exclude-group=memcached,redis.

Comments

Revise logic behind determining ttl for lock

Currently it's a half of grace_ttl. More a guess, and not logical really. Don't have a better idea for now though.

It's important for cases when first request fails for some reason. New content is not generated while lock is not released.

    public function getLockTtl()
    {
        if (!isset($this->lockTtl)) {
            // educated guess (remove lock early enough so if anything goes wrong
            // with first process, another one can pick up)
            // SMELL: a bit problematic, why $grace_ttl/2 ???
            $this->lockTtl = max(1, (int)($this->getGraceTtl()/2));
        }

        return $this->lockTtl;
    }

opened by sobstel 3

Dead lock issue

In case of fatal error, server restart... we can have a situation of dead lock issue.

Why not putting a ttl in the lock data and in case cache is not regenerating until this ttl, another thread is allow to get the lock and generate the cache.

opened by lchenay 2

Add FilePhpStore Class

Save the file in php with: deny access from web-browser.

It is based on the FileStore class.

use Metaphore\Cache;
use Metaphore\Store\FilePhpStore;

$cache = new Cache(new FilePhpStore('data/')); 

$cache->cache('key', function() {
		//code
	}, 60);

folder result:

| + - data/
  | + - 3c6e0b8a9c15224a8228b9a98ca1531d.php

opened by dziul 1

Ttl issue when it's timestamp (ttl > 30days)

Hi, i'm using your nice library for our platform and i notice an issue :

When we set a ttl > 30days, your class Ttl convert in unix timestamp the value, then at the moment of save with setResult you add again time(). Obviously it will not work if the value is already a unix timestamp

$obj->cache('aa', function({ return 'aaa'}, (time() + 24*60*60*365))) => ttl generated : 2979400318 instead of 1505468441

@edit : my mistake i just realize your library handle this and i should not set the timestamp but only seconds :)

opened by kruggs 1
fix getting value from non existing key from redis

Metaphore relies on 'false' type to mark result value as non existing

Redis will return NULL when key does not exist http://redis.io/commands/GET

That's why there is a need to cast null to false when getting value from redis

opened by peengle 0
pcntl_fork

Have you considered implementing pcntl_fork for the callback functions? That might avoid freezing the callback request to the client that currently is "unstaling" the result.
wontfix

opened by larcho 1
Consider PSR-6 compatibility
Standard cache interface (will be PSR-6) has got similar concepts to metaphore:

CacheItemInterface resembles Value object

CacheItemPoolInterface indicates cache storage mechanism, like Memcache

PSR-6 is not finalized (official) yet, but the approach seems to be discussed and decided already. Due to similarities I though it might be beneficial to be forward-compatible, heck even be the first implementation.

Up to discussion.
wontfix
opened by adambro 4

Releases(v1.2.6)

v1.2.6(Jun 24, 2019)

Source code(tar.gz)
Source code(zip)
v1.2.5(Nov 8, 2017)

Source code(tar.gz)
Source code(zip)

Owner

Przemek Sobstel

⛰🏃🇦🇷⚽⌨️🧉🐕

GitHub

The place to keep your cache.

Stash - A PHP Caching Library Stash makes it easy to speed up your code by caching the results of expensive functions or code. Certain actions, like d

944 Jan 4, 2023

PHP cache library, with adapters for e.g. Memcached, Redis, Couchbase, APC(u), SQL and additional capabilities (e.g. transactions, stampede protection) built on top.

Donate/Support: Documentation: https://www.scrapbook.cash - API reference: https://docs.scrapbook.cash Table of contents Installation & usage Adapters

295 Nov 28, 2022

:zap: Simple Cache Abstraction Layer for PHP

⚡ Simple Cache Class This is a simple Cache Abstraction Layer for PHP >= 7.0 that provides a simple interaction with your cache-server. You can define

27 Dec 8, 2022

Doctrine Cache component

Doctrine Cache Cache component extracted from the Doctrine Common project. Documentation This library is deprecated and will no longer receive bug fix

7.6k Jan 3, 2023

A high-performance backend cache system. It is intended for use in speeding up dynamic web applications by alleviating database load. Well implemented, it can drops the database load to almost nothing, yielding faster page load times for users, better resource utilization. It is simple yet powerful.

⚠️ Please note that the V8 is an important (with small BC breaking) update of PhpFastCache ! As the V8 is relatively not compatible with previous vers