feat: fix sonar

lucas-myx · lucas-myx · commit ff1c728771a7 · 2024-12-08T23:25:06.000+08:00
diff --git a/arex-agent-bootstrap/src/main/java/io/arex/agent/bootstrap/model/ArexMocker.java b/arex-agent-bootstrap/src/main/java/io/arex/agent/bootstrap/model/ArexMocker.java
@@ -24,7 +24,9 @@ public class ArexMocker implements Mocker {
     private transient Map<Integer, Long> eigenMap;
     private Map<String, String> tags;
 
+    // original compressed text for request
     private transient String request;
+    // original compressed text for response
     private transient String response;
 
     /**
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/config/Config.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/config/Config.java
@@ -24,12 +24,10 @@ public class Config {
     private static final char SEPARATOR = ',';
     private static Config INSTANCE = null;
 
-    static void update(boolean enableDebug, String serviceName, List<DynamicClassEntity> dynamicClassList,
-        Map<String, String> properties, Set<String> excludeServiceOperations,
-        int dubboStreamReplayThreshold, int recordRate, CompareConfigurationEntity compareConfigurationEntity) {
-        INSTANCE = new Config(enableDebug, serviceName, dynamicClassList, properties,
-            excludeServiceOperations,
-            dubboStreamReplayThreshold, recordRate, compareConfigurationEntity);
+    static void update(boolean enableDebug, String serviceName,
+        int dubboStreamReplayThreshold, int recordRate, ConfigExtendEntity extendEntity) {
+        INSTANCE = new Config(enableDebug, serviceName,
+            dubboStreamReplayThreshold, recordRate, extendEntity);
     }
 
     public static Config get() {
@@ -51,22 +49,21 @@ public static Config get() {
     private final Map<String, String> mockerTags;
     private final CompareConfigurationEntity compareConfigurationEntity;
 
-    Config(boolean enableDebug, String serviceName, List<DynamicClassEntity> dynamicClassList,
-           Map<String, String> properties, Set<String> excludeServiceOperations, int dubboStreamReplayThreshold,
-           int recordRate, CompareConfigurationEntity compareConfigurationEntity) {
+    Config(boolean enableDebug, String serviceName, int dubboStreamReplayThreshold,
+           int recordRate, ConfigExtendEntity extendEntity) {
         this.enableDebug = enableDebug;
         this.serviceName = serviceName;
-        this.dynamicClassList = dynamicClassList;
-        this.properties = properties;
-        this.excludeServiceOperations = buildExcludeServiceOperations(excludeServiceOperations);
+        this.dynamicClassList = extendEntity.getDynamicClassList();
+        this.properties = extendEntity.getProperties();
+        this.excludeServiceOperations = buildExcludeServiceOperations(extendEntity.getExcludeServiceOperations());
         this.dubboStreamReplayThreshold = dubboStreamReplayThreshold;
         this.recordRate = recordRate;
         this.recordVersion = properties.get("arex.agent.version");
         this.includeServiceOperations = StringUtil.splitToSet(properties.get("includeServiceOperations"), SEPARATOR);
         this.mockerTags = StringUtil.asMap(System.getProperty(ConfigConstants.MOCKER_TAGS));
         buildCoveragePackages(properties);
         buildDynamicClassInfo();
-        this.compareConfigurationEntity = compareConfigurationEntity;
+        this.compareConfigurationEntity = extendEntity.getCompareConfigurationEntity();
     }
 
     /**
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/config/ConfigBuilder.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/config/ConfigBuilder.java
@@ -77,7 +77,8 @@ public ConfigBuilder recordRate(int recordRate) {
     }
 
     public void build() {
-        Config.update(enableDebug, serviceName, dynamicClassList, Collections.unmodifiableMap(new HashMap<>(properties)),
-            excludeServiceOperations, dubboStreamReplayThreshold, recordRate, compareConfigurationEntity);
+        Config.update(enableDebug, serviceName, dubboStreamReplayThreshold, recordRate,
+                ConfigExtendEntity.of(dynamicClassList, Collections.unmodifiableMap(new HashMap<>(properties)),
+                        excludeServiceOperations, compareConfigurationEntity));
     }
 }
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/config/ConfigExtendEntity.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/config/ConfigExtendEntity.java
@@ -0,0 +1,47 @@
+package io.arex.inst.runtime.config;
+
+import io.arex.inst.runtime.model.CompareConfigurationEntity;
+import io.arex.inst.runtime.model.DynamicClassEntity;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class ConfigExtendEntity {
+    private final List<DynamicClassEntity> dynamicClassList;
+    private final Map<String, String> properties;
+    private final Set<String> excludeServiceOperations;
+    private final CompareConfigurationEntity compareConfigurationEntity;
+
+    private ConfigExtendEntity(List<DynamicClassEntity> dynamicClassList,
+                               Map<String, String> properties, Set<String> excludeServiceOperations,
+                               CompareConfigurationEntity compareConfigurationEntity) {
+        this.dynamicClassList = dynamicClassList;
+        this.properties = properties;
+        this.excludeServiceOperations = excludeServiceOperations;
+        this.compareConfigurationEntity = compareConfigurationEntity;
+    }
+
+    public static ConfigExtendEntity of(List<DynamicClassEntity> dynamicClassList,
+                                        Map<String, String> properties, Set<String> excludeServiceOperations,
+                                        CompareConfigurationEntity compareConfigurationEntity) {
+        return new ConfigExtendEntity(dynamicClassList, properties, excludeServiceOperations,
+                compareConfigurationEntity);
+    }
+
+    public List<DynamicClassEntity> getDynamicClassList() {
+        return dynamicClassList;
+    }
+
+    public Map<String, String> getProperties() {
+        return properties;
+    }
+
+    public Set<String> getExcludeServiceOperations() {
+        return excludeServiceOperations;
+    }
+
+    public CompareConfigurationEntity getCompareConfigurationEntity() {
+        return compareConfigurationEntity;
+    }
+}
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/context/ArexContext.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/context/ArexContext.java
@@ -5,8 +5,7 @@
 import io.arex.agent.bootstrap.util.StringUtil;
 import io.arex.inst.runtime.model.ArexConstants;
 import io.arex.inst.runtime.model.ReplayCompareResultDTO;
-import io.arex.inst.runtime.util.MergeRecordUtil;
-import io.arex.inst.runtime.util.ReplayUtil;
+import io.arex.inst.runtime.util.MockManager;
 
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
@@ -177,7 +176,7 @@ public void clear() {
             methodSignatureHashList.clear();
         }
         if (cachedReplayResultMap != null) {
-            ReplayUtil.saveRemainCompareResult(this);
+            MockManager.saveReplayRemainCompareRelation(this);
             cachedReplayResultMap.clear();
         }
         if (excludeMockTemplate != null) {
@@ -188,7 +187,7 @@ public void clear() {
         }
         if (mergeRecordQueue != null) {
             // async thread merge record (main entry has ended)
-            MergeRecordUtil.recordRemain(this);
+            MockManager.recordRemain(this);
             mergeRecordQueue.clear();
         }
         if (replayCompareResultQueue != null) {
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/listener/EventProcessor.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/listener/EventProcessor.java
@@ -9,6 +9,7 @@
 import io.arex.agent.bootstrap.util.StringUtil;
 import io.arex.agent.bootstrap.util.ServiceLoader;
 import io.arex.inst.runtime.config.Config;
+import io.arex.inst.runtime.model.ArexConstants;
 import io.arex.inst.runtime.model.InitializeEnum;
 import io.arex.inst.runtime.request.RequestHandlerManager;
 import io.arex.inst.runtime.log.LogManager;
@@ -24,6 +25,8 @@
 
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 
 import io.arex.inst.runtime.util.ReplayUtil;
@@ -37,6 +40,10 @@ public class EventProcessor {
     private static final AtomicReference<InitializeEnum> INIT_DEPENDENCY = new AtomicReference<>(InitializeEnum.START);
     private static final Method FIND_LOADED_METHOD = ReflectUtil.getMethod(ClassLoader.class, "findLoadedClass", String.class);
     private static boolean existJacksonDependency = true;
+
+    private static final ScheduledThreadPoolExecutor SCHEDULER =
+            new ScheduledThreadPoolExecutor(1, r -> new Thread(r, "arex-replay-manager-thread"));
+
     static {
         try {
             Class.forName("com.fasterxml.jackson.databind.ObjectMapper",true, Thread.currentThread().getContextClassLoader());
@@ -113,6 +120,13 @@ private static void initClock(){
     public static void onExit(){
         ReplayUtil.saveReplayCompareResult();
         ContextManager.remove();
+        // if replay plan complete end(the last replay case), delay clear context (include async thread context)
+        ArexContext context = ContextManager.currentContext();
+        if (context.getAttachment(ArexConstants.REPLAY_END_FLAG) != null
+                && Boolean.parseBoolean(String.valueOf(context.getAttachment(ArexConstants.REPLAY_END_FLAG)))) {
+            // must contain LatencyContextHashMap#overdueCleanUp time(1 minutes)
+            SCHEDULER.schedule(ContextManager::clear, 2, TimeUnit.MINUTES);
+        }
     }
 
     /**
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/match/ReplayMatcher.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/match/ReplayMatcher.java
@@ -40,7 +40,7 @@ public static Mocker match(Mocker requestMocker, MockStrategyEnum mockStrategy)
 
         logMatchResult(context);
 
-        setCompareResult(context);
+        saveCompareResult(context);
 
         return context.getMatchMocker();
     }
@@ -123,11 +123,11 @@ private static void logMatchResult(MatchStrategyContext context) {
      * new call (recordMocker is null)
      * (call missing after entry point)
      */
-    private static void setCompareResult(MatchStrategyContext context) {
+    private static boolean saveCompareResult(MatchStrategyContext context) {
         Mocker replayMocker = context.getRequestMocker();
         boolean isEntryPoint = replayMocker.getCategoryType().isEntryPoint();
         if (replayMocker.getCategoryType().isSkipComparison() && !isEntryPoint) {
-            return;
+            return false;
         }
 
         String recordMsg = null;
@@ -155,6 +155,6 @@ private static void setCompareResult(MatchStrategyContext context) {
         ReplayCompareResultDTO compareResultDTO = ReplayUtil.convertCompareResult(
                 replayMocker, recordMsg, replayMsg, recordTime, replayTime, sameMsg);
         compareResultDTO.setExtendMessage(extendMessage);
-        replayCompareResultQueue.offer(compareResultDTO);
+        return replayCompareResultQueue.offer(compareResultDTO);
     }
 }
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/match/key/DatabaseMatchKeyBuilderImpl.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/match/key/DatabaseMatchKeyBuilderImpl.java
@@ -133,19 +133,26 @@ private static int findIndexWholeIgnoreCase(String source, int sourceCount, Stri
                 while (++i <= max && firstCharacterWordBoundaryNotMatch(source, first, i)) {}
             }
             //  Found first character, now look at the rest of target
-            if (i <= max) {
-                int j = i + 1;
-                int end = j + targetCount - 1;
-                for (int k = 1; j < end && equalsIgnoreCase(source.charAt(j), target.charAt(k)); j++, k++) {}
-                if (j == end && isWordBoundary(source, j)) {
-                    // Found whole string
-                    return i;
-                }
+            if (findFirstChar(i, max, targetCount, source, target)) {
+                return i;
             }
         }
         return INDEX_NOT_FOUND;
     }
 
+    private static boolean findFirstChar(int i, int max, int targetCount, String source, String target) {
+        if (i <= max) {
+            int j = i + 1;
+            int end = j + targetCount - 1;
+            for (int k = 1; j < end && equalsIgnoreCase(source.charAt(j), target.charAt(k)); j++, k++) {}
+            if (j == end && isWordBoundary(source, j)) {
+                // Found whole string
+                return true;
+            }
+        }
+        return false;
+    }
+
     private static boolean readShouldTerminal(char src) {
         return src == SQL_BATCH_TERMINAL_CHAR || isWhitespace(src);
     }
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/match/strategy/EigenMatchStrategy.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/match/strategy/EigenMatchStrategy.java
@@ -75,9 +75,9 @@ private int coincidePath(Map<Integer, Long> replayEigenMap, Map<Integer, Long> r
             return row;
         }
 
-        for (Integer key : recordEigenMap.keySet()) {
-            Long recordPathValue = recordEigenMap.get(key);
-            Long replayPathValue = replayEigenMap.get(key);
+        for (Map.Entry<Integer, Long> recordEigenEntry : recordEigenMap.entrySet()) {
+            Long recordPathValue = recordEigenEntry.getValue();
+            Long replayPathValue = replayEigenMap.get(recordEigenEntry.getKey());
             if (Objects.equals(recordPathValue, replayPathValue)) {
                 row ++;
             }
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/model/ArexConstants.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/model/ArexConstants.java
@@ -80,4 +80,5 @@ private ArexConstants() {}
     public static final String MATCH_LOG_TITLE = "replay.match";
     public static final String MOCKER_TARGET_TYPE = "io.arex.agent.bootstrap.model.Mocker$Target";
     public static final String SPRING_SCAN_PACKAGES = "arex.spring.scan.packages";
+    public static final String REPLAY_END_FLAG = "arex-replay-end";
 }
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/service/DataCollector.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/service/DataCollector.java
@@ -2,7 +2,6 @@
 
 import io.arex.agent.bootstrap.model.MockStrategyEnum;
 import io.arex.agent.bootstrap.model.Mocker;
-import io.arex.inst.runtime.model.ReplayCompareResultDTO;
 
 import java.util.List;
 
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/util/MergeRecordUtil.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/util/MergeRecordUtil.java
@@ -24,7 +24,7 @@ private MergeRecordUtil() {}
     public static void mergeRecord(Mocker requestMocker) {
         List<List<Mocker>> mergeList = merge(requestMocker);
         for (List<Mocker> mergeRecords : mergeList) {
-            MockUtils.executeRecord(mergeRecords);
+            MockManager.executeRecord(mergeRecords);
         }
     }
 
@@ -128,7 +128,7 @@ public static void recordRemain(ArexContext context) {
             mergeRecordQueue.drainTo(mergeRecordList);
             List<List<Mocker>> splitList = checkAndSplit(mergeRecordList);
             for (List<Mocker> mergeRecords : splitList) {
-                MockUtils.executeRecord(mergeRecords);
+                MockManager.executeRecord(mergeRecords);
             }
         } catch (Exception e) {
             LogManager.warn("merge.record.remain.error", e);
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/util/MockManager.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/util/MockManager.java
@@ -0,0 +1,27 @@
+package io.arex.inst.runtime.util;
+
+import io.arex.agent.bootstrap.model.Mocker;
+import io.arex.inst.runtime.context.ArexContext;
+
+import java.util.List;
+
+/**
+ * decouple, resolve cycle dependency
+ */
+public class MockManager {
+    public static void mergeRecord(Mocker requestMocker) {
+        MergeRecordUtil.mergeRecord(requestMocker);
+    }
+
+    public static void recordRemain(ArexContext context) {
+        MergeRecordUtil.recordRemain(context);
+    }
+
+    public static void executeRecord(List<Mocker> mockerList) {
+        MockUtils.executeRecord(mockerList);
+    }
+
+    public static void saveReplayRemainCompareRelation(ArexContext context) {
+        ReplayUtil.saveRemainCompareResult(context);
+    }
+}
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/util/MockUtils.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/util/MockUtils.java
@@ -19,7 +19,6 @@
 import io.arex.inst.runtime.service.DataService;
 import io.arex.inst.runtime.util.sizeof.AgentSizeOf;
 
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
@@ -101,15 +100,15 @@ public static void recordMocker(Mocker requestMocker) {
             return;
         }
         if (requestMocker.isNeedMerge() && enableMergeRecord()) {
-            MergeRecordUtil.mergeRecord(requestMocker);
+            MockManager.mergeRecord(requestMocker);
             return;
         }
 
         executeRecord(Collections.singletonList(requestMocker));
 
         if (requestMocker.getCategoryType().isEntryPoint()) {
             // after main entry record finished, record remain merge mocker that have not reached the merge threshold once(such as dynamicClass)
-            MergeRecordUtil.recordRemain(ContextManager.currentContext());
+            MockManager.recordRemain(ContextManager.currentContext());
         }
     }
 
diff --git a/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/util/ReplayUtil.java b/arex-instrumentation-api/src/main/java/io/arex/inst/runtime/util/ReplayUtil.java
@@ -224,13 +224,16 @@ public static void saveReplayCompareResult() {
                         String.valueOf(cachedMocker.isMatched()), cachedMocker.logBuilder().toString()));
             }
         }
