Update object-cache.php

Author: jessuppi

object-cache.php

@@ -2,836 +2,1214 @@
 /*
 Plugin Name: Object Cache
 Plugin URI: https://www.littlebizzy.com/plugins/object-cache
-Description: Drop-in persistent object cache for WordPress based on Redis in-memory storage that supports Predis, clusters, and WP-CLI (forked from PressJitsu).
-Version: 1.2.3
+Description: Memcached backend for the WP Object Cache.
+Version: 2.0.0
 Author: LittleBizzy
 Author URI: https://www.littlebizzy.com
 License: GPLv3
 License URI: https://www.gnu.org/licenses/gpl-3.0.html
-Upstream Plugin Name: Pressjitsu Redis Object Cache
-Upstream Plugin URI: https://github.com/pressjitsu/pj-object-cache-red
-Upstream Author: Eric Mann + Erick Hitter + Pressjitsu, Inc.
-Upstream Author URI: https://pressjitsu.com
-PBP Version: N/A
-WC requires at least: 3.3
-WC tested up to: 3.8
-Prefix: OBJCHE
+Upstream Plugin Name: Memcached
+Upstream Plugin URI: https://github.com/Automattic/wp-memcached
+Upstream Author: Ryan Boren, Denis de Bernardy, Matt Martz, Andy Skelton
+Upstream Author URI: https://wordpress.org
+Upstream Version: 4.0.0
 */
 
