Basic instrumentation changes behind a flag

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

@@ -15,6 +15,7 @@
  */
 package com.netflix.config;
 
+import java.util.Arrays;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -26,6 +27,7 @@
 import java.util.ListIterator;
 import java.util.Map;
 import java.util.Set;
+import java.util.HashSet;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 
@@ -66,7 +68,7 @@
  * {@link ConcurrentMapConfiguration} or ConcurrentCompositeConfiguration using 
  * {@link com.netflix.config.util.ConfigurationUtils} to achieve
  * maximal performance and thread safety.
- * 
+ *
  * <p>
  * Example:
  * <pre>
@@ -102,8 +104,21 @@
 public class ConcurrentCompositeConfiguration extends ConcurrentMapConfiguration 
         implements AggregatedConfiguration, ConfigurationListener, Cloneable {
 
+    public static final String ENABLE_STACK_TRACE = "archaius_enable_stack_trace";
+    public static final String ENABLE_INSTRUMENTATION = "archaius_enable_instrumentation";
+    private final boolean enableStackTrace = Boolean.parseBoolean(System.getProperty(ENABLE_STACK_TRACE));
+    private final boolean enableInstrumentation = Boolean.parseBoolean(System.getProperty(ENABLE_INSTRUMENTATION));
+
     private Map<String, AbstractConfiguration> namedConfigurations = new ConcurrentHashMap<String, AbstractConfiguration>();
-
+
+    private final Map<String, Integer> stackTraces = new ConcurrentHashMap<>();
+    private final Set<String> usedProperties = ConcurrentHashMap.newKeySet();
+
+    public Set<String> getUsedProperties() {
+        return usedProperties;
+    }
+
+
     private List<AbstractConfiguration> configList = new CopyOnWriteArrayList<AbstractConfiguration>();
 
     private static final Logger logger = LoggerFactory.getLogger(ConcurrentCompositeConfiguration.class);
@@ -509,6 +524,14 @@ public void addProperty(String key, Object value) {
     public void clearProperty(String key) {
         containerConfiguration.clearProperty(key);
     }
+
+    public Object getProperty(String key) {
+        return getProperty(key, true);
+    }
+
+    public Object getPropertyUninstrumented(String key) {
+        return getProperty(key, false);
+    }
     /**
      * Read property from underlying composite. It first checks if the property has been overridden
      * by {@link #setOverrideProperty(String, Object)} and if so return the overriding value.
@@ -520,23 +543,33 @@ public void clearProperty(String key) {
      *
      * @return object associated with the given configuration key. null if it does not exist.
      */
-    public Object getProperty(String key)
+    private Object getProperty(String key, boolean instrument)
     {
         if (overrideProperties.containsKey(key)) {
             return overrideProperties.getProperty(key);
         }
         Configuration firstMatchingConfiguration = null;
-        for (Configuration config : configList)
-        {
-            if (config.containsKey(key))
-            {
+        for (Configuration config : configList) {
+            if (config.containsKey(key)) {
+                if (instrument && enableInstrumentation) {
+                    usedProperties.add(key);
+                    if (enableStackTrace) {
+                        String trace = Arrays.toString(Thread.currentThread().getStackTrace());
+                        stackTraces.merge(trace, 1, (v1, v2) -> v1 + 1);
+                    }
+                }
                 firstMatchingConfiguration = config;
                 break;
             }
         }
 
-        if (firstMatchingConfiguration != null)
-        {
+        if (firstMatchingConfiguration != null) {
+            // Propagate uninstrumented call if necessary
+            if (enableInstrumentation
+                    && !instrument
+                    && firstMatchingConfiguration instanceof ConcurrentCompositeConfiguration) {
+                return ((ConcurrentCompositeConfiguration) firstMatchingConfiguration).getPropertyUninstrumented(key);
+            }
             return firstMatchingConfiguration.getProperty(key);
         }
         else

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

@@ -27,7 +27,7 @@ public ConfigurationBackedDynamicPropertySupportImpl(AbstractConfiguration confi
         }
         this.config = config;
     }
-    
+
     @Override
     public String getString(String key) {
         try {

archaius-core/src/test/java/com/netflix/config/ConcurrentCompositeConfigurationTest.java

@@ -70,6 +70,23 @@ public void testProperties() {
         config.clearProperty("prop3");
         assertEquals("prop3", prop3.get());
         assertEquals("prop3", config.getProperty("prop3"));
+        assertTrue(config.getUsedProperties().isEmpty());
+    }
+
+    @Test
+    public void testInstrumentation() {
+        System.setProperty(ConcurrentCompositeConfiguration.ENABLE_INSTRUMENTATION, "true");
+        ConcurrentCompositeConfiguration config = new ConcurrentCompositeConfiguration();
+        config.addProperty("prop1", "val1");
+        config.addProperty("prop2", "val2");
+        assertEquals(config.getProperty("prop1"), "val1");
+        assertEquals(config.getUsedProperties().size(), 1);
+        assertEquals(config.getUsedProperties().iterator().next(), "prop1");
+        assertEquals(config.getPropertyUninstrumented("prop2"), "val2");
+        assertEquals(config.getUsedProperties().size(), 1);
+        assertEquals(config.getUsedProperties().iterator().next(), "prop1");
+
+        System.clearProperty(ConcurrentCompositeConfiguration.ENABLE_INSTRUMENTATION);
     }
 
     @Test