adaptive-caching-framework

diff --git a/framework/autonomicmanager/pom.xml b/framework/autonomicmanager/pom.xml
index bbdf139..7e03b64 100644
--- a/framework/autonomicmanager/pom.xml
+++ b/framework/autonomicmanager/pom.xml
@@ -6,10 +6,10 @@
 
     <groupId>br.ufrgs.inf.prosoft.adaptivecaching</groupId>
     <artifactId>autonomicmanager</artifactId>
-    <version>0.7.0-SNAPSHOT</version>
+    <version>0.9.0-SNAPSHOT</version>
 
     <properties>
-        <aspectj.version>1.8.10</aspectj.version>
+        <aspectj.version>1.8.9</aspectj.version>
         <java.version>1.8</java.version>
     </properties>
 
@@ -198,14 +198,6 @@
                     </dependency>
                 </dependencies>
             </plugin>
-            <plugin>
-                <groupId>org.codehaus.mojo</groupId>
-                <artifactId>exec-maven-plugin</artifactId>
-                <version>1.3.2</version>
-                <configuration>
-                    <mainClass>br.ufrgs.inf.prosoft.adaptivecaching.analysis.Analyzer</mainClass>
-                </configuration>
-            </plugin>
         </plugins>
     </build>
 

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/CacheDecider.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/CacheDecider.java
index 26f1882..937fd77 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/CacheDecider.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/CacheDecider.java
@@ -1,11 +1,22 @@
 package br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision;
 
 import br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.model.MethodStats;
-import br.ufrgs.inf.prosoft.adaptivecaching.monitoring.application.metadata.MethodInfo;
-import br.ufrgs.inf.prosoft.adaptivecaching.monitoring.cache.CacheInfo;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.metadata.MethodInfo;
+import br.ufrgs.inf.prosoft.adaptivecaching.cache.CacheInfo;
 
+/**
+ * The interface Cache decider.
+ */
 public interface CacheDecider {
 
+    /**
+     * Is cacheable boolean.
+     *
+     * @param cacheInfo   the cache info
+     * @param methodInfo  the method info
+     * @param methodStats the method stats
+     * @return the boolean
+     */
     boolean isCacheable(CacheInfo cacheInfo, MethodInfo methodInfo, MethodStats methodStats);
 
 }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/FlowchartWorkFlow.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/FlowchartWorkFlow.java
index 6a4811a..b12505b 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/FlowchartWorkFlow.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/FlowchartWorkFlow.java
@@ -5,10 +5,10 @@ import br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.model.Me
 import br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.model.MethodStats;
 import br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.stats.CacheabilityMetrics;
 import br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.stats.CacheabilityPatternDecider;
-import br.ufrgs.inf.prosoft.adaptivecaching.monitoring.application.aspects.TracerAspect;
-import br.ufrgs.inf.prosoft.adaptivecaching.monitoring.application.metadata.LogTrace;
-import br.ufrgs.inf.prosoft.adaptivecaching.monitoring.application.metadata.MethodInfo;
-import br.ufrgs.inf.prosoft.adaptivecaching.monitoring.cache.CacheInfo;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.aspects.AdaptiveCachingCoordinator;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.metadata.LogTrace;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.metadata.MethodInfo;
+import br.ufrgs.inf.prosoft.adaptivecaching.cache.CacheInfo;
 import org.apache.commons.lang3.builder.EqualsBuilder;
 import org.apache.commons.math3.stat.descriptive.SummaryStatistics;
 import org.slf4j.Logger;
