CacheBackendDecorator.php

Same filename in other branches
  1. 11.x core/modules/system/tests/modules/performance_test/src/Cache/CacheBackendDecorator.php

Namespace

Drupal\performance_test\Cache

File

core/modules/system/tests/modules/performance_test/src/Cache/CacheBackendDecorator.php

View source
<?php

declare (strict_types=1);
namespace Drupal\performance_test\Cache;

use Drupal\Core\Cache\Cache;
use Drupal\Core\Cache\CacheBackendInterface;
use Drupal\Core\Cache\CacheTagsInvalidatorInterface;
use Drupal\performance_test\PerformanceDataCollector;

/**
 * Wraps an existing cache backend to track calls to the cache backend.
 */
class CacheBackendDecorator implements CacheBackendInterface, CacheTagsInvalidatorInterface {
    public function __construct(PerformanceDataCollector $performanceDataCollector, CacheBackendInterface $cacheBackend, string $bin) {
    }
    
    /**
     * Logs a cache operation.
     *
     * @param string|array $cids
     *   The cache IDs.
     * @param float $start
     *   The start microtime.
     * @param float $stop
     *   The stop microtime.
     * @param string $operation
     *   The type of operation being logged.
     *
     * @return void
     */
    protected function logCacheOperation(string|array $cids, float $start, float $stop, string $operation) : void {
        $this->performanceDataCollector
            ->addCacheOperation([
            'operation' => $operation,
            'cids' => implode(', ', (array) $cids),
            'bin' => $this->bin,
            'start' => $start,
            'stop' => $stop,
        ]);
    }
    
    /**
     * {@inheritdoc}
     */
    public function get($cid, $allow_invalid = FALSE) : object|bool {
        $start = microtime(TRUE);
        $cache = $this->cacheBackend
            ->get($cid, $allow_invalid);
        $stop = microtime(TRUE);
        $this->logCacheOperation($cid, $start, $stop, 'get');
        return $cache;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getMultiple(&$cids, $allow_invalid = FALSE) : array {
        $cids_copy = $cids;
        $start = microtime(TRUE);
        $cache = $this->cacheBackend
            ->getMultiple($cids, $allow_invalid);
        $stop = microtime(TRUE);
        $this->logCacheOperation($cids_copy, $start, $stop, 'getMultiple');
        return $cache;
    }
    
    /**
     * {@inheritdoc}
     */
    public function set($cid, $data, $expire = Cache::PERMANENT, array $tags = []) {
        $start = microtime(TRUE);
        $this->cacheBackend
            ->set($cid, $data, $expire, $tags);
        $stop = microtime(TRUE);
        $this->logCacheOperation($cid, $start, $stop, 'set');
    }
    
    /**
     * {@inheritdoc}
     */
    public function setMultiple(array $items) {
        $cids = array_keys($items);
        $start = microtime(TRUE);
        $this->cacheBackend
            ->setMultiple($items);
        $stop = microtime(TRUE);
        $this->logCacheOperation($cids, $start, $stop, 'setMultiple');
    }
    
    /**
     * {@inheritdoc}
     */
    public function delete($cid) {
        $start = microtime(TRUE);
        $this->cacheBackend
            ->delete($cid);
        $stop = microtime(TRUE);
        $this->logCacheOperation($cid, $start, $stop, 'delete');
    }
    
    /**
     * {@inheritdoc}
     */
    public function deleteMultiple(array $cids) {
        $start = microtime(TRUE);
        $this->cacheBackend
            ->deleteMultiple($cids);
        $stop = microtime(TRUE);
        $this->logCacheOperation($cids, $start, $stop, 'deleteMultiple');
    }
    
    /**
     * {@inheritdoc}
     */
    public function deleteAll() {
        $start = microtime(TRUE);
        $this->cacheBackend
            ->deleteAll();
        $stop = microtime(TRUE);
        $this->logCacheOperation([], $start, $stop, 'deleteAll');
    }
    
    /**
     * {@inheritdoc}
     */
    public function invalidate($cid) {
        $start = microtime(TRUE);
        $this->cacheBackend
            ->invalidate($cid);
        $stop = microtime(TRUE);
        $this->logCacheOperation($cid, $start, $stop, 'invalidate');
    }
    
    /**
     * {@inheritdoc}
     */
    public function invalidateMultiple(array $cids) {
        $start = microtime(TRUE);
        $this->cacheBackend
            ->invalidateMultiple($cids);
        $stop = microtime(TRUE);
        $this->logCacheOperation($cids, $start, $stop, 'invalidateMultiple');
    }
    
    /**
     * {@inheritdoc}
     */
    public function invalidateTags(array $tags) {
        if ($this->cacheBackend instanceof CacheTagsInvalidatorInterface) {
            $this->cacheBackend
                ->invalidateTags($tags);
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public function invalidateAll() {
        $start = microtime(TRUE);
        $this->cacheBackend
            ->invalidateAll();
        $stop = microtime(TRUE);
        $this->logCacheOperation([], $start, $stop, 'invalidateAll');
    }
    
    /**
     * {@inheritdoc}
     */
    public function garbageCollection() {
        $this->cacheBackend
            ->garbageCollection();
    }
    
    /**
     * {@inheritdoc}
     */
    public function removeBin() {
        $this->cacheBackend
            ->removeBin();
    }

}

Classes

Title Deprecated Summary
CacheBackendDecorator Wraps an existing cache backend to track calls to the cache backend.

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.