Nemcio/SCM-Manager
1
0
Fork 0
mirror of https://github.com/scm-manager/scm-manager.git synced 2025-11-18 03:01:05 +01:00
Code Issues Packages Projects Releases Activity

Collect cache metrics using guava cache statistics instead own counters. (#1590)

Browse Source 
Collect guava cache statistics as metrics using micrometer. We replaced the own counter implementation of guava statistics with the guava internal caching statistics.
This commit is contained in:
Eduard Heimbuch
2021-03-22 08:56:26 +01:00
committed by GitHub
parent 9a057ec655
commit 5a20eaea49
10 changed files with 184 additions and 452 deletions
Download Patch File Download Diff File Expand all files Collapse all files

212
scm-webapp/src/main/java/sonia/scm/cache/GuavaCache.java vendored
View File

@@ -24,143 +24,56 @@
package sonia.scm.cache;
//~--- non-JDK imports --------------------------------------------------------
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Predicate;
import com.google.common.cache.CacheStats;
import com.google.common.collect.Sets;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
//~--- JDK imports ------------------------------------------------------------
import java.util.Collection;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.atomic.AtomicLong;
/**
*
* @author Sebastian Sdorra
*
* @param <K>
* @param <V>
*/
public class GuavaCache<K, V> implements Cache<K, V>
{
public class GuavaCache<K, V> implements Cache<K, V> {
/**
* the logger for GuavaCache
*/
private static final Logger logger = LoggerFactory.getLogger(GuavaCache.class);
//~--- constructors ---------------------------------------------------------
private final com.google.common.cache.Cache<K, V> cache;
private final CopyStrategy copyStrategy;
private final String name;
/**
* Constructs ...
*
*
* @param configuration
*/
public GuavaCache(GuavaNamedCacheConfiguration configuration)
{
this(configuration, configuration.getName());
}
/**
* Constructs ...
*
*
* @param configuration
* @param name
*/
@SuppressWarnings("unchecked")
public GuavaCache(GuavaCacheConfiguration configuration, String name)
{
this(GuavaCaches.create(configuration, name), configuration.getCopyStrategy(), name);
}
/**
* Constructs ...
*
*
* @param cache
* @param copyStrategy
* @param name
*/
@VisibleForTesting
protected GuavaCache(com.google.common.cache.Cache<K, V> cache,
CopyStrategy copyStrategy, String name)
{
GuavaCache(com.google.common.cache.Cache<K, V> cache, CopyStrategy copyStrategy, String name) {
this.cache = cache;
this.name = name;
if (copyStrategy != null)
{
if (copyStrategy != null) {
this.copyStrategy = copyStrategy;
}
else
{
} else {
this.copyStrategy = CopyStrategy.NONE;
}
}
//~--- methods --------------------------------------------------------------
/**
* Method description
*
*/
@Override
public void clear()
{
if (logger.isDebugEnabled())
{
public void clear() {
if (logger.isDebugEnabled()) {
logger.debug("clear cache {}", name);
}
cache.invalidateAll();
}
/**
* Method description
*
*
* @param key
*
* @return
*/
@Override
public boolean contains(K key)
{
public boolean contains(K key) {
return cache.getIfPresent(key) != null;
}
/**
* Method description
*
*
* @return
*/
@Override
public Set<K> keys()
{
public Set<K> keys() {
return cache.asMap().keySet();
}
/**
* Method description
*
*
* @param key
* @param value
*
* @return
*/
@Override
public V put(K key, V value)
{
public V put(K key, V value) {
V previous = cache.getIfPresent(key);
cache.put(key, copyStrategy.copyOnWrite(value));
@@ -168,17 +81,8 @@ public class GuavaCache<K, V> implements Cache<K, V>
return previous;
}
/**
* Method description
*
*
* @param key
*
* @return
*/
@Override
public V remove(K key)
{
public V remove(K key) {
V value = cache.getIfPresent(key);
cache.invalidate(key);
@@ -186,116 +90,50 @@ public class GuavaCache<K, V> implements Cache<K, V>
return value;
}
/**
* Method description
*
*
* @param filter
*
* @return
*/
@Override
@SuppressWarnings("java:S4738") // we have to use guava predicate for compatibility
public Iterable<V> removeAll(Predicate<K> filter)
{
public Iterable<V> removeAll(Predicate<K> filter) {
Set<V> removedValues = Sets.newHashSet();
Set<K> keysToRemove = Sets.newHashSet();
for (Entry<K, V> e : cache.asMap().entrySet())
{
if (filter.apply(e.getKey()))
{
for (Entry<K, V> e : cache.asMap().entrySet()) {
if (filter.apply(e.getKey())) {
keysToRemove.add(e.getKey());
removedValues.add(e.getValue());
}
}
if (!keysToRemove.isEmpty())
{
if (!keysToRemove.isEmpty()) {
cache.invalidateAll(keysToRemove);
}
return removedValues;
}
/**
* Method description
*
*
* @return
*/
@Override
public int size()
{
public int size() {
return (int) cache.size();
}
/**
* Method description
*
*
* @return
*/
@Override
public Collection<V> values()
{
public Collection<V> values() {
return cache.asMap().values();
}
//~--- get methods ----------------------------------------------------------
/**
* Method description
*
*
* @param key
*
* @return
*/
@Override
public V get(K key)
{
public V get(K key) {
V value = cache.getIfPresent(key);
if (value != null)
{
if (value != null) {
value = copyStrategy.copyOnRead(value);
hitCount.incrementAndGet();
}
else
{
missCount.incrementAndGet();
}
return value;
}
/**
* Method description
*
*
* @return
*/
@Override
public CacheStatistics getStatistics()
{
return new CacheStatistics(name, hitCount.get(), missCount.get());
public CacheStatistics getStatistics() {
CacheStats cacheStats = cache.stats();
return new CacheStatistics(name, cacheStats.hitCount(), cacheStats.missCount());
}
//~--- fields ---------------------------------------------------------------
/** Field description */
private final com.google.common.cache.Cache<K, V> cache;
/** Field description */
private final CopyStrategy copyStrategy;
/** Field description */
private final AtomicLong hitCount = new AtomicLong();
/** Field description */
private final AtomicLong missCount = new AtomicLong();
/** Field description */
private final String name;
}

49
scm-webapp/src/main/java/sonia/scm/cache/GuavaCacheFactory.java vendored Normal file
View File

@@ -0,0 +1,49 @@
/*
* MIT License
*
* Copyright (c) 2020-present Cloudogu GmbH and Contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package sonia.scm.cache;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.binder.cache.GuavaCacheMetrics;
import javax.inject.Inject;
import java.util.Collections;
public class GuavaCacheFactory {
private final MeterRegistry meterRegistry;
@Inject
public GuavaCacheFactory(MeterRegistry meterRegistry) {
this.meterRegistry = meterRegistry;
}
<K, V> GuavaCache<K, V> create(GuavaCacheConfiguration configuration, String name) {
com.google.common.cache.Cache<K, V> cache = GuavaCaches.create(configuration, name);
new GuavaCacheMetrics(cache, name, Collections.emptySet()).bindTo(meterRegistry);
return new GuavaCache<>(cache, configuration.getCopyStrategy(), name);
}
}

17
scm-webapp/src/main/java/sonia/scm/cache/GuavaCacheManager.java vendored
View File

@@ -24,8 +24,6 @@
package sonia.scm.cache;
//~--- non-JDK imports --------------------------------------------------------
import com.google.common.annotations.VisibleForTesting;
import com.google.inject.Singleton;
import org.slf4j.Logger;
@@ -35,8 +33,6 @@ import javax.inject.Inject;
import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;
//~--- JDK imports ------------------------------------------------------------
/**
* Guava based implementation of {@link CacheManager} and {@link org.apache.shiro.cache.CacheManager}.
*
@@ -49,22 +45,23 @@ public class GuavaCacheManager implements CacheManager, org.apache.shiro.cache.C
@SuppressWarnings({"java:S3740", "rawtypes"})
private final ConcurrentHashMap<String, GuavaCache> caches = new ConcurrentHashMap<>();
private final GuavaCacheConfiguration defaultConfiguration;
private final GuavaCacheFactory cacheFactory;
@Inject
public GuavaCacheManager(GuavaCacheConfigurationReader configurationReader) {
this(configurationReader.read());
public GuavaCacheManager(GuavaCacheConfigurationReader configurationReader, GuavaCacheFactory cacheFactory) {
this(configurationReader.read(), cacheFactory);
}
@VisibleForTesting
protected GuavaCacheManager(GuavaCacheManagerConfiguration config) {
protected GuavaCacheManager(GuavaCacheManagerConfiguration config, GuavaCacheFactory cacheFactory) {
defaultConfiguration = config.getDefaultCache();
this.cacheFactory = cacheFactory;
for (GuavaNamedCacheConfiguration ncc : config.getCaches()) {
LOG.debug("create cache {} from configured configuration {}", ncc.getName(), ncc);
caches.put(ncc.getName(), new GuavaCache<>(ncc));
caches.put(ncc.getName(), cacheFactory.create(ncc, ncc.getName()));
}
}
@@ -78,7 +75,7 @@ public class GuavaCacheManager implements CacheManager, org.apache.shiro.cache.C
"cache {} does not exists, creating a new instance from default configuration: {}",
cacheName, defaultConfiguration
);
return new GuavaCache<>(defaultConfiguration, cacheName);
return cacheFactory.create(defaultConfiguration, cacheName);
});
}

94
scm-webapp/src/main/java/sonia/scm/cache/GuavaCaches.java vendored
View File

@@ -24,126 +24,76 @@
package sonia.scm.cache;
//~--- non-JDK imports --------------------------------------------------------
import com.google.common.cache.CacheBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
//~--- JDK imports ------------------------------------------------------------
import java.util.concurrent.TimeUnit;
/**
*
* @author Sebastian Sdorra
*/
public final class GuavaCaches
{
public final class GuavaCaches {
/**
* the logger for GuavaCaches
*/
private static final Logger logger =
LoggerFactory.getLogger(GuavaCaches.class);
private static final Logger LOG = LoggerFactory.getLogger(GuavaCaches.class);
//~--- constructors ---------------------------------------------------------
private GuavaCaches() {
}
/**
* Constructs ...
*
*/
private GuavaCaches() {}
//~--- methods --------------------------------------------------------------
/**
* Method description
*
*
* @param configuration
* @param name
*
* @return
*/
public static <K,V> com.google.common.cache.Cache<K, V> create(
GuavaCacheConfiguration configuration, String name)
{
public static <K, V> com.google.common.cache.Cache<K, V> create(
GuavaCacheConfiguration configuration, String name) {
CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder();
if (configuration.getConcurrencyLevel() != null)
{
// Collect guava cache statistics
builder.recordStats();
if (configuration.getConcurrencyLevel() != null) {
builder.concurrencyLevel(configuration.getConcurrencyLevel());
}
if (configuration.getExpireAfterAccess() != null)
{
if (configuration.getExpireAfterAccess() != null) {
builder.expireAfterAccess(configuration.getExpireAfterAccess(),
TimeUnit.SECONDS);
}
if (configuration.getExpireAfterWrite() != null)
{
if (configuration.getExpireAfterWrite() != null) {
builder.expireAfterWrite(configuration.getExpireAfterWrite(),
TimeUnit.SECONDS);
}
if (configuration.getInitialCapacity() != null)
{
if (configuration.getInitialCapacity() != null) {
builder.initialCapacity(configuration.getInitialCapacity());
}
if (configuration.getMaximumSize() != null)
{
if (configuration.getMaximumSize() != null) {
builder.maximumSize(configuration.getMaximumSize());
}
if (configuration.getMaximumWeight() != null)
{
if (configuration.getMaximumWeight() != null) {
builder.maximumWeight(configuration.getMaximumWeight());
}
if (isEnabled(configuration.getRecordStats()))
{
if (isEnabled(configuration.getRecordStats())) {
builder.recordStats();
}
if (isEnabled(configuration.getSoftValues()))
{
if (isEnabled(configuration.getSoftValues())) {
builder.softValues();
}
if (isEnabled(configuration.getWeakKeys()))
{
if (isEnabled(configuration.getWeakKeys())) {
builder.weakKeys();
}
if (isEnabled(configuration.getWeakValues()))
{
if (isEnabled(configuration.getWeakValues())) {
builder.weakKeys();
}
if (logger.isTraceEnabled())
{
logger.trace("create new cache {} from builder: {}", name, builder);
if (LOG.isTraceEnabled()) {
LOG.trace("create new cache {} from builder: {}", name, builder);
}
return builder.build();
}
//~--- get methods ----------------------------------------------------------
/**
* Method description
*
*
* @param v
*
* @return
*/
private static boolean isEnabled(Boolean v)
{
private static boolean isEnabled(Boolean v) {
return (v != null) && v;
}
}