trace dag ui seem good

apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/Const.java

@@ -9,5 +9,4 @@ public class Const {
     public static final String PEERS_FRONT_SPLIT = "[";
     public static final String PEERS_BEHIND_SPLIT = "]";
     public static final String USER_CODE = "User";
-    public static final String RESULT = "result";
 }

apm-collector/apm-collector-boot/src/main/resources/application.yml

@@ -20,7 +20,7 @@ ui:
   jetty:
     host: localhost
     port: 12800
-    context_path: /ui
+    context_path: /
 storage:
   elasticsearch:
     cluster_name: CollectorDBCluster

apm-collector/apm-collector-ui/pom.xml

@@ -33,5 +33,10 @@
             <artifactId>apm-collector-storage</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.skywalking</groupId>
+            <artifactId>apm-collector-agentstream</artifactId>
+            <version>${project.version}</version>
+        </dependency>
     </dependencies>
 </project>
\ No newline at end of file

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/INodeComponentDAO.java

+package org.skywalking.apm.collector.ui.dao;
+
+import com.google.gson.JsonArray;
+
+/**
+ * @author pengys5
+ */
+public interface INodeComponentDAO {
+    JsonArray load(long startTime, long endTime);
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/INodeMappingDAO.java

+package org.skywalking.apm.collector.ui.dao;
+
+import com.google.gson.JsonArray;
+
+/**
+ * @author pengys5
+ */
+public interface INodeMappingDAO {
+    JsonArray load(long startTime, long endTime);
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/INodeRefSumDAO.java

+package org.skywalking.apm.collector.ui.dao;
+
+import com.google.gson.JsonArray;
+
+/**
+ * @author pengys5
+ */
+public interface INodeRefSumDAO {
+    JsonArray load(long startTime, long endTime);
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/INodeReferenceDAO.java

+package org.skywalking.apm.collector.ui.dao;
+
+import com.google.gson.JsonArray;
+
+/**
+ * @author pengys5
+ */
+public interface INodeReferenceDAO {
+    JsonArray load(long startTime, long endTime);
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeComponentEsDAO.java

+package org.skywalking.apm.collector.ui.dao;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import org.elasticsearch.action.search.SearchRequestBuilder;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.action.search.SearchType;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.search.aggregations.AggregationBuilders;
+import org.elasticsearch.search.aggregations.bucket.terms.Terms;
+import org.skywalking.apm.collector.agentstream.worker.Const;
+import org.skywalking.apm.collector.agentstream.worker.node.component.define.NodeComponentTable;
+import org.skywalking.apm.collector.storage.elasticsearch.dao.EsDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @author pengys5
+ */
+public class NodeComponentEsDAO extends EsDAO implements INodeComponentDAO {
+
+    private final Logger logger = LoggerFactory.getLogger(NodeComponentEsDAO.class);
+
+    @Override public JsonArray load(long startTime, long endTime) {
+        SearchRequestBuilder searchRequestBuilder = getClient().prepareSearch(NodeComponentTable.TABLE);
+        searchRequestBuilder.setTypes(NodeComponentTable.TABLE_TYPE);
+        searchRequestBuilder.setSearchType(SearchType.DFS_QUERY_THEN_FETCH);
+        searchRequestBuilder.setQuery(QueryBuilders.rangeQuery(NodeComponentTable.COLUMN_TIME_BUCKET).gte(startTime).lte(endTime));
+        searchRequestBuilder.setSize(0);
+
+        searchRequestBuilder.addAggregation(AggregationBuilders.terms(NodeComponentTable.COLUMN_AGG).field(NodeComponentTable.COLUMN_AGG).size(100));
+        SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
+
+        Terms genders = searchResponse.getAggregations().get(NodeComponentTable.COLUMN_AGG);
+
+        JsonArray nodeComponentArray = new JsonArray();
+        for (Terms.Bucket entry : genders.getBuckets()) {
+            String aggId = entry.getKeyAsString();
+            String[] aggIds = aggId.split(Const.IDS_SPLIT);
+            String code = aggIds[0];
+            String peers = aggIds[1];
+
+            JsonObject nodeComponentObj = new JsonObject();
+            nodeComponentObj.addProperty("name", code);
+            nodeComponentObj.addProperty("peers", peers);
+            nodeComponentArray.add(nodeComponentObj);
+        }
+        logger.debug("node component data: {}", nodeComponentArray.toString());
+        return nodeComponentArray;
+    }
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeComponentH2DAO.java

+package org.skywalking.apm.collector.ui.dao;
+
+import com.google.gson.JsonArray;
+import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+
+/**
+ * @author pengys5
+ */
+public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO {
+
+    @Override public JsonArray load(long startTime, long endTime) {
+        return null;
+    }
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeMappingEsDAO.java

+package org.skywalking.apm.collector.ui.dao;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import org.elasticsearch.action.search.SearchRequestBuilder;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.action.search.SearchType;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.search.aggregations.AggregationBuilders;
+import org.elasticsearch.search.aggregations.bucket.terms.Terms;
+import org.skywalking.apm.collector.agentstream.worker.Const;
+import org.skywalking.apm.collector.agentstream.worker.node.mapping.define.NodeMappingTable;
+import org.skywalking.apm.collector.storage.elasticsearch.dao.EsDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @author pengys5
+ */
+public class NodeMappingEsDAO extends EsDAO implements INodeMappingDAO {
+
+    private final Logger logger = LoggerFactory.getLogger(NodeMappingEsDAO.class);
+
+    @Override public JsonArray load(long startTime, long endTime) {
+        SearchRequestBuilder searchRequestBuilder = getClient().prepareSearch(NodeMappingTable.TABLE);
+        searchRequestBuilder.setTypes(NodeMappingTable.TABLE_TYPE);
+        searchRequestBuilder.setSearchType(SearchType.DFS_QUERY_THEN_FETCH);
+        searchRequestBuilder.setQuery(QueryBuilders.rangeQuery(NodeMappingTable.COLUMN_TIME_BUCKET).gte(startTime).lte(endTime));
+        searchRequestBuilder.setSize(0);
+
+        searchRequestBuilder.addAggregation(AggregationBuilders.terms(NodeMappingTable.COLUMN_AGG).field(NodeMappingTable.COLUMN_AGG).size(100));
+        SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
+
+        Terms genders = searchResponse.getAggregations().get(NodeMappingTable.COLUMN_AGG);
+
+        JsonArray nodeMappingArray = new JsonArray();
+        for (Terms.Bucket entry : genders.getBuckets()) {
+            String aggId = entry.getKeyAsString();
+            String[] aggIds = aggId.split(Const.IDS_SPLIT);
+            String code = aggIds[0];
+            String peers = aggIds[1];
+
+            JsonObject nodeMappingObj = new JsonObject();
+            nodeMappingObj.addProperty("code", code);
+            nodeMappingObj.addProperty("peers", peers);
+            nodeMappingArray.add(nodeMappingObj);
+        }
+        logger.debug("node mapping data: {}", nodeMappingArray.toString());
+        return nodeMappingArray;
+    }
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeMappingH2DAO.java

+package org.skywalking.apm.collector.ui.dao;
+
+import com.google.gson.JsonArray;
+import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+
+/**
+ * @author pengys5
+ */
+public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO {
+
+    @Override public JsonArray load(long startTime, long endTime) {
+        return null;
+    }
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeRefSumEsDAO.java

+package org.skywalking.apm.collector.ui.dao;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import org.elasticsearch.action.search.SearchRequestBuilder;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.action.search.SearchType;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.search.aggregations.AggregationBuilders;
+import org.elasticsearch.search.aggregations.bucket.terms.Terms;
+import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
+import org.elasticsearch.search.aggregations.metrics.sum.Sum;
+import org.skywalking.apm.collector.agentstream.worker.Const;
+import org.skywalking.apm.collector.agentstream.worker.noderef.summary.define.NodeRefSumTable;
+import org.skywalking.apm.collector.storage.elasticsearch.dao.EsDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @author pengys5
+ */
+public class NodeRefSumEsDAO extends EsDAO implements INodeRefSumDAO {
+
+    private final Logger logger = LoggerFactory.getLogger(NodeRefSumEsDAO.class);
+
+    @Override public JsonArray load(long startTime, long endTime) {
+        SearchRequestBuilder searchRequestBuilder = getClient().prepareSearch(NodeRefSumTable.TABLE);
+        searchRequestBuilder.setTypes(NodeRefSumTable.TABLE_TYPE);
+        searchRequestBuilder.setSearchType(SearchType.DFS_QUERY_THEN_FETCH);
+        searchRequestBuilder.setQuery(QueryBuilders.rangeQuery(NodeRefSumTable.COLUMN_TIME_BUCKET).gte(startTime).lte(endTime));
+        searchRequestBuilder.setSize(0);
+
+        TermsAggregationBuilder aggregationBuilder = AggregationBuilders.terms(NodeRefSumTable.COLUMN_AGG).field(NodeRefSumTable.COLUMN_AGG);
+        aggregationBuilder.subAggregation(AggregationBuilders.sum(NodeRefSumTable.COLUMN_ONE_SECOND_LESS).field(NodeRefSumTable.COLUMN_ONE_SECOND_LESS));
+        aggregationBuilder.subAggregation(AggregationBuilders.sum(NodeRefSumTable.COLUMN_THREE_SECOND_LESS).field(NodeRefSumTable.COLUMN_THREE_SECOND_LESS));
+        aggregationBuilder.subAggregation(AggregationBuilders.sum(NodeRefSumTable.COLUMN_FIVE_SECOND_LESS).field(NodeRefSumTable.COLUMN_FIVE_SECOND_LESS));
+        aggregationBuilder.subAggregation(AggregationBuilders.sum(NodeRefSumTable.COLUMN_FIVE_SECOND_GREATER).field(NodeRefSumTable.COLUMN_FIVE_SECOND_GREATER));
+        aggregationBuilder.subAggregation(AggregationBuilders.sum(NodeRefSumTable.COLUMN_ERROR).field(NodeRefSumTable.COLUMN_ERROR));
+        aggregationBuilder.subAggregation(AggregationBuilders.sum(NodeRefSumTable.COLUMN_SUMMARY).field(NodeRefSumTable.COLUMN_SUMMARY));
+
+        searchRequestBuilder.addAggregation(aggregationBuilder);
+
+        SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
+
+        JsonArray nodeRefResSumArray = new JsonArray();
+        Terms aggTerms = searchResponse.getAggregations().get(NodeRefSumTable.COLUMN_AGG);
+        for (Terms.Bucket bucket : aggTerms.getBuckets()) {
+            String aggId = String.valueOf(bucket.getKey());
+            Sum oneSecondLess = bucket.getAggregations().get(NodeRefSumTable.COLUMN_ONE_SECOND_LESS);
+            Sum threeSecondLess = bucket.getAggregations().get(NodeRefSumTable.COLUMN_THREE_SECOND_LESS);
+            Sum fiveSecondLess = bucket.getAggregations().get(NodeRefSumTable.COLUMN_FIVE_SECOND_LESS);
+            Sum fiveSecondGreater = bucket.getAggregations().get(NodeRefSumTable.COLUMN_FIVE_SECOND_GREATER);
+            Sum error = bucket.getAggregations().get(NodeRefSumTable.COLUMN_ERROR);
+            Sum summary = bucket.getAggregations().get(NodeRefSumTable.COLUMN_SUMMARY);
+            logger.debug("aggId: {}, oneSecondLess: {}, threeSecondLess: {}, fiveSecondLess: {}, fiveSecondGreater: {}, error: {}, summary: {}", aggId,
+                oneSecondLess.getValue(), threeSecondLess.getValue(), fiveSecondLess.getValue(), fiveSecondGreater.getValue(), error.getValue(), summary.getValue());
+
+            JsonObject nodeRefResSumObj = new JsonObject();
+            String[] ids = aggId.split(Const.IDS_SPLIT);
+            String front = ids[0];
+            String behind = ids[1];
+
+            nodeRefResSumObj.addProperty("front", front);
+            nodeRefResSumObj.addProperty("behind", behind);
+
+            nodeRefResSumObj.addProperty(NodeRefSumTable.COLUMN_ONE_SECOND_LESS, oneSecondLess.getValue());
+            nodeRefResSumObj.addProperty(NodeRefSumTable.COLUMN_THREE_SECOND_LESS, threeSecondLess.getValue());
+            nodeRefResSumObj.addProperty(NodeRefSumTable.COLUMN_FIVE_SECOND_LESS, fiveSecondLess.getValue());
+            nodeRefResSumObj.addProperty(NodeRefSumTable.COLUMN_FIVE_SECOND_GREATER, fiveSecondGreater.getValue());
+            nodeRefResSumObj.addProperty(NodeRefSumTable.COLUMN_ERROR, error.getValue());
+            nodeRefResSumObj.addProperty(NodeRefSumTable.COLUMN_SUMMARY, summary.getValue());
+            nodeRefResSumArray.add(nodeRefResSumObj);
+        }
+
+        return nodeRefResSumArray;
+    }
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeRefSumH2DAO.java

+package org.skywalking.apm.collector.ui.dao;
+
+import com.google.gson.JsonArray;
+import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+
+/**
+ * @author pengys5
+ */
+public class NodeRefSumH2DAO extends H2DAO implements INodeRefSumDAO {
+    @Override public JsonArray load(long startTime, long endTime) {
+        return null;
+    }
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeReferenceEsDAO.java

+package org.skywalking.apm.collector.ui.dao;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import org.elasticsearch.action.search.SearchRequestBuilder;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.action.search.SearchType;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.search.aggregations.AggregationBuilders;
+import org.elasticsearch.search.aggregations.bucket.terms.Terms;
+import org.skywalking.apm.collector.agentstream.worker.Const;
+import org.skywalking.apm.collector.agentstream.worker.noderef.reference.define.NodeRefTable;
+import org.skywalking.apm.collector.storage.elasticsearch.dao.EsDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @author pengys5
+ */
+public class NodeReferenceEsDAO extends EsDAO implements INodeReferenceDAO {
+
+    private final Logger logger = LoggerFactory.getLogger(NodeReferenceEsDAO.class);
+
+    @Override public JsonArray load(long startTime, long endTime) {
+        SearchRequestBuilder searchRequestBuilder = getClient().prepareSearch(NodeRefTable.TABLE);
+        searchRequestBuilder.setTypes(NodeRefTable.TABLE_TYPE);
+        searchRequestBuilder.setSearchType(SearchType.DFS_QUERY_THEN_FETCH);
+        searchRequestBuilder.setQuery(QueryBuilders.rangeQuery(NodeRefTable.COLUMN_TIME_BUCKET).gte(startTime).lte(endTime));
+        searchRequestBuilder.setSize(0);
+
+        searchRequestBuilder.addAggregation(AggregationBuilders.terms(NodeRefTable.COLUMN_AGG).field(NodeRefTable.COLUMN_AGG).size(100));
+
+        SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
+
+        Terms genders = searchResponse.getAggregations().get(NodeRefTable.COLUMN_AGG);
+
+        JsonArray nodeRefArray = new JsonArray();
+        for (Terms.Bucket entry : genders.getBuckets()) {
+            String aggId = entry.getKeyAsString();
+            String[] aggIds = aggId.split(Const.IDS_SPLIT);
+            String front = aggIds[0];
+            String behind = aggIds[1];
+
+            JsonObject nodeRefObj = new JsonObject();
+            nodeRefObj.addProperty("front", front);
+            nodeRefObj.addProperty("behind", behind);
+            nodeRefArray.add(nodeRefObj);
+        }
+        logger.debug("node ref data: {}", nodeRefArray.toString());
+        return nodeRefArray;
+    }
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeReferenceH2DAO.java

+package org.skywalking.apm.collector.ui.dao;
+
+import com.google.gson.JsonArray;
+import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+
+/**
+ * @author pengys5
+ */
+public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO {
+    @Override public JsonArray load(long startTime, long endTime) {
+        return null;
+    }
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/jetty/UIJettyModuleDefine.java

@@ -10,6 +10,7 @@ import org.skywalking.apm.collector.core.server.Server;
 import org.skywalking.apm.collector.server.jetty.JettyServer;
 import org.skywalking.apm.collector.ui.UIModuleDefine;
 import org.skywalking.apm.collector.ui.UIModuleGroupDefine;
+import org.skywalking.apm.collector.ui.jetty.handler.TraceDagGetHandler;
 import org.skywalking.apm.collector.ui.jetty.handler.UIJettyServerHandler;
 
 /**
@@ -46,6 +47,7 @@ public class UIJettyModuleDefine extends UIModuleDefine {
     @Override public List<Handler> handlerList() {
         List<Handler> handlers = new LinkedList<>();
         handlers.add(new UIJettyServerHandler());
+        handlers.add(new TraceDagGetHandler());
         return handlers;
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/jetty/handler/TraceDagGetHandler.java

 package org.skywalking.apm.collector.ui.jetty.handler;
 
+import com.google.gson.JsonObject;
 import java.io.IOException;
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import org.skywalking.apm.collector.server.jetty.JettyHandler;
+import org.skywalking.apm.collector.ui.service.TraceDagService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * @author pengys5
  */
 public class TraceDagGetHandler extends JettyHandler {
 
+    private final Logger logger = LoggerFactory.getLogger(TraceDagGetHandler.class);
+
     @Override public String pathSpec() {
         return "/traceDag";
     }
 
+    private TraceDagService service = new TraceDagService();
+
     @Override
     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        String startTimeStr = req.getParameter("startTime");
+        String endTimeStr = req.getParameter("endTime");
+        String timeBucketType = req.getParameter("timeBucketType");
+        logger.debug("startTime: {}, endTimeStr: {}, timeBucketType: {}", startTimeStr, endTimeStr, timeBucketType);
+
+        long startTime = Long.valueOf(startTimeStr);
+        long endTime = Long.valueOf(endTimeStr);
+        JsonObject traceDagJson = service.load(startTime, endTime, timeBucketType);
+
+        reply(resp, traceDagJson, HttpServletResponse.SC_OK);
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/service/TraceDagDataBuilder.java

+package org.skywalking.apm.collector.ui.service;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import java.util.HashMap;
+import java.util.Map;
+import org.skywalking.apm.collector.agentstream.worker.Const;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @author pengys5
+ */
+public class TraceDagDataBuilder {
+    private final Logger logger = LoggerFactory.getLogger(TraceDagDataBuilder.class);
+
+    private Integer nodeId = new Integer(-1);
+    private Map<String, String> mappingMap = new HashMap<>();
+    private Map<String, String> nodeCompMap = new HashMap<>();
+    private Map<String, Long> resSumMap = new HashMap<>();
+    private Map<String, Integer> nodeIdMap = new HashMap<>();
+    private JsonArray pointArray = new JsonArray();
+    private JsonArray lineArray = new JsonArray();
+
+    public JsonObject build(JsonArray nodeCompArray, JsonArray nodesMappingArray, JsonArray nodeRefsArray,
+        JsonArray resSumArray) {
+        changeMapping2Map(nodesMappingArray);
+        changeNodeComp2Map(nodeCompArray);
+        resSumMerge(resSumArray);
+
+        for (int i = 0; i < nodeRefsArray.size(); i++) {
+            JsonObject nodeRefJsonObj = nodeRefsArray.get(i).getAsJsonObject();
+            String front = nodeRefJsonObj.get("front").getAsString();
+            String behind = nodeRefJsonObj.get("behind").getAsString();
+
+            String behindCode = findRealCode(behind);
+            logger.debug("behind: %s, behindCode: {}", behind, behindCode);
+
+            JsonObject lineJsonObj = new JsonObject();
+            lineJsonObj.addProperty("from", findOrCreateNode(front));
+            lineJsonObj.addProperty("to", findOrCreateNode(behindCode));
+            lineJsonObj.addProperty("resSum", resSumMap.get(front + Const.ID_SPLIT + behindCode));
+
+            lineArray.add(lineJsonObj);
+            logger.debug("line: {}", lineJsonObj);
+        }
+
+        JsonObject dagJsonObj = new JsonObject();
+        dagJsonObj.add("nodes", pointArray);
+        dagJsonObj.add("nodeRefs", lineArray);
+        return dagJsonObj;
+    }
+
+    private Integer findOrCreateNode(String peers) {
+        if (nodeIdMap.containsKey(peers) && !peers.equals(Const.USER_CODE)) {
+            return nodeIdMap.get(peers);
+        } else {
+            nodeId++;
+            JsonObject nodeJsonObj = new JsonObject();
+            nodeJsonObj.addProperty("id", nodeId);
+            nodeJsonObj.addProperty("peer", peers);
+            if (peers.equals(Const.USER_CODE)) {
+                nodeJsonObj.addProperty("component", Const.USER_CODE);
+            } else {
+                nodeJsonObj.addProperty("component", nodeCompMap.get(peers));
+            }
+            pointArray.add(nodeJsonObj);
+
+            nodeIdMap.put(peers, nodeId);
+            logger.debug("node: {}", nodeJsonObj);
+        }
+        return nodeId;
+    }
+
+    private void changeMapping2Map(JsonArray nodesMappingArray) {
+        for (int i = 0; i < nodesMappingArray.size(); i++) {
+            JsonObject nodesMappingJsonObj = nodesMappingArray.get(i).getAsJsonObject();
+            String code = nodesMappingJsonObj.get("code").getAsString();
+            String peers = nodesMappingJsonObj.get("peers").getAsString();
+            mappingMap.put(peers, code);
+        }
+    }
+
+    private void changeNodeComp2Map(JsonArray nodeCompArray) {
+        for (int i = 0; i < nodeCompArray.size(); i++) {
+            JsonObject nodesJsonObj = nodeCompArray.get(i).getAsJsonObject();
+            logger.debug(nodesJsonObj.toString());
+            String component = nodesJsonObj.get("name").getAsString();
+            String peers = nodesJsonObj.get("peers").getAsString();
+            nodeCompMap.put(peers, component);
+        }
+    }
+
+    private String findRealCode(String peers) {
+        if (mappingMap.containsKey(peers)) {
+            return mappingMap.get(peers);
+        } else {
+            return peers;
+        }
+    }
+
+    private void resSumMerge(JsonArray resSumArray) {
+        for (int i = 0; i < resSumArray.size(); i++) {
+            JsonObject resSumJsonObj = resSumArray.get(i).getAsJsonObject();
+            String front = resSumJsonObj.get("front").getAsString();
+            String behind = resSumJsonObj.get("behind").getAsString();
+            Long summary = resSumJsonObj.get("summary").getAsLong();
+
+            if (mappingMap.containsKey(behind)) {
+                behind = mappingMap.get(behind);
+            }
+
+            String id = front + Const.ID_SPLIT + behind;
+            if (resSumMap.containsKey(id)) {
+                resSumMap.put(id, summary + resSumMap.get(id));
+            } else {
+                resSumMap.put(id, summary);
+            }
+        }
+    }
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/service/TraceDagService.java

+package org.skywalking.apm.collector.ui.service;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import org.skywalking.apm.collector.storage.dao.DAOContainer;
+import org.skywalking.apm.collector.ui.dao.INodeComponentDAO;
+import org.skywalking.apm.collector.ui.dao.INodeMappingDAO;
+import org.skywalking.apm.collector.ui.dao.INodeRefSumDAO;
+import org.skywalking.apm.collector.ui.dao.INodeReferenceDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @author pengys5
+ */
+public class TraceDagService {
+
+    private final Logger logger = LoggerFactory.getLogger(TraceDagService.class);
+
+    public JsonObject load(long startTime, long endTime, String timeBucketType) {
+        logger.debug("startTime: {}, endTime: {}, timeSliceType: {}", startTime, endTime, timeBucketType);
+        INodeComponentDAO nodeComponentDAO = (INodeComponentDAO)DAOContainer.INSTANCE.get(INodeComponentDAO.class.getName());
+        JsonArray nodeComponentArray = nodeComponentDAO.load(startTime, endTime);
+
+        INodeMappingDAO nodeMappingDAO = (INodeMappingDAO)DAOContainer.INSTANCE.get(INodeMappingDAO.class.getName());
+        JsonArray nodeMappingArray = nodeMappingDAO.load(startTime, endTime);
+
+        INodeReferenceDAO nodeReferenceDAO = (INodeReferenceDAO)DAOContainer.INSTANCE.get(INodeReferenceDAO.class.getName());
+        JsonArray nodeRefArray = nodeReferenceDAO.load(startTime, endTime);
+
+        INodeRefSumDAO nodeRefSumDAO = (INodeRefSumDAO)DAOContainer.INSTANCE.get(INodeRefSumDAO.class.getName());
+        JsonArray nodeRefSumArray = nodeRefSumDAO.load(startTime, endTime);
+
+        TraceDagDataBuilder builder = new TraceDagDataBuilder();
+        JsonObject traceDag = builder.build(nodeComponentArray, nodeMappingArray, nodeRefArray, nodeRefSumArray);
+
+        return traceDag;
+    }
+}

apm-collector/apm-collector-ui/src/main/resources/META-INF/defines/es_dao.define

+org.skywalking.apm.collector.ui.dao.NodeComponentEsDAO
+org.skywalking.apm.collector.ui.dao.NodeMappingEsDAO
+org.skywalking.apm.collector.ui.dao.NodeReferenceEsDAO
+org.skywalking.apm.collector.ui.dao.NodeRefSumEsDAO
\ No newline at end of file

apm-collector/apm-collector-ui/src/main/resources/META-INF/defines/h2_dao.define

+org.skywalking.apm.collector.ui.dao.NodeComponentH2DAO
+org.skywalking.apm.collector.ui.dao.NodeMappingH2DAO
+org.skywalking.apm.collector.ui.dao.NodeReferenceH2DAO
+org.skywalking.apm.collector.ui.dao.NodeRefSumH2DAO
\ No newline at end of file