@@ -22,20 +22,50 @@ import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 
+/**
+ * The type Flowchart work flow.
+ */
 public class FlowchartWorkFlow {
 
+    /**
+     * The Methods info map.
+     */
     protected HashMap<MethodInfo, MethodStats> methodsInfoMap;
+    /**
+     * The Logger.
+     */
     Logger logger = LoggerFactory.getLogger(FlowchartWorkFlow.class);
 
     private CacheDecider decider;
     private CacheInfo cacheInfo;
 
+    /**
+     * The Execution time stats.
+     */
     SummaryStatistics executionTimeStats = new SummaryStatistics();
+    /**
+     * The Shareability stats.
+     */
     SummaryStatistics shareabilityStats = new SummaryStatistics();
+    /**
+     * The Frequency stats.
+     */
     SummaryStatistics frequencyStats = new SummaryStatistics();
+    /**
+     * The Miss stats.
+     */
     SummaryStatistics missStats = new SummaryStatistics();
+    /**
+     * The Hit stats.
+     */
     SummaryStatistics hitStats = new SummaryStatistics();
 
+    /**
+     * Instantiates a new Flowchart work flow.
+     *
+     * @param cacheInfo the cache info
+     * @param logList   the log list
+     */
     public FlowchartWorkFlow(CacheInfo cacheInfo, List<LogTrace> logList) {
         this.decider = new CacheabilityPatternDecider(logList.size(), this);
         this.cacheInfo = cacheInfo;
@@ -64,6 +94,12 @@ public class FlowchartWorkFlow {
         logger.debug("Threshold frequency: " + frequencyThreshold(k));
     }
 
+    /**
+     * Filter cacheable methods set.
+     *
+     * @param expiryTime the expiry time
+     * @return the set
+     */
     public Set<MethodEntry> filterCacheableMethods(long expiryTime) {
         logger.debug("Deciding if methods are cacheable...");
 
@@ -78,6 +114,12 @@ public class FlowchartWorkFlow {
         return cacheableMethods;
     }
 
+    /**
+     * Count occurrences hash map.
+     *
+     * @param logs the logs
+     * @return the hash map
+     */
     public HashMap<MethodInfo, MethodStats> countOccurrences(List<LogTrace> logs) {
         HashMap<MethodInfo, MethodStats> methodInfoMap = new HashMap<>();
 
@@ -117,30 +159,65 @@ public class FlowchartWorkFlow {
         return methodInfoMap;
     }
 
+    /**
+     * Gets methods info map.
+     *
+     * @return the methods info map
+     */
     public HashMap<MethodInfo, MethodStats> getMethodsInfoMap() {
         return methodsInfoMap;
     }
 
-    //getting X% with most hits
+    /**
+     * Hit threshold double.
+     *
+     * @param kStdDev the k std dev
+     * @return the double
+     */
+//getting X% with most hits
     public double hitThreshold(int kStdDev) {
         return hitStats.getMean() + (kStdDev * hitStats.getStandardDeviation());
     }
 
-    //getting X% with most misses
+    /**
+     * Miss threshold double.
+     *
+     * @param kStdDev the k std dev
+     * @return the double
+     */
+//getting X% with most misses
     public double missThreshold(int kStdDev) {
         return missStats.getMean() + (kStdDev * missStats.getStandardDeviation());
     }
 
-    //getting X% most expensive methods
+    /**
+     * Expensiveness threshold double.
+     *
+     * @param kStdDev the k std dev
+     * @return the double
+     */
+//getting X% most expensive methods
     public double expensivenessThreshold(int kStdDev) {
         return executionTimeStats.getMean() + (kStdDev * executionTimeStats.getStandardDeviation());
     }
 
+    /**
+     * Shareability threshold double.
+     *
+     * @param kStdDev the k std dev
+     * @return the double
+     */
     public double shareabilityThreshold(int kStdDev) {
         return shareabilityStats.getMean() + (kStdDev * shareabilityStats.getStandardDeviation());
     }
 
-    //getting X% most frenquent
+    /**
+     * Frequency threshold double.
+     *
+     * @param kStdDev the k std dev
+     * @return the double
+     */
+//getting X% most frenquent
     public double frequencyThreshold(int kStdDev) {
         return frequencyStats.getMean() + (kStdDev * frequencyStats.getStandardDeviation());
     }
@@ -148,8 +225,8 @@ public class FlowchartWorkFlow {
     /**
      * General miss ratio from a signature
      *
-     * @param signature
-     * @return
+     * @param signature the signature
+     * @return miss ratio
      */
     public double getMissRatio(String signature) {
         long occurrences = 0;
@@ -166,8 +243,8 @@ public class FlowchartWorkFlow {
     /**
      * General hit ratio from a signature
      *
-     * @param signature
-     * @return
+     * @param signature the signature
+     * @return hit ratio
      */
     public double getHitRatio(String signature) {
         long occurrences = 0;
@@ -201,17 +278,5 @@ public class FlowchartWorkFlow {
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         }
-
-        //TODO remove: print black list to csv file
-        try {
-            if (TracerAspect.methodBlackList != null && !TracerAspect.methodBlackList.isEmpty()) {
-                final PrintWriter pw = new PrintWriter(new File("backlisted.csv"));
-                pw.write("signature\n");
-                TracerAspect.methodBlackList.stream().forEach(ma -> pw.write(ma + '\n'));
-                pw.close();
-            }
-        } catch (FileNotFoundException e) {
-            e.printStackTrace();
-        }
     }
 }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/model/MethodEntry.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/model/MethodEntry.java
index 6e42ed9..3249823 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/model/MethodEntry.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/model/MethodEntry.java
@@ -1,31 +1,59 @@
 package br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.model;
 
-import br.ufrgs.inf.prosoft.adaptivecaching.monitoring.application.metadata.MethodInfo;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.metadata.MethodInfo;
 
+/**
+ * The type Method entry.
+ */
 public class MethodEntry {
 
     private MethodInfo methodInfo;
     private MethodStats methodStats;
     private long lifetime;
 
+    /**
+     * Instantiates a new Method entry.
+     */
     public MethodEntry(){
 
     }
 
+    /**
+     * Instantiates a new Method entry.
+     *
+     * @param methodInfo  the method info
+     * @param methodStats the method stats
+     * @param lifetime    the lifetime
+     */
     public MethodEntry(MethodInfo methodInfo, MethodStats methodStats, long lifetime) {
         this.methodInfo = methodInfo;
         this.methodStats = methodStats;
         this.lifetime = lifetime;
     }
 
+    /**
+     * Gets method info.
+     *
+     * @return the method info
+     */
     public MethodInfo getMethodInfo() {
         return methodInfo;
     }
 
+    /**
+     * Gets method info key.
+     *
+     * @return the method info key
+     */
     public Object getMethodInfoKey() {
         return methodInfo.getKey();
     }
 
+    /**
+     * Gets method stats.
+     *
+     * @return the method stats
+     */
     public MethodStats getMethodStats() {
         return methodStats;
     }
@@ -58,6 +86,11 @@ public class MethodEntry {
         return result;
     }
 
+    /**
+     * Expired boolean.
+     *
+     * @return the boolean
+     */
     public boolean expired() {
         return lifetime < System.currentTimeMillis();
     }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/model/MethodStats.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/model/MethodStats.java
index 02fdd50..8fbf074 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/model/MethodStats.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/model/MethodStats.java
@@ -1,12 +1,15 @@
 package br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.model;
 
-import br.ufrgs.inf.prosoft.adaptivecaching.monitoring.application.metadata.LogTrace;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.metadata.LogTrace;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.util.HashSet;
 import java.util.Set;
 
+/**
+ * The type Method stats.
+ */
 public class MethodStats {
 
     //exactly same method calls
@@ -20,6 +23,9 @@ public class MethodStats {
     private Long amountOfIdentifiedSameOccurences;
     private Set<String> uniqueUsers;
 
+    /**
+     * Instantiates a new Method stats.
+     */
     public MethodStats() {
         sameOccurrences = 0L;
         differentReturnOccurrences = 0L;
@@ -29,11 +35,21 @@ public class MethodStats {
         uniqueUsers = new HashSet<>();
     }
 
+    /**
+     * Instantiates a new Method stats.
+     *
+     * @param logTrace the log trace
+     */
     public MethodStats(LogTrace logTrace) {
         this();
         addSameOccurrence(logTrace);
     }
 
+    /**
+     * Add same occurrence.
+     *
+     * @param logTrace the log trace
+     */
     public void addSameOccurrence(LogTrace logTrace) {
         sameOccurrences++;
         addSameOccurrencesTotalExecutionTime(logTrace.totalTime());
@@ -45,6 +61,9 @@ public class MethodStats {
         }
     }
 
+    /**
+     * Add different return occurrence.
+     */
     public void addDifferentReturnOccurrence() {
         //todo if the request was identified, it should counts
         //addIdentifiedSameOccurence();
@@ -57,47 +76,89 @@ public class MethodStats {
             sameOccurrencesHigherExecutionTime = executionTime;
     }
 
+    /**
+     * Gets same occurrences total execution time.
+     *
+     * @return the same occurrences total execution time
+     */
     public Long getSameOccurrencesTotalExecutionTime() {
         return sameOccurrencesExecutionTime;
     }
 
+    /**
+     * Gets same occurrences average execution time.
+     *
+     * @return the same occurrences average execution time
+     */
     public double getSameOccurrencesAverageExecutionTime() {
         return new BigDecimal(getSameOccurrencesTotalExecutionTime())
                 .divide(new BigDecimal(sameOccurrences), 5, RoundingMode.HALF_UP)
                 .doubleValue();
     }
 
+    /**
+     * Gets same occurrences higher execution time.
+     *
+     * @return the same occurrences higher execution time
+     */
     public long getSameOccurrencesHigherExecutionTime() {
         return sameOccurrencesHigherExecutionTime;
     }
 
     /**
+     * Gets number of occurrences.
+     *
      * @return All occurrences of a method, i.e. with different params and return or not
      */
     public Long getNumberOfOccurrences() {
         return sameOccurrences + differentReturnOccurrences;
     }
 
+    /**
+     * Gets number of same occurrences.
+     *
+     * @return the number of same occurrences
+     */
     public Long getNumberOfSameOccurrences() {
         return sameOccurrences;
     }
 
+    /**
+     * Gets number of different return occurrences.
+     *
+     * @return the number of different return occurrences
+     */
     public Long getNumberOfDifferentReturnOccurrences() {
         return differentReturnOccurrences;
     }
 
-    //from 0% to 100%
+    /**
+     * Hit ratio double.
+     *
+     * @return the double
+     */
+//from 0% to 100%
     public double hitRatio() {
         BigDecimal bd = new BigDecimal(getNumberOfSameOccurrences() * 100);
         return bd.divide(new BigDecimal(getNumberOfOccurrences()), 5, RoundingMode.HALF_UP).doubleValue();
     }
 
-    //from 0% to 100%
+    /**
+     * Miss ratio double.
+     *
+     * @return the double
+     */
+//from 0% to 100%
     public double missRatio() {
         BigDecimal bd = new BigDecimal(getNumberOfDifferentReturnOccurrences() * 100);
         return bd.divide(new BigDecimal(getNumberOfOccurrences()), 5, RoundingMode.HALF_UP).doubleValue();
     }
 
+    /**
+     * Shareability double.
+     *
+     * @return the double
+     */
     public double shareability() {
 
         Long amountOfIdentifiedSameOccurences = getAmountOfIdentifiedSameOccurences();
@@ -108,6 +169,11 @@ public class MethodStats {
         return bd.divide(new BigDecimal(amountOfIdentifiedSameOccurences), 5, RoundingMode.HALF_UP).doubleValue();
     }
 
+    /**
+     * To csv string.
+     *
+     * @return the string
+     */
     public String toCSV() {
         //numberOfSameOccurrences,numberOfDifferentReturnOccurrences,totalOccurrences,sameOccurrencesAverageExecutionTime,sameOccurrencesTotalExecutionTime,hitRatio,missRatio
         return getNumberOfSameOccurrences() +
@@ -133,14 +199,29 @@ public class MethodStats {
                         '}';
     }
 
+    /**
+     * Gets amount of identified same occurences.
+     *
+     * @return the amount of identified same occurences
+     */
     public Long getAmountOfIdentifiedSameOccurences() {
         return amountOfIdentifiedSameOccurences;
     }
 
+    /**
+     * Gets amount of unique identified same occurences.
+     *
+     * @return the amount of unique identified same occurences
+     */
     public int getAmountOfUniqueIdentifiedSameOccurences() {
         return uniqueUsers.size();
     }
 
+    /**
+     * Gets amount of anonymous same occurences.
+     *
+     * @return the amount of anonymous same occurences
+     */
     public Long getAmountOfAnonymousSameOccurences() {
         return sameOccurrences - amountOfIdentifiedSameOccurences;
     }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/stats/CacheabilityMetrics.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/stats/CacheabilityMetrics.java
index cd56c19..9172edc 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/stats/CacheabilityMetrics.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/stats/CacheabilityMetrics.java
@@ -2,14 +2,25 @@ package br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.stats;
 
 import br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.FlowchartWorkFlow;
 import br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.model.MethodStats;
-import br.ufrgs.inf.prosoft.adaptivecaching.monitoring.application.metadata.MethodInfo;
-import br.ufrgs.inf.prosoft.adaptivecaching.monitoring.cache.CacheInfo;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.metadata.MethodInfo;
+import br.ufrgs.inf.prosoft.adaptivecaching.cache.CacheInfo;
 
 import java.util.Optional;
 
+/**
+ * The type Cacheability metrics.
+ */
 public class CacheabilityMetrics {
 
-    //total da população
+    /**
+     * Sample size long.
+     *
+     * @param N the n
+     * @param Z the z
+     * @param e the e
+     * @return the long
+     */
+//total da população
     public static long sampleSize(long N, double Z, double e) {
         //Nível de confiança 90% -> Z=1.645
         //Nível de confiança 95% -> Z=1.96
@@ -32,6 +43,14 @@ public class CacheabilityMetrics {
         return n;
     }
 
+    /**
+     * Is static data optional.
+     *
+     * @param methodStats the method stats
+     * @param workflow    the workflow
+     * @param population  the population
+     * @return the optional
+     */
     public static Optional<Boolean> isStaticData(MethodStats methodStats, FlowchartWorkFlow workflow, int population) {
 
         //executions of a method should represent a good portion of total logs in order to avoid 1 occur == 100% hit
@@ -48,6 +67,13 @@ public class CacheabilityMetrics {
             return Optional.of(false);
     }
 
+    /**
+     * Change more than used optional.
+     *
+     * @param methodStats the method stats
+     * @param workflow    the workflow
+     * @return the optional
+     */
     public static Optional<Boolean> changeMoreThanUsed(MethodStats methodStats, FlowchartWorkFlow workflow) {
         //+/- k sds
         if (methodStats.missRatio() > workflow.missThreshold(0))
@@ -56,6 +82,14 @@ public class CacheabilityMetrics {
             return Optional.of(false);
     }
 
+    /**
+     * Used by many requests optional.
+     *
+     * @param methodStats the method stats
+     * @param workflow    the workflow
+     * @param population  the population
+     * @return the optional
+     */
     public static Optional<Boolean> usedByManyRequests(MethodStats methodStats, FlowchartWorkFlow workflow, int population) {
 
         //same executions of a method should represent a good portion of total execution of such method
@@ -65,6 +99,13 @@ public class CacheabilityMetrics {
         } else return Optional.of(false);
     }
 
+    /**
+     * Is user specific optional.
+     *
+     * @param methodStats the method stats
+     * @param workflow    the workflow
+     * @return the optional
+     */
     public static Optional<Boolean> isUserSpecific(MethodStats methodStats, FlowchartWorkFlow workflow) {
 
         if (methodStats.getAmountOfIdentifiedSameOccurences() == 0)
@@ -77,16 +118,36 @@ public class CacheabilityMetrics {
             return Optional.of(false);
     }
 
+    /**
+     * Is cache size large optional.
+     *
+     * @param cacheInfo the cache info
+     * @return the optional
+     */
     public static Optional<Boolean> isCacheSizeLarge(CacheInfo cacheInfo) {
         //concept considered while caching
         return Optional.of(true);
     }
 
+    /**
+     * Is data size large optional.
+     *
+     * @param cacheInfo  the cache info
+     * @param methodInfo the method info
+     * @return the optional
+     */
     public static Optional<Boolean> isDataSizeLarge(CacheInfo cacheInfo, MethodInfo methodInfo) {
         //concept considered while caching
         return Optional.of(false);
     }
 
+    /**
+     * Is expensive optional.
+     *
+     * @param methodStats the method stats
+     * @param workflow    the workflow
+     * @return the optional
+     */
     public static Optional<Boolean> isExpensive(MethodStats methodStats, FlowchartWorkFlow workflow) {
         if (methodStats.getSameOccurrencesAverageExecutionTime() >= workflow.expensivenessThreshold(0))
             return Optional.of(true);
@@ -94,6 +155,16 @@ public class CacheabilityMetrics {
             return Optional.of(false);
     }
 
+    /**
+     * All metrics to string string.
+     *
+     * @param cacheInfo   the cache info
+     * @param methodInfo  the method info
+     * @param methodStats the method stats
+     * @param workflow    the workflow
+     * @param population  the population
+     * @return the string
+     */
     public static String allMetricsToString(CacheInfo cacheInfo, MethodInfo methodInfo, MethodStats methodStats, FlowchartWorkFlow workflow, int population) {
         //isStaticData,changeMoreThanUsed,usedByManyRequests,isUserSpecific,isCacheSizeLarge,isDataSizeLarge,isExpensive
         return isStaticData(methodStats, workflow, population) +

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/stats/CacheabilityPatternDecider.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/stats/CacheabilityPatternDecider.java
index a9af7fa..ea25e7f 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/stats/CacheabilityPatternDecider.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/stats/CacheabilityPatternDecider.java
@@ -3,8 +3,8 @@ package br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.stats;
 import br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.CacheDecider;
 import br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.FlowchartWorkFlow;
 import br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.model.MethodStats;
-import br.ufrgs.inf.prosoft.adaptivecaching.monitoring.application.metadata.MethodInfo;
-import br.ufrgs.inf.prosoft.adaptivecaching.monitoring.cache.CacheInfo;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.metadata.MethodInfo;
+import br.ufrgs.inf.prosoft.adaptivecaching.cache.CacheInfo;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -18,10 +18,22 @@ import java.util.Optional;
 public class CacheabilityPatternDecider implements CacheDecider {
 
     private final int population;
+    /**
+     * The Logger.
+     */
     Logger logger = LoggerFactory.getLogger(CacheabilityPatternDecider.class);
 
+    /**
+     * The Workflow.
+     */
     FlowchartWorkFlow workflow;
 
+    /**
+     * Instantiates a new Cacheability pattern decider.
+     *
+     * @param size     the size
+     * @param workflow the workflow
+     */
     public CacheabilityPatternDecider(int size, FlowchartWorkFlow workflow) {
         this.workflow = workflow;
         this.population = size;

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cache/CacheMonitor.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cache/CacheMonitor.java
new file mode 100644
index 0000000..511eb88
--- /dev/null
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cache/CacheMonitor.java
@@ -0,0 +1,14 @@
+package br.ufrgs.inf.prosoft.adaptivecaching.cache;
+
+/**
+ * The interface Cache monitor.
+ */
+public interface CacheMonitor {
+
+    /**
+     * Gets cache info.
+     *
+     * @return the cache info
+     */
+    CacheInfo getCacheInfo();
+}

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/cacher/AdaptiveMethodCacher.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/cacher/AdaptiveMethodCacher.java
index 6d06026..2ec7c68 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/cacher/AdaptiveMethodCacher.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/cacher/AdaptiveMethodCacher.java
@@ -11,14 +11,26 @@ import org.aspectj.lang.ProceedingJoinPoint;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+/**
+ * The type Adaptive method cacher.
+ */
 public class AdaptiveMethodCacher implements MethodCacher {
 
+    /**
+     * The Logger.
+     */
     Logger logger = LoggerFactory.getLogger(AdaptiveMethodCacher.class);
 
     //caching components
     private CacheManager cacheManager;
     private Cache cache;
 
+    /**
+     * Instantiates a new Adaptive method cacher.
+     *
+     * @param cacheProviderType the cache provider type
+     * @param expiryInterval    the expiry interval
+     */
     public AdaptiveMethodCacher(CacheProviderType cacheProviderType, long expiryInterval) {
         this.cacheManager = CacheManagerFactory.getCacheManager(cacheProviderType, expiryInterval);
         this.cache = cacheManager.getCache("adaptivecaching");
@@ -55,6 +67,11 @@ public class AdaptiveMethodCacher implements MethodCacher {
 
     }
 
+    /**
+     * Gets cache.
+     *
+     * @return the cache
+     */
     public Cache getCache() {
         return cache;
     }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/cacher/key/Key.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/cacher/key/Key.java
index ea372b4..debc04b 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/cacher/key/Key.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/cacher/key/Key.java
@@ -28,12 +28,10 @@ public class Key {
      */
     private final transient Object[] arguments;
 
-    Logger logger = LoggerFactory.getLogger(Key.class);
-
     /**
-     * Log level.
+     * The Logger.
      */
-//    private final int level;
+    Logger logger = LoggerFactory.getLogger(Key.class);
 
     /**
      * Public ctor.
@@ -45,21 +43,8 @@ public class Key {
                 .cast(point.getSignature()).getMethod();
         this.target = Key.targetize(point);
         this.arguments = point.getArgs();
-//        if (this.method.isAnnotationPresent(Loggable.class)) {
-//            this.level = this.method.getAnnotation(Loggable.class).value();
-//        } else {
-//            this.level = Loggable.DEBUG;
-//        }
     }
 
-//    /**
-//     * Get log level.
-//     * @return Log level of current method.
-//     */
-//    public final int getLevel() {
-//        return this.level;
-//    }
-
     /**
      * Calculate its target.
      *
@@ -93,20 +78,6 @@ public class Key {
     }
 
     @Override
-//    public final boolean equals(final Object obj) {
-//        final boolean equals;
-//        if (this == obj) {
-//            equals = true;
-//        } else if (obj instanceof Key) {
-//            final Key key = Key.class.cast(obj);
-//            equals = key.method.equals(this.method)
-//                    && this.target.equals(key.target)
-//                    && Arrays.deepEquals(key.arguments, this.arguments);
-//        } else {
-//            equals = false;
-//        }
-//        return equals;
-//    }
     public final boolean equals(final Object obj) {
 
         final boolean equals;
@@ -132,13 +103,11 @@ public class Key {
      */
     public Object through(final Object result) {
         final Class<?> type = this.method.getDeclaringClass();
-//        if (hit > 0 && LogHelper.enabled(this.level, type)) {
         logger.debug(
                 "%s: %s from model (hit #%d, %[ms]s old)",
                 this,
                 Mnemos.toText(result, true, false)
         );
-//        }
         return result;
     }
 

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/cacher/MethodCacher.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/cacher/MethodCacher.java
index 4a8a053..d581a46 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/cacher/MethodCacher.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/cacher/MethodCacher.java
@@ -3,12 +3,39 @@ package br.ufrgs.inf.prosoft.adaptivecaching.cachemanager.cacher;
 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;
 
+/**
+ * The interface Method cacher.
+ */
 public interface MethodCacher {
+    /**
+     * Put in cache.
+     *
+     * @param key    the key
+     * @param result the result
+     * @throws Throwable the throwable
+     */
     void putInCache(final Object key, Object result) throws Throwable;
 
+    /**
+     * Gets from cache.
+     *
+     * @param key the key
+     * @return the from cache
+     * @throws Throwable the throwable
+     */
     Object getFromCache(final Object key) throws Throwable;
 
+    /**
+     * Preflush.
+     *
+     * @param joinPoint the join point
+     */
     void preflush(final JoinPoint joinPoint);
 
+    /**
+     * Postflush.
+     *
+     * @param joinPoint the join point
+     */
     void postflush(final JoinPoint joinPoint);
 }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/AbstractCacheManager.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/AbstractCacheManager.java
index d2fb692..026be75 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/AbstractCacheManager.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/AbstractCacheManager.java
@@ -13,7 +13,6 @@ import java.util.concurrent.ConcurrentMap;
 /**
  * Abstract base class implementing the common {@link CacheManager} methods.
  * Useful for 'static' environments where the backing caches do not change.
- *
  */
 public abstract class AbstractCacheManager implements CacheManager {
 
@@ -21,13 +20,14 @@ public abstract class AbstractCacheManager implements CacheManager {
 
 	private volatile Set<String> cacheNames = Collections.emptySet();
 
-	/**
-	 * Initialize the static configuration of caches.
-	 * <p>Triggered on startup through {@link #afterPropertiesSet()};
-	 * can also be called to re-initialize at runtime.
-	 * @see #loadCaches()
-	 */
-	public void initializeCaches() {
+    /**
+     * Initialize the static configuration of caches.
+     * <p>Triggered on startup through {@link #afterPropertiesSet()};
+     * can also be called to re-initialize at runtime.
+     *
+     * @see #loadCaches() #loadCaches()
+     */
+    public void initializeCaches() {
 		Collection<? extends Cache> caches = loadCaches();
 
 		synchronized (this.cacheMap) {
@@ -43,12 +43,14 @@ public abstract class AbstractCacheManager implements CacheManager {
 		}
 	}
 
-	/**
-	 * Load the initial caches for this cache manager.
-	 * <p>Called by {@link #afterPropertiesSet()} on startup.
-	 * The returned collection may be empty but must not be {@code null}.
-	 */
-	protected abstract Collection<? extends Cache> loadCaches();
+    /**
+     * Load the initial caches for this cache manager.
+     * <p>Called by {@link #afterPropertiesSet()} on startup.
+     * The returned collection may be empty but must not be {@code null}.
+     *
+     * @return the collection
+     */
+    protected abstract Collection<? extends Cache> loadCaches();
 
 
 	// Lazy cache initialization on access
@@ -84,25 +86,27 @@ public abstract class AbstractCacheManager implements CacheManager {
 
 	// Common cache initialization delegates for subclasses
 
-	/**
-	 * Check for a registered cache of the given name.
-	 * In contrast to {@link #getCache(String)}, this method does not trigger
-	 * the lazy creation of missing caches via {@link #getMissingCache(String)}.
-	 * @param name the cache identifier (must not be {@code null})
-	 * @return the associated Cache instance, or {@code null} if none found
-	 * @see #getCache(String)
-	 * @see #getMissingCache(String)
-	 */
-	protected final Cache lookupCache(String name) {
+    /**
+     * Check for a registered cache of the given name.
+     * In contrast to {@link #getCache(String)}, this method does not trigger
+     * the lazy creation of missing caches via {@link #getMissingCache(String)}.
+     *
+     * @param name the cache identifier (must not be {@code null})
+     * @return the associated Cache instance, or {@code null} if none found
+     * @see #getCache(String) #getCache(String)
+     * @see #getMissingCache(String) #getMissingCache(String)
+     */
+    protected final Cache lookupCache(String name) {
 		return this.cacheMap.get(name);
 	}
 
-	/**
-	 * Dynamically register an additional Cache with this manager.
-	 * @param cache the Cache to register
-	 * @deprecated as of Spring 4.3, in favor of {@link #getMissingCache(String)}
-	 */
-	@Deprecated
+    /**
+     * Dynamically register an additional Cache with this manager.
+     *
+     * @param cache the Cache to register
+     * @deprecated as of Spring 4.3, in favor of {@link #getMissingCache(String)}
+     */
+    @Deprecated
 	protected final void addCache(Cache cache) {
 		String name = cache.getName();
 		synchronized (this.cacheMap) {
@@ -129,29 +133,29 @@ public abstract class AbstractCacheManager implements CacheManager {
 
 	// Overridable template methods for cache initialization
 
-	/**
-	 * Decorate the given Cache object if necessary.
-	 * @param cache the Cache object to be added to this CacheManager
-	 * @return the decorated Cache object to be used instead,
-	 * or simply the passed-in Cache object by default
-	 */
-	protected Cache decorateCache(Cache cache) {
+    /**
+     * Decorate the given Cache object if necessary.
+     *
+     * @param cache the Cache object to be added to this CacheManager
+     * @return the decorated Cache object to be used instead, or simply the passed-in Cache object by default
+     */
+    protected Cache decorateCache(Cache cache) {
 		return cache;
 	}
 
-	/**
-	 * Return a missing cache with the specified {@code name} or {@code null} if
-	 * such cache does not exist or could not be created on the fly.
-	 * <p>Some caches may be created at runtime if the native provider supports
-	 * it. If a lookup by name does not yield any result, a subclass gets a chance
-	 * to register such a cache at runtime. The returned cache will be automatically
-	 * added to this instance.
-	 * @param name the name of the cache to retrieve
-	 * @return the missing cache or {@code null} if no such cache exists or could be
-	 * created
-	 * @see #getCache(String)
-	 */
-	protected Cache getMissingCache(String name) {
+    /**
+     * Return a missing cache with the specified {@code name} or {@code null} if
+     * such cache does not exist or could not be created on the fly.
+     * <p>Some caches may be created at runtime if the native provider supports
+     * it. If a lookup by name does not yield any result, a subclass gets a chance
+     * to register such a cache at runtime. The returned cache will be automatically
+     * added to this instance.
+     *
+     * @param name the name of the cache to retrieve
+     * @return the missing cache or {@code null} if no such cache exists or could be created
+     * @see #getCache(String) #getCache(String)
+     */
+    protected Cache getMissingCache(String name) {
 		return null;
 	}
 

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/caffeine/CaffeineCache.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/caffeine/CaffeineCache.java
index 6b47fed..092ee3c 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/caffeine/CaffeineCache.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/caffeine/CaffeineCache.java
@@ -40,8 +40,7 @@ public class CaffeineCache extends AbstractValueAdaptingCache {
      *
      * @param name            the name of the cachemanager
      * @param cache           the backing Caffeine Cache instance
-     * @param allowNullValues whether to accept and convert {@code null}
-     *                        values for this cachemanager
+     * @param allowNullValues whether to accept and convert {@code null}                        values for this cachemanager
      */
     public CaffeineCache(String name, com.github.benmanes.caffeine.cache.Cache<Object, Object> cache,
                          boolean allowNullValues) {
@@ -113,6 +112,11 @@ public class CaffeineCache extends AbstractValueAdaptingCache {
 
         private boolean called;
 
+        /**
+         * Instantiates a new Put if absent function.
+         *
+         * @param value the value
+         */
         public PutIfAbsentFunction(Object value) {
             this.value = value;
         }
@@ -129,6 +133,11 @@ public class CaffeineCache extends AbstractValueAdaptingCache {
 
         private final Callable<?> valueLoader;
 
+        /**
+         * Instantiates a new Load function.
+         *
+         * @param valueLoader the value loader
+         */
         public LoadFunction(Callable<?> valueLoader) {
             this.valueLoader = valueLoader;
         }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/caffeine/CaffeineCacheManager.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/caffeine/CaffeineCacheManager.java
index 85110b3..6adbb66 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/caffeine/CaffeineCacheManager.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/caffeine/CaffeineCacheManager.java
@@ -52,6 +52,8 @@ public class CaffeineCacheManager implements CacheManager {
     /**
      * Construct a static CaffeineCacheManager,
      * managing caches for the specified cachemanager names only.
+     *
+     * @param cacheNames the cache names
      */
     public CaffeineCacheManager(String... cacheNames) {
         setCacheNames(Arrays.asList(cacheNames));
@@ -61,8 +63,9 @@ public class CaffeineCacheManager implements CacheManager {
      * Set the Caffeine to use for building each individual
      * {@link CaffeineCache} instance.
      *
-     * @see #createNativeCaffeineCache
-     * @see com.github.benmanes.caffeine.cache.Caffeine#build()
+     * @param caffeine the caffeine
+     * @see #createNativeCaffeineCache #createNativeCaffeineCache
+     * @see com.github.benmanes.caffeine.cache.Caffeine#build() com.github.benmanes.caffeine.cache.Caffeine#build()
      */
     public void setCaffeine(Caffeine<Object, Object> caffeine) {
         Assert.notNull(caffeine, "Caffeine must not be null");
@@ -73,8 +76,9 @@ public class CaffeineCacheManager implements CacheManager {
      * Set the {@link CaffeineSpec} to use for building each individual
      * {@link CaffeineCache} instance.
      *
-     * @see #createNativeCaffeineCache
-     * @see com.github.benmanes.caffeine.cache.Caffeine#from(CaffeineSpec)
+     * @param caffeineSpec the caffeine spec
+     * @see #createNativeCaffeineCache #createNativeCaffeineCache
+     * @see com.github.benmanes.caffeine.cache.Caffeine#from(CaffeineSpec) com.github.benmanes.caffeine.cache.Caffeine#from(CaffeineSpec)
      */
     public void setCaffeineSpec(CaffeineSpec caffeineSpec) {
         doSetCaffeine(Caffeine.from(caffeineSpec));
@@ -85,8 +89,9 @@ public class CaffeineCacheManager implements CacheManager {
      * individual {@link CaffeineCache} instance. The given value needs to
      * comply with Caffeine's {@link CaffeineSpec} (see its javadoc).
      *
-     * @see #createNativeCaffeineCache
-     * @see com.github.benmanes.caffeine.cache.Caffeine#from(String)
+     * @param cacheSpecification the cache specification
+     * @see #createNativeCaffeineCache #createNativeCaffeineCache
+     * @see com.github.benmanes.caffeine.cache.Caffeine#from(String) com.github.benmanes.caffeine.cache.Caffeine#from(String)
      */
     public void setCacheSpecification(String cacheSpecification) {
         doSetCaffeine(Caffeine.from(cacheSpecification));
@@ -96,8 +101,9 @@ public class CaffeineCacheManager implements CacheManager {
      * Set the Caffeine CacheLoader to use for building each individual
      * {@link CaffeineCache} instance, turning it into a LoadingCache.
      *
-     * @see #createNativeCaffeineCache
-     * @see com.github.benmanes.caffeine.cache.Caffeine#build(CacheLoader)
+     * @param cacheLoader the cache loader
+     * @see #createNativeCaffeineCache #createNativeCaffeineCache
+     * @see com.github.benmanes.caffeine.cache.Caffeine#build(CacheLoader) com.github.benmanes.caffeine.cache.Caffeine#build(CacheLoader)
      * @see com.github.benmanes.caffeine.cache.LoadingCache
      */
     public void setCacheLoader(CacheLoader<Object, Object> cacheLoader) {
@@ -110,6 +116,8 @@ public class CaffeineCacheManager implements CacheManager {
     /**
      * Return whether this cachemanager manager accepts and converts {@code null} values
      * for all of its caches.
+     *
+     * @return the boolean
      */
     public boolean isAllowNullValues() {
         return this.allowNullValues;
@@ -120,6 +128,8 @@ public class CaffeineCacheManager implements CacheManager {
      * in this cachemanager manager.
      * <p>Default is "true", despite Caffeine itself not supporting {@code null} values.
      * An internal holder object will be used to store user-level {@code null}s.
+     *
+     * @param allowNullValues the allow null values
      */
     public void setAllowNullValues(boolean allowNullValues) {
         if (this.allowNullValues != allowNullValues) {
@@ -139,6 +149,8 @@ public class CaffeineCacheManager implements CacheManager {
      * with no creation of further cachemanager regions at runtime.
      * <p>Calling this with a {@code null} collection argument resets the
      * mode to 'dynamic', allowing for further creation of caches again.
+     *
+     * @param cacheNames the cache names
      */
     public void setCacheNames(Collection<String> cacheNames) {
         if (cacheNames != null) {

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/ehcache/EhCacheCacheManager.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/ehcache/EhCacheCacheManager.java
index 54649b9..02a1d67 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/ehcache/EhCacheCacheManager.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/ehcache/EhCacheCacheManager.java
@@ -11,7 +11,6 @@ import java.util.LinkedHashSet;
 
 /**
  * CacheManager backed by an EhCache {@link net.sf.ehcache.CacheManager}.
- *
  */
 public class EhCacheCacheManager extends AbstractCacheManager {
 
@@ -39,6 +38,8 @@ public class EhCacheCacheManager extends AbstractCacheManager {
 
     /**
      * Return the backing EhCache {@link net.sf.ehcache.CacheManager}.
+     *
+     * @return the cache manager
      */
     public net.sf.ehcache.CacheManager getCacheManager() {
         return this.cacheManager;
@@ -46,6 +47,8 @@ public class EhCacheCacheManager extends AbstractCacheManager {
 
     /**
      * Set the backing EhCache {@link net.sf.ehcache.CacheManager}.
+     *
+     * @param cacheManager the cache manager
      */
     public void setCacheManager(net.sf.ehcache.CacheManager cacheManager) {
         this.cacheManager = cacheManager;
@@ -77,6 +80,11 @@ public class EhCacheCacheManager extends AbstractCacheManager {
         return null;
     }
 
+    /**
+     * Add cache.
+     *
+     * @param name the name
+     */
     public void addCache(String name){
         cacheManager.addCache(name);
     }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/ehcache/EhCacheManagerFactoryBean.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/ehcache/EhCacheManagerFactoryBean.java
index 7370ce5..25c5271 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/ehcache/EhCacheManagerFactoryBean.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/ehcache/EhCacheManagerFactoryBean.java
@@ -24,6 +24,9 @@ import org.springframework.core.io.Resource;
  */
 public class EhCacheManagerFactoryBean {
 
+    /**
+     * The Logger.
+     */
     protected final Log logger = LogFactory.getLog(getClass());
 
     private Resource configLocation;
@@ -38,6 +41,9 @@ public class EhCacheManagerFactoryBean {
 
     private boolean locallyManaged = true;
 
+    /**
+     * Instantiates a new Eh cache manager factory bean.
+     */
     public EhCacheManagerFactoryBean() {
         if (logger.isInfoEnabled()) {
             logger.info("Initializing EhCache CacheManager" +
@@ -79,8 +85,9 @@ public class EhCacheManagerFactoryBean {
      * <p>Default is "ehcache.xml" in the root of the class path, or if not found,
      * "ehcache-failsafe.xml" in the EhCache jar (default EhCache initialization).
      *
-     * @see net.sf.ehcache.CacheManager#create(java.io.InputStream)
-     * @see net.sf.ehcache.CacheManager#CacheManager(java.io.InputStream)
+     * @param configLocation the config location
+     * @see net.sf.ehcache.CacheManager#create(java.io.InputStream) net.sf.ehcache.CacheManager#create(java.io.InputStream)
+     * @see net.sf.ehcache.CacheManager#CacheManager(java.io.InputStream) net.sf.ehcache.CacheManager#CacheManager(java.io.InputStream)
      */
     public void setConfigLocation(Resource configLocation) {
         this.configLocation = configLocation;
@@ -89,7 +96,8 @@ public class EhCacheManagerFactoryBean {
     /**
      * Set the name of the EhCache CacheManager (if a specific name is desired).
      *
-     * @see net.sf.ehcache.config.Configuration#setName(String)
+     * @param cacheManagerName the cache manager name
+     * @see net.sf.ehcache.config.Configuration#setName(String) net.sf.ehcache.config.Configuration#setName(String)
      */
     public void setCacheManagerName(String cacheManagerName) {
         this.cacheManagerName = cacheManagerName;
@@ -103,10 +111,10 @@ public class EhCacheManagerFactoryBean {
      * All references to the same CacheManager name (or the same default) in the
      * same ClassLoader space will share the specified CacheManager then.
      *
-     * @see #setCacheManagerName
-     * #see #setShared
-     * @see net.sf.ehcache.CacheManager#getCacheManager(String)
-     * @see net.sf.ehcache.CacheManager#CacheManager()
+     * @param acceptExisting the accept existing
+     * @see #setCacheManagerName #setCacheManagerName #see #setShared
+     * @see net.sf.ehcache.CacheManager#getCacheManager(String) net.sf.ehcache.CacheManager#getCacheManager(String)
+     * @see net.sf.ehcache.CacheManager#CacheManager() net.sf.ehcache.CacheManager#CacheManager()
      */
     public void setAcceptExisting(boolean acceptExisting) {
         this.acceptExisting = acceptExisting;
@@ -124,27 +132,46 @@ public class EhCacheManagerFactoryBean {
      * <p>This flag overrides {@link #setAcceptExisting "acceptExisting"} if both are set,
      * since it indicates the 'stronger' mode of sharing.
      *
-     * @see #setCacheManagerName
-     * @see #setAcceptExisting
-     * @see net.sf.ehcache.CacheManager#create()
-     * @see net.sf.ehcache.CacheManager#CacheManager()
+     * @param shared the shared
+     * @see #setCacheManagerName #setCacheManagerName
+     * @see #setAcceptExisting #setAcceptExisting
+     * @see net.sf.ehcache.CacheManager#create() net.sf.ehcache.CacheManager#create()
+     * @see net.sf.ehcache.CacheManager#CacheManager() net.sf.ehcache.CacheManager#CacheManager()
      */
     public void setShared(boolean shared) {
         this.shared = shared;
     }
 
+    /**
+     * Gets object.
+     *
+     * @return the object
+     */
     public CacheManager getObject() {
         return this.cacheManager;
     }
 
+    /**
+     * Gets object type.
+     *
+     * @return the object type
+     */
     public Class<? extends CacheManager> getObjectType() {
         return (this.cacheManager != null ? this.cacheManager.getClass() : CacheManager.class);
     }
 
+    /**
+     * Is singleton boolean.
+     *
+     * @return the boolean
+     */
     public boolean isSingleton() {
         return true;
     }
 
+    /**
+     * Destroy.
+     */
     public void destroy() {
         if (this.locallyManaged) {
             if (logger.isInfoEnabled()) {

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/ehcache/EhCacheManagerUtils.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/ehcache/EhCacheManagerUtils.java
index 37694a4..8ce5b12 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/ehcache/EhCacheManagerUtils.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/ehcache/EhCacheManagerUtils.java
@@ -83,8 +83,8 @@ public abstract class EhCacheManagerUtils {
      * @param configLocation the location of the configuration file (as a Spring resource)
      * @return the EhCache Configuration handle
      * @throws CacheException in case of configuration parsing failure
-     * @see CacheManager#CacheManager(Configuration)
-     * @see CacheManager#create(Configuration)
+     * @see CacheManager#CacheManager(Configuration) CacheManager#CacheManager(Configuration)
+     * @see CacheManager#create(Configuration) CacheManager#create(Configuration)
      */
     public static Configuration parseConfiguration(Resource configLocation) throws CacheException {
         InputStream is = null;

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/guava/GuavaCache.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/guava/GuavaCache.java
index a3d4002..24f2016 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/guava/GuavaCache.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/guava/GuavaCache.java
@@ -13,7 +13,6 @@ import java.util.concurrent.ExecutionException;
  * on top of a Guava {@link com.google.common.cache.Cache} instance.
  * <p>
  * <p>Requires Google Guava 12.0 or higher.
- *
  */
 public class GuavaCache extends AbstractValueAdaptingCache {
 
@@ -39,8 +38,7 @@ public class GuavaCache extends AbstractValueAdaptingCache {
      *
      * @param name            the name of the cachemanager
      * @param cache           the backing Guava Cache instance
-     * @param allowNullValues whether to accept and convert {@code null}
-     *                        values for this cachemanager
+     * @param allowNullValues whether to accept and convert {@code null}                        values for this cachemanager
      */
     public GuavaCache(String name, com.google.common.cache.Cache<Object, Object> cache, boolean allowNullValues) {
         super(allowNullValues);
@@ -129,6 +127,11 @@ public class GuavaCache extends AbstractValueAdaptingCache {
 
         private boolean called;
 
+        /**
+         * Instantiates a new Put if absent callable.
+         *
+         * @param value the value
+         */
         public PutIfAbsentCallable(Object value) {
             this.value = value;
         }
@@ -140,11 +143,18 @@ public class GuavaCache extends AbstractValueAdaptingCache {
         }
     }
 
+    /**
+     * Stats cache stats.
+     *
+     * @return the cache stats
+     */
     public CacheStats stats(){
         return this.cache.stats();
     }
 
     /**
+     * Size long.
+     *
      * @return Returns the approximate number of entries in this cache.
      */
     public long size(){

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/guava/GuavaCacheManager.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/guava/GuavaCacheManager.java
index 97e0864..58cfbff 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/guava/GuavaCacheManager.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/extensions/guava/GuavaCacheManager.java
@@ -27,7 +27,6 @@ import java.util.concurrent.ConcurrentMap;
  * via the {@link #setCacheSpecification "cacheSpecification"} bean property.
  * <p>
  * <p>Requires Google Guava 12.0 or higher.
- *
  */
 public class GuavaCacheManager implements CacheManager {
 
@@ -52,6 +51,8 @@ public class GuavaCacheManager implements CacheManager {
     /**
      * Construct a static GuavaCacheManager,
      * managing caches for the specified cachemanager names only.
+     *
+     * @param cacheNames the cache names
      */
     public GuavaCacheManager(String... cacheNames) {
         setCacheNames(Arrays.asList(cacheNames));
@@ -61,8 +62,9 @@ public class GuavaCacheManager implements CacheManager {
      * Set the Guava CacheBuilder to use for building each individual
      * {@link GuavaCache} instance.
      *
-     * @see #createNativeGuavaCache
-     * @see CacheBuilder#build()
+     * @param cacheBuilder the cache builder
+     * @see #createNativeGuavaCache #createNativeGuavaCache
+     * @see CacheBuilder#build() CacheBuilder#build()
      */
     public void setCacheBuilder(CacheBuilder<Object, Object> cacheBuilder) {
 //		Assert.notNull(cacheBuilder, "CacheBuilder must not be null");
@@ -73,8 +75,9 @@ public class GuavaCacheManager implements CacheManager {
      * Set the Guava CacheBuilderSpec to use for building each individual
      * {@link GuavaCache} instance.
      *
-     * @see #createNativeGuavaCache
-     * @see CacheBuilder#from(CacheBuilderSpec)
+     * @param cacheBuilderSpec the cache builder spec
+     * @see #createNativeGuavaCache #createNativeGuavaCache
+     * @see CacheBuilder#from(CacheBuilderSpec) CacheBuilder#from(CacheBuilderSpec)
      */
     public void setCacheBuilderSpec(CacheBuilderSpec cacheBuilderSpec) {
         doSetCacheBuilder(CacheBuilder.from(cacheBuilderSpec));
@@ -85,8 +88,9 @@ public class GuavaCacheManager implements CacheManager {
      * individual {@link GuavaCache} instance. The given value needs to
      * comply with Guava's {@link CacheBuilderSpec} (see its javadoc).
      *
-     * @see #createNativeGuavaCache
-     * @see CacheBuilder#from(String)
+     * @param cacheSpecification the cache specification
+     * @see #createNativeGuavaCache #createNativeGuavaCache
+     * @see CacheBuilder#from(String) CacheBuilder#from(String)
      */
     public void setCacheSpecification(String cacheSpecification) {
         doSetCacheBuilder(CacheBuilder.from(cacheSpecification));
@@ -96,8 +100,9 @@ public class GuavaCacheManager implements CacheManager {
      * Set the Guava CacheLoader to use for building each individual
      * {@link GuavaCache} instance, turning it into a LoadingCache.
      *
-     * @see #createNativeGuavaCache
-     * @see CacheBuilder#build(CacheLoader)
+     * @param cacheLoader the cache loader
+     * @see #createNativeGuavaCache #createNativeGuavaCache
+     * @see CacheBuilder#build(CacheLoader) CacheBuilder#build(CacheLoader)
      * @see com.google.common.cache.LoadingCache
      */
     public void setCacheLoader(CacheLoader<Object, Object> cacheLoader) {
@@ -110,6 +115,8 @@ public class GuavaCacheManager implements CacheManager {
     /**
      * Return whether this cachemanager manager accepts and converts {@code null} values
      * for all of its caches.
+     *
+     * @return the boolean
      */
     public boolean isAllowNullValues() {
         return this.allowNullValues;
@@ -120,6 +127,8 @@ public class GuavaCacheManager implements CacheManager {
      * in this cachemanager manager.
      * <p>Default is "true", despite Guava itself not supporting {@code null} values.
      * An internal holder object will be used to store user-level {@code null}s.
+     *
+     * @param allowNullValues the allow null values
      */
     public void setAllowNullValues(boolean allowNullValues) {
         if (this.allowNullValues != allowNullValues) {
@@ -139,6 +148,8 @@ public class GuavaCacheManager implements CacheManager {
      * with no creation of further cachemanager regions at runtime.
      * <p>Calling this with a {@code null} collection argument resets the
      * mode to 'dynamic', allowing for further creation of caches again.
+     *
+     * @param cacheNames the cache names
      */
     public void setCacheNames(Collection<String> cacheNames) {
         if (cacheNames != null) {

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/AdaptiveCacheManager.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/AdaptiveCacheManager.java
index 3e2b2ee..736bed9 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/AdaptiveCacheManager.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/AdaptiveCacheManager.java
@@ -9,20 +9,36 @@ import java.util.Collection;
 //        CompositeCacheManager, ConcurrentMapCacheManager, EhCacheCacheManager, GuavaCacheManager, JCacheCacheManager,
 //        NoOpCacheManager, SimpleCacheManager, TransactionAwareCacheManagerProxy
 
+/**
+ * The type Adaptive cache manager.
+ */
 //For future use, do not use it yet
 @Deprecated
 public class AdaptiveCacheManager implements CacheManager {
 
     private CacheManager cacheManager;
 
+    /**
+     * Instantiates a new Adaptive cache manager.
+     */
     public AdaptiveCacheManager() {
         this(new GuavaCacheManager());
     }
 
+    /**
+     * Instantiates a new Adaptive cache manager.
+     *
+     * @param cacheManager the cache manager
+     */
     public AdaptiveCacheManager(CacheManager cacheManager) {
         this.cacheManager = cacheManager;
     }
 
+    /**
+     * Gets cache manager.
+     *
+     * @return the cache manager
+     */
     public CacheManager getCacheManager() {
         return this.cacheManager;
     }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/Cache.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/Cache.java
index 503c525..cf7a99d 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/Cache.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/Cache.java
@@ -13,11 +13,15 @@ public interface Cache {
 
     /**
      * Return the model name.
+     *
+     * @return the name
      */
     String getName();
 
     /**
      * Return the underlying native model provider.
+     *
+     * @return the native cache
      */
     Object getNativeCache();
 
@@ -28,11 +32,8 @@ public interface Cache {
      * be returned in a {@link ValueWrapper}.
      *
      * @param key the key whose associated value is to be returned
-     * @return the value to which this model maps the specified key,
-     * contained within a {@link ValueWrapper} which may also hold
-     * a cached {@code null} value. A straight {@code null} being
-     * returned means that the model contains no mapping for this key.
-     * @see #get(Object, Class)
+     * @return the value to which this model maps the specified key, contained within a {@link ValueWrapper} which may also hold a cached {@code null} value. A straight {@code null} being returned means that the model contains no mapping for this key.
+     * @see #get(Object, Class) #get(Object, Class)
      */
     ValueWrapper get(Object key);
 
@@ -43,16 +44,12 @@ public interface Cache {
      * between a cached {@code null} value and no model entry found at all.
      * Use the standard {@link #get(Object)} variant for that purpose instead.
      *
+     * @param <T>  the type parameter
      * @param key  the key whose associated value is to be returned
-     * @param type the required type of the returned value (may be
-     *             {@code null} to bypass a type check; in case of a {@code null}
-     *             value found in the model, the specified type is irrelevant)
-     * @return the value to which this model maps the specified key
-     * (which may be {@code null} itself), or also {@code null} if
-     * the model contains no mapping for this key
-     * @throws IllegalStateException if a model entry has been found
-     *                               but failed to match the specified type
-     * @see #get(Object)
+     * @param type the required type of the returned value (may be             {@code null} to bypass a type check; in case of a {@code null}             value found in the model, the specified type is irrelevant)
+     * @return the value to which this model maps the specified key (which may be {@code null} itself), or also {@code null} if the model contains no mapping for this key
+     * @throws IllegalStateException if a model entry has been found                               but failed to match the specified type
+     * @see #get(Object) #get(Object)
      */
     <T> T get(Object key, Class<T> type);
 
@@ -67,7 +64,9 @@ public interface Cache {
      * <p>If the {@code valueLoader} throws an exception, it is wrapped in
      * a {@link ValueRetrievalException}
      *
-     * @param key the key whose associated value is to be returned
+     * @param <T>         the type parameter
+     * @param key         the key whose associated value is to be returned
+     * @param valueLoader the value loader
      * @return the value to which this model maps the specified key
      * @throws ValueRetrievalException if the {@code valueLoader} throws an exception
      * @since 4.3
@@ -105,10 +104,7 @@ public interface Cache {
      *
      * @param key   the key with which the specified value is to be associated
      * @param value the value to be associated with the specified key
-     * @return the value to which this model maps the specified key (which may be
-     * {@code null} itself), or also {@code null} if the model did not contain any
-     * mapping for that key prior to this call. Returning {@code null} is therefore
-     * an indicator that the given {@code value} has been associated with the key.
+     * @return the value to which this model maps the specified key (which may be {@code null} itself), or also {@code null} if the model did not contain any mapping for that key prior to this call. Returning {@code null} is therefore an indicator that the given {@code value} has been associated with the key.
      */
     ValueWrapper putIfAbsent(Object key, Object value);
 
@@ -128,18 +124,29 @@ public interface Cache {
     /**
      * Wrapper exception to be thrown from {@link #get(Object, Callable)}
      * in case of the value loader callback failing with an exception.
-     *
      */
     @SuppressWarnings("serial")
     class ValueRetrievalException extends RuntimeException {
 
         private final Object key;
 
+        /**
+         * Instantiates a new Value retrieval exception.
+         *
+         * @param key    the key
+         * @param loader the loader
+         * @param ex     the ex
+         */
         public ValueRetrievalException(Object key, Callable<?> loader, Throwable ex) {
             super(String.format("Value for key '%s' could not be loaded using '%s'", key, loader), ex);
             this.key = key;
         }
 
+        /**
+         * Gets key.
+         *
+         * @return the key
+         */
         public Object getKey() {
             return this.key;
         }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/CacheManager.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/CacheManager.java
index 129cee1..9c7d60e 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/CacheManager.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/CacheManager.java
@@ -2,6 +2,9 @@ package br.ufrgs.inf.prosoft.adaptivecaching.cachemanager.model;
 
 import java.util.Collection;
 
+/**
+ * The interface Cache manager.
+ */
 public interface CacheManager {
 
     /**

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/AbstractValueAdaptingCache.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/AbstractValueAdaptingCache.java
index 5bc5652..1ed8edb 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/AbstractValueAdaptingCache.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/AbstractValueAdaptingCache.java
@@ -29,6 +29,8 @@ public abstract class AbstractValueAdaptingCache implements Cache {
 
     /**
      * Return whether {@code null} values are allowed in this model.
+     *
+     * @return the boolean
      */
     public final boolean isAllowNullValues() {
         return this.allowNullValues;

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/CompositeCacheManager.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/CompositeCacheManager.java
index 565f9f8..b368a4a 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/CompositeCacheManager.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/CompositeCacheManager.java
@@ -20,7 +20,6 @@ import java.util.*;
  * However, most {@link CacheManager} implementations fall back to lazy creation
  * of named caches once requested; check out the specific configuration details
  * for a 'static' mode with fixed model names, if available.
- *
  */
 public class CompositeCacheManager implements CacheManager {
 
@@ -48,6 +47,8 @@ public class CompositeCacheManager implements CacheManager {
 
     /**
      * Specify the CacheManagers to delegate to.
+     *
+     * @param cacheManagers the cache managers
      */
     public void setCacheManagers(Collection<CacheManager> cacheManagers) {
         this.cacheManagers.addAll(cacheManagers);
@@ -57,12 +58,17 @@ public class CompositeCacheManager implements CacheManager {
      * Indicate whether a {@link NoOpCacheManager} should be added at the end of the delegate list.
      * In this case, any {@code getCache} requests not handled by the configured CacheManagers will
      * be automatically handled by the {@link NoOpCacheManager} (and hence never return {@code null}).
+     *
+     * @param fallbackToNoOpCache the fallback to no op cache
      */
     public void setFallbackToNoOpCache(boolean fallbackToNoOpCache) {
         this.fallbackToNoOpCache = fallbackToNoOpCache;
     }
 
-    //@Override
+    /**
+     * After properties set.
+     */
+//@Override
     public void afterPropertiesSet() {
         if (this.fallbackToNoOpCache) {
             this.cacheManagers.add(new NoOpCacheManager());

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/NoOpCacheManager.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/NoOpCacheManager.java
index ffb34f9..712e195 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/NoOpCacheManager.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/NoOpCacheManager.java
@@ -19,7 +19,6 @@ import java.util.concurrent.ConcurrentMap;
  * without an actual backing store.
  * <p>
  * <p>Will simply accept any items into the model not actually storing them.
- *
  */
 public class NoOpCacheManager implements CacheManager {
 
@@ -60,6 +59,11 @@ public class NoOpCacheManager implements CacheManager {
 
         private final String name;
 
+        /**
+         * Instantiates a new No op cache.
+         *
+         * @param name the name
+         */
         public NoOpCache(String name) {
             this.name = name;
         }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/NullValue.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/NullValue.java
index c012f03..b3f4ef5 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/NullValue.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/NullValue.java
@@ -5,10 +5,12 @@ import java.io.Serializable;
 /**
  * Simple serializable class that serves as a {@code null} replacement
  * for model stores which otherwise do not support {@code null} values.
- *
  */
 public final class NullValue implements Serializable {
 
+    /**
+     * The Instance.
+     */
     static final Object INSTANCE = new NullValue();
 
     private static final long serialVersionUID = 1L;

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/SimpleCacheManager.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/SimpleCacheManager.java
index 2882bfc..07174ea 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/SimpleCacheManager.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/SimpleCacheManager.java
@@ -8,7 +8,6 @@ import java.util.Collection;
 /**
  * Simple model manager working against a given collection of caches.
  * Useful for testing or simple caching declarations.
- *
  */
 public class SimpleCacheManager extends AbstractCacheManager {
 
@@ -17,6 +16,8 @@ public class SimpleCacheManager extends AbstractCacheManager {
 
     /**
      * Specify the collection of Cache instances to use for this CacheManager.
+     *
+     * @param caches the caches
      */
     public void setCaches(Collection<? extends Cache> caches) {
         this.caches = caches;

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/SimpleValueWrapper.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/SimpleValueWrapper.java
index c1776c9..9c6fcc2 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/SimpleValueWrapper.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/support/SimpleValueWrapper.java
@@ -5,7 +5,6 @@ import br.ufrgs.inf.prosoft.adaptivecaching.cachemanager.model.ValueWrapper;
 /**
  * Straightforward implementation of {@link },
  * simply holding the value as given at construction and returning it from {@link #get()}.
- *
  */
 public class SimpleValueWrapper implements ValueWrapper {
 

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/ValueWrapper.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/ValueWrapper.java
index 85fc162..8a6659e 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/ValueWrapper.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/model/ValueWrapper.java
@@ -7,6 +7,8 @@ public interface ValueWrapper {
 
     /**
      * Return the actual value in the model.
+     *
+     * @return the object
      */
     Object get();
 }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/CacheManagerFactory.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/CacheManagerFactory.java
index a8009cd..a9e4e0f 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/CacheManagerFactory.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/CacheManagerFactory.java
@@ -15,9 +15,22 @@ import org.slf4j.LoggerFactory;
 import javax.management.MBeanServer;
 import java.lang.management.ManagementFactory;
 
+/**
+ * The type Cache manager factory.
+ */
 public class CacheManagerFactory {
+    /**
+     * The Logger.
+     */
     static Logger logger = LoggerFactory.getLogger(CacheManagerFactory.class);
 
+    /**
+     * Gets cache manager.
+     *
+     * @param cacheProviderType the cache provider type
+     * @param expiryInterval    the expiry interval
+     * @return the cache manager
+     */
     public static CacheManager getCacheManager(CacheProviderType cacheProviderType, long expiryInterval) {
         switch (cacheProviderType) {
             case GUAVA:

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/Mnemos.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/Mnemos.java
index 615bb7d..6a8c4c3 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/Mnemos.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/Mnemos.java
@@ -6,6 +6,9 @@ import org.aspectj.lang.reflect.MethodSignature;
 import java.lang.reflect.Method;
 import java.util.Arrays;
 
+/**
+ * The type Mnemos.
+ */
 @SuppressWarnings({"PMD.TooManyMethods", "PMD.AvoidUsingShortType"})
 public class Mnemos {
 

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/threads/NamedThreads.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/threads/NamedThreads.java
index ac28892..737cdeb 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/threads/NamedThreads.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/threads/NamedThreads.java
@@ -5,6 +5,9 @@ import org.slf4j.LoggerFactory;
 
 import java.util.concurrent.ThreadFactory;
 
+/**
+ * The type Named threads.
+ */
 public class NamedThreads implements ThreadFactory {
 
     /**
@@ -19,6 +22,9 @@ public class NamedThreads implements ThreadFactory {
      * Thread group to use.
      */
     private final transient ThreadGroup group;
+    /**
+     * The Logger.
+     */
     Logger logger = LoggerFactory.getLogger(NamedThreads.class);
 
     /**

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/threads/VerboseRunnable.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/threads/VerboseRunnable.java
index cd9261c..07850f1 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/threads/VerboseRunnable.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/cachemanager/util/threads/VerboseRunnable.java
@@ -6,6 +6,9 @@ import org.slf4j.LoggerFactory;
 import java.util.concurrent.Callable;
 import java.util.concurrent.TimeUnit;
 
+/**
+ * The type Verbose runnable.
+ */
 @SuppressWarnings("PMD.DoNotUseThreads")
 public final class VerboseRunnable implements Runnable {
 
@@ -21,6 +24,9 @@ public final class VerboseRunnable implements Runnable {
      * Shall we report a full stacktrace?
      */
     private final transient boolean verbose;
+    /**
+     * The Logger.
+     */
     Logger logger = LoggerFactory.getLogger(NamedThreads.class);
 
     /**
@@ -46,11 +52,7 @@ public final class VerboseRunnable implements Runnable {
      * Default constructor, doesn't swallow exceptions.
      *
      * @param callable Callable to wrap
-     * @param swallow  Shall we swallow exceptions
-     *                 ({@code TRUE}) or re-throw
-     *                 ({@code FALSE})? Exception swallowing means that {@link #run()}
-     *                 will never throw any exceptions (in any case all exceptions are logged
-     *                 using {@link Logger}.
+     * @param swallow  Shall we swallow exceptions                 ({@code TRUE}) or re-throw                 ({@code FALSE})? Exception swallowing means that {@link #run()}                 will never throw any exceptions (in any case all exceptions are logged                 using {@link Logger}.
      * @since 0.1.10
      */
     public VerboseRunnable(final Callable<?> callable, final boolean swallow) {
@@ -61,14 +63,8 @@ public final class VerboseRunnable implements Runnable {
      * Default constructor.
      *
      * @param callable Callable to wrap
-     * @param swallow  Shall we swallow exceptions
-     *                 ({@code TRUE}) or re-throw
-     *                 ({@code FALSE})? Exception swallowing means that {@link #run()}
-     *                 will never throw any exceptions (in any case all exceptions are logged
-     *                 using {@link Logger}.
-     * @param vrbs     Shall we report the entire
-     *                 stacktrace of the exception
-     *                 ({@code TRUE}) or just its message in one line ({@code FALSE})
+     * @param swallow  Shall we swallow exceptions                 ({@code TRUE}) or re-throw                 ({@code FALSE})? Exception swallowing means that {@link #run()}                 will never throw any exceptions (in any case all exceptions are logged                 using {@link Logger}.
+     * @param vrbs     Shall we report the entire                 stacktrace of the exception                 ({@code TRUE}) or just its message in one line ({@code FALSE})
      * @since 0.7.17
      */
     @SuppressWarnings("PMD.AvoidCatchingGenericException")
@@ -103,11 +99,7 @@ public final class VerboseRunnable implements Runnable {
      * Default constructor, with configurable behavior for exceptions.
      *
      * @param runnable Runnable to wrap
-     * @param swallow  Shall we swallow exceptions
-     *                 ({@code TRUE}) or re-throw
-     *                 ({@code FALSE})? Exception swallowing means that {@link #run()}
-     *                 will never throw any exceptions (in any case all exceptions are logged
-     *                 using {@link Logger}.
+     * @param swallow  Shall we swallow exceptions                 ({@code TRUE}) or re-throw                 ({@code FALSE})? Exception swallowing means that {@link #run()}                 will never throw any exceptions (in any case all exceptions are logged                 using {@link Logger}.
      * @since 0.1.4
      */
     public VerboseRunnable(final Runnable runnable, final boolean swallow) {
@@ -118,14 +110,8 @@ public final class VerboseRunnable implements Runnable {
      * Default constructor, with fully configurable behavior.
      *
      * @param runnable Runnable to wrap
-     * @param swallow  Shall we swallow exceptions
-     *                 ({@code TRUE}) or re-throw
-     *                 ({@code FALSE})? Exception swallowing means that {@link #run()}
-     *                 will never throw any exceptions (in any case all exceptions are logged
-     *                 using {@link Logger}.
-     * @param vrbs     Shall we report the entire
-     *                 stacktrace of the exception
-     *                 ({@code TRUE}) or just its message in one line ({@code FALSE})
+     * @param swallow  Shall we swallow exceptions                 ({@code TRUE}) or re-throw                 ({@code FALSE})? Exception swallowing means that {@link #run()}                 will never throw any exceptions (in any case all exceptions are logged                 using {@link Logger}.
+     * @param vrbs     Shall we report the entire                 stacktrace of the exception                 ({@code TRUE}) or just its message in one line ({@code FALSE})
      * @since 0.7.17
      */
     @SuppressWarnings("PMD.BooleanInversion")
@@ -204,6 +190,12 @@ public final class VerboseRunnable implements Runnable {
         return result;
     }
 
+    /**
+     * Can equal boolean.
+     *
+     * @param other the other
+     * @return the boolean
+     */
     protected boolean canEqual(Object other) {
         return other instanceof VerboseRunnable;
     }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/AdaptiveCaching.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/AdaptiveCaching.java
index c3a8704..8a1d1d2 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/AdaptiveCaching.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/AdaptiveCaching.java
@@ -7,46 +7,93 @@ import br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation.types.Trigg
 
 import java.lang.annotation.*;
 
+/**
+ * The interface Adaptive caching.
+ */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
 @Documented
 public @interface AdaptiveCaching {
 
-    //enabling configurations
-    boolean enabled() default true;
-    boolean tracerEnabled() default true;
-    boolean analyzerEnabled() default true;
-
-    RepositoryType logRepository() default RepositoryType.MONGODB;
-
+    /**
+     * Cache provider cache provider type.
+     *
+     * @return the cache provider type
+     */
     CacheProviderType cacheProvider() default CacheProviderType.GUAVA;
 
+    /**
+     * Modelling modelling.
+     *
+     * @return the modelling
+     */
     Modelling modelling() default Modelling.ACCUMULATION;
 
+    /**
+     * Expiry interval long.
+     *
+     * @return the long
+     */
     long expiryInterval() default 300000; //5 minutes
+
+    /**
+     * First expiry long.
+     *
+     * @return the long
+     */
     @Deprecated long firstExpiry() default 300000; //5 minutes
 
-    //todo when analysis based on trigger do not make sense to have this, its similar to trigger by time
+    /**
+     * Analysis interval long.
+     *
+     * @return the long
+     */
+//todo when analysis based on trigger do not make sense to have this, its similar to trigger by time
     @Deprecated long analysisInterval() default 1200000; //20 minutes
+
+    /**
+     * First analysis long.
+     *
+     * @return the long
+     */
     @Deprecated long firstAnalysis() default 240000; //4 minutes
 //    @Deprecated long firstAnalysis() default 60000; //1 minutes
 
+    /**
+     * Trigger type trigger type.
+     *
+     * @return the trigger type
+     */
     TriggerType triggerType() default TriggerType.TIME; //if were not by time, load the class that implements the interface @Trigger
 
+    /**
+     * Trigger time long.
+     *
+     * @return the long
+     */
     long triggerTime() default 300000; //5 minutes
 
-    //enables the analyzer to be executed just once
+    /**
+     * Analyze once boolean.
+     *
+     * @return the boolean
+     */
+//enables the analyzer to be executed just once
     boolean analyzeOnce() default false;
 
-    //disable the monitoring after the first analyses
+    /**
+     * Disable monitoring after analysis boolean.
+     *
+     * @return the boolean
+     */
+//disable the monitoring after the first analyses
     boolean disableMonitoringAfterAnalysis() default false;
 
     /**
+     * Trace async boolean.
+     *
+     * @return the boolean
      * @deprecated async use may consume too much memory and cause stack overflow
      */
     @Deprecated boolean traceAsync() default true;
-    boolean clearMonitoringDataOnStart() default false;
-
-    //when a method cannot be traced, any future calls can be blacklisted
-    boolean enableBlacklist() default false;
 }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/Cacheable.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/Cacheable.java
index 449a131..d27d049 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/Cacheable.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/Cacheable.java
@@ -2,16 +2,60 @@ package br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation;
 
 import java.lang.annotation.*;
 
+/**
+ * The interface Cacheable.
+ */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
 @Documented
 //TODO parser such annotation on flowchart caching decision
 public @interface Cacheable {
+    /**
+     * Value boolean.
+     *
+     * @return the boolean
+     */
     boolean value();
+
+    /**
+     * Statical boolean.
+     *
+     * @return the boolean
+     */
     boolean statical() default false;
+
+    /**
+     * Less changing boolean.
+     *
+     * @return the boolean
+     */
     boolean lessChanging() default false;
+
+    /**
+     * Frequent boolean.
+     *
+     * @return the boolean
+     */
     boolean frequent() default false;
+
+    /**
+     * Shareable boolean.
+     *
+     * @return the boolean
+     */
     boolean shareable() default false;
+
+    /**
+     * Expensive boolean.
+     *
+     * @return the boolean
+     */
     boolean expensive() default false;
+
+    /**
+     * Large boolean.
+     *
+     * @return the boolean
+     */
     boolean large() default false;
 }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/ComponentScan.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/ComponentScan.java
index eeaf821..29b1427 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/ComponentScan.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/ComponentScan.java
@@ -2,6 +2,9 @@ package br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation;
 
 import java.lang.annotation.*;
 
+/**
+ * The interface Component scan.
+ */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
 @Documented
@@ -9,8 +12,15 @@ public @interface ComponentScan {
 
     /**
      * Base packages to scan for annotated components.
+     *
+     * @return the string pattern
      */
-    String[] allowed();
+    String allowed();
 
-    String[] denied() default {};
+    /**
+     * Denied string pattern.
+     *
+     * @return the string pattern
+     */
+    String denied();
 }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/CacheProviderType.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/CacheProviderType.java
index 5376181..bc27f69 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/CacheProviderType.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/CacheProviderType.java
@@ -1,9 +1,27 @@
 package br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation.types;
 
+/**
+ * The enum Cache provider type.
+ */
 public enum CacheProviderType {
+    /**
+     * Memcached cache provider type.
+     */
     MEMCACHED,
+    /**
+     * Redis cache provider type.
+     */
     REDIS,
+    /**
+     * Ehcache cache provider type.
+     */
     EHCACHE,
+    /**
+     * Guava cache provider type.
+     */
     GUAVA,
+    /**
+     * Caffeine cache provider type.
+     */
     CAFFEINE;
 }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/Modelling.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/Modelling.java
index b3bcbbb..7d73aed 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/Modelling.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/Modelling.java
@@ -1,15 +1,27 @@
 package br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation.types;
 
+/**
+ * The enum Modelling.
+ */
 //TODO implement this
 public enum Modelling {
 
-    //erase all previous data
+    /**
+     * The Fullexploration.
+     */
+//erase all previous data
     FULLEXPLORATION,
 
-    //do not erase anything
+    /**
+     * The Accumulation.
+     */
+//do not erase anything
     ACCUMULATION,
 
-    //erase only the oldest % of previous data
+    /**
+     * The Partialexploration.
+     */
+//erase only the oldest % of previous data
     PARTIALEXPLORATION;
 
 }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/RepositoryType.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/RepositoryType.java
index f2f4033..46146d7 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/RepositoryType.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/RepositoryType.java
@@ -1,9 +1,27 @@
 package br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation.types;
 
+/**
+ * The enum Repository type.
+ */
 public enum RepositoryType {
+    /**
+     * Mongodb repository type.
+     */
     MONGODB,
+    /**
+     * Textfile repository type.
+     */
     TEXTFILE,
+    /**
+     * The Memory.
+     */
     @Deprecated MEMORY,
+    /**
+     * The Console.
+     */
     @Deprecated CONSOLE,
+    /**
+     * Redis repository type.
+     */
     REDIS;
 }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/TriggerType.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/TriggerType.java
index ddb5287..da38dbb 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/TriggerType.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/types/TriggerType.java
@@ -1,6 +1,15 @@
 package br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation.types;
 
+/**
+ * The enum Trigger type.
+ */
 public enum TriggerType {
+    /**
+     * Time trigger type.
+     */
     TIME,
+    /**
+     * Customized trigger type.
+     */
     CUSTOMIZED;
 }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/Uncacheable.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/Uncacheable.java
index f0d901d..c856d37 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/Uncacheable.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/annotation/Uncacheable.java
@@ -2,6 +2,9 @@ package br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation;
 
 import java.lang.annotation.*;
 
+/**
+ * The interface Uncacheable.
+ */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
 @Documented

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/interfaces/Trigger.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/interfaces/Trigger.java
index 256e95a..654bb5f 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/interfaces/Trigger.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/configuration/interfaces/Trigger.java
@@ -1,5 +1,8 @@
 package br.ufrgs.inf.prosoft.adaptivecaching.configuration.interfaces;
 
+/**
+ * The interface Trigger.
+ */
 //TODO
 public interface Trigger {
 }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/exceptions/CacheProviderException.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/exceptions/CacheProviderException.java
index b71b48a..5851ef7 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/exceptions/CacheProviderException.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/exceptions/CacheProviderException.java
@@ -1,15 +1,34 @@
 package br.ufrgs.inf.prosoft.adaptivecaching.exceptions;
 
+/**
+ * The type Cache provider exception.
+ */
 public class CacheProviderException extends RuntimeException {
 
+    /**
+     * Instantiates a new Cache provider exception.
+     *
+     * @param message the message
+     * @param cause   the cause
+     */
     public CacheProviderException(String message, Throwable cause) {
         super(message, cause);
     }
 
+    /**
+     * Instantiates a new Cache provider exception.
+     *
+     * @param cause the cause
+     */
     public CacheProviderException(Throwable cause) {
         super(cause);
     }
 
+    /**
+     * Instantiates a new Cache provider exception.
+     *
+     * @param message the message
+     */
     public CacheProviderException(String message) {
         super(message);
     }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/exceptions/ConfigurationException.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/exceptions/ConfigurationException.java
index dfb73b0..3b36dd5 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/exceptions/ConfigurationException.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/exceptions/ConfigurationException.java
@@ -1,15 +1,34 @@
 package br.ufrgs.inf.prosoft.adaptivecaching.exceptions;
 
+/**
+ * The type Configuration exception.
+ */
 public class ConfigurationException extends RuntimeException {
 
+    /**
+     * Instantiates a new Configuration exception.
+     *
+     * @param message the message
+     * @param cause   the cause
+     */
     public ConfigurationException(String message, Throwable cause) {
         super(message, cause);
     }
 
+    /**
+     * Instantiates a new Configuration exception.
+     *
+     * @param cause the cause
+     */
     public ConfigurationException(Throwable cause) {
         super(cause);
     }
 
+    /**
+     * Instantiates a new Configuration exception.
+     *
+     * @param message the message
+     */
     public ConfigurationException(String message) {
         super(message);
     }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/exceptions/StorageException.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/exceptions/StorageException.java
index 3efdec5..76de647 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/exceptions/StorageException.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/adaptivecaching/exceptions/StorageException.java
@@ -1,15 +1,34 @@
 package br.ufrgs.inf.prosoft.adaptivecaching.exceptions;
 
+/**
+ * The type Storage exception.
+ */
 public class StorageException extends RuntimeException {
 
+    /**
+     * Instantiates a new Storage exception.
+     *
+     * @param message the message
+     * @param cause   the cause
+     */
     public StorageException(String message, Throwable cause) {
         super(message, cause);
     }
 
+    /**
+     * Instantiates a new Storage exception.
+     *
+     * @param cause the cause
+     */
     public StorageException(Throwable cause) {
         super(cause);
     }
 
+    /**
+     * Instantiates a new Storage exception.
+     *
+     * @param message the message
+     */
     public StorageException(String message) {
         super(message);
     }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/annotations/TigrisConfiguration.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/annotations/TigrisConfiguration.java
index d77bd88..a00e74a 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/annotations/TigrisConfiguration.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/annotations/TigrisConfiguration.java
@@ -1,24 +1,52 @@
 package br.ufrgs.inf.prosoft.tigrisframework.annotations;
 
-import br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation.types.CacheProviderType;
-import br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation.types.Modelling;
 import br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation.types.RepositoryType;
-import br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation.types.TriggerType;
 
 import java.lang.annotation.*;
 
+/**
+ * The interface Tigris configuration.
+ */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
 @Documented
 public @interface TigrisConfiguration {
 
-    //enabling configurations
-    boolean enabled() default true;
-    boolean coarseMonitoringEnabled() default true;
-    boolean fineMonitoringEnabled() default true;
-    boolean samplingEnabled() default true;
-    int samplingPercentage() default 50;
-
+    /**
+     * Static metric file string.
+     *
+     * @return the string
+     */
     String staticMetricFile();
 
+
+    /**
+     * Log repository repository type.
+     *
+     * @return the repository type
+     */
+    RepositoryType logRepository() default RepositoryType.MONGODB;
+
+    /**
+     * Clear monitoring data on start boolean.
+     *
+     * @return the boolean
+     */
+    boolean clearMonitoringDataOnStart() default false;
+
+    /**
+     * Criteria in form of SET operations over the criteria.
+     * <p>
+     * Operations allowed: union (U), intersection (I), difference (D), complement (C)
+     * Verbs: frequent, expensive, changeable, errorprone, globalimpact
+     * Additional: more, less
+     * <p>
+     * Examples:
+     * more frequent U more expensive C less changeable
+     * less frequent C less expensive
+     *
+     * @return the string
+     */
+    String criteria();
+
 }

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/metrics/DataFiltering.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/metrics/DataFiltering.java
index ae37e2c..59cefc7 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/metrics/DataFiltering.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/metrics/DataFiltering.java
@@ -1,23 +1,152 @@
 package br.ufrgs.inf.prosoft.tigrisframework.metrics;
 
-import br.ufrgs.inf.prosoft.tigrisframework.statistics.StatisticalTest;
+import br.ufrgs.inf.prosoft.utils.StatisticalTest;
 import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;
 
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.util.Map;
+
+/**
+ * The type Data filtering.
+ */
 public class DataFiltering {
 
-    public static boolean isGroup(String group, DescriptiveStatistics criteria, double value){
+    private final StaticMetrics staticMetrics;
+    private final Map<String, LightweightMetrics> metrics;
+
+    public DataFiltering(StaticMetrics staticMetrics, Map<String, LightweightMetrics> metrics) {
+        this.staticMetrics = staticMetrics;
+        this.metrics = metrics;
+    }
+
+    public boolean extendedFilter(LightweightMetrics methodMetrics) {
+        DescriptiveStatistics frequencies = new DescriptiveStatistics();
+        DescriptiveStatistics changeabilities = new DescriptiveStatistics();
+        DescriptiveStatistics errorprones = new DescriptiveStatistics();
+        DescriptiveStatistics latencies = new DescriptiveStatistics();
+        DescriptiveStatistics maintainabilities = new DescriptiveStatistics();
+        DescriptiveStatistics userBehaviors = new DescriptiveStatistics();
+        DescriptiveStatistics concurrencies = new DescriptiveStatistics();
+        DescriptiveStatistics expensiveness = new DescriptiveStatistics();
+        DescriptiveStatistics globalimpacts = new DescriptiveStatistics();
+        System.out.println("---------------------------");
+        for (String method : metrics.keySet()) {
+            System.out.println(method);
+            LightweightMetrics sc = metrics.get(method);
+            StaticMetrics.StaticMetric staticMetric = staticMetrics.getMetrics(sc.getName());
+            if (staticMetric == null)
+                continue;
+            frequencies.addValue(sc.getFrequency());
+            changeabilities.addValue(sc.getChangeability());
+            errorprones.addValue(staticMetric.maxNesting);
+            latencies.addValue(sc.getLatency());
+            maintainabilities.addValue(staticMetric.cyclomatic);
+            userBehaviors.addValue(sc.getUserBehavior());
+            concurrencies.addValue(sc.getConcurrency());
+            expensiveness.addValue(sc.getExpensiveness());
+            globalimpacts.addValue(staticMetric.countOutput);
+        }
+
+        System.out.println("---------------------------");
+        System.out.println("Metric: frequency; Distribution: " +
+                ((StatisticalTest.isNormalDistribution(frequencies.getValues(), 0.05)) ? "normal" : "not_normal"));
+        System.out.println("Metric: maintainability; Distribution: " +
+                ((StatisticalTest.isNormalDistribution(maintainabilities.getValues(), 0.05)) ? "normal" : "not_normal"));
+        System.out.println("Metric: changeability; Distribution: " +
+                ((StatisticalTest.isNormalDistribution(changeabilities.getValues(), 0.05)) ? "normal" : "not_normal"));
+        System.out.println("Metric: userBehavior; Distribution: " +
+                ((StatisticalTest.isNormalDistribution(userBehaviors.getValues(), 0.05)) ? "normal" : "not_normal"));
+        System.out.println("Metric: concurrency; Distribution: " +
+                ((StatisticalTest.isNormalDistribution(concurrencies.getValues(), 0.05)) ? "normal" : "not_normal"));
+        System.out.println("Metric: errorprone; Distribution: " +
+                ((StatisticalTest.isNormalDistribution(errorprones.getValues(), 0.05)) ? "normal" : "not_normal"));
+        System.out.println("Metric: expensiveness; Distribution: " +
+                ((StatisticalTest.isNormalDistribution(expensiveness.getValues(), 0.05)) ? "normal" : "not_normal"));
+        System.out.println("Metric: globalimpact; Distribution: " +
+                ((StatisticalTest.isNormalDistribution(globalimpacts.getValues(), 0.05)) ? "normal" : "not_normal"));
+        System.out.println("Metric: latency; Distribution: " +
+                ((StatisticalTest.isNormalDistribution(latencies.getValues(), 0.05)) ? "normal" : "not_normal"));
+
+        try {
+            final PrintWriter pw = new PrintWriter(new File("lightweightanalysis.csv"));
+            pw.write("method,frequency,maintainability,changeability,userBehavior,concurrency,errorprone,expensiveness,globalimpact,latency,vfrequency,vmaintainability,vchangeability,vuserBehavior,vconcurrency,verrorprone,vexpensiveness,vglobalimpact,vlatency\n");
+            for (String name : metrics.keySet()) {
+                LightweightMetrics lm = metrics.get(name);
+                StaticMetrics.StaticMetric staticMetric = staticMetrics.getMetrics(lm.getName());
+                if (staticMetric == null)
+                    continue;
+                pw.write(metrics.get(name).getName() + "," +
+                        DataFiltering.getGroup(frequencies, metrics.get(name).getFrequency()) +
+                        "," + DataFiltering.getGroup(maintainabilities, staticMetric.cyclomatic) +
+                        "," + DataFiltering.getGroup(changeabilities, lm.getChangeability()) +
+                        "," + DataFiltering.getGroup(userBehaviors, lm.getUserBehavior()) +
+                        "," + DataFiltering.getGroup(concurrencies, lm.getConcurrency()) +
+                        "," + DataFiltering.getGroup(errorprones, staticMetric.maxNesting) +
+                        "," + DataFiltering.getGroup(expensiveness, lm.getExpensiveness()) +
+                        "," + DataFiltering.getGroup(globalimpacts, staticMetric.countOutput) +
+                        "," + DataFiltering.getGroup(latencies, metrics.get(name).getLatency()) +
+                        "," +
+                        DataFiltering.allMetricsToString(lm, staticMetrics) + '\n');
+            }
+            pw.close();
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        return
+                //extended filter: less changeable C more frequent C (more user_behavior U (less user_behavior C more expensive))
+                ((DataFiltering.isGroup("less", changeabilities, methodMetrics.getChangeability())
+                        || DataFiltering.isGroup("normal", changeabilities, methodMetrics.getChangeability()))
+                        && (DataFiltering.isGroup("more", frequencies, methodMetrics.getFrequency())
+                        || DataFiltering.isGroup("normal", frequencies, methodMetrics.getFrequency()))
+                        && ((DataFiltering.isGroup("more", userBehaviors, methodMetrics.getUserBehavior())
+                        || DataFiltering.isGroup("normal", userBehaviors, methodMetrics.getUserBehavior()))
+                        || ((DataFiltering.isGroup("less", userBehaviors, methodMetrics.getUserBehavior())
+                        || DataFiltering.isGroup("normal", userBehaviors, methodMetrics.getUserBehavior()))
+                        && (DataFiltering.isGroup("normal", expensiveness, methodMetrics.getExpensiveness())
+                        || DataFiltering.isGroup("more", expensiveness, methodMetrics.getExpensiveness())))));
+
+        //restricted filter: less changeable C more frequent C (more user_behavior U (less user_behavior C more expensive))
+//            (DataFiltering.isGroup("less", changeabilities, sc.getChangeability())
+//                && DataFiltering.isGroup("more", frequencies, sc.getFrequency())
+//                && (DataFiltering.isGroup("more", userBehaviors, sc.getUserBehavior())
+//                    || (DataFiltering.isGroup("less", userBehaviors, sc.getUserBehavior())
+//                        && DataFiltering.isGroup("more", expensiveness, sc.getExpensiveness()))))
+
+//            if (DataFiltering.isGroup("least", changeabilities, sc.getChangeability())
+//                && DataFiltering.isGroup("most", frequencies, sc.getFrequency())
+//                && (DataFiltering.isGroup("most", userBehaviors, sc.getUserBehavior())
+//                    || (DataFiltering.isGroup("least", userBehaviors, sc.getUserBehavior())
+//                        && DataFiltering.isGroup("most", expensiveness, sc.getExpensiveness()))))
+
+//            if (DataFiltering.isGroup("less", changeabilities, sc.getChangeability())
+//                    && DataFiltering.isGroup("most", frequencies, sc.getFrequency())
+//                    && DataFiltering.isGroup("most", expensiveness, sc.getExpensiveness()))
+    }
+
+    /**
+     * Is group boolean.
+     *
+     * @param group    the group
+     * @param criteria the criteria
+     * @param value    the value
+     * @return the boolean
+     */
+    public static boolean isGroup(String group, DescriptiveStatistics criteria, double value) {
 
         boolean isNormal = StatisticalTest.isNormalDistribution(criteria.getValues(), 0.05);
         DescriptiveStatistics half = new DescriptiveStatistics();
-        if(!isNormal && (group.equals("most") || group.equals("least"))) {
-            for(double val : criteria.getValues())
-                if(group.equals("most") && val >= criteria.getPercentile(75))
+        if (!isNormal && (group.equals("most") || group.equals("least"))) {
+            for (double val : criteria.getValues())
+                if (group.equals("most") && val >= criteria.getPercentile(75))
                     half.addValue(val);
-                else if(group.equals("least") && val <= criteria.getPercentile(25))
+                else if (group.equals("least") && val <= criteria.getPercentile(25))
                     half.addValue(val);
         }
 
-        switch (group){
+        switch (group) {
             case "normal":
                 if (isNormal)
                     return (value > (criteria.getMean() - criteria.getStandardDeviation()) &&
@@ -27,12 +156,12 @@ public class DataFiltering {
                             value < criteria.getPercentile(75));
             case "most":
                 if (isNormal)
-                    return value >= (criteria.getMean() + (2*criteria.getStandardDeviation()));
+                    return value >= (criteria.getMean() + (2 * criteria.getStandardDeviation()));
                 else
                     return value >= half.getPercentile(50);
             case "least":
                 if (isNormal)
-                    return value <= (criteria.getMean() + (2*criteria.getStandardDeviation()));
+                    return value <= (criteria.getMean() + (2 * criteria.getStandardDeviation()));
                 else
                     return value <= half.getPercentile(50);
             case "more":
@@ -50,48 +179,62 @@ public class DataFiltering {
         throw new RuntimeException("Não foi possível classificar...");
     }
 
-    public static String getGroup(DescriptiveStatistics criteria, double value){
+    /**
+     * Get group string.
+     *
+     * @param criteria the criteria
+     * @param value    the value
+     * @return the string
+     */
+    public static String getGroup(DescriptiveStatistics criteria, double value) {
 
         boolean isNormal = StatisticalTest.isNormalDistribution(criteria.getValues(), 0.05);
         DescriptiveStatistics upperHalf = new DescriptiveStatistics();
         DescriptiveStatistics lowerHalf = new DescriptiveStatistics();
-        if(!isNormal) {
-            for(double val : criteria.getValues())
-                if(val >= criteria.getPercentile(75))
+        if (!isNormal) {
+            for (double val : criteria.getValues())
+                if (val >= criteria.getPercentile(75))
                     upperHalf.addValue(val);
-                else if(val <= criteria.getPercentile(25))
+                else if (val <= criteria.getPercentile(25))
                     lowerHalf.addValue(val);
         }
 
-        if (isNormal){
-            if(value > (criteria.getMean() - criteria.getStandardDeviation()) &&
+        if (isNormal) {
+            if (value > (criteria.getMean() - criteria.getStandardDeviation()) &&
                     value < (criteria.getMean() + criteria.getStandardDeviation()))
                 return "normal";
-            else if(value >= (criteria.getMean() + (2*criteria.getStandardDeviation())))
+            else if (value >= (criteria.getMean() + (2 * criteria.getStandardDeviation())))
                 return "most";
-            else if(value <= (criteria.getMean() + (2*criteria.getStandardDeviation())))
+            else if (value <= (criteria.getMean() + (2 * criteria.getStandardDeviation())))
                 return "least";
-            else if(value >= (criteria.getMean() + criteria.getStandardDeviation()))
+            else if (value >= (criteria.getMean() + criteria.getStandardDeviation()))
                 return "more";
-            else if(value <= (criteria.getMean() - criteria.getStandardDeviation()))
+            else if (value <= (criteria.getMean() - criteria.getStandardDeviation()))
                 return "less";
         } else {
-            if(value > criteria.getPercentile(25) &&
+            if (value > criteria.getPercentile(25) &&
                     value < criteria.getPercentile(75))
                 return "normal";
-            else if(value >= upperHalf.getPercentile(50))
+            else if (value >= upperHalf.getPercentile(50))
                 return "most";
-            else if(value <= lowerHalf.getPercentile(50))
+            else if (value <= lowerHalf.getPercentile(50))
                 return "least";
-            else if(value >= criteria.getPercentile(75))
+            else if (value >= criteria.getPercentile(75))
                 return "more";
-            else if(value <= criteria.getPercentile(25))
+            else if (value <= criteria.getPercentile(25))
                 return "less";
         }
 
         throw new RuntimeException("Não foi possível classificar...");
     }
 
+    /**
+     * All metrics to string string.
+     *
+     * @param lightweightMetrics the lightweight metrics
+     * @param staticMetrics      the static metrics
+     * @return the string
+     */
     public static String allMetricsToString(LightweightMetrics lightweightMetrics, StaticMetrics staticMetrics) {
         //frequency,maintainability,changeability,userBehavior,concurrency,errorprone,expensiveness,globalimpact,latency
         return lightweightMetrics.getFrequency() +

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/metrics/LightweightMetrics.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/metrics/LightweightMetrics.java
index 1d1ecca..7c63da2 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/metrics/LightweightMetrics.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/metrics/LightweightMetrics.java
@@ -9,6 +9,9 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
+/**
+ * The type Lightweight metrics.
+ */
 public class LightweightMetrics {
 
     private static SizeOf sizeOf = SizeOf.newInstance();
@@ -23,6 +26,13 @@ public class LightweightMetrics {
     private String name;
     private String longName;
 
+    /**
+     * Instantiates a new Lightweight metrics.
+     *
+     * @param name     the name
+     * @param longName the long name
+     * @throws IOException the io exception
+     */
     public LightweightMetrics(String name, String longName) throws IOException {
         this.name = name;
         this.longName = longName;
@@ -36,6 +46,12 @@ public class LightweightMetrics {
         users = new HashSet<>();
     }
 
+    /**
+     * Add time.
+     *
+     * @param startTime the start time
+     * @param time      the time
+     */
     public void addTime(long startTime, long time){
         startTimes.add(startTime);
         timeStatistics.addValue(time);
@@ -51,6 +67,11 @@ public class LightweightMetrics {
 //        memoryStatistics.addValue(memory);
 //    }
 
+    /**
+     * Add return size.
+     *
+     * @param returnObject the return object
+     */
     public void addReturnSize(Object returnObject){
         if(returnObject != null)
             returnSizeStatistics.addValue(sizeOf.sizeOf(returnObject));
@@ -62,14 +83,27 @@ public class LightweightMetrics {
 //        thrownCounter++;
 //    }
 
+    /**
+     * Inc occurrence.
+     */
     public void incOccurrence() {
         occurrences++;
     }
 
+    /**
+     * Add user.
+     *
+     * @param currentUser the current user
+     */
     public void addUser(String currentUser) {
         users.add(currentUser);
     }
 
+    /**
+     * Inter intervals list.
+     *
+     * @return the list
+     */
     public List<Long> interIntervals(){
         List<Long> intervalTimes = new ArrayList<>();
         long lastTime = startTimes.get(0);
@@ -80,10 +114,20 @@ public class LightweightMetrics {
         return intervalTimes;
     }
 
+    /**
+     * Gets name.
+     *
+     * @return the name
+     */
     public String getName() {
         return name;
     }
 
+    /**
+     * Gets long name.
+     *
+     * @return the long name
+     */
     public String getLongName() {
         return longName;
     }
@@ -101,6 +145,7 @@ public class LightweightMetrics {
 
     /**
      * Number of occurrences (calls)
+     *
      * @return number of occurrences
      */
     public long getFrequency() {
@@ -117,6 +162,7 @@ public class LightweightMetrics {
 
     /**
      * std classSize of the return
+     *
      * @return class size
      */
     public double getChangeability(){
@@ -125,6 +171,7 @@ public class LightweightMetrics {
 
     /**
      * Mean number of different users that triggered the method
+     *
      * @return number of different users
      */
     public long getUserBehavior(){
@@ -133,6 +180,7 @@ public class LightweightMetrics {
 
     /**
      * Mean Interval inter-calls
+     *
      * @return inter interval times
      */
     public double getConcurrency(){
@@ -149,6 +197,7 @@ public class LightweightMetrics {
 
     /**
      * Mean processing time
+     *
      * @return processing times
      */
     public double getExpensiveness(){
@@ -166,7 +215,8 @@ public class LightweightMetrics {
 
     /**
      * Throughput
-     * @return Throughput
+     *
+     * @return Throughput double
      */
     public double getLatency(){
         return (startTimes.get(startTimes.size()-1) - startTimes.get(0)) / startTimes.size();

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/metrics/StaticMetrics.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/metrics/StaticMetrics.java
index fa0cb60..3944d33 100644
--- a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/metrics/StaticMetrics.java
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/metrics/StaticMetrics.java
@@ -7,18 +7,39 @@ import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 
+/**
+ * The type Static metrics.
+ */
 public class StaticMetrics {
 
     private Map<String, StaticMetric> metrics;
 
+    /**
+     * Instantiates a new Static metrics.
+     *
+     * @param filename the filename
+     * @throws IOException the io exception
+     */
     public StaticMetrics(String filename) throws IOException {
         loadMetrics(filename);
     }
 
+    /**
+     * Get metrics static metric.
+     *
+     * @param method the method
+     * @return the static metric
+     */
     public StaticMetric getMetrics(String method){
         return metrics.get(method);
     }
 
+    /**
+     * Load metrics.
+     *
+     * @param filename the filename
+     * @throws IOException the io exception
+     */
     public void loadMetrics(String filename) throws IOException {
         BufferedReader br = new BufferedReader(new FileReader(filename));
         String line = null;
@@ -31,15 +52,39 @@ public class StaticMetrics {
         }
     }
 
+    /**
+     * Gets all metrics.
+     *
+     * @return the all metrics
+     */
     public Map<String, StaticMetric> getAllMetrics() {
         return metrics;
     }
 
-    class StaticMetric {
+    /**
+     * The type Static metric.
+     */
+    public class StaticMetric {
+        /**
+         * The Count output.
+         */
         public long countOutput;
+        /**
+         * The Cyclomatic.
+         */
         public long cyclomatic;
+        /**
+         * The Max nesting.
+         */
         public long maxNesting;
 
+        /**
+         * Instantiates a new Static metric.
+         *
+         * @param countOutput the count output
+         * @param cyclomatic  the cyclomatic
+         * @param maxNesting  the max nesting
+         */
         public StaticMetric(long countOutput, long cyclomatic, long maxNesting) {
             this.countOutput = countOutput;
             this.cyclomatic = cyclomatic;

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/aspects/AdaptiveCachingCoordinator.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/aspects/AdaptiveCachingCoordinator.java
new file mode 100644
index 0000000..71d8067
--- /dev/null
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/aspects/AdaptiveCachingCoordinator.java
@@ -0,0 +1,164 @@
+package br.ufrgs.inf.prosoft.tigrisframework.monitoring.aspects;
+
+import br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.FlowchartWorkFlow;
+import br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.model.MethodEntry;
+import br.ufrgs.inf.prosoft.adaptivecaching.cache.CacheMonitor;
+import br.ufrgs.inf.prosoft.adaptivecaching.cache.CacheMonitorFactory;
+import br.ufrgs.inf.prosoft.adaptivecaching.cachemanager.cacher.AdaptiveMethodCacher;
+import br.ufrgs.inf.prosoft.adaptivecaching.cachemanager.cacher.key.Key;
+import br.ufrgs.inf.prosoft.adaptivecaching.cachemanager.util.threads.NamedThreads;
+import br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation.AdaptiveCaching;
+import br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation.types.Modelling;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.metadata.LogTrace;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.storage.Repository;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.usersession.UserGetter;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.usersession.UserGetterFactory;
+import br.ufrgs.inf.prosoft.utils.ConfigurationUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.ConcurrentSkipListSet;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+public class AdaptiveCachingCoordinator implements Runnable{
+
+    //used in case the method info is required
+    private Set<MethodEntry> cacheableMethods = new ConcurrentSkipListSet<>();
+    //used in case the method info is not required
+    private Set<Object> cacheableMethodKeys = new ConcurrentSkipListSet<>();
+
+    private boolean enabled = true;
+
+    private final ScheduledExecutorService analyzerExecutor = Executors.newSingleThreadScheduledExecutor(new NamedThreads(
+            "adaptivecaching-analyzer",
+            "identifying cacheable methods"
+    ));
+
+    Logger logger = LoggerFactory.getLogger(AdaptiveCachingCoordinator.class);
+
+    private AdaptiveMethodCacher cacher;
+    private CacheMonitor cacheMonitor;
+
+    //adaptive caching configurations
+    private AdaptiveCaching cachingConfig;
+    private Properties properties;
+    private UserGetter userGetter;
+    private Repository repository;
+
+    public AdaptiveCachingCoordinator(Repository repository, AdaptiveCaching cachingConfig) throws IOException {
+        this.repository = repository;
+        this.cachingConfig = cachingConfig;
+
+        //todo load uncacheable annotation and methods and add to the blacklist
+        //todo load cacheable annotation and methods and add to the must-cache list
+
+        //setting up the repository
+        properties = getPropertiesFile();
+        if (properties == null || properties.isEmpty()) {
+            logger.error("adaptivecaching.properties is not defined, adaptive caching disabled.");
+            enabled = false;
+        } else
+            logger.info("adaptivecaching.properties found, loading properties...");
+
+        //TODO switch and build: pass a parameter and build
+        userGetter = UserGetterFactory.getInstance();
+
+        this.cacher = new AdaptiveMethodCacher(cachingConfig.cacheProvider(), cachingConfig.expiryInterval());
+        this.cacheMonitor = CacheMonitorFactory.getCacheMonitor(this.cacher.getCache(), cachingConfig.cacheProvider());
+
+        //TODO load another options from @AdaptiveCaching
+        //TODO get time from properties or see the external process
+        //TODO trigger by time
+        analyzerExecutor.scheduleWithFixedDelay(
+                this::run,
+                cachingConfig.firstAnalysis(), cachingConfig.analysisInterval(), TimeUnit.MILLISECONDS);
+    }
+
+    public boolean isCacheable(Key key){
+        return cacheableMethodKeys.contains(key);
+    }
+
+    private Properties getPropertiesFile() throws IOException {
+        Properties properties = new Properties();
+        properties.load(getClass().getClassLoader().getResourceAsStream("adaptivecaching.properties"));
+        return properties;
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void turnoff() {
+        enabled = false;
+    }
+
+    public Object getFromCache(Key key) throws Throwable {
+        return this.cacher.getFromCache(key);
+    }
+
+    public void putInCache(Key key, Object value) throws Throwable {
+        this.cacher.putInCache(key, value);
+    }
+
+    @Override
+    public void run() {
+
+        if(!enabled) {
+            logger.info("Analyzer disabled, waiting until next run to check again...");
+            return;
+        }
+
+        List all = repository.findAll();
+
+        Set<MethodEntry> process = analyzeAndReturn(all);
+
+        //todo maybe clean the cache here?
+        cacheableMethods = process;
+        cacheableMethodKeys = process.stream().parallel().map(MethodEntry::getMethodInfoKey).collect(Collectors.toSet());
+
+        String methods = "";
+        for (MethodEntry me : process) methods = methods.concat(me.getMethodInfo().getSignature() + ",");
+
+        //TODO maybe after the analysis end, new data would be already registered, which should not be deleted
+        if (cachingConfig.modelling().equals(Modelling.FULLEXPLORATION)) {
+            repository.removeAll();
+            logger.info("Old monitoring data deleted.");
+        }
+
+        if (cachingConfig.analyzeOnce())
+            enabled = false;
+
+        logger.info("Start caching...");
+    }
+
+    /**
+     * Analyze and return set.
+     *
+     * @param logList the log list
+     * @return the set
+     */
+    private Set<MethodEntry> analyzeAndReturn(List<LogTrace> logList) {
+        logger.info("Starting the analysis of cacheable methods from logs: " + logList.size() + " loaded.");
+
+        FlowchartWorkFlow workflow = new FlowchartWorkFlow(cacheMonitor.getCacheInfo(), logList);
+        Set<MethodEntry> process = workflow.filterCacheableMethods(cachingConfig.expiryInterval());
+        logger.info(process.size() + " cacheable methods identified.");
+
+        //TODO find by annotations @Ignore and remove the methods marked
+
+        //if disable monitoring, should not schedule future analysis
+        if (cachingConfig.disableMonitoringAfterAnalysis()) {
+            enabled = false;
+            logger.info("Adaptive caching monitoring disabled since the model was built.");
+        }
+
+        return process;
+    }
+}
\ No newline at end of file

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/aspects/MonitorAspect.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/aspects/MonitorAspect.java
new file mode 100644
index 0000000..4d4c782
--- /dev/null
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/aspects/MonitorAspect.java
@@ -0,0 +1,39 @@
+package br.ufrgs.inf.prosoft.tigrisframework.monitoring.aspects;
+
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+
+import java.io.IOException;
+
+@Aspect
+public class MonitorAspect {
+
+    @Pointcut(
+            //any execution except the own framework
+            "(execution(!void *(..)) && !within(br.ufrgs.inf.prosoft..*) " +
+                    //avoid calls from repository while serializing objects, it is necessary if a hash could not be used
+                    "&& !cflow(call(* br.ufrgs.inf.prosoft.tigrisframework.monitoring.storage..*(..))) " +
+                    //conditional to enable and disable at runtime
+                    "&& if())"
+    )
+    public static boolean anyCall() {
+        return TigrisCoordinator.isEnabled();
+    }
+
+    private TigrisCoordinator tigrisCoordinator;
+
+    public MonitorAspect() throws IOException {
+        tigrisCoordinator = new TigrisCoordinator();
+    }
+
+    @Around("anyCall()")
+    public Object aroundMethods(ProceedingJoinPoint joinPoint) throws Throwable {
+        if (tigrisCoordinator.isAllowed(joinPoint)) {
+            return tigrisCoordinator.process(joinPoint);
+        } else {
+            return joinPoint.proceed();
+        }
+    }
+}
\ No newline at end of file

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/aspects/TigrisCoordinator.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/aspects/TigrisCoordinator.java
new file mode 100644
index 0000000..4af0618
--- /dev/null
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/aspects/TigrisCoordinator.java
@@ -0,0 +1,240 @@
+package br.ufrgs.inf.prosoft.tigrisframework.monitoring.aspects;
+
+import br.ufrgs.inf.prosoft.adaptivecaching.cachemanager.cacher.key.Key;
+import br.ufrgs.inf.prosoft.adaptivecaching.cachemanager.util.threads.NamedThreads;
+import br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation.AdaptiveCaching;
+import br.ufrgs.inf.prosoft.adaptivecaching.configuration.annotation.ComponentScan;
+import br.ufrgs.inf.prosoft.adaptivecaching.exceptions.ConfigurationException;
+import br.ufrgs.inf.prosoft.tigrisframework.annotations.TigrisConfiguration;
+import br.ufrgs.inf.prosoft.tigrisframework.metrics.DataFiltering;
+import br.ufrgs.inf.prosoft.tigrisframework.metrics.LightweightMetrics;
+import br.ufrgs.inf.prosoft.tigrisframework.metrics.StaticMetrics;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.metadata.LogTrace;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.metadata.MethodInfo;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.storage.Repository;
+import br.ufrgs.inf.prosoft.tigrisframework.monitoring.storage.RepositoryFactory;
+import br.ufrgs.inf.prosoft.tigrisframework.sampling.Granularity;
+import br.ufrgs.inf.prosoft.tigrisframework.sampling.Sampling;
+import br.ufrgs.inf.prosoft.tigrisframework.sampling.SamplingConfiguration;
+import br.ufrgs.inf.prosoft.utils.ConfigurationUtils;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.*;
+import java.util.regex.Pattern;
+
+import static java.lang.System.currentTimeMillis;
+
+public class TigrisCoordinator implements Runnable {
+    private static boolean enabled = true;
+    private boolean coarseMonitoringEnabled = true;
+
+    Logger logger = LoggerFactory.getLogger(TigrisCoordinator.class);
+
+    //traceable configuration
+    private Pattern allowedPattern;
+    private Pattern deniedPattern;
+
+    //tigris config
+    private final TigrisConfiguration tigrisConfiguration;
+    private final SamplingConfiguration samplingConfiguration;
+    private final Sampling sampling;
+    private final Repository repository;
+    private AdaptiveCachingCoordinator adaptiveCachingCoordinator;
+
+    private final String staticFile;
+    private Map<String, LightweightMetrics> metrics;
+
+    private final ScheduledExecutorService samplingAdaptationExecutor = Executors.newSingleThreadScheduledExecutor(new NamedThreads(
+            "sampling-adaptation",
+            "adapting sampling rate and sample readiness"
+    ));
+
+    private final ScheduledExecutorService lightweightAnalyzerExecutor = Executors.newSingleThreadScheduledExecutor(new NamedThreads(
+            "lightweight-analyzer",
+            "computing lightweight metrics and setting allowed methods"
+    ));
+
+    public TigrisCoordinator() throws IOException {
+        Class<?> configClass = ConfigurationUtils.getAvailableConfigurationClass(TigrisConfiguration.class);
+        if (configClass == null) {
+            turnoff();
+            logger.info("Tigris tracing disabled, there is no annotations.");
+            throw new ConfigurationException("Tigris tracing disabled, there is no annotations.");
+        }
+
+        tigrisConfiguration = configClass.getAnnotation(TigrisConfiguration.class);
+        staticFile = tigrisConfiguration.staticMetricFile();
+
+        //getting allowed packages from @ComponentScan
+        ComponentScan componentScanConfig = configClass.getAnnotation(ComponentScan.class);
+        if (componentScanConfig == null) {
+            //if not specified, it assumes the same package where @AdaptiveCaching were declared
+            allowedPattern = Pattern.compile(configClass.getPackage().getName() + ".*");
+            logger.info("ComponentScan for TigrisConfiguration not found, assuming the same package where @TigrisConfiguration were declared.");
+        }
+        allowedPattern = Pattern.compile(componentScanConfig.allowed());
+        deniedPattern = Pattern.compile(componentScanConfig.denied());
+        logger.info("@TigrisConfiguration will trace and cache methods into {} and deny {} package.", allowedPattern.pattern(), deniedPattern.pattern());
+
+        samplingConfiguration = configClass.getAnnotation(SamplingConfiguration.class);
+        sampling = new Sampling(samplingConfiguration.samplingPercentage());
+        samplingAdaptationExecutor.scheduleWithFixedDelay(
+                sampling, 120000, 450000, TimeUnit.MILLISECONDS);
+
+        repository = RepositoryFactory.getRepository(null, tigrisConfiguration.logRepository());
+
+        if (tigrisConfiguration.clearMonitoringDataOnStart()) {
+            repository.removeAll();
+            logger.debug("Repository starting cleaned.");
+        }
+
+        if (coarseMonitoringEnabled) {
+            metrics = new ConcurrentHashMap<>();
+            lightweightAnalyzerExecutor.scheduleWithFixedDelay(
+                    this::run,
+                    120000, 450000, TimeUnit.MILLISECONDS);
+        }
+
+        try {
+            Class<?> cachingConfig = ConfigurationUtils.getAvailableConfigurationClass(AdaptiveCaching.class);
+            adaptiveCachingCoordinator = new AdaptiveCachingCoordinator(repository,
+                    cachingConfig.getAnnotation(AdaptiveCaching.class));
+        } catch (ConfigurationException e){
+            logger.info("AdaptiveCaching not found, disabling...");
+        }
+    }
+
+    public boolean isAllowed(ProceedingJoinPoint joinPoint) {
+        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
+        return
+                isEnabled()
+                        && !signature.getName().contains("br.ufrgs.inf.prosoft")
+                        && allowedPattern.matcher(signature.getMethod().getDeclaringClass().getPackage().getName()).matches()
+                        && !deniedPattern.matcher(signature.getMethod().getDeclaringClass().getPackage().getName()).matches();
+    }
+
+    public Object process(ProceedingJoinPoint joinPoint) throws Throwable {
+        boolean detailedTrace = (!coarseMonitoringEnabled ||
+                (coarseMonitoringEnabled && allowedFineGrained
+                        .contains(joinPoint.getSignature().toLongString())));
+
+        //generate a hash of the method that will be used as: key to cache and compare if the method is allowed or not
+        Key key = new Key(joinPoint);
+
+        boolean cacheable = adaptiveCachingCoordinator != null && adaptiveCachingCoordinator.isCacheable(key);
+        if (cacheable) {
+            Object cachedResult = adaptiveCachingCoordinator.getFromCache(key);
+            if (cachedResult != null)
+                return cachedResult;
+        }
+
+        Object[] joinPointArgs = null;
+        //method calls can change the args, so it is better to get it at the beginning
+        if (detailedTrace)
+            joinPointArgs = joinPoint.getArgs();
+
+        String signature = joinPoint.getSignature().toString();
+
+        long startTime = currentTimeMillis();
+        Object result = joinPoint.proceed();
+        long endTime = currentTimeMillis();
+
+        if (coarseMonitoringEnabled) {
+            LightweightMetrics metric = metrics.get(signature);
+            if (metric != null)
+                metric.incOccurrence();
+            else {
+                String name = joinPoint.getSignature().toString().split(" ")[1];
+                name = name.substring(0, name.indexOf("("));
+                metric = new LightweightMetrics(name, joinPoint.getSignature().toLongString());
+                metric.incOccurrence();
+                metrics.put(signature, metric);
+            }
+            metric.addTime(startTime, endTime - startTime);
+            metric.addReturnSize(result);
+        }
+
+        Granularity granularity = new Granularity(samplingConfiguration.granularity(), signature);
+
+        //trace only allowed by lightweight metrics
+        if (coarseMonitoringEnabled
+                && detailedTrace
+                && sampling.samplingDecision(granularity)) {
+            logger.debug("New trace: " + signature);
+
+            //we do not cache null returns, but we trace them
+            //maybe the method can sometimes return null... so there is not verification here
+            LogTrace logTrace = new LogTrace();
+            logTrace.setStartTime(startTime);
+            logTrace.setEndTime(endTime);
+
+            MethodInfo methodInfo = new MethodInfo(joinPoint.getSignature().toLongString(), joinPointArgs, result, key);
+            logTrace.setMethodInfo(methodInfo);
+
+            try {
+                repository.save(logTrace);
+                logger.debug("New trace entry: " + logTrace);
+            } catch (Exception e) {
+                logger.debug("Couldn't trace " + logTrace.getMethodInfo().getSignature() + " due to: " + e.getMessage());
+            }
+        }
+
+        if (detailedTrace && cacheable && result != null) {
+            adaptiveCachingCoordinator.putInCache(key, result);
+        }
+
+        return result;
+    }
+
+    public void turnoff() {
+        enabled = false;
+    }
+
+    public static boolean isEnabled() {
+        return enabled;
+    }
+
+    public Repository getRepository() {
+        return repository;
+    }
+
+    /**
+     * The constant allowedFineGrained.
+     */
+    public static Set<String> allowedFineGrained = new ConcurrentSkipListSet<>();
+
+    @Override
+    public void run() {
+        try {
+            logger.info("Analyzing {} lightweight methods for relevance...", metrics.size());
+
+            StaticMetrics staticMetrics = new StaticMetrics(staticFile);
+            DataFiltering dataFiltering = new DataFiltering(staticMetrics, metrics);
+
+            //cleaning selected methods
+            allowedFineGrained = new ConcurrentSkipListSet<>();
+
+            //TODO process SET operations dynamically
+            // using criteria
+
+            for(String method : metrics.keySet()) {
+                LightweightMetrics sc = metrics.get(method);
+//                if (dataFiltering.retrictedFilter())
+                if (dataFiltering.extendedFilter(sc))
+                    allowedFineGrained.add(sc.getLongName());
+            }
+            logger.info("Selected methods for fine-grained ({}): {}", allowedFineGrained.size(), allowedFineGrained);
+
+            //analyze once
+            coarseMonitoringEnabled = false;
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}
\ No newline at end of file

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/storage/Repository.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/storage/Repository.java
new file mode 100644
index 0000000..3f6c8e5
--- /dev/null
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/storage/Repository.java
@@ -0,0 +1,40 @@
+package br.ufrgs.inf.prosoft.tigrisframework.monitoring.storage;
+
+import br.ufrgs.inf.prosoft.adaptivecaching.exceptions.StorageException;
+
+import java.util.List;
+
+/**
+ * The interface Repository.
+ *
+ * @param <T> the type parameter
+ */
+public interface Repository<T> {
+
+    /**
+     * Save.
+     *
+     * @param t the t
+     * @throws StorageException the storage exception
+     */
+    void save(T t) throws StorageException;
+
+    /**
+     * Find all list.
+     *
+     * @return the list
+     */
+    List<T> findAll();
+
+    /**
+     * Remove all.
+     */
+    void removeAll();
+
+    /**
+     * Save all.
+     *
+     * @param toSave the to save
+     */
+    void saveAll(List<T> toSave);
+}

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/usersession/UserGetter.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/usersession/UserGetter.java
new file mode 100644
index 0000000..ee7ff2e
--- /dev/null
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/monitoring/usersession/UserGetter.java
@@ -0,0 +1,15 @@
+package br.ufrgs.inf.prosoft.tigrisframework.monitoring.usersession;
+
+/**
+ * The interface User getter.
+ */
+public interface UserGetter {
+
+    /**
+     * Gets current user.
+     *
+     * @return the current user
+     */
+    String getCurrentUser();
+
+}

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/FrequencyDataSet.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/FrequencyDataSet.java
new file mode 100644
index 0000000..d179b59
--- /dev/null
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/FrequencyDataSet.java
@@ -0,0 +1,43 @@
+package br.ufrgs.inf.prosoft.tigrisframework.sampling;
+
+import org.apache.commons.math3.stat.descriptive.SummaryStatistics;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class FrequencyDataSet {
+
+    private Map<Granularity, Integer> granularityPopulation = new HashMap<>();
+    private long n;
+
+    public void addItem(Granularity item) {
+        if (granularityPopulation.containsKey(item)){
+            granularityPopulation.put(item, granularityPopulation.get(item) + 1);
+        }
+        else {
+            granularityPopulation.put(item, 1);
+        }
+        n++;
+    }
+
+    public long getTotalItems(){
+        return n;
+    }
+
+    public double getProportion(Granularity granularity){
+        return granularityPopulation.get(granularity) / getTotalItems();
+    }
+
+    public Set<Granularity> getGranularities(){
+        return granularityPopulation.keySet();
+    }
+
+    public SummaryStatistics getAsDescriptiveStatistics(){
+        SummaryStatistics summaryStatistics = new SummaryStatistics();
+        for (Map.Entry<Granularity, Integer> populationEntry : granularityPopulation.entrySet()) {
+            summaryStatistics.addValue(populationEntry.getValue());
+        }
+        return summaryStatistics;
+    }
+}

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/Granularity.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/Granularity.java
new file mode 100644
index 0000000..61cc118
--- /dev/null
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/Granularity.java
@@ -0,0 +1,28 @@
+package br.ufrgs.inf.prosoft.tigrisframework.sampling;
+
+import java.util.Objects;
+
+public class Granularity {
+
+    public GranularityType granularityType;
+    public String name;
+
+    public Granularity(GranularityType granularityType, String name) {
+        this.granularityType = granularityType;
+        this.name = name;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Granularity that = (Granularity) o;
+        return granularityType == that.granularityType &&
+                Objects.equals(name, that.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(granularityType, name);
+    }
+}

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/GranularityType.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/GranularityType.java
new file mode 100644
index 0000000..c82bd43
--- /dev/null
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/GranularityType.java
@@ -0,0 +1,8 @@
+package br.ufrgs.inf.prosoft.tigrisframework.sampling;
+
+public enum GranularityType {
+    PACKAGE,
+    CLASS,
+    METHOD,
+    CALL;
+}

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/Sampling.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/Sampling.java
new file mode 100644
index 0000000..2ae2622
--- /dev/null
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/Sampling.java
@@ -0,0 +1,132 @@
+package br.ufrgs.inf.prosoft.tigrisframework.sampling;
+
+import org.apache.commons.math3.distribution.BinomialDistribution;
+import org.apache.commons.math3.random.RandomDataGenerator;
+import org.apache.commons.math3.random.RandomGenerator;
+import org.apache.commons.math3.stat.inference.TestUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.security.SecureRandom;
+import java.util.Random;
+
+/**
+ * The type Sampling decision.
+ */
+public class Sampling implements Runnable {
+
+    private boolean samplingEnabled = true;
+    private int samplingRate = 50; // in percentage, 1 to 100
+    private FrequencyDataSet population = new FrequencyDataSet(), sample = new FrequencyDataSet();
+
+    Logger logger = LoggerFactory.getLogger(Sampling.class);
+
+    /**
+     * z confidence value, ex: 1.96 for 95%
+     * p proportion of the population, 0.5 is default
+     * e margin of error, ex: 0.05 for 5%
+     */
+    private double z = 1.96, p = 0.5, e = 0.05;
+
+    private static SecureRandom rand = new SecureRandom();
+
+    public Sampling(int initialSamplingRate) {
+        samplingRate = initialSamplingRate;
+    }
+
+    public boolean samplingDecision(Granularity granularity) {
+        population.addItem(granularity);
+//
+//        RandomDataGenerator randomDataGenerator = new RandomDataGenerator();
+//        RandomGenerator
+//        BinomialDistribution binomialDistribution = new BinomialDistribution(1, samplingRate);
+//        binomialDistribution.sample();
+//
+//        UniformRandomProvider rg = RandomUtils.asUniformRandomProvider(new java.security.SecureRandom());
+
+        boolean decision = samplingEnabled
+                && ((rand.nextInt(100) + 1) > (100 - samplingRate)) // sampling rate evaluation
+                && population.getProportion(granularity) > sample.getProportion(granularity); // sample has not enough items of that granularity compared to the population
+
+        if (decision)
+            sample.addItem(granularity);
+
+        return decision;
+    }
+
+    public boolean isReady() {
+        return
+                // margin of error is lower than threshold
+                getSampleSizeErrorMargin() < e
+                // the sample has the min sample size based on the population
+                && sample.getTotalItems() > getMinimumSampleSize()
+                // proportion test
+                && isSameProportion()
+                // t-test
+                && tTestEvaluation();
+    }
+
+    private boolean tTestEvaluation() {
+        //To test the (2-sided) hypothesis sample mean = mu at the 95% level
+        return TestUtils.tTest(population.getAsDescriptiveStatistics().getMean(),
+                sample.getAsDescriptiveStatistics(),
+                0.05);
+    }
+
+    //sample proportion is the same as population
+    public boolean isSameProportion() {
+        return population.getGranularities().stream().allMatch(granularity -> population.getProportion(granularity) == sample.getProportion(granularity));
+    }
+
+    /**
+     * @return the minimum sample size for the population
+     */
+    public long getMinimumSampleSize() {
+        long n_inf = (long) ((Math.pow(z, 2) * p * (1 - p)) / Math.pow(e, 2));
+        return n_inf / (1 + ((n_inf - 1) / population.getTotalItems()));
+    }
+
+    public double getSampleSizeErrorMargin() {
+        double e_n_inf = Math.sqrt((Math.pow(z, 2) * p * (1 - p)) / sample.getTotalItems());
+        return e_n_inf * Math.sqrt((population.getTotalItems() - sample.getTotalItems()) / (population.getTotalItems() - 1));
+    }
+
+    public void disable() {
+        samplingEnabled = false;
+    }
+
+    public void enable() {
+        samplingEnabled = true;
+    }
+
+    public boolean isSamplingEnabled() {
+        return samplingEnabled;
+    }
+
+    public int getSamplingRate() {
+        return samplingRate;
+    }
+
+    public void adaptSamplingRate() {
+        //TODO
+    }
+
+    @Override
+    public void run() {
+        logger.info("Running sampling adaptation.");
+
+        if (isReady()) {
+            logger.info("Sample is ready, releasing for analysis and resetting");
+            //TODO
+            releaseForAnalysis();
+            reset();
+        }
+        adaptSamplingRate();
+    }
+
+    public void releaseForAnalysis() {
+    }
+
+    public void reset() {
+    }
+}

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/SamplingConfiguration.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/SamplingConfiguration.java
new file mode 100644
index 0000000..678adc8
--- /dev/null
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/tigrisframework/sampling/SamplingConfiguration.java
@@ -0,0 +1,21 @@
+package br.ufrgs.inf.prosoft.tigrisframework.sampling;
+
+import java.lang.annotation.*;
+
+/**
+ * The interface Criteria.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Documented
+public @interface SamplingConfiguration {
+
+    GranularityType granularity() default GranularityType.CALL;
+
+    /**
+     * Sampling percentage int.
+     *
+     * @return the int
+     */
+    int samplingPercentage() default 50;
+}

diff --git a/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/utils/ConfigurationUtils.java b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/utils/ConfigurationUtils.java
new file mode 100644
index 0000000..c2d20a9
--- /dev/null
+++ b/framework/autonomicmanager/src/main/java/br/ufrgs/inf/prosoft/utils/ConfigurationUtils.java
@@ -0,0 +1,30 @@
+package br.ufrgs.inf.prosoft.utils;
+
+import br.ufrgs.inf.prosoft.adaptivecaching.exceptions.ConfigurationException;
+import org.reflections.Reflections;
+import org.reflections.scanners.ResourcesScanner;
+import org.reflections.scanners.SubTypesScanner;
+import org.reflections.scanners.TypeAnnotationsScanner;
+import org.reflections.util.ClasspathHelper;
+import org.reflections.util.ConfigurationBuilder;
+
+import java.util.Set;
+
+public final class ConfigurationUtils {
+
+    public static Class<?> getAvailableConfigurationClass(Class annotation) {
+        Reflections reflections = new Reflections(
+                new ConfigurationBuilder()
+                        .setUrls(ClasspathHelper.forClassLoader())
+                        .setScanners(new SubTypesScanner(false), new ResourcesScanner(), new TypeAnnotationsScanner()));
+
+        Set<Class<?>> configurations =
+                reflections.getTypesAnnotatedWith(annotation);
+        if (configurations.isEmpty())
+            throw new ConfigurationException(annotation.getName() + " not found.");
+        if (configurations.size() > 1)
+            throw new ConfigurationException(annotation.getName() + " has too many definitions.");
+        return configurations.iterator().next();
+    }
+
+}

diff --git a/framework/autonomicmanager/src/test/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/CacheabilityMetricsTest.java b/framework/autonomicmanager/src/test/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/CacheabilityMetricsTest.java
index eb14962..8eb44fd 100644
--- a/framework/autonomicmanager/src/test/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/CacheabilityMetricsTest.java
+++ b/framework/autonomicmanager/src/test/java/br/ufrgs/inf/prosoft/adaptivecaching/analysis/decision/flowchart/CacheabilityMetricsTest.java
@@ -1,11 +1,9 @@
 package br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart;
 
 import br.ufrgs.inf.prosoft.adaptivecaching.analysis.decision.flowchart.stats.CacheabilityMetrics;
+import org.junit.Assert;
 import org.junit.Test;
 
-/**
- * Created by jhonnymertz on 13/11/17.
- */
 public class CacheabilityMetricsTest {
 
     @Test