This is an automated email from the ASF dual-hosted git repository. reschke pushed a commit to branch SLING-12402 in repository https://gitbox.apache.org/repos/asf/sling-org-apache-sling-resourceresolver.git
commit 628608224a9a28850fcecf1ee6027fa21d299f62 Author: Julian Reschke <[email protected]> AuthorDate: Fri Sep 13 11:47:50 2024 +0100 SLING-12402: metrics for defunct aliases - add warning after init when over (minimal) threshold --- .../resourceresolver/impl/mapping/MapEntries.java | 33 ++++++++++++++++++++-- 1 file changed, 30 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/apache/sling/resourceresolver/impl/mapping/MapEntries.java b/src/main/java/org/apache/sling/resourceresolver/impl/mapping/MapEntries.java index 2d34b8f..d41ce69 100644 --- a/src/main/java/org/apache/sling/resourceresolver/impl/mapping/MapEntries.java +++ b/src/main/java/org/apache/sling/resourceresolver/impl/mapping/MapEntries.java @@ -64,11 +64,13 @@ import java.util.Map; import java.util.Map.Entry; import java.util.NoSuchElementException; import java.util.Optional; +import java.util.Queue; import java.util.Set; import java.util.SortedMap; import java.util.TreeMap; import java.util.TreeSet; import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; @@ -149,6 +151,11 @@ public class MapEntries implements private final AtomicLong detectedConflictingAliases; private final AtomicLong detectedInvalidAliases; + // keep track of some defunct aliases for diagnostics (thus size-limited) + private static final int MAX_REPORT_DEFUNCT_ALIASES = 50; + private Queue<String> conflictingAliases; + private Queue<String> invalidAliases; + private final ReentrantLock initializing = new ReentrantLock(); private final AtomicLong vanityCounter; @@ -181,6 +188,9 @@ public class MapEntries implements this.aliasMapsMap = new ConcurrentHashMap<>(); this.stringInterpolationProvider = stringInterpolationProvider; + this.conflictingAliases = new ConcurrentLinkedQueue<>(); + this.invalidAliases = new ConcurrentLinkedQueue<>(); + this.aliasResourcesOnStartup = new AtomicLong(0); this.detectedConflictingAliases = new AtomicLong(0); this.detectedInvalidAliases = new AtomicLong(0); @@ -250,7 +260,16 @@ public class MapEntries implements try { final Map<String, Map<String, Collection<String>>> loadedMap = this.loadAliases(resolver); this.aliasMapsMap = loadedMap; - + + // warn if there are more than a few defunct aliases + if (conflictingAliases.size() >= MAX_REPORT_DEFUNCT_ALIASES) { + log.warn("There are {} conflicting aliases; excerpt: {}", conflictingAliases.size(), conflictingAliases); + } + if (invalidAliases.size() >= MAX_REPORT_DEFUNCT_ALIASES) { + log.warn("There are {} invalid aliases; excerpt: {}", invalidAliases.size(), invalidAliases); + } + conflictingAliases.clear(); + invalidAliases.clear(); } catch (final Exception e) { logDisableAliasOptimization(e); @@ -1275,7 +1294,11 @@ public class MapEntries implements for (final String alias : aliasArray) { if (isAliasInvalid(alias)) { long invalids = detectedInvalidAliases.incrementAndGet(); - log.warn("Encountered invalid alias '{}' under parent path '{}' (total so far: {}). Refusing to use it.", alias, parentPath, invalids); + log.warn("Encountered invalid alias '{}' under parent path '{}' (total so far: {}). Refusing to use it.", + alias, parentPath, invalids); + if (invalids < MAX_REPORT_DEFUNCT_ALIASES) { + invalidAliases.add((String.format("'%s'/'%s'", parentPath, alias))); + } } else { Map<String, Collection<String>> parentMap = map.computeIfAbsent(parentPath, key -> new ConcurrentHashMap<>()); Optional<String> siblingResourceNameWithDuplicateAlias = parentMap.entrySet().stream() @@ -1284,9 +1307,13 @@ public class MapEntries implements .findFirst().map(Map.Entry::getKey); if (siblingResourceNameWithDuplicateAlias.isPresent()) { long conflicting = detectedConflictingAliases.incrementAndGet(); - log.error( + log.warn( "Encountered duplicate alias '{}' under parent path '{}'. Refusing to replace current target '{}' with '{}' (total so far: {}).", alias, parentPath, siblingResourceNameWithDuplicateAlias.get(), resourceName, conflicting); + if (conflicting < MAX_REPORT_DEFUNCT_ALIASES) { + conflictingAliases.add((String.format("'%s': '%s'/'%s' vs '%s'/'%s'", parentPath, resourceName, + alias, siblingResourceNameWithDuplicateAlias.get(), alias))); + } } else { Collection<String> existingAliases = parentMap.computeIfAbsent(resourceName, name -> new CopyOnWriteArrayList<>()); existingAliases.add(alias);
