vendor/symfony/cache/Adapter/TraceableAdapter.php line 38

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Cache\Adapter;
  14. use Psr\Cache\CacheItemInterface;
  15. use Symfony\Component\Cache\CacheItem;
  16. use Symfony\Component\Cache\PruneableInterface;
  17. use Symfony\Component\Cache\ResettableInterface;
  18. use Symfony\Contracts\Cache\CacheInterface;
  19. use Symfony\Contracts\Service\ResetInterface;
  21. /**
  22.  * An adapter that collects data about all cache calls.
  23.  *
  24.  * @author Aaron Scherer <aequasi@gmail.com>
  25.  * @author Tobias Nyholm <tobias.nyholm@gmail.com>
  26.  * @author Nicolas Grekas <p@tchwork.com>
  27.  */
  28. class TraceableAdapter implements AdapterInterface, CacheInterface, PruneableInterface, ResettableInterface
  29. {
  30.     protected $pool;
  31.     private array $calls = [];
  33.     public function __construct(AdapterInterface $pool)
  34.     {
  35.         $this->pool = $pool;
  36.     }
  38.     public function get(string $key, callable $callback, float $beta = null, array &$metadata = null): mixed
  39.     {
  40.         if (!$this->pool instanceof CacheInterface) {
  41.             throw new \BadMethodCallException(sprintf('Cannot call "%s::get()": this class doesn\'t implement "%s".', get_debug_type($this->pool), CacheInterface::class));
  42.         }
  44.         $isHit = true;
  45.         $callback = function (CacheItem $item, bool &$save) use ($callback, &$isHit) {
  46.             $isHit = $item->isHit();
  48.             return $callback($item, $save);
  49.         };
  51.         $event = $this->start(__FUNCTION__);
  52.         try {
  53.             $value = $this->pool->get($key, $callback, $beta, $metadata);
  54.             $event->result[$key] = get_debug_type($value);
  55.         } finally {
  56.             $event->end = microtime(true);
  57.         }
  58.         if ($isHit) {
  59.             ++$event->hits;
  60.         } else {
  61.             ++$event->misses;
  62.         }
  64.         return $value;
  65.     }
  67.     public function getItem(mixed $key): CacheItem
  68.     {
  69.         $event = $this->start(__FUNCTION__);
  70.         try {
  71.             $item = $this->pool->getItem($key);
  72.         } finally {
  73.             $event->end = microtime(true);
  74.         }
  75.         if ($event->result[$key] = $item->isHit()) {
  76.             ++$event->hits;
  77.         } else {
  78.             ++$event->misses;
  79.         }
  81.         return $item;
  82.     }
  84.     public function hasItem(mixed $key): bool
  85.     {
  86.         $event = $this->start(__FUNCTION__);
  87.         try {
  88.             return $event->result[$key] = $this->pool->hasItem($key);
  89.         } finally {
  90.             $event->end = microtime(true);
  91.         }
  92.     }
  94.     public function deleteItem(mixed $key): bool
  95.     {
  96.         $event = $this->start(__FUNCTION__);
  97.         try {
  98.             return $event->result[$key] = $this->pool->deleteItem($key);
  99.         } finally {
  100.             $event->end = microtime(true);
  101.         }
  102.     }
  104.     public function save(CacheItemInterface $item): bool
  105.     {
  106.         $event = $this->start(__FUNCTION__);
  107.         try {
  108.             return $event->result[$item->getKey()] = $this->pool->save($item);
  109.         } finally {
  110.             $event->end = microtime(true);
  111.         }
  112.     }
  114.     public function saveDeferred(CacheItemInterface $item): bool
  115.     {
  116.         $event = $this->start(__FUNCTION__);
  117.         try {
  118.             return $event->result[$item->getKey()] = $this->pool->saveDeferred($item);
  119.         } finally {
  120.             $event->end = microtime(true);
  121.         }
  122.     }
  124.     public function getItems(array $keys = []): iterable
  125.     {
  126.         $event = $this->start(__FUNCTION__);
  127.         try {
  128.             $result = $this->pool->getItems($keys);
  129.         } finally {
  130.             $event->end = microtime(true);
  131.         }
  132.         $f = function () use ($result, $event) {
  133.             $event->result = [];
  134.             foreach ($result as $key => $item) {
  135.                 if ($event->result[$key] = $item->isHit()) {
  136.                     ++$event->hits;
  137.                 } else {
  138.                     ++$event->misses;
  139.                 }
  140.                 yield $key => $item;
  141.             }
  142.         };
  144.         return $f();
  145.     }
  147.     public function clear(string $prefix = ''): bool
  148.     {
  149.         $event = $this->start(__FUNCTION__);
  150.         try {
  151.             if ($this->pool instanceof AdapterInterface) {
  152.                 return $event->result = $this->pool->clear($prefix);
  153.             }
  155.             return $event->result = $this->pool->clear();
  156.         } finally {
  157.             $event->end = microtime(true);
  158.         }
  159.     }
  161.     public function deleteItems(array $keys): bool
  162.     {
  163.         $event = $this->start(__FUNCTION__);
  164.         $event->result['keys'] = $keys;
  165.         try {
  166.             return $event->result['result'] = $this->pool->deleteItems($keys);
  167.         } finally {
  168.             $event->end = microtime(true);
  169.         }
  170.     }
  172.     public function commit(): bool
  173.     {
  174.         $event = $this->start(__FUNCTION__);
  175.         try {
  176.             return $event->result = $this->pool->commit();
  177.         } finally {
  178.             $event->end = microtime(true);
  179.         }
  180.     }
  182.     public function prune(): bool
  183.     {
  184.         if (!$this->pool instanceof PruneableInterface) {
  185.             return false;
  186.         }
  187.         $event = $this->start(__FUNCTION__);
  188.         try {
  189.             return $event->result = $this->pool->prune();
  190.         } finally {
  191.             $event->end = microtime(true);
  192.         }
  193.     }
  195.     public function reset()
  196.     {
  197.         if ($this->pool instanceof ResetInterface) {
  198.             $this->pool->reset();
  199.         }
  201.         $this->clearCalls();
  202.     }
  204.     public function delete(string $key): bool
  205.     {
  206.         $event = $this->start(__FUNCTION__);
  207.         try {
  208.             return $event->result[$key] = $this->pool->deleteItem($key);
  209.         } finally {
  210.             $event->end = microtime(true);
  211.         }
  212.     }
  214.     public function getCalls()
  215.     {
  216.         return $this->calls;
  217.     }
  219.     public function clearCalls()
  220.     {
  221.         $this->calls = [];
  222.     }
  224.     public function getPool(): AdapterInterface
  225.     {
  226.         return $this->pool;
  227.     }
  229.     protected function start(string $name)
  230.     {
  231.         $this->calls[] = $event = new TraceableAdapterEvent();
  232.         $event->name = $name;
  233.         $event->start = microtime(true);
  235.         return $event;
  236.     }
  237. }
  239. /**
  240.  * @internal
  241.  */
  242. class TraceableAdapterEvent
  243. {
  244.     public string $name;
  245.     public float $start;
  246.     public float $end;
  247.     public array|bool $result;
  248.     public int $hits = 0;
  249.     public int $misses = 0;
  250. }