DATAREDIS-1082 - Expose cache metrics for RedisCache.

We now expose CacheStatistics for RedisCache. Each cache tracks its statistics (retrievals, hits, misses, stores, removals, lock wait) locally. CacheStatistics is exposed through RedisCacheWriter to allow for statistics customization depending on the cache writer strategy. The statistic object is a singleton per cache instance that gets updated with as the cache operates. RedisCache cache = …; CacheStatistics statistics = cache.getStatistics(); statistics.getRetrievals(); statistics.getHits(); Original Pull Request: spring-projects#545

Author: mp911de

src/main/asciidoc/new-features.adoc

@@ -3,7 +3,13 @@
 
 This section briefly covers items that are new and noteworthy in the latest releases.
 
+[[new-in-2.4.0]]
+== New in Spring Data Redis 2.4
+
+* `RedisCache` now exposes `CacheStatistics`.
+
 [[new-in-2.3.0]]
+
 == New in Spring Data Redis 2.3
 
 * Template API Method Refinements for `Duration` and `Instant`.

src/main/java/org/springframework/data/redis/cache/CacheStatistics.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.redis.cache;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Cache statistics for a Redis Cache.
+ *
+ * @author Mark Paluch
+ * @since 2.4
+ */
+public interface CacheStatistics {
+
+/**
+ * @return number of put operations on the cache.
+ */
+long getStores();
+
+/**
+ * @return number of get operations.
+ */
+long getRetrievals();
+
+/**
+ * @return number of cache get hits.
+ */
+long getHits();
+
+/**
+ * @return number of cache get misses.
+ */
+long getMisses();
+
+/**
+ * @return number of cache removals.
+ */
+long getRemovals();
+
+/**
+ * @param unit the time unit to report the lock wait duration.
+ * @return lock duration using the given {@link TimeUnit} if the cache is configured to use locking.
+ */
+long getLockWaitDuration(TimeUnit unit);
+}

src/main/java/org/springframework/data/redis/cache/DefaultCacheStatistics.java

@@ -0,0 +1,125 @@
+/*
+ * Copyright 2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.redis.cache;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.LongAdder;
+
+import org.springframework.util.Assert;
+
+/**
+ * Default mutable {@link CacheStatistics} implementation.
+ *
+ * @author Mark Paluch
+ * @since 2.4
+ */
+class DefaultCacheStatistics implements CacheStatistics {
+
+private final LongAdder stores = new LongAdder();
+private final LongAdder retrievals = new LongAdder();
+private final LongAdder hits = new LongAdder();
+private final LongAdder misses = new LongAdder();
+private final LongAdder removals = new LongAdder();
+private final LongAdder lockWaitTimeNs = new LongAdder();
+
+/*
+ * (non-Javadoc)
+ * @see org.springframework.data.redis.cache.CacheStatistics#getStores()
+ */
+@Override
+public long getStores() {
+return stores.sum();
+}
+
+void incrementStores() {
+stores.increment();
+}
+
+/*
+ * (non-Javadoc)
+ * @see org.springframework.data.redis.cache.CacheStatistics#getRetrievals()
+ */
+@Override
+public long getRetrievals() {
+return retrievals.sum();
+}
+
+void incrementRetrievals() {
+retrievals.increment();
+}
+
+/*
+ * (non-Javadoc)
+ * @see org.springframework.data.redis.cache.CacheStatistics#getHits()
+ */
+@Override
+public long getHits() {
+return hits.sum();
+}
+
+void incrementHits() {
+hits.increment();
+}
+
+/*
+ * (non-Javadoc)
+ * @see org.springframework.data.redis.cache.CacheStatistics#getMisses()
+ */
+@Override
+public long getMisses() {
+return misses.sum();
+}
+
+void incrementMisses() {
+misses.increment();
+}
+
+/*
+ * (non-Javadoc)
+ * @see org.springframework.data.redis.cache.CacheStatistics#getRemovals()
+ */
+@Override
+public long getRemovals() {
+return removals.sum();
+}
+
+void incrementRemovals() {
+incrementRemovals(1);
+}
+
+/**
+ * @param x number of removals to add.
+ */
+void incrementRemovals(int x) {
+removals.add(x);
+}
+
+/*
+ * (non-Javadoc)
+ * @see org.springframework.data.redis.cache.CacheStatistics#getLockWaitDuration(java.util.concurrent.TimeUnit)
+ */
+@Override
+public long getLockWaitDuration(TimeUnit unit) {
+
+Assert.notNull(unit, "TimeUnit must not be null");
+
+return unit.convert(lockWaitTimeNs.sum(), TimeUnit.NANOSECONDS);
+}
+
+void incrementLockWaitTime(long waitTimeNs) {
+lockWaitTimeNs.add(waitTimeNs);
+}
+}