-        LogManager.info("CachedReplayResultMap", message.toString());
+        LogManager.info("saveReplayCompareResult", message.toString());
     }
 
     /**
-     * call missing 类型只能在最后统计一次，保证所有的回放匹配（包括异步的）都匹配结束，这样统计的call missing才是准确的
-     * 如果在主接口就统计call missing，可能会有异步接口还未匹配，导致call missing统计不准确，
-     * 虽然现在是未匹配过的状态，但等异步匹配之后可能变成了匹配中的状态了，所以要放到最后统计
+     * Record the compare relationship again when delaying the context cleaning to ensure
+     * that all replay matches (including asynchronous ones) match correctly.
+     * And this time we counted call missing, because if call missing is counted on the main interface,
+     * there may be asynchronous interfaces that have not been matched yet,
+     * Although it is currently in an unmatched state, it may become a matching state after asynchronous matching,
+     * so it needs to be counted call missing last.
      */
     public static void saveRemainCompareResult(ArexContext context) {
         if (context == null) {
@@ -265,6 +268,7 @@ public static void saveRemainCompareResult(ArexContext context) {
         List<ReplayCompareResultDTO> replayCompareList = new ArrayList<>();
         replayCompareResultQueue.drainTo(replayCompareList);
         MockUtils.saveReplayCompareResult(context, replayCompareList);
+        LogManager.info("saveRemainCompareResult", "remain size: " + replayCompareList.size());
     }
 
     public static ReplayCompareResultDTO convertCompareResult(Mocker replayMocker, String recordMsg, String replayMsg,
diff --git a/arex-instrumentation-api/src/test/java/io/arex/inst/runtime/listener/EventProcessorTest.java b/arex-instrumentation-api/src/test/java/io/arex/inst/runtime/listener/EventProcessorTest.java
diff --git a/arex-instrumentation-api/src/test/java/io/arex/inst/runtime/util/MockManagerTest.java b/arex-instrumentation-api/src/test/java/io/arex/inst/runtime/util/MockManagerTest.java
diff --git a/arex-instrumentation/dubbo/arex-dubbo-common/src/main/java/io/arex/inst/dubbo/common/DubboExtractor.java b/arex-instrumentation/dubbo/arex-dubbo-common/src/main/java/io/arex/inst/dubbo/common/DubboExtractor.java
diff --git a/arex-instrumentation/netty/arex-netty-v3/src/main/java/io/arex/inst/netty/v3/server/RequestTracingHandler.java b/arex-instrumentation/netty/arex-netty-v3/src/main/java/io/arex/inst/netty/v3/server/RequestTracingHandler.java
diff --git a/arex-instrumentation/netty/arex-netty-v4/src/main/java/io/arex/inst/netty/v4/server/RequestTracingHandler.java b/arex-instrumentation/netty/arex-netty-v4/src/main/java/io/arex/inst/netty/v4/server/RequestTracingHandler.java
diff --git a/arex-instrumentation/servlet/arex-httpservlet/src/main/java/io/arex/inst/httpservlet/ServletAdviceHelper.java b/arex-instrumentation/servlet/arex-httpservlet/src/main/java/io/arex/inst/httpservlet/ServletAdviceHelper.java

Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,8 @@ public ConfigBuilder recordRate(int recordRate) {`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`public void build() {`
`80`		`- Config.update(enableDebug, serviceName, dynamicClassList, Collections.unmodifiableMap(new HashMap<>(properties)),`
`81`		`- excludeServiceOperations, dubboStreamReplayThreshold, recordRate, compareConfigurationEntity);`
	`80`	`+ Config.update(enableDebug, serviceName, dubboStreamReplayThreshold, recordRate,`
	`81`	`+ ConfigExtendEntity.of(dynamicClassList, Collections.unmodifiableMap(new HashMap<>(properties)),`
	`82`	`+ excludeServiceOperations, compareConfigurationEntity));`
`82`	`83`	`}`
`83`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,9 +75,9 @@ private int coincidePath(Map<Integer, Long> replayEigenMap, Map<Integer, Long> r`
`75`	`75`	`return row;`
`76`	`76`	`}`
`77`	`77`
`78`		`- for (Integer key : recordEigenMap.keySet()) {`
`79`		`- Long recordPathValue = recordEigenMap.get(key);`
`80`		`- Long replayPathValue = replayEigenMap.get(key);`
	`78`	`+ for (Map.Entry<Integer, Long> recordEigenEntry : recordEigenMap.entrySet()) {`
	`79`	`+ Long recordPathValue = recordEigenEntry.getValue();`
	`80`	`+ Long replayPathValue = replayEigenMap.get(recordEigenEntry.getKey());`
`81`	`81`	`if (Objects.equals(recordPathValue, replayPathValue)) {`
`82`	`82`	`row ++;`
`83`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -80,4 +80,5 @@ private ArexConstants() {}`
`80`	`80`	`public static final String MATCH_LOG_TITLE = "replay.match";`
`81`	`81`	`public static final String MOCKER_TARGET_TYPE = "io.arex.agent.bootstrap.model.Mocker$Target";`
`82`	`82`	`public static final String SPRING_SCAN_PACKAGES = "arex.spring.scan.packages";`
	`83`	`+ public static final String REPLAY_END_FLAG = "arex-replay-end";`
`83`	`84`	`}`