Improve Stack Trace tracking for Instrumentation

archaius-core/src/main/java/com/netflix/config/ConcurrentCompositeConfiguration.java

@@ -20,6 +20,7 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.ConcurrentModificationException;
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
@@ -107,14 +108,26 @@ public class ConcurrentCompositeConfiguration extends ConcurrentMapConfiguration
 
     public static final String ENABLE_STACK_TRACE = "archaius_enable_stack_trace";
     public static final String ENABLE_INSTRUMENTATION = "archaius_enable_instrumentation";
+    public static final String STACK_TRACE_ENABLED_PROPERTIES = "archaius_stack_trace_enabled_properties";
     private final boolean enableStackTrace = Boolean.parseBoolean(System.getProperty(ENABLE_STACK_TRACE));
     private final boolean enableInstrumentation = Boolean.parseBoolean(System.getProperty(ENABLE_INSTRUMENTATION));
+    private final Set<String> stackTraceEnabledProperties = convertStringFlag(System.getProperty(STACK_TRACE_ENABLED_PROPERTIES));
 
     private Map<String, AbstractConfiguration> namedConfigurations = new ConcurrentHashMap<>();
 
     private final Map<String, Integer> stackTraces = new ConcurrentHashMap<>();
+    private final Map<String, Set<String>> stackTracesAndProperties = new ConcurrentHashMap<>();
     private final AtomicReference<Set<String>> usedPropertiesRef = new AtomicReference<>(ConcurrentHashMap.newKeySet());
 
+    private Set<String> convertStringFlag(String properties) {
+        if (properties == null) {
+            return Collections.emptySet();
+        }
+        Set<String> ret = new HashSet<>();
+        Collections.addAll(ret, properties.split(","));
+        return ret;
+    }
+
     public Set<String> getUsedProperties() {
         return Collections.unmodifiableSet(new HashSet<>(usedPropertiesRef.get()));
     }
@@ -124,6 +137,15 @@ public Set<String> getAndClearUsedProperties() {
         return Collections.unmodifiableSet(ret);
     }
 
+    public Map<String, Integer> getInstrumentationStackTraces() {
+        return Collections.unmodifiableMap(new HashMap<>(stackTraces));
+    }
+
+    public Map<String, Set<String>> getInstrumentationStackTracesAndProperties() {
+        // Shallow copy
+        return Collections.unmodifiableMap(new HashMap<>(stackTracesAndProperties));
+    }
+
     private List<AbstractConfiguration> configList = new CopyOnWriteArrayList<AbstractConfiguration>();
 
     private static final Logger logger = LoggerFactory.getLogger(ConcurrentCompositeConfiguration.class);
@@ -589,13 +611,30 @@ private Object getProperty(String key, boolean instrument)
     public void recordUsage(String key) {
         if (enableInstrumentation) {
             usedPropertiesRef.get().add(key);
-            if (enableStackTrace) {
+            boolean isTrackedProperty = !stackTraceEnabledProperties.isEmpty() && stackTraceEnabledProperties.contains(key);
+            if (enableStackTrace || isTrackedProperty) {
                 String trace = Arrays.toString(Thread.currentThread().getStackTrace());
-                stackTraces.merge(trace, 1, (v1, v2) -> v1 + 1);
+                if (enableStackTrace) {
+                    stackTraces.merge(trace, 1, (v1, v2) -> v1 + 1);
+                }
+                if (isTrackedProperty) {
+                    stackTracesAndProperties.merge(trace, createSet(key), this::union);
+                }
             }
         }
     }
 
+    private Set<String> union(Set<String> s1, Set<String> s2) {
+        s1.addAll(s2);
+        return s1;
+    }
+
+    private Set<String> createSet(String s) {
+        Set<String> ret = new HashSet<>();
+        ret.add(s);
+        return ret;
+    }
+
     /**
      * Get all the keys contained by sub configurations.
      *