c0323bd24b
* 4.1: fixed tests fixed CS fixed CS fixed CS fixed short array CS in comments fixed CS in ExpressionLanguage fixtures fixed CS in generated files fixed CS on generated container files fixed CS on Form PHP templates fixed CS on YAML fixtures fixed fixtures switched array() to []
282 lines
6.5 KiB
PHP
282 lines
6.5 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of the Symfony package.
|
|
*
|
|
* (c) Fabien Potencier <fabien@symfony.com>
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace Symfony\Component\Cache\Adapter;
|
|
|
|
use Psr\Cache\CacheItemInterface;
|
|
use Symfony\Component\Cache\CacheItem;
|
|
use Symfony\Component\Cache\PruneableInterface;
|
|
use Symfony\Component\Cache\ResettableInterface;
|
|
use Symfony\Contracts\Cache\CacheInterface;
|
|
use Symfony\Contracts\Service\ResetInterface;
|
|
|
|
/**
|
|
* An adapter that collects data about all cache calls.
|
|
*
|
|
* @author Aaron Scherer <aequasi@gmail.com>
|
|
* @author Tobias Nyholm <tobias.nyholm@gmail.com>
|
|
* @author Nicolas Grekas <p@tchwork.com>
|
|
*/
|
|
class TraceableAdapter implements AdapterInterface, CacheInterface, PruneableInterface, ResettableInterface
|
|
{
|
|
protected $pool;
|
|
private $calls = [];
|
|
|
|
public function __construct(AdapterInterface $pool)
|
|
{
|
|
$this->pool = $pool;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function get(string $key, callable $callback, float $beta = null, array &$metadata = null)
|
|
{
|
|
if (!$this->pool instanceof CacheInterface) {
|
|
throw new \BadMethodCallException(sprintf('Cannot call "%s::get()": this class doesn\'t implement "%s".', \get_class($this->pool), CacheInterface::class));
|
|
}
|
|
|
|
$isHit = true;
|
|
$callback = function (CacheItem $item) use ($callback, &$isHit) {
|
|
$isHit = $item->isHit();
|
|
|
|
return $callback($item);
|
|
};
|
|
|
|
$event = $this->start(__FUNCTION__);
|
|
try {
|
|
$value = $this->pool->get($key, $callback, $beta, $metadata);
|
|
$event->result[$key] = \is_object($value) ? \get_class($value) : \gettype($value);
|
|
} finally {
|
|
$event->end = microtime(true);
|
|
}
|
|
if ($isHit) {
|
|
++$event->hits;
|
|
} else {
|
|
++$event->misses;
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function getItem($key)
|
|
{
|
|
$event = $this->start(__FUNCTION__);
|
|
try {
|
|
$item = $this->pool->getItem($key);
|
|
} finally {
|
|
$event->end = microtime(true);
|
|
}
|
|
if ($event->result[$key] = $item->isHit()) {
|
|
++$event->hits;
|
|
} else {
|
|
++$event->misses;
|
|
}
|
|
|
|
return $item;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function hasItem($key)
|
|
{
|
|
$event = $this->start(__FUNCTION__);
|
|
try {
|
|
return $event->result[$key] = $this->pool->hasItem($key);
|
|
} finally {
|
|
$event->end = microtime(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function deleteItem($key)
|
|
{
|
|
$event = $this->start(__FUNCTION__);
|
|
try {
|
|
return $event->result[$key] = $this->pool->deleteItem($key);
|
|
} finally {
|
|
$event->end = microtime(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function save(CacheItemInterface $item)
|
|
{
|
|
$event = $this->start(__FUNCTION__);
|
|
try {
|
|
return $event->result[$item->getKey()] = $this->pool->save($item);
|
|
} finally {
|
|
$event->end = microtime(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function saveDeferred(CacheItemInterface $item)
|
|
{
|
|
$event = $this->start(__FUNCTION__);
|
|
try {
|
|
return $event->result[$item->getKey()] = $this->pool->saveDeferred($item);
|
|
} finally {
|
|
$event->end = microtime(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function getItems(array $keys = [])
|
|
{
|
|
$event = $this->start(__FUNCTION__);
|
|
try {
|
|
$result = $this->pool->getItems($keys);
|
|
} finally {
|
|
$event->end = microtime(true);
|
|
}
|
|
$f = function () use ($result, $event) {
|
|
$event->result = [];
|
|
foreach ($result as $key => $item) {
|
|
if ($event->result[$key] = $item->isHit()) {
|
|
++$event->hits;
|
|
} else {
|
|
++$event->misses;
|
|
}
|
|
yield $key => $item;
|
|
}
|
|
};
|
|
|
|
return $f();
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function clear()
|
|
{
|
|
$event = $this->start(__FUNCTION__);
|
|
try {
|
|
return $event->result = $this->pool->clear();
|
|
} finally {
|
|
$event->end = microtime(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function deleteItems(array $keys)
|
|
{
|
|
$event = $this->start(__FUNCTION__);
|
|
$event->result['keys'] = $keys;
|
|
try {
|
|
return $event->result['result'] = $this->pool->deleteItems($keys);
|
|
} finally {
|
|
$event->end = microtime(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function commit()
|
|
{
|
|
$event = $this->start(__FUNCTION__);
|
|
try {
|
|
return $event->result = $this->pool->commit();
|
|
} finally {
|
|
$event->end = microtime(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function prune()
|
|
{
|
|
if (!$this->pool instanceof PruneableInterface) {
|
|
return false;
|
|
}
|
|
$event = $this->start(__FUNCTION__);
|
|
try {
|
|
return $event->result = $this->pool->prune();
|
|
} finally {
|
|
$event->end = microtime(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function reset()
|
|
{
|
|
if (!$this->pool instanceof ResetInterface) {
|
|
return;
|
|
}
|
|
$event = $this->start(__FUNCTION__);
|
|
try {
|
|
$this->pool->reset();
|
|
} finally {
|
|
$event->end = microtime(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function delete(string $key): bool
|
|
{
|
|
$event = $this->start(__FUNCTION__);
|
|
try {
|
|
return $event->result[$key] = $this->pool->deleteItem($key);
|
|
} finally {
|
|
$event->end = microtime(true);
|
|
}
|
|
}
|
|
|
|
public function getCalls()
|
|
{
|
|
return $this->calls;
|
|
}
|
|
|
|
public function clearCalls()
|
|
{
|
|
$this->calls = [];
|
|
}
|
|
|
|
protected function start($name)
|
|
{
|
|
$this->calls[] = $event = new TraceableAdapterEvent();
|
|
$event->name = $name;
|
|
$event->start = microtime(true);
|
|
|
|
return $event;
|
|
}
|
|
}
|
|
|
|
class TraceableAdapterEvent
|
|
{
|
|
public $name;
|
|
public $start;
|
|
public $end;
|
|
public $result;
|
|
public $hits = 0;
|
|
public $misses = 0;
|
|
}
|