-declare(strict_types=1);
+// Users with setups where multiple installs share a common wp-config.php or $table_prefix
+// can use this to guarantee uniqueness for the keys generated by this object cache
+if ( ! defined( 'WP_CACHE_KEY_SALT' ) ) {
+	define( 'WP_CACHE_KEY_SALT', '' );
+}
+
+function wp_cache_add( $key, $data, $group = '', $expire = 0 ) {
+	global $wp_object_cache;
 
-// check if OBJECT_CACHE is disabled in wp-config.php
-if ( defined( 'OBJECT_CACHE' ) && !OBJECT_CACHE ) {
-	return;
+	return $wp_object_cache->add( $key, $data, $group, $expire );
 }
 
-// check if 'Redis' class exists
-if( class_exists( 'Redis' ) ) :
+function wp_cache_add_multiple( array $data, $group = '', $expire = 0 ) {
+	global $wp_object_cache;
 
-/**
- * Adds a value to cache.
- *
- * If the specified key wp_cache_addalready exists, the value is not stored and the function
- * returns false.
- *
- * @param string $key        The key under which to store the value.
- * @param mixed  $value      The value to store.
- * @param string $group      The group value appended to the $key.
- * @param int    $expiration The expiration time, defaults to 0.
- *
- * @global WP_Object_Cache $wp_object_cache
- *
- * @return bool              Returns TRUE on success or FALSE on failure.
- */
-function wp_cache_add( $key, $value, $group = 'default', $expiration = 0 ) {
+	return $wp_object_cache->add_multiple( $data, $group, $expire );
+}
+
+function wp_cache_incr( $key, $n = 1, $group = '' ) {
 	global $wp_object_cache;
-	return $wp_object_cache->add( $key, $value, $group, $expiration );
+
+	return $wp_object_cache->incr( $key, $n, $group );
+}
+
+function wp_cache_decr( $key, $n = 1, $group = '' ) {
+	global $wp_object_cache;
+
+	return $wp_object_cache->decr( $key, $n, $group );
 }
 
-/**
- * Closes the cache.
- *
- * This function has ceased to do anything since WordPress 2.5. The
- * functionality was removed along with the rest of the persistent cache. This
- * does not mean that plugins can't implement this function when they need to
- * make sure that the cache is cleaned up after WordPress no longer needs it.
- *
- * @return  bool    Always returns True
- */
 function wp_cache_close() {
-	return true;
+	global $wp_object_cache;
+
+	return $wp_object_cache->close();
 }
 
-/**
- * Decrement a numeric item's value.
- *
- * @param string $key    The key under which to store the value.
- * @param int    $offset The amount by which to decrement the item's value.
- * @param string $group  The group value appended to the $key.
- *
- * @global WP_Object_Cache $wp_object_cache
- *
- * @return int|bool      Returns item's new value on success or FALSE on failure.
- */
-function wp_cache_decr( $key, $offset = 1, $group = 'default' ) {
+function wp_cache_delete( $key, $group = '' ) {
 	global $wp_object_cache;
-	return $wp_object_cache->decr( $key, $offset, $group );
+
+	return $wp_object_cache->delete( $key, $group );
 }
 
-/**
- * Remove the item from the cache.
- *
- * @param string $key    The key under which to store the value.
- * @param string $group  The group value appended to the $key.
- * @param int    $time   The amount of time the server will wait to delete the item in seconds.
- *
- * @global WP_Object_Cache $wp_object_cache
- *
- * @return bool           Returns TRUE on success or FALSE on failure.
- */
-function wp_cache_delete( $key, $group = 'default', $time = 0 ) {
+function wp_cache_delete_multiple( array $keys, $group = '' ) {
 	global $wp_object_cache;
-	return $wp_object_cache->delete( $key, $group, $time );
+
+	return $wp_object_cache->delete_multiple( $keys, $group );
 }
 
-/**
- * Invalidate all items in the cache.
- *
- * @param int $delay  Number of seconds to wait before invalidating the items.
- *
- * @global WP_Object_Cache $wp_object_cache
- *
- * @return bool             Returns TRUE on success or FALSE on failure.
- */
-function wp_cache_flush( $delay = 0 ) {
+function wp_cache_flush() {
 	global $wp_object_cache;
-	return $wp_object_cache->flush( $delay );
+
+	return $wp_object_cache->flush();
 }
 
-/**
- * Retrieve object from cache.
- *
- * Gets an object from cache based on $key and $group.
- *
- * @param string      $key        The key under which to store the value.
- * @param string      $group      The group value appended to the $key.
- *
- * @global WP_Object_Cache $wp_object_cache
- *
- * @return bool|mixed             Cached object value.
- */
-function wp_cache_get( $key, $group = 'default', $force = false ) {
+function wp_cache_flush_runtime() {
 	global $wp_object_cache;
-	return $wp_object_cache->get( $key, $group, $force );
+
+	return $wp_object_cache->flush_runtime();
 }
 
-/**
- * Retrieve multiple values from cache.
- *
- * Gets multiple values from cache, including across multiple groups
- *
- * Usage: array( 'group0' => array( 'key0', 'key1', 'key2', ), 'group1' => array( 'key0' ) )
- *
- * Mirrors the Memcached Object Cache plugin's argument and return-value formats
- *
- * @param   array       $groups  Array of groups and keys to retrieve
- *
- * @global WP_Object_Cache $wp_object_cache
- *
- * @return  bool|mixed           Array of cached values, keys in the format $group:$key. Non-existent keys false
- */
-function wp_cache_get_multi( $groups, $unserialize = true ) {
+function wp_cache_get( $key, $group = '', $force = false, &$found = null ) {
 	global $wp_object_cache;
-	return $wp_object_cache->get_multi( $groups, $unserialize );
+
+	if ( function_exists( 'apply_filters' ) ) {
+		$value = apply_filters( 'pre_wp_cache_get', false, $key, $group, $force );
+		if ( false !== $value ) {
+			$found = true;
+			return $value;
+		}
+	}
+
+	return $wp_object_cache->get( $key, $group, $force, $found );
 }
 
-/**
- * Increment a numeric item's value.
- *
- * @param string $key    The key under which to store the value.
- * @param int    $offset The amount by which to increment the item's value.
- * @param string $group  The group value appended to the $key.
- *
- * @global WP_Object_Cache $wp_object_cache
- *
- * @return int|bool      Returns item's new value on success or FALSE on failure.
- */
-function wp_cache_incr( $key, $offset = 1, $group = 'default' ) {
+function wp_cache_get_multiple( $keys, $group = '', $force = false ) {
 	global $wp_object_cache;
-	return $wp_object_cache->incr( $key, $offset, $group );
+
+	return $wp_object_cache->get_multiple( $keys, $group, $force );
 }
 
 /**
- * Sets up Object Cache Global and assigns it.
- *
- * @global  WP_Object_Cache $wp_object_cache    WordPress Object Cache
+ * Retrieve multiple cache entries
  *
- * @return  void
+ * @param array $groups Array of arrays, of groups and keys to retrieve
+ * @return mixed
  */
+function wp_cache_get_multi( $groups ) {
+	global $wp_object_cache;
+
+	return $wp_object_cache->get_multi( $groups );
+}
+
 function wp_cache_init() {
 	global $wp_object_cache;
+
 	$wp_object_cache = new WP_Object_Cache();
 }
 
-/**
- * Replaces a value in cache.
- *
- * This method is similar to "add"; however, is does not successfully set a value if
- * the object's key is not already set in cache.
- *
- * @param string $key        The key under which to store the value.
- * @param mixed  $value      The value to store.
- * @param string $group      The group value appended to the $key.
- * @param int    $expiration The expiration time, defaults to 0.
- *
- * @global WP_Object_Cache $wp_object_cache
- *
- * @return bool              Returns TRUE on success or FALSE on failure.
- */
-function wp_cache_replace( $key, $value, $group = 'default', $expiration = 0 ) {
+function wp_cache_replace( $key, $data, $group = '', $expire = 0 ) {
 	global $wp_object_cache;
-	return $wp_object_cache->replace( $key, $value, $group, $expiration );
+
+	return $wp_object_cache->replace( $key, $data, $group, $expire );
 }
 
-/**
- * Sets a value in cache.
- *
- * The value is set whether or not this key already exists in Redis.
- *
- * @param string $key        The key under which to store the value.
- * @param mixed  $value      The value to store.
- * @param string $group      The group value appended to the $key.
- * @param int    $expiration The expiration time, defaults to 0.
- *
- * @global WP_Object_Cache $wp_object_cache
- *
- * @return bool              Returns TRUE on success or FALSE on failure.
- */
-function wp_cache_set( $key, $value, $group = 'default', $expiration = 0 ) {
+function wp_cache_set( $key, $data, $group = '', $expire = 0 ) {
 	global $wp_object_cache;
-	return $wp_object_cache->set( $key, $value, $group, $expiration );
+
+	if ( defined( 'WP_INSTALLING' ) === false ) {
+		return $wp_object_cache->set( $key, $data, $group, $expire );
+	} else {
+		return $wp_object_cache->delete( $key, $group );
+	}
 }
 
-/**
- * Switch the interal blog id.
- *
- * This changes the blog id used to create keys in blog specific groups.
- *
- * @param  int $_blog_id Blog ID
- *
- * @global WP_Object_Cache $wp_object_cache
- *
- * @return bool
- */
-function wp_cache_switch_to_blog( $_blog_id ) {
+function wp_cache_set_multiple( array $data, $group = '', $expire = 0 ) {
 	global $wp_object_cache;
-	return $wp_object_cache->switch_to_blog( $_blog_id );
+
+	return $wp_object_cache->set_multiple( $data, $group, $expire );
+}
+
+function wp_cache_switch_to_blog( $blog_id ) {
+	global $wp_object_cache;
+
+	return $wp_object_cache->switch_to_blog( $blog_id );
 }
 
-/**
- * Adds a group or set of groups to the list of Redis groups.
- *
- * @param   string|array $groups     A group or an array of groups to add.
- *
- * @global WP_Object_Cache $wp_object_cache
- *
- * @return  void
- */
 function wp_cache_add_global_groups( $groups ) {
 	global $wp_object_cache;
+
 	$wp_object_cache->add_global_groups( $groups );
 }
 
-/**
- * Adds a group or set of groups to the list of non-Redis groups.
- *
- * @param   string|array $groups     A group or an array of groups to add.
- *
- * @global WP_Object_Cache $wp_object_cache
- *
- * @return  void
- */
 function wp_cache_add_non_persistent_groups( $groups ) {
 	global $wp_object_cache;
+
 	$wp_object_cache->add_non_persistent_groups( $groups );
 }
 
+/**
+ * Determines whether the object cache implementation supports a particular feature.
+ *
+ * @param string $feature Name of the feature to check for. Possible values include:
+ *                        'add_multiple', 'set_multiple', 'get_multiple', 'delete_multiple',
+ *                        'flush_runtime', 'flush_group'.
+ * @return bool True if the feature is supported, false otherwise.
+ */
+function wp_cache_supports( $feature ) {
+	switch ( $feature ) {
+		case 'get_multiple':
+		case 'flush_runtime':
+			return true;
+
+		default:
+			return false;
+	}
+}
+
 class WP_Object_Cache {
+	var $global_groups = array( 'WP_Object_Cache_global' );
+
+	var $no_mc_groups = array();
+
+	var $cache         = array();
+	/** @var Memcache[] */
+	var $mc            = array();
+	var $default_mcs   = array();
+	var $stats         = array(
+		'get'          => 0,
+		'get_local'    => 0,
+		'get_multi'    => 0,
+		'set'          => 0,
+		'set_local'    => 0,
+		'add'          => 0,
+		'delete'       => 0,
+		'delete_local' => 0,
+		'slow-ops'     => 0,
+	);
+	var $group_ops     = array();
+	var $cache_hits    = 0;
+	var $cache_misses  = 0;
+	var $global_prefix = '';
+	var $blog_prefix   = '';
+	var $key_salt      = '';
+
+	var $flush_group         = 'WP_Object_Cache';
+	var $global_flush_group  = 'WP_Object_Cache_global';
+	var $flush_key           = "flush_number_v4";
+	var $old_flush_key       = "flush_number";
+	var $flush_number        = array();
+	var $global_flush_number = null;
+
+	var $cache_enabled      = true;
+	var $default_expiration = 0;
+	var $max_expiration     = 2592000; // 30 days
+
+	var $stats_callback = null;
+
+	var $connection_errors = array();
+
+	var $time_start = 0;
+	var $time_total = 0;
+	var $size_total = 0;
+	var $slow_op_microseconds = 0.005; // 5 ms
+
+	function add( $id, $data, $group = 'default', $expire = 0 ) {
+		$key = $this->key( $id, $group );
+
+		if ( is_object( $data ) ) {
+			$data = clone $data;
+		}
 
-	/**
-	 * Holds the Redis client.
-	 *
-	 * @var Redis
-	 */
-	private $redis;
+		if ( in_array( $group, $this->no_mc_groups ) ) {
+			if ( ! isset( $this->cache[ $key ] ) ) {
+				$this->cache[ $key ] = [
+					'value' => $data,
+					'found' => false,
+				];
 
-	/**
-	 * Track if Redis is available
-	 *
-	 * @var bool
-	 */
-	private $redis_connected = false;
+				return true;
+			}
 
-	/**
-	 * Local cache
-	 *
-	 * @var array
-	 */
-	public $cache = array();
+			return false;
+		}
 
-	private $to_unserialize = array();
+		if ( isset( $this->cache[ $key ][ 'value' ] ) && false !== $this->cache[ $key ][ 'value' ] ) {
+			return false;
+		}
 
-	public $to_preload = array();
+		$mc = $this->get_mc( $group );
 
-	/**
-	 * List of global groups.
-	 *
-	 * @var array
-	 */
-	public $global_groups = array(
-        'blog-details',
-        'blog-id-cache',
-        'blog-lookup',
-        'global-posts',
-        'networks',
-        'rss',
-        'sites',
-        'site-details',
-        'site-lookup',
-        'site-options',
-        'site-transient',
-        'users',
-        'useremail',
-        'userlogins',
-        'usermeta',
-        'user_meta',
-        'userslugs',
-    );
-
-	private $_global_groups;
+		$expire = intval( $expire );
+		if ( 0 === $expire || $expire > $this->max_expiration ) {
+			$expire = $this->default_expiration;
+		}
 
-	/**
-	 * List of groups not saved to Redis.
-	 *
-	 * @var array
-	 */
-	public $no_redis_groups = array( 'comment', 'counts' );
+		$size = $this->get_data_size( $data );
+		$this->timer_start();
+		$result = $mc->add( $key, $data, false, $expire );
+		$elapsed = $this->timer_stop();
 
-	/**
-	 * Prefix used for global groups.
-	 *
-	 * @var string
-	 */
-	public $global_prefix = '';
+		$comment = '';
+		if ( isset( $this->cache[ $key ] ) ) {
+			$comment .= ' [lc already]';
+		}
+		if ( false === $result ) {
+			$comment .= ' [mc already]';
+		}
 
-	/**
-	 * Prefix used for non-global groups.
-	 *
-	 * @var string
-	 */
-	public $blog_prefix = '';
+		$this->group_ops_stats( 'add', $key, $group, $size, $elapsed, $comment );
+
+		if ( false !== $result ) {
+			$this->cache[ $key ] = [
+				'value' => $data,
+				'found' => true,
+			];
+		} else if ( false === $result && true === isset( $this->cache[$key][ 'value' ] ) && false === $this->cache[$key][ 'value' ] ) {
+			/*
+			 * Here we unset local cache if remote add failed and local cache value is equal to `false` in order
+			 * to update the local cache anytime we get a new information from remote server. This way, the next
+			 * cache get will go to remote server and will fetch recent data.
+			 */
+			unset( $this->cache[$key] );
+		}
 
-	/**
-	 * Track how many requests were found in cache
-	 *
-	 * @var int
-	 */
-	public $cache_hits = 0;
+		return $result;
+	}
 
-	/**
-	 * Track how may requests were not cached
-	 *
-	 * @var int
-	 */
-	public $cache_misses = 0;
+	public function add_multiple( array $data, $group = '', $expire = 0 ) {
+		$values = array();
 
-	private $multisite;
+		foreach ( $data as $key => $value ) {
+			$values[ $key ] = $this->add( $key, $value, $group, $expire );
+		}
 
-	public $stats = array();
+		return $values;
+	}
 
-	/**
-	 * Instantiate the Redis class.
-	 *
-	 * Instantiates the Redis class.
-	 *
-	 * @param   null $persistent_id      To create an instance that persists between requests, use persistent_id to specify a unique ID for the instance.
-	 */
-	public function __construct( $redis_instance = null ) {
-		// General Redis settings
-		$redis = array(
-			'host' => '127.0.0.1',
-			'port' => 6379,
-		);
+	function add_global_groups( $groups ) {
+		if ( ! is_array( $groups ) ) {
+			$groups = (array) $groups;
+		}
 
-		if ( defined( 'WP_REDIS_BACKEND_HOST' ) && WP_REDIS_BACKEND_HOST ) {
-			$redis['host'] = WP_REDIS_BACKEND_HOST;
+		$this->global_groups = array_merge( $this->global_groups, $groups );
+		$this->global_groups = array_unique( $this->global_groups );
+	}
+
+	function add_non_persistent_groups( $groups ) {
+		if ( ! is_array( $groups ) ) {
+			$groups = (array) $groups;
 		}
-		if ( defined( 'WP_REDIS_BACKEND_PORT' ) && WP_REDIS_BACKEND_PORT ) {
-			$redis['port'] = WP_REDIS_BACKEND_PORT;
+
+		$this->no_mc_groups = array_merge( $this->no_mc_groups, $groups );
+		$this->no_mc_groups = array_unique( $this->no_mc_groups );
+	}
+
+	function incr( $id, $n = 1, $group = 'default' ) {
+		$key = $this->key( $id, $group );
+		$mc = $this->get_mc( $group );
+
+		$incremented = $mc->increment( $key, $n );
+
+		$this->cache[ $key ] = [
+			'value' => $incremented,
+			'found' => false !== $incremented,
+		];
+
+		return $this->cache[ $key ][ 'value' ];
+	}
+
+	function decr( $id, $n = 1, $group = 'default' ) {
+		$key = $this->key( $id, $group );
+		$mc = $this->get_mc( $group );
+
+		$decremented = $mc->decrement( $key, $n );
+		$this->cache[ $key ] = [
+			'value' => $decremented,
+			'found' => false !== $decremented,
+		];
+
+		return $this->cache[ $key ][ 'value' ];
+	}
+
+	function close() {
+		foreach ( $this->mc as $bucket => $mc ) {
+			$mc->close();
 		}
-		if ( defined( 'WP_REDIS_BACKEND_AUTH' ) && WP_REDIS_BACKEND_AUTH ) {
-			$redis['auth'] = WP_REDIS_BACKEND_AUTH;
+	}
+
+	function delete( $id, $group = 'default' ) {
+		$key = $this->key( $id, $group );
+
+		if ( in_array( $group, $this->no_mc_groups ) ) {
+			unset( $this->cache[ $key ] );
+
+			return true;
 		}
-		if ( defined( 'WP_REDIS_BACKEND_DB' ) && WP_REDIS_BACKEND_DB ) {
-			$redis['database'] = WP_REDIS_BACKEND_DB;
+
+		$mc = $this->get_mc( $group );
+
+		$this->timer_start();
+		$result = $mc->delete( $key );
+		$elapsed = $this->timer_stop();
+
+		$this->group_ops_stats( 'delete', $key, $group, null, $elapsed );
+
+		if ( false !== $result ) {
+			unset( $this->cache[ $key ] );
 		}
 
-		// Use Redis PECL library.
-		try {
-			if ( is_null( $redis_instance ) ) {
-				$redis_instance = new Redis();
+		return $result;
+	}
+
+	public function delete_multiple( array $keys, $group = '' ) {
+		$values = array();
+
+		foreach ( $keys as $key ) {
+			$values[ $key ] = $this->delete( $key, $group );
+		}
+
+		return $values;
+	}
+
+	// Gets number from all default servers, replicating if needed
+	function get_max_flush_number( $group ) {
+		$key = $this->key( $this->flush_key, $group );
+
+		$values = array();
+		$size = 19; // size of microsecond timestamp serialized
+		foreach ( $this->default_mcs as $i => $mc ) {
+			$flags = false;
+			$this->timer_start();
+			$values[ $i ] = $mc->get( $key, $flags );
+			$elapsed = $this->timer_stop();
+
+			if ( empty( $values[ $i ] ) ) {
+				$this->group_ops_stats( 'get_flush_number', $key, $group, null, $elapsed, 'not_in_memcache' );
+			} else {
+				$this->group_ops_stats( 'get_flush_number', $key, $group, $size, $elapsed, 'memcache' );
 			}
-			$this->redis = $redis_instance;
-			$this->redis->connect( $redis['host'], $redis['port'] );
-			$this->redis->setOption( Redis::OPT_SERIALIZER, (string) Redis::SERIALIZER_PHP );
+		}
+
+		$max = max( $values );
+
+		if ( ! $max > 0 ) {
+			return false;
+		}
 
-			if ( isset( $redis['auth'] ) ) {
-				$this->redis->auth( $redis['auth'] );
+		// Replicate to servers not having the max.
+		$expire = 0;
+		foreach ( $this->default_mcs as $i => $mc ) {
+			if ( $values[ $i ] < $max ) {
+				$this->timer_start();
+				$mc->set( $key, $max, false, $expire );
+				$elapsed = $this->timer_stop();
+				$this->group_ops_stats( 'set_flush_number', $key, $group, $size, $elapsed, 'replication_repair' );
 			}
+		}
+
+		return $max;
+	}
+
+	function set_flush_number( $value, $group ) {
+		$key = $this->key( $this->flush_key, $group );
+		$expire = 0;
+		$size = 19;
+		foreach ( $this->default_mcs as $i => $mc ) {
+			$this->timer_start();
+			$mc->set( $key, $value, false, $expire );
+			$elapsed = $this->timer_stop();
+			$this->group_ops_stats( 'set_flush_number', $key, $group, $size, $elapsed, 'replication' );
+		}
+	}
 
-			if ( isset( $redis['database'] ) ) {
-				$this->redis->select( $redis['database'] );
+	function get_flush_number( $group ) {
+		$flush_number = $this->get_max_flush_number( $group );
+		// What if there is no v4 flush number?
+		if ( empty( $flush_number ) ) {
+			// Look for the v3 flush number key.
+			$flush_number = intval( $this->get( $this->old_flush_key, $group ) );
+			if ( !empty( $flush_number ) ) {
+				// Found v3 flush number. Upgrade to v4 with replication.
+				$this->set_flush_number( $flush_number, $group );
+				// Delete v3 key so we can't later restore it and find stale keys.
+			} else {
+				// No flush number found anywhere. Make a new one. This flushes the cache.
+				$flush_number = $this->new_flush_number();
+				$this->set_flush_number( $flush_number, $group );
 			}
+		}
+
+		return $flush_number;
+	}
 
-			$this->redis_connected = true;
-		} catch ( RedisException $e ) {
-			// When Redis is unavailable, fall back to the internal back by forcing all groups to be "no redis" groups
-			$this->no_redis_groups = array_unique( array_merge( $this->no_redis_groups, $this->global_groups ) );
-			$this->redis_connected = false;
+	function get_global_flush_number() {
+		if ( ! isset( $this->global_flush_number ) ) {
+			$this->global_flush_number = $this->get_flush_number( $this->global_flush_group );
 		}
+		return $this->global_flush_number;
+	}
 
-		/**
-		 * This approach is borrowed from Sivel and Boren. Use the salt for easy cache invalidation and for
-		 * multi single WP installs on the same server.
-		 */
-		if ( ! defined( 'WP_CACHE_KEY_SALT' ) ) {
-			define( 'WP_CACHE_KEY_SALT', '' );
+	function get_blog_flush_number() {
+		if ( ! isset( $this->flush_number[ $this->blog_prefix ] ) ) {
+			$this->flush_number[ $this->blog_prefix ] = $this->get_flush_number( $this->flush_group );
 		}
+		return $this->flush_number[ $this->blog_prefix ];
+	}
 
-		$this->multisite = is_multisite();
-		$this->blog_prefix = $this->multisite ? get_current_blog_id() . ':' : '';
-		$this->_global_groups = array_flip( $this->global_groups );
+	function flush_runtime() {
+		$this->cache     = array();
+		$this->group_ops = array();
 
-		$this->maybe_preload();
+		return true;
 	}
 
-	public function maybe_preload() {
-		if ( ! $this->can_redis() || empty( $_SERVER['REQUEST_URI'] ) ) {
-			return;
+	function flush() {
+		// Do not use the memcached flush method. It acts on an
+		// entire memcached server, affecting all sites.
+		// Flush is also unusable in some setups, e.g. twemproxy.
+		// Instead, rotate the key prefix for the current site.
+		// Global keys are rotated when flushing on any network's
+		// main site.
+		$this->cache = array();
+
+		$flush_number = $this->new_flush_number();
+
+		$this->rotate_site_keys( $flush_number );
+
+		if ( function_exists( 'is_main_site' ) && is_main_site() ) {
+			$this->rotate_global_keys( $flush_number );
 		}
 
-		if ( defined( 'WP_CLI' ) && WP_CLI ) {
-			return;
+		return true;
+	}
+
+	function rotate_site_keys( $flush_number = null ) {
+		if ( is_null( $flush_number ) ) {
+			$flush_number = $this->new_flush_number();
 		}
 
-		$request_hash = md5( json_encode( array(
-			$_SERVER['HTTP_HOST'],
-			$_SERVER['REQUEST_URI'],
-		) ) );
+		$this->set_flush_number( $flush_number, $this->flush_group );
 
-		$this->preload( $request_hash );
+		$this->flush_number[ $this->blog_prefix ] = $flush_number;
+	}
 
-		if ( defined( 'DOING_TESTS' ) && DOING_TESTS ) {
-			return $request_hash;
+	function rotate_global_keys( $flush_number = null ) {
+		if ( is_null( $flush_number ) ) {
+			$flush_number = $this->new_flush_number();
 		}
 
-		register_shutdown_function( array( $this, 'save_preloads' ), $request_hash );
+		$this->set_flush_number( $flush_number, $this->global_flush_group );
+
+		$this->global_flush_number = $flush_number;
 	}
 
-	public function preload( $hash ) {
-		$keys = $this->get( $hash, 'pj-preload' );
-		if ( is_array( $keys ) ) {
-			$this->get_multi( $keys, false );
-		}
+	function new_flush_number() {
+		return intval( microtime( true ) * 1e6 );
 	}
 
-	public function save_preloads( $hash ) {
-		$keys = array();
+	function get( $id, $group = 'default', $force = false, &$found = null ) {
+		$key = $this->key( $id, $group );
+		$mc = $this->get_mc( $group );
+		$found = true;
 
-		foreach ( $this->to_preload as $group => $_keys ) {
-			if ( $group === 'pj-preload' ) {
-				continue;
+		if ( isset( $this->cache[ $key ] ) && ( ! $force || in_array( $group, $this->no_mc_groups ) ) ) {
+			if ( isset( $this->cache[ $key ][ 'value' ] ) && is_object( $this->cache[ $key ][ 'value' ] ) ) {
+				$value = clone $this->cache[ $key ][ 'value' ];
+			} else {
+				$value = $this->cache[ $key ][ 'value' ];
 			}
+			$found = $this->cache[ $key ][ 'found' ];
 
-			if ( in_array( $group, $this->no_redis_groups ) ) {
-				continue;
+			$this->group_ops_stats( 'get_local', $key, $group, null, null, 'local' );
+		} else if ( in_array( $group, $this->no_mc_groups ) ) {
+			$this->cache[ $key ] = [
+				'value' => $value = false,
+				'found' => false,
+			];
+
+			$found = false;
+
+			$this->group_ops_stats( 'get_local', $key, $group, null, null, 'not_in_local' );
+		} else {
+			$flags = false;
+			$this->timer_start();
+			$value = $mc->get( $key, $flags );
+			$elapsed = $this->timer_stop();
+
+			// Value will be unchanged if the key doesn't exist.
+			if ( false === $flags ) {
+				$found = false;
+				$value = false;
+			} elseif ( false === $value && ( $flags & 0xFF01 ) === 0x01 ) {
+				/*
+				 * The lowest byte is used for flags.
+				 * 0x01 means the value is serialized (MMC_SERIALIZED).
+				 * The second lowest indicates data type: 0 is string, 1 is bool, 3 is long, 7 is double.
+				 * `null` is serialized into a string, thus $flags is 0x0001
+				 * Empty string will correspond to $flags = 0x0000 (not serialized).
+				 * For `false` or `true` $flags will be 0x0100
+				 *
+				 * See:
+				 * - https://github.com/websupport-sk/pecl-memcache/blob/2a5de3c5d9c0bd0acbcf7e6e0b7570f15f89f55b/php7/memcache_pool.h#L61-L76 - PHP 7.x
+				 * - https://github.com/websupport-sk/pecl-memcache/blob/ccf702b14b18fce18a1863e115a7b4c964df952e/src/memcache_pool.h#L57-L76 - PHP 8.x
+				 *
+				 * In PHP 8, they changed the way memcache_get() handles `null`:
+				 * https://github.com/websupport-sk/pecl-memcache/blob/ccf702b14b18fce18a1863e115a7b4c964df952e/src/memcache.c#L2175-L2177
+				 *
+				 * If the return value is `null`, it is silently converted to `false`. We can only rely upon $flags to find out whether `false` is real.
+				 */
+				$value = null;
 			}
 
-			$_keys = array_keys( $_keys );
-			$keys[ $group ] = $_keys;
+			$this->cache[ $key ] = [
+				'value' => $value,
+				'found' => $found,
+			];
+
+			if ( is_null( $value ) || $value === false ) {
+				$this->group_ops_stats( 'get', $key, $group, null, $elapsed, 'not_in_memcache' );
+			} else if ( 'checkthedatabaseplease' === $value ) {
+				$this->group_ops_stats( 'get', $key, $group, null, $elapsed, 'checkthedatabaseplease' );
+			} else {
+				$size = $this->get_data_size( $value );
+				$this->group_ops_stats( 'get', $key, $group, $size, $elapsed, 'memcache' );
+			}
+		}
+
+		if ( 'checkthedatabaseplease' === $value ) {
+			unset( $this->cache[ $key ] );
+
+			$found = false;
+			$value = false;
 		}
 
-		$this->set( $hash, $keys, 'pj-preload' );
+		return $value;
 	}
 
-	/**
-	 * Is Redis available?
-	 *
-	 * @return bool
-	 */
-	protected function can_redis() {
-		return $this->redis_connected;
+	function get_multi( $groups ) {
+		/*
+		format: $get['group-name'] = array( 'key1', 'key2' );
+		*/
+		$return = array();
+		$return_cache = array(
+			'value' => false,
+			'found' => false,
+		);
+
+		foreach ( $groups as $group => $ids ) {
+			$mc = $this->get_mc( $group );
+			$keys = array();
+			$this->timer_start();
+
+			foreach ( $ids as $id ) {
+				$key = $this->key( $id, $group );
+				$keys[] = $key;
+
+				if ( isset( $this->cache[ $key ] ) ) {
+					if ( is_object( $this->cache[ $key ][ 'value'] ) ) {
+						$return[ $key ] = clone $this->cache[ $key ][ 'value'];
+						$return_cache[ $key ] = [
+							'value' => clone $this->cache[ $key ][ 'value'],
+							'found' => $this->cache[ $key ][ 'found'],
+						];
+					} else {
+						$return[ $key ] = $this->cache[ $key ][ 'value'];
+						$return_cache[ $key ] = [
+							'value' => $this->cache[ $key ][ 'value' ],
+							'found' => $this->cache[ $key ][ 'found' ],
+						];
+					}
+
+					continue;
+				} else if ( in_array( $group, $this->no_mc_groups ) ) {
+					$return[ $key ] = false;
+					$return_cache[ $key ] = [
+						'value' => false,
+						'found' => false,
+					];
+
+					continue;
+				} else {
+					$fresh_get = $mc->get( $key );
+					$return[ $key ] = $fresh_get;
+					$return_cache[ $key ] = [
+						'value' => $fresh_get,
+						'found' => false !== $fresh_get,
+					];
+				}
+			}
+
+			$elapsed = $this->timer_stop();
+			$this->group_ops_stats( 'get_multi', $keys, $group, null, $elapsed );
+		}
+
+		$this->cache = array_merge( $this->cache, $return_cache );
+
+		return $return;
 	}
 
-	/**
-	 * Adds a value to cache.
-	 *
-	 * If the specified key already exists, the value is not stored and the function
-	 * returns false.
-	 *
-	 * @param   string $key            The key under which to store the value.
-	 * @param   mixed  $value          The value to store.
-	 * @param   string $group          The group value appended to the $key.
-	 * @param   int    $expiration     The expiration time, defaults to 0.
-	 * @return  bool                   Returns TRUE on success or FALSE on failure.
-	 */
-	public function add( $_key, $value, $group, $expiration = 0 ) {
-		if ( wp_suspend_cache_addition() ) {
-			return false;
+	public function get_multiple( $keys, $group = 'default', $force = false ) {
+		$mc = $this->get_mc( $group );
+
+		$no_mc = in_array( $group, $this->no_mc_groups, true );
+
+		$uncached_keys = array();
+		$return        = array();
+		$return_cache  = array();
+
+		foreach ( $keys as $id ) {
+			$key = $this->key( $id, $group );
+
+			if ( isset( $this->cache[ $key ] ) && ( ! $force || $no_mc ) ) {
+				$value         = $this->cache[ $key ]['found'] ? $this->cache[ $key ]['value'] : false;
+				$return[ $id ] = is_object( $value ) ? clone $value : $value;
+			} else if ( $no_mc ) {
+				$return[ $id ]        = false;
+				$return_cache[ $key ] = [
+					'value' => false,
+					'found' => false,
+				];
+			} else {
+				$uncached_keys[ $id ] = $key;
+			}
 		}
 
-		list( $key, $redis_key ) = $this->build_key( $_key, $group );
+		if ( $uncached_keys ) {
+			$this->timer_start();
+			$uncached_keys_list = array_values( $uncached_keys );
+			$values             = $mc->get( $uncached_keys_list );
+			$elapsed            = $this->timer_stop();
 
-		if ( isset( $this->cache[ $group ], $this->cache[ $group ][ $key ] ) && false !== $this->cache[ $group ][ $key ] ) {
-			return false;
+			$this->group_ops_stats( 'get_multiple', $uncached_keys_list, $group, null, $elapsed );
+
+			foreach ( $uncached_keys as $id => $key ) {
+				$found = array_key_exists( $key, $values );
+				$value = $found ? $values[ $key ] : false;
+
+				$return[ $id ]        = $value;
+				$return_cache[ $key ] = [
+					'value' => $value,
+					'found' => $found,
+				];
+			}
 		}
 
-		return $this->set( $_key, $value, $group, $expiration );
+		$this->cache = array_merge( $this->cache, $return_cache );
+
+		return $return;
 	}
 
-	/**
-	 * Replace a value in the cache.
-	 *
-	 * If the specified key doesn't exist, the value is not stored and the function
-	 * returns false.
-	 *
-	 * @param   string $key            The key under which to store the value.
-	 * @param   mixed  $value          The value to store.
-	 * @param   string $group          The group value appended to the $key.
-	 * @param   int    $expiration     The expiration time, defaults to 0.
-	 * @return  bool                   Returns TRUE on success or FALSE on failure.
-	 */
-	public function replace( $_key, $value, $group, $expiration = 0 ) {
-		list( $key, $redis_key ) = $this->build_key( $_key, $group );
+	function flush_prefix( $group ) {
+		if ( $group === $this->flush_group || $group === $this->global_flush_group ) {
+			// Never flush the flush numbers.
+			$number = '_';
+		} elseif ( false !== array_search( $group, $this->global_groups ) ) {
+			$number = $this->get_global_flush_number();
+		} else {
+			$number = $this->get_blog_flush_number();
+		}
+		return $number . ':';
+	}
 
-		// If group is a non-Redis group, save to internal cache, not Redis
-		if ( in_array( $group, $this->no_redis_groups ) || ! $this->can_redis() ) {
-			if ( ! isset( $this->cache[ $group ], $this->cache[ $group ][ $key ] ) ) {
-				return false;
-			}
+	function key( $key, $group ) {
+		if ( empty( $group ) ) {
+			$group = 'default';
+		}
+
+		$prefix = $this->key_salt;
+
+		$prefix .= $this->flush_prefix( $group );
+
+		if ( false !== array_search( $group, $this->global_groups ) ) {
+			$prefix .= $this->global_prefix;
 		} else {
-			if ( ! $this->redis->exists( $redis_key ) ) {
-				return false;
-			}
+			$prefix .= $this->blog_prefix;
 		}
 
-		return $this->set( $_key, $value, $group, $expiration );
+		return preg_replace( '/\s+/', '', "$prefix:$group:$key" );
 	}
 
-	/**
-	 * Remove the item from the cache.
-	 *
-	 * @param   string $key        The key under which to store the value.
-	 * @param   string $group      The group value appended to the $key.
-	 * @return  bool               Returns TRUE on success or FALSE on failure.
-	 */
-	public function delete( $_key, $group ) {
-		list( $key, $redis_key ) = $this->build_key( $_key, $group );
+	function replace( $id, $data, $group = 'default', $expire = 0 ) {
+		$key = $this->key( $id, $group );
+		$expire = intval( $expire );
+		if ( 0 === $expire || $expire > $this->max_expiration ) {
+			$expire = $this->default_expiration;
+		}
+		$mc = $this->get_mc( $group );
 
-		if ( in_array( $group, $this->no_redis_groups ) || ! $this->can_redis() ) {
-			if ( ! isset( $this->cache[ $group ], $this->cache[ $group ][ $key ] ) ) {
-				return false;
-			}
+		if ( is_object( $data ) ) {
+			$data = clone $data;
+		}
+
+		$size = $this->get_data_size( $data );
+		$this->timer_start();
+		$result = $mc->replace( $key, $data, false, $expire );
+		$elapsed = $this->timer_stop();
+		$this->group_ops_stats( 'replace', $key, $group, $size, $elapsed );
+
+		if ( false !== $result ) {
+			$this->cache[ $key ] = [
+				'value' => $data,
+				'found' => true,
+			];
+		}
+
+		return $result;
+	}
+
+	function set( $id, $data, $group = 'default', $expire = 0 ) {
+		$key = $this->key( $id, $group );
+
+		if ( isset( $this->cache[ $key ] ) && ( 'checkthedatabaseplease' === $this->cache[ $key ][ 'value' ] ) ) {
+			return false;
+		}
+
+		if ( is_object( $data ) ) {
+			$data = clone $data;
+		}
+
+		$this->cache[ $key ] = [
+			'value' => $data,
+			'found' => false, // Set to false as not technically found in memcache at this point.
+		];
+
+		if ( in_array( $group, $this->no_mc_groups ) ) {
+			$this->group_ops_stats( 'set_local', $key, $group, null, null );
 
-			unset( $this->cache[ $group ][ $key ] );
-			unset( $this->to_preload[ $group ][ $key ] );
-			unset( $this->to_unserialize[ $redis_key ] );
 			return true;
 		}
 
-		unset( $this->cache[ $group ][ $key ] );
-		unset( $this->to_preload[ $group ][ $key ] );
-		unset( $this->to_unserialize[ $redis_key ] );
+		$expire = intval( $expire );
+		if ( 0 === $expire || $expire > $this->max_expiration ) {
+			$expire = $this->default_expiration;
+		}
+
+		$mc = $this->get_mc( $group );
+
+		$size = $this->get_data_size( $data );
+		$this->timer_start();
+		$result = $mc->set( $key, $data, false, $expire );
+		$elapsed = $this->timer_stop();
+		$this->group_ops_stats( 'set', $key, $group, $size, $elapsed );
 
-		return (bool) $this->redis->del( $redis_key );
+		// Update the found cache value with the result of the set in memcache.
+		$this->cache[ $key ][ 'found' ] = $result;
+
+		return $result;
 	}
 
-	/**
-	 * Invalidate all items in the cache.
-	 *
-	 * @return  bool
-	 */
-	public function flush() {
-		$this->cache = array();
-		$this->to_preload = array();
-		$this->to_unserialize = array();
+	public function set_multiple( array $data, $group = '', $expire = 0 ) {
+		$values = array();
 
-		if ( $this->can_redis() ) {
-			$this->redis->flushDb();
+		foreach ( $data as $key => $value ) {
+			$values[ $key ] = $this->set( $key, $value, $group, $expire );
 		}
 
-		return true;
+		return $values;
 	}
 
-	/**
-	 * Retrieve object from cache.
-	 *
-	 * Gets an object from cache based on $key and $group.
-	 *
-	 * @param   string        $key        The key under which to store the value.
-	 * @param   string        $group      The group value appended to the $key.
-	 * @return  bool|mixed                Cached object value.
-	 */
-	public function get( $_key, $group = 'default', $force = false ) {
-		list( $key, $redis_key ) = $this->build_key( $_key, $group );
+	function switch_to_blog( $blog_id ) {
+		global $table_prefix;
 
-		$this->to_preload[ $group ][ $_key ] = true;
+		$blog_id = (int) $blog_id;
 
-		if ( ! $force && isset( $this->cache[ $group ][ $key ] ) ) {
-			$value = $this->cache[ $group ][ $key ];
+		$this->blog_prefix = ( is_multisite() ? $blog_id : $table_prefix );
+	}
 
-			if ( isset( $this->to_unserialize[ $redis_key ] ) ) {
-				unset( $this->to_unserialize[ $redis_key ] );
+	function colorize_debug_line( $line, $trailing_html = '' ) {
+		$colors = array(
+			'get' => 'green',
+			'get_local' => 'lightgreen',
+			'get_multi' => 'fuchsia',
+			'get_multiple' => 'navy',
+			'set' => 'purple',
+			'set_local' => 'orchid',
+			'add' => 'blue',
+			'delete' => 'red',
+			'delete_local' => 'tomato',
+			'slow-ops' => 'crimson',
+		);
 
-				if ( is_string( $value ) ) {
-					$value = unserialize( $value );
-				}
+		$cmd = substr( $line, 0, strpos( $line, ' ' ) );
 
-				$this->cache[ $group ][ $key ] = $value;
-			}
+		// Start off with a neutral default color...
+		$color_for_cmd = 'brown';
+		// And if the cmd has a specific color, use that instead
+		if ( isset( $colors[ $cmd ] ) ) {
+			$color_for_cmd = $colors[ $cmd ];
+		}
 
-			$this->cache_hits += 1;
+		$cmd2 = "<span style='color:" . esc_attr( $color_for_cmd ) . "; font-weight: bold;'>" . esc_html( $cmd ) . "</span>";
 
-			return is_object( $value ) ? clone $value : $value;
-		}
+		return $cmd2 . esc_html( substr( $line, strlen( $cmd ) ) ) . "$trailing_html\n";
+	}
 
-		if ( in_array( $group, $this->no_redis_groups ) || ! $this->can_redis() ) {
-			$this->cache_misses += 1;
-			return false;
-		}
+	function js_toggle() {
+		echo "
+		<script>
+		function memcachedToggleVisibility( id, hidePrefix ) {
+			var element = document.getElementById( id );
+			if ( ! element ) {
+				return;
+			}
 
-		// Fetch from Redis
-		$value = $this->redis->get( $redis_key );
+			// Hide all element with `hidePrefix` if given. Used to display only one element at a time.
+			if ( hidePrefix ) {
+				var groupStats = document.querySelectorAll( '[id^=\"' + hidePrefix + '\"]' );
+				groupStats.forEach(
+					function ( element ) {
+					    element.style.display = 'none';
+					}
+				);
+			}
 
-		if ( ! is_string( $value ) ) {
-			$this->cache[ $group ][ $key ] = false;
-			$this->cache_misses += 1;
-			return false;
+			// Toggle the one we clicked.
+			if ( 'none' === element.style.display ) {
+				element.style.display = 'block';
+			} else {
+				element.style.display = 'none';
+			}
 		}
-
-		$value = is_numeric( $value ) ? $value : unserialize( $value );
-		$this->cache[ $group ][ $key ] = $value;
-		$this->cache_hits += 1;
-		return $value;
+		</script>
+		";
 	}
 
 	/**
-	 * Retrieve multiple values from cache.
-	 *
-	 * Gets multiple values from cache, including across multiple groups
+	 * Returns the collected raw stats.
 	 *
-	 * Usage: array( 'group0' => array( 'key0', 'key1', 'key2', ), 'group1' => array( 'key0' ) )
-	 *
-	 * @param   array                           $groups  Array of groups and keys to retrieve
-	 * @return  bool|mixed                               Array of cached values, keys in the format $group:$key. Non-existent keys null.
+	 * @return array $stats
 	 */
-	public function get_multi( $groups, $unserialize = true ) {
-		if ( empty( $groups ) || ! is_array( $groups ) ) {
-			return false;
-		}
+	function get_stats() {
+		$stats = [];
+		$stats['totals'] = [
+			'query_time' => $this->time_total,
+			'size' => $this->size_total,
+		];
+		$stats['operation_counts'] = $this->stats;
+		$stats['operations'] = [];
+		$stats['groups'] = [];
+		$stats['slow-ops'] = [];
+		$stats['slow-ops-groups'] = [];
+		foreach ( $this->group_ops as $cache_group => $dataset ) {
+			if ( empty( $cache_group ) ) {
+				$cache_group = 'default';
+			}
+
+			foreach ( $dataset as $data ) {
+				$operation = $data[0];
+				$op = [
+					'key' => $data[1],
+					'size' => $data[2],
+					'time' => $data[3],
+					'group' => $cache_group,
+					'result' => $data[4],
+				];
+
+				if ( $cache_group === 'slow-ops' ) {
+					$key             = 'slow-ops';
+					$groups_key      = 'slow-ops-groups';
+					$op['group']     = $data[5];
+					$op['backtrace'] = $data[6];
+				} else {
+					$key        = 'operations';
+					$groups_key = 'groups';
+				}
 
-		// Retrieve requested caches and reformat results to mimic Memcached Object Cache's output
-		$cache = array();
-		$fetch_keys = array();
-		$map = array();
+				$stats[ $key ][ $operation ][] = $op;
 
-		foreach ( $groups as $group => $keys ) {
-			if ( in_array( $group, $this->no_redis_groups ) || ! $this->can_redis() ) {
-				foreach ( $keys as $_key ) {
-					list( $key, $redis_key ) = $this->build_key( $_key, $group );
-					$cache[ $group ][ $key ] = $this->get( $_key, $group );
+				if ( ! in_array( $op['group'], $stats[ $groups_key ] ) ) {
+					$stats[ $groups_key ][] = $op['group'];
 				}
+			}
+		}
+
+		return $stats;
+	}
 
+
+	function stats() {
+		$this->js_toggle();
+
+		echo '<h2><span>Total memcache query time:</span>' . number_format_i18n( sprintf( '%0.1f', $this->time_total * 1000 ), 1 ) . ' ms</h2>';
+		echo "\n";
+		echo '<h2><span>Total memcache size:</span>' . esc_html( size_format( $this->size_total, 2 ) ) . '</h2>';
+		echo "\n";
+
+		foreach ( $this->stats as $stat => $n ) {
+			if ( empty( $n ) ) {
 				continue;
 			}
 
-			if ( empty( $cache[ $group ] ) ) {
-				$cache[ $group ] = array();
-			}
+			echo '<h2>';
+			echo $this->colorize_debug_line( "$stat $n" );
+			echo '</h2>';
+		}
 
-			foreach ( $keys as $_key ) {
-				list( $key, $redis_key ) = $this->build_key( $_key, $group );
+		echo "<ul class='debug-menu-links' style='clear:left;font-size:14px;'>\n";
+		$groups = array_keys( $this->group_ops );
+		usort( $groups, 'strnatcasecmp' );
+
+		$active_group = $groups[0];
+		// Always show `slow-ops` first
+		if ( in_array( 'slow-ops', $groups ) ) {
+			$slow_ops_key = array_search( 'slow-ops', $groups );
+			$slow_ops = $groups[ $slow_ops_key ];
+			unset( $groups[ $slow_ops_key ] );
+			array_unshift( $groups, $slow_ops );
+			$active_group = 'slow-ops';
+		}
 
-				if ( isset( $this->cache[ $group ][ $key ] ) ) {
-					$cache[ $group ][ $key ] = $this->cache[ $group ][ $key ];
-					continue;
-				}
+		$total_ops = 0;
+		$group_titles = array();
+		foreach ( $groups as $group ) {
+			$group_name = $group;
+			if ( empty( $group_name ) ) {
+				$group_name = 'default';
+			}
+			$group_ops = count( $this->group_ops[ $group ] );
+			$group_size = size_format( array_sum( array_map( function ( $op ) { return $op[2]; }, $this->group_ops[ $group ] ) ), 2 );
+			$group_time = number_format_i18n( sprintf( '%0.1f', array_sum( array_map( function ( $op ) { return $op[3]; }, $this->group_ops[ $group ] ) ) * 1000 ), 1 );
+			$total_ops += $group_ops;
+			$group_title = "{$group_name} [$group_ops][$group_size][{$group_time} ms]";
+			$group_titles[ $group ] = $group_title;
+			echo "\t<li><a href='#' onclick='memcachedToggleVisibility( \"object-cache-stats-menu-target-" . esc_js( $group_name ) . "\", \"object-cache-stats-menu-target-\" );'>" . esc_html( $group_title ) . "</a></li>\n";
+		}
+		echo "</ul>\n";
 
-				// Fetch these from Redis
-				$map[ $redis_key ] = array( $group, $key );
-				$fetch_keys[] = $redis_key;
+		echo "<div id='object-cache-stats-menu-targets'>\n";
+		foreach ( $groups as $group ) {
+			$group_name = $group;
+			if ( empty( $group_name ) ) {
+				$group_name = 'default';
 			}
+			$current = $active_group == $group ? 'style="display: block"' : 'style="display: none"';
+			echo "<div id='object-cache-stats-menu-target-" . esc_attr( $group_name ) . "' class='object-cache-stats-menu-target' $current>\n";
+			echo '<h3>' . esc_html( $group_titles[ $group ] ) . '</h3>' . "\n";
+			echo "<pre>\n";
+			foreach ( $this->group_ops[ $group ] as $index => $arr ) {
+				printf( '%3d ', $index );
+				echo $this->get_group_ops_line( $index, $arr );
+			}
+			echo "</pre>\n";
+			echo "</div>";
 		}
 
-		// Nothing else to fetch
-		if ( empty( $fetch_keys ) ) {
-			return $cache;
+		echo "</div>";
+	}
+
+	function get_group_ops_line( $index, $arr ) {
+		// operation
+		$line = "{$arr[0]} ";
+
+		// key
+		$json_encoded_key = json_encode( $arr[1] );
+		$line .= $json_encoded_key . " ";
+
+		// comment
+		if ( ! empty( $arr[4] ) ) {
+			$line .= "{$arr[4]} ";
 		}
 
-		$results = $this->redis->mget( $fetch_keys );
-		foreach( array_combine( $fetch_keys, $results ) as $redis_key => $value ) {
-			list( $group, $key ) = $map[ $redis_key ];
+		// size
+		if ( isset( $arr[2] ) ) {
+			$line .= '(' . size_format( $arr[2], 2 ) . ') ';
+		}
 
-			if ( is_string( $value ) ) {
-				if ( ! $unserialize && ! is_numeric( $value ) ) {
-					$this->to_unserialize[ $redis_key ] = true;
-				} elseif ( $unserialize ) {
-					$this->to_preload[ $group ][ $key ] = true;
-					$value = is_numeric( $value ) ? $value : unserialize( $value );
-				}
-			} else {
-				$value = false;
-			}
+		// time
+		if ( isset( $arr[3] ) ) {
+			$line .= '(' . number_format_i18n( sprintf( '%0.1f', $arr[3] * 1000 ), 1 ) . ' ms)';
+		}
 
-			$this->cache[ $group ][ $key ] = $cache[ $group ][ $key ] = $value;
+		// backtrace
+		$bt_link = '';
+		if ( isset( $arr[6] ) ) {
+			$key_hash = md5( $index . $json_encoded_key );
+			$bt_link = " <small><a href='#' onclick='memcachedToggleVisibility( \"object-cache-stats-debug-$key_hash\" );'>Toggle Backtrace</a></small>";
+			$bt_link .= "<pre id='object-cache-stats-debug-$key_hash' style='display:none'>" . esc_html( $arr[6] ) . "</pre>";
 		}
 
-		return $cache;
+		return $this->colorize_debug_line( $line, $bt_link );
 	}
 
 	/**
-	 * Sets a value in cache.
-	 *
-	 * The value is set whether or not this key already exists in Redis.
-	 *
-	 * @param   string $key        The key under which to store the value.
-	 * @param   mixed  $value      The value to store.
-	 * @param   string $group      The group value appended to the $key.
-	 * @param   int    $expiration The expiration time, defaults to 0.
-	 * @return  bool               Returns TRUE on success or FALSE on failure.
+	 * @param int|string $group
+	 * @return Memcache
 	 */
-	public function set( $_key, $value, $group = 'default', $expiration = 0 ) {
-		list( $key, $redis_key ) = $this->build_key( $_key, $group );
-
-		if ( is_object( $value ) ) {
-			$value = clone $value;
+	function get_mc( $group ) {
+		if ( isset( $this->mc[ $group ] ) ) {
+			return $this->mc[ $group ];
 		}
 
-		$this->cache[ $group ][ $key ] = $value;
+		return $this->mc['default'];
+	}
 
-		if ( in_array( $group, $this->no_redis_groups ) || ! $this->can_redis() ) {
-			return true;
+	function failure_callback( $host, $port ) {
+		$this->connection_errors[] = array(
+			'host' => $host,
+			'port' => $port,
+		);
+	}
+
+	function salt_keys( $key_salt ) {
+		if ( strlen( $key_salt ) ) {
+			$this->key_salt = $key_salt . ':';
+		} else {
+			$this->key_salt = '';
 		}
+	}
 
-		$value = is_numeric( $value ) ? $value : serialize( $value );
+	function __construct() {
+		global $memcached_servers;
 
-		// Save to Redis
-		if ( $expiration ) {
-			$this->redis->setex( $redis_key, $expiration, $value );
+		if ( isset( $memcached_servers ) ) {
+			$buckets = $memcached_servers;
 		} else {
-			$this->redis->set( $redis_key, $value );
+			$buckets = array( '127.0.0.1:11211' );
 		}
 
-		return true;
-	}
+		reset( $buckets );
 
-	/**
-	 * Increment a Redis counter by the amount specified
-	 *
-	 * @param  string $key
-	 * @param  int    $offset
-	 * @param  string $group
-	 * @return bool
-	 */
-	public function incr( $_key, $offset = 1, $group ) {
-		list( $key, $redis_key ) = $this->build_key( $_key, $group );
+		if ( is_int( key( $buckets ) ) ) {
+			$buckets = array( 'default' => $buckets );
+		}
+
+		foreach ( $buckets as $bucket => $servers ) {
+			$this->mc[ $bucket ] = new Memcache();
+
+			foreach ( $servers as $i => $server  ) {
+				if ( 'unix://' == substr( $server, 0, 7 ) ) {
+					$node = $server;
+					$port = 0;
+				} else {
+					if ( false === strpos( $server, ':' ) ) {
+						$node = $server;
+						$port = ini_get( 'memcache.default_port' );
+					} else {
+						list ( $node, $port ) = explode( ':', $server, 2 );
+					}
+
+					$port = intval( $port );
+
+					if ( ! $port ) {
+						$port = 11211;
+					}
+				}
+
+				$this->mc[ $bucket ]->addServer( $node, $port, true, 1, 1, 15, true, array( $this, 'failure_callback' ) );
+				$this->mc[ $bucket ]->setCompressThreshold( 20000, 0.2 );
 
-		if ( in_array( $group, $this->no_redis_groups ) || ! $this->can_redis() ) {
-			// Consistent with the Redis behavior (start from 0 if not exists)
-			if ( ! isset( $this->cache[ $group ][ $key ] ) ) {
-				$this->cache[ $group ][ $key ] = 0;
+				// Prepare individual connections to servers in default bucket for flush_number redundancy
+				if ( 'default' === $bucket ) {
+					$this->default_mcs[ $i ] = new Memcache();
+					$this->default_mcs[ $i ]->addServer( $node, $port, true, 1, 1, 15, true, array( $this, 'failure_callback' ) );
+				}
 			}
+		}
 
-			$this->cache[ $group ][ $key ] += $offset;
-			return true;
+		global $blog_id, $table_prefix;
+
+		$this->global_prefix = '';
+		$this->blog_prefix   = '';
+
+		if ( function_exists( 'is_multisite' ) ) {
+			$this->global_prefix = ( is_multisite() || defined( 'CUSTOM_USER_TABLE' ) && defined( 'CUSTOM_USER_META_TABLE' ) ) ? '' : $table_prefix;
+			$this->blog_prefix   = ( is_multisite() ? $blog_id : $table_prefix );
 		}
 
-		// Save to Redis
-		$value = $this->redis->incrBy( $redis_key, $offset );
-		$this->cache[ $group ][ $key ] = $value;
-		return $value;
+		$this->salt_keys( WP_CACHE_KEY_SALT );
+
+		$this->cache_hits   =& $this->stats['get'];
+		$this->cache_misses =& $this->stats['add'];
 	}
 
-	/**
-	 * Decrement a Redis counter by the amount specified
-	 *
-	 * @param  string $key
-	 * @param  int    $offset
-	 * @param  string $group
-	 * @return bool
-	 */
-	public function decr( $key, $offset = 1, $group = 'default' ) {
-		return $this->incr( $key, $offset * -1, $group );
+	function increment_stat( $field, $num = 1 ) {
+		if ( ! isset( $this->stats[ $field ] ) ) {
+			$this->stats[ $field ] = $num;
+		} else {
+			$this->stats[ $field ] += $num;
+		}
 	}
 
-	/**
-	 * Builds a key for the cached object using the blog_id, key, and group values.
-	 *
-	 * @author  Ryan Boren   This function is inspired by the original WP Memcached Object cache.
-	 * @link    http://wordpress.org/extend/plugins/memcached/
-	 *
-	 * @param   string $key        The key under which to store the value.
-	 * @param   string $group      The group value appended to the $key.
-	 *
-	 * @return  array
-	 */
-	public function build_key( $key, $group = 'default' ) {
-		$prefix = '';
-		if ( ! isset( $this->_global_groups[ $group ] ) ) {
-			$prefix = $this->blog_prefix;
+	function group_ops_stats( $op, $keys, $group, $size, $time, $comment = '' ) {
+		$this->increment_stat( $op );
+
+		// we have no use of the local ops details for now
+		if ( strpos( $op, '_local' ) ) {
+			return;
 		}
 
-		$local_key = $prefix . $key;
-		return array( $local_key, WP_CACHE_KEY_SALT . "$prefix$group:$key" );
-	}
+		$this->size_total += $size;
 
-	/**
-	 * In multisite, switch blog prefix when switching blogs
-	 *
-	 * @param int $_blog_id
-	 * @return bool
-	 */
-	public function switch_to_blog( $blog_id ) {
-		$this->blog_prefix = $this->multisite ? $blog_id . ':' : '';
+		$keys = $this->strip_memcached_keys( $keys );
+
+		// @codeCoverageIgnoreStart
+		if ( $time > $this->slow_op_microseconds && 'get_multi' !== $op ) {
+			$this->increment_stat( 'slow-ops' );
+			$backtrace = null;
+			if ( function_exists( 'wp_debug_backtrace_summary' ) ) {
+				$backtrace = wp_debug_backtrace_summary();
+			}
+			$this->group_ops['slow-ops'][] = array( $op, $keys, $size, $time, $comment, $group, $backtrace );
+		}
+		// @codeCoverageIgnoreEnd
+
+		$this->group_ops[ $group ][] = array( $op, $keys, $size, $time, $comment );
 	}
 
 	/**
-	 * Sets the list of global groups.
+	 * Key format: key_salt:flush_number:table_prefix:key_name
 	 *
-	 * @param array $groups List of groups that are global.
+	 * We want to strip the `key_salt:flush_number` part to not leak the memcached keys.
+	 * If `key_salt` is set we strip `'key_salt:flush_number`, otherwise just strip the `flush_number` part.
 	 */
-	public function add_global_groups( $groups ) {
-		$groups = (array) $groups;
+	function strip_memcached_keys( $keys ) {
+		if ( ! is_array( $keys ) ) {
+			$keys = [ $keys ];
+		}
 
-		if ( $this->can_redis() ) {
-			$this->global_groups = array_unique( array_merge( $this->global_groups, $groups ) );
-		} else {
-			$this->no_redis_groups = array_unique( array_merge( $this->no_redis_groups, $groups ) );
+		foreach ( $keys as $key => $value ) {
+			$offset = 0;
+			if ( ! empty( $this->key_salt ) ) {
+				$offset = strpos( $value, ':' ) + 1;
+			}
+
+			$start = strpos( $value, ':', $offset );
+			$keys[ $key ] = substr( $value, $start + 1 );
+		}
+
+		if ( 1 === count( $keys ) ) {
+			return $keys[0];
 		}
 
-		$this->_global_groups = array_flip( $this->global_groups );
+		return $keys;
 	}
 
-	/**
-	 * Sets the list of groups not to be cached by Redis.
-	 *
-	 * @param array $groups List of groups that are to be ignored.
-	 */
-	public function add_non_persistent_groups( $groups ) {
-		$groups = (array) $groups;
+	function timer_start() {
+		$this->time_start = microtime( true );
 
-		$this->no_redis_groups = array_unique( array_merge( $this->no_redis_groups, $groups ) );
+		return true;
 	}
-}
 
-endif; // if 'Redis' class exists
+	function timer_stop() {
+		$time_total = microtime( true ) - $this->time_start;
+		$this->time_total += $time_total;
+
+		return $time_total;
+	}
+
+	function get_data_size( $data ) {
+		if ( is_string( $data ) ) {
+			return strlen( $data );
+		}
+
+		$serialized = serialize( $data );
+
+		return strlen( $serialized );
+	}
+}