src/main/java/org/springframework/data/redis/cache/DefaultRedisCacheWriter.java

@@ -51,6 +51,7 @@ class DefaultRedisCacheWriter implements RedisCacheWriter {
 
 private final RedisConnectionFactory connectionFactory;
 private final Duration sleepTime;
+private final DefaultCacheStatistics statistics;
 
 /**
  * @param connectionFactory must not be {@literal null}.
@@ -71,6 +72,7 @@ class DefaultRedisCacheWriter implements RedisCacheWriter {
 
 this.connectionFactory = connectionFactory;
 this.sleepTime = sleepTime;
+this.statistics = new DefaultCacheStatistics();
 }
 
 /*
@@ -94,6 +96,8 @@ public void put(String name, byte[] key, byte[] value, @Nullable Duration ttl) {
 
 return "OK";
 });
+
+statistics.incrementStores();
 }
 
 /*
@@ -106,7 +110,17 @@ public byte[] get(String name, byte[] key) {
 Assert.notNull(name, "Name must not be null!");
 Assert.notNull(key, "Key must not be null!");
 
-return execute(name, connection -> connection.get(key));
+byte[] result = execute(name, connection -> connection.get(key));
+
+statistics.incrementRetrievals();
+
+if (result != null) {
+statistics.incrementHits();
+} else {
+statistics.incrementMisses();
+}
+
+return result;
 }
 
 /*
@@ -132,6 +146,8 @@ public byte[] putIfAbsent(String name, byte[] key, byte[] value, @Nullable Durat
 if (shouldExpireWithin(ttl)) {
 connection.pExpire(key, ttl.toMillis());
 }
+
+statistics.incrementStores();
 return null;
 }
 
@@ -156,6 +172,7 @@ public void remove(String name, byte[] key) {
 Assert.notNull(key, "Key must not be null!");
 
 execute(name, connection -> connection.del(key));
+statistics.incrementRemovals();
 }
 
 /*
@@ -183,6 +200,7 @@ public void clean(String name, byte[] pattern) {
 .toArray(new byte[0][]);
 
 if (keys.length > 0) {
+statistics.incrementRemovals(keys.length);
 connection.del(keys);
 }
 } finally {
@@ -196,6 +214,15 @@ public void clean(String name, byte[] pattern) {
 });
 }
 
+/*
+ * (non-Javadoc)
+ * @see org.springframework.data.redis.cache.RedisCacheWriter#getStatistics()
+ */
+@Override
+public DefaultCacheStatistics getStatistics() {
+return statistics;
+}
+
 /**
  * Explicitly set a write lock on a cache.
  *
@@ -262,6 +289,7 @@ private void checkAndPotentiallyWaitUntilUnlocked(String name, RedisConnection c
 return;
 }
 
+long lockWaitTimeNs = System.nanoTime();
 try {
 
 while (doCheckLock(name, connection)) {
@@ -274,6 +302,8 @@ private void checkAndPotentiallyWaitUntilUnlocked(String name, RedisConnection c
 
 throw new PessimisticLockingFailureException(String.format("Interrupted while waiting to unlock cache %s", name),
 ex);
+} finally {
+statistics.incrementLockWaitTime(System.nanoTime() - lockWaitTimeNs);
 }
 }
 

src/main/java/org/springframework/data/redis/cache/RedisCache.java

@@ -193,6 +193,17 @@ public void clear() {
 cacheWriter.clean(name, pattern);
 }
 
+/**
+ * Return the {@link CacheStatistics} for this cache instance. Statistics are accumulated per cache instance and not
+ * from the backing Redis data store. Cache statistics are accumulated starting from the time a cache is created.
+ *
+ * @return statistics object for this {@link RedisCache}.
+ * @since 2.4
+ */
+public CacheStatistics getStatistics() {
+return cacheWriter.getStatistics();
+}
+
 /**
  * Get {@link RedisCacheConfiguration} used.
  *

src/main/java/org/springframework/data/redis/cache/RedisCacheWriter.java

@@ -106,4 +106,13 @@ static RedisCacheWriter lockingRedisCacheWriter(RedisConnectionFactory connectio
  * @param pattern The pattern for the keys to remove. Must not be {@literal null}.
  */
 void clean(String name, byte[] pattern);
+
+/**
+ * Return the {@link CacheStatistics} for this cache instance. Statistics are accumulated per cache instance and not
+ * from the backing Redis data store. Cache statistics are accumulated starting from the time a cache is created.
+ *
+ * @return statistics object for this {@link RedisCache}.
+ * @since 2.4
+ */
+CacheStatistics getStatistics();
 }