spans;
+
+ /**
+ * The applicationCode represents a name of current application/JVM and indicates which is business
+ * role in the cluster.
+ *
+ * e.g. account_app, billing_app
+ */
+ @Expose
+ @SerializedName(value = "ac")
+ private String applicationCode;
+
+ /**
+ * The relatedGlobalTraces represent a set of all related trace. Most time it contains only one
+ * element, because only one parent {@link TraceSegment} exists, but, in batch scenario, the num becomes greater
+ * than 1, also meaning multi-parents {@link TraceSegment}.
+ *
+ * The difference between relatedGlobalTraces and {@link #refs} is:
+ * {@link #refs} targets this {@link TraceSegment}'s direct parent,
+ *
+ * and
+ *
+ * relatedGlobalTraces targets this {@link TraceSegment}'s related call chain, a call chain contains
+ * multi {@link TraceSegment}s, only using {@link #refs} is not enough for analysis and ui.
+ */
+ @Expose
+ @SerializedName(value = "gt")
+ private DistributedTraceIds relatedGlobalTraces;
+
+ /**
+ * Establish the link between this segment and its parents.
+ *
+ * @param refSegment {@link TraceSegmentRef}
+ */
+ public void ref(TraceSegmentRef refSegment) {
+ if (refs == null) {
+ refs = new LinkedList();
+ }
+ if (!refs.contains(refSegment)) {
+ refs.add(refSegment);
+ }
+ }
+
+ public void relatedGlobalTraces(List distributedTraceIds) {
+ if (distributedTraceIds == null || distributedTraceIds.size() == 0) {
+ return;
+ }
+ for (DistributedTraceId distributedTraceId : distributedTraceIds) {
+ relatedGlobalTraces.append(distributedTraceId);
+ }
+ }
+
+ public String getTraceSegmentId() {
+ return traceSegmentId;
+ }
+
+ public long getStartTime() {
+ return startTime;
+ }
+
+ public long getEndTime() {
+ return endTime;
+ }
+
+ public List getRefs() {
+ if (refs == null) {
+ return null;
+ }
+ return Collections.unmodifiableList(refs);
+ }
+
+ public List getRelatedGlobalTraces() {
+ return relatedGlobalTraces.getRelatedGlobalTraces();
+ }
+
+ public List getSpans() {
+ return Collections.unmodifiableList(spans);
+ }
+
+ public String getApplicationCode() {
+ return applicationCode;
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/logic/SegmentDeserialize.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/logic/SegmentDeserialize.java
new file mode 100644
index 000000000..3dedc35c0
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/logic/SegmentDeserialize.java
@@ -0,0 +1,17 @@
+package com.a.eye.skywalking.collector.worker.segment.logic;
+
+import com.google.gson.Gson;
+
+/**
+ * @author pengys5
+ */
+public enum SegmentDeserialize {
+ INSTANCE;
+
+ private Gson gson = new Gson();
+
+ public Segment deserializeFromES(String segmentSource) {
+ Segment segment = gson.fromJson(segmentSource, Segment.class);
+ return segment;
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/logic/SpanView.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/logic/SpanView.java
new file mode 100644
index 000000000..f38bb35cd
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/logic/SpanView.java
@@ -0,0 +1,106 @@
+package com.a.eye.skywalking.collector.worker.segment.logic;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author pengys5
+ */
+public class SpanView implements Comparable {
+
+ private int spanId;
+ private String segId;
+ private String appCode;
+ private String spanSegId;
+ private String parentSpanSegId;
+ private long startTime;
+ private long relativeStartTime;
+ private long cost;
+ private String operationName;
+ private Set childSpans;
+
+ public SpanView() {
+ childSpans = new HashSet<>();
+ }
+
+ public int getSpanId() {
+ return spanId;
+ }
+
+ public void setSpanId(int spanId) {
+ this.spanId = spanId;
+ }
+
+ public String getSegId() {
+ return segId;
+ }
+
+ public void setSegId(String segId) {
+ this.segId = segId;
+ }
+
+ public String getAppCode() {
+ return appCode;
+ }
+
+ public void setAppCode(String appCode) {
+ this.appCode = appCode;
+ }
+
+ public String getSpanSegId() {
+ return spanSegId;
+ }
+
+ public void setSpanSegId(String spanSegId) {
+ this.spanSegId = spanSegId;
+ }
+
+ public String getParentSpanSegId() {
+ return parentSpanSegId;
+ }
+
+ public long getStartTime() {
+ return startTime;
+ }
+
+ public void setStartTime(long startTime) {
+ this.startTime = startTime;
+ }
+
+ public void setParentSpanSegId(String parentSpanSegId) {
+ this.parentSpanSegId = parentSpanSegId;
+ }
+
+ public long getRelativeStartTime() {
+ return relativeStartTime;
+ }
+
+ public void setRelativeStartTime(long relativeStartTime) {
+ this.relativeStartTime = relativeStartTime;
+ }
+
+ public long getCost() {
+ return cost;
+ }
+
+ public void setCost(long cost) {
+ this.cost = cost;
+ }
+
+ public String getOperationName() {
+ return operationName;
+ }
+
+ public void setOperationName(String operationName) {
+ this.operationName = operationName;
+ }
+
+ public void addChild(SpanView childSpan) {
+ childSpans.add(childSpan);
+ }
+
+ @Override
+ public int compareTo(SpanView o) {
+ return Long.valueOf(this.startTime - o.getStartTime()).intValue();
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentCostSave.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentCostSave.java
new file mode 100644
index 000000000..9fe2cc6c4
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentCostSave.java
@@ -0,0 +1,109 @@
+package com.a.eye.skywalking.collector.worker.segment.persistence;
+
+
+import com.a.eye.skywalking.collector.actor.AbstractLocalAsyncWorkerProvider;
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.actor.selector.WorkerSelector;
+import com.a.eye.skywalking.collector.worker.RecordPersistenceMember;
+import com.a.eye.skywalking.collector.worker.WorkerConfig;
+import com.a.eye.skywalking.collector.worker.segment.SegmentCostIndex;
+import com.a.eye.skywalking.collector.worker.segment.SegmentPost;
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.CollectionTools;
+import com.a.eye.skywalking.trace.Span;
+import com.a.eye.skywalking.trace.TraceSegment;
+import com.google.gson.JsonObject;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * @author pengys5
+ */
+public class SegmentCostSave extends RecordPersistenceMember {
+
+ private Logger logger = LogManager.getFormatterLogger(SegmentCostSave.class);
+
+ @Override
+ public String esIndex() {
+ return SegmentCostIndex.Index;
+ }
+
+ @Override
+ public String esType() {
+ return SegmentCostIndex.Type_Record;
+ }
+
+ protected SegmentCostSave(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
+ super(role, clusterContext, selfContext);
+ }
+
+ @Override
+ public void analyse(Object message) throws Exception {
+ if (message instanceof SegmentPost.SegmentWithTimeSlice) {
+ SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice = (SegmentPost.SegmentWithTimeSlice) message;
+ TraceSegment segment = segmentWithTimeSlice.getTraceSegment();
+
+ if (CollectionTools.isNotEmpty(segment.getSpans())) {
+ for (Span span : segment.getSpans()) {
+ if (span.getParentSpanId() == -1) {
+ JsonObject dataJsonObj = new JsonObject();
+ dataJsonObj.addProperty(SegmentCostIndex.SegId, segment.getTraceSegmentId());
+ dataJsonObj.addProperty(SegmentCostIndex.StartTime, span.getStartTime());
+ dataJsonObj.addProperty(SegmentCostIndex.EndTime, span.getEndTime());
+ dataJsonObj.addProperty(SegmentCostIndex.OperationName, span.getOperationName());
+ dataJsonObj.addProperty(SegmentCostIndex.Time_Slice, segmentWithTimeSlice.getMinute());
+
+ long startTime = span.getStartTime();
+ long endTime = span.getEndTime();
+ long cost = endTime - startTime;
+ if (cost == 0) {
+ cost = 1;
+ }
+ dataJsonObj.addProperty(SegmentCostIndex.Cost, cost);
+
+ RecordData recordData = new RecordData(segment.getTraceSegmentId());
+ recordData.setRecord(dataJsonObj);
+ super.analyse(recordData);
+ }
+ }
+ }
+ } else {
+ logger.error("unhandled message, message instance must JsonObject, but is %s", message.getClass().toString());
+ }
+ }
+
+ public static class Factory extends AbstractLocalAsyncWorkerProvider {
+ public static Factory INSTANCE = new Factory();
+
+ @Override
+ public Role role() {
+ return Role.INSTANCE;
+ }
+
+ @Override
+ public int queueSize() {
+ return WorkerConfig.Queue.Segment.SegmentCostSave.Size;
+ }
+
+ @Override
+ public SegmentCostSave workerInstance(ClusterWorkerContext clusterContext) {
+ return new SegmentCostSave(role(), clusterContext, new LocalWorkerContext());
+ }
+ }
+
+ public enum Role implements com.a.eye.skywalking.collector.actor.Role {
+ INSTANCE;
+
+ @Override
+ public String roleName() {
+ return SegmentCostSave.class.getSimpleName();
+ }
+
+ @Override
+ public WorkerSelector workerSelector() {
+ return new RollingSelector();
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentExceptionSave.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentExceptionSave.java
new file mode 100644
index 000000000..6caccfa10
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentExceptionSave.java
@@ -0,0 +1,115 @@
+package com.a.eye.skywalking.collector.worker.segment.persistence;
+
+
+import com.a.eye.skywalking.collector.actor.AbstractLocalAsyncWorkerProvider;
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.actor.selector.WorkerSelector;
+import com.a.eye.skywalking.collector.worker.RecordPersistenceMember;
+import com.a.eye.skywalking.collector.worker.WorkerConfig;
+import com.a.eye.skywalking.collector.worker.segment.SegmentExceptionIndex;
+import com.a.eye.skywalking.collector.worker.segment.SegmentPost;
+import com.a.eye.skywalking.collector.worker.storage.AbstractIndex;
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.CollectionTools;
+import com.a.eye.skywalking.trace.LogData;
+import com.a.eye.skywalking.trace.Span;
+import com.a.eye.skywalking.trace.TraceSegment;
+import com.a.eye.skywalking.trace.tag.Tags;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+/**
+ * @author pengys5
+ */
+public class SegmentExceptionSave extends RecordPersistenceMember {
+
+ private Logger logger = LogManager.getFormatterLogger(SegmentExceptionSave.class);
+
+ @Override
+ public String esIndex() {
+ return SegmentExceptionIndex.Index;
+ }
+
+ @Override
+ public String esType() {
+ return AbstractIndex.Type_Record;
+ }
+
+ protected SegmentExceptionSave(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
+ super(role, clusterContext, selfContext);
+ }
+
+ @Override
+ public void analyse(Object message) throws Exception {
+ if (message instanceof SegmentPost.SegmentWithTimeSlice) {
+ SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice = (SegmentPost.SegmentWithTimeSlice) message;
+ TraceSegment segment = segmentWithTimeSlice.getTraceSegment();
+
+ if (CollectionTools.isNotEmpty(segment.getSpans())) {
+ for (Span span : segment.getSpans()) {
+ boolean isError = Tags.ERROR.get(span);
+
+ JsonObject dataJsonObj = new JsonObject();
+ dataJsonObj.addProperty(SegmentExceptionIndex.IsError, isError);
+ dataJsonObj.addProperty(SegmentExceptionIndex.SegId, segment.getTraceSegmentId());
+
+ JsonArray errorKind = new JsonArray();
+ if (isError) {
+ List logDataList = span.getLogs();
+ for (LogData logData : logDataList) {
+ if (logData.getFields().containsKey("error.kind")) {
+ errorKind.add(String.valueOf(logData.getFields().get("error.kind")));
+ }
+ }
+ }
+ dataJsonObj.add(SegmentExceptionIndex.ErrorKind, errorKind);
+
+ RecordData recordData = new RecordData(segment.getTraceSegmentId());
+ recordData.setRecord(dataJsonObj);
+ super.analyse(recordData);
+ }
+ }
+ } else {
+ logger.error("unhandled message, message instance must JsonObject, but is %s", message.getClass().toString());
+ }
+ }
+
+ public static class Factory extends AbstractLocalAsyncWorkerProvider {
+ public static Factory INSTANCE = new Factory();
+
+ @Override
+ public Role role() {
+ return Role.INSTANCE;
+ }
+
+ @Override
+ public int queueSize() {
+ return WorkerConfig.Queue.Segment.SegmentExceptionSave.Size;
+ }
+
+ @Override
+ public SegmentExceptionSave workerInstance(ClusterWorkerContext clusterContext) {
+ return new SegmentExceptionSave(role(), clusterContext, new LocalWorkerContext());
+ }
+ }
+
+ public enum Role implements com.a.eye.skywalking.collector.actor.Role {
+ INSTANCE;
+
+ @Override
+ public String roleName() {
+ return SegmentExceptionSave.class.getSimpleName();
+ }
+
+ @Override
+ public WorkerSelector workerSelector() {
+ return new RollingSelector();
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentExceptionWithSegId.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentExceptionWithSegId.java
new file mode 100644
index 000000000..4102a6698
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentExceptionWithSegId.java
@@ -0,0 +1,71 @@
+package com.a.eye.skywalking.collector.worker.segment.persistence;
+
+import com.a.eye.skywalking.collector.actor.*;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.actor.selector.WorkerSelector;
+import com.a.eye.skywalking.collector.worker.segment.SegmentExceptionIndex;
+import com.a.eye.skywalking.collector.worker.storage.EsClient;
+import com.google.gson.JsonObject;
+import org.elasticsearch.action.get.GetResponse;
+
+/**
+ * @author pengys5
+ */
+public class SegmentExceptionWithSegId extends AbstractLocalSyncWorker {
+
+ private SegmentExceptionWithSegId(Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
+ super(role, clusterContext, selfContext);
+ }
+
+ @Override
+ protected void onWork(Object request, Object response) throws Exception {
+ if (request instanceof RequestEntity) {
+ RequestEntity search = (RequestEntity) request;
+
+ GetResponse getResponse = EsClient.getClient().prepareGet(SegmentExceptionIndex.Index, SegmentExceptionIndex.Type_Record, search.segId).get();
+
+ JsonObject dataJson = new JsonObject();
+ dataJson.addProperty(SegmentExceptionIndex.SegId, (String) getResponse.getSource().get(SegmentExceptionIndex.SegId));
+ dataJson.addProperty(SegmentExceptionIndex.IsError, (Boolean) getResponse.getSource().get(SegmentExceptionIndex.IsError));
+
+ JsonObject resJsonObj = (JsonObject) response;
+ resJsonObj.add("result", dataJson);
+ }
+ }
+
+ public static class RequestEntity {
+ private String segId;
+
+ public RequestEntity(String segId) {
+ this.segId = segId;
+ }
+ }
+
+ public static class Factory extends AbstractLocalSyncWorkerProvider {
+ public static Factory INSTANCE = new Factory();
+
+ @Override
+ public Role role() {
+ return WorkerRole.INSTANCE;
+ }
+
+ @Override
+ public SegmentExceptionWithSegId workerInstance(ClusterWorkerContext clusterContext) {
+ return new SegmentExceptionWithSegId(role(), clusterContext, new LocalWorkerContext());
+ }
+ }
+
+ public enum WorkerRole implements Role {
+ INSTANCE;
+
+ @Override
+ public String roleName() {
+ return SegmentExceptionWithSegId.class.getSimpleName();
+ }
+
+ @Override
+ public WorkerSelector workerSelector() {
+ return new RollingSelector();
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentSave.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentSave.java
new file mode 100644
index 000000000..0875545ae
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentSave.java
@@ -0,0 +1,83 @@
+package com.a.eye.skywalking.collector.worker.segment.persistence;
+
+
+import com.a.eye.skywalking.collector.actor.AbstractLocalAsyncWorkerProvider;
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.actor.selector.WorkerSelector;
+import com.a.eye.skywalking.collector.worker.RecordPersistenceMember;
+import com.a.eye.skywalking.collector.worker.WorkerConfig;
+import com.a.eye.skywalking.collector.worker.segment.SegmentIndex;
+import com.a.eye.skywalking.collector.worker.storage.AbstractIndex;
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.google.gson.JsonObject;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * @author pengys5
+ */
+public class SegmentSave extends RecordPersistenceMember {
+
+ private Logger logger = LogManager.getFormatterLogger(SegmentSave.class);
+
+ @Override
+ public String esIndex() {
+ return SegmentIndex.Index;
+ }
+
+ @Override
+ public String esType() {
+ return AbstractIndex.Type_Record;
+ }
+
+ public SegmentSave(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
+ super(role, clusterContext, selfContext);
+ }
+
+ @Override
+ public void analyse(Object message) throws Exception {
+ if (message instanceof JsonObject) {
+ JsonObject segmentJson = (JsonObject) message;
+ RecordData recordData = new RecordData(segmentJson.get("ts").getAsString());
+ recordData.setRecord(segmentJson);
+ super.analyse(recordData);
+ } else {
+ logger.error("unhandled message, message instance must JsonObject, but is %s", message.getClass().toString());
+ }
+ }
+
+ public static class Factory extends AbstractLocalAsyncWorkerProvider {
+ public static Factory INSTANCE = new Factory();
+
+ @Override
+ public Role role() {
+ return Role.INSTANCE;
+ }
+
+ @Override
+ public int queueSize() {
+ return WorkerConfig.Queue.Segment.SegmentSave.Size;
+ }
+
+ @Override
+ public SegmentSave workerInstance(ClusterWorkerContext clusterContext) {
+ return new SegmentSave(role(), clusterContext, new LocalWorkerContext());
+ }
+ }
+
+ public enum Role implements com.a.eye.skywalking.collector.actor.Role {
+ INSTANCE;
+
+ @Override
+ public String roleName() {
+ return SegmentSave.class.getSimpleName();
+ }
+
+ @Override
+ public WorkerSelector workerSelector() {
+ return new RollingSelector();
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentTopSearchWithGlobalTraceId.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentTopSearchWithGlobalTraceId.java
new file mode 100644
index 000000000..9ecf8c6bd
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentTopSearchWithGlobalTraceId.java
@@ -0,0 +1,155 @@
+package com.a.eye.skywalking.collector.worker.segment.persistence;
+
+import com.a.eye.skywalking.collector.actor.*;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.actor.selector.WorkerSelector;
+import com.a.eye.skywalking.collector.worker.globaltrace.GlobalTraceIndex;
+import com.a.eye.skywalking.collector.worker.segment.SegmentCostIndex;
+import com.a.eye.skywalking.collector.worker.segment.SegmentExceptionIndex;
+import com.a.eye.skywalking.collector.worker.segment.SegmentIndex;
+import com.a.eye.skywalking.collector.worker.segment.logic.Segment;
+import com.a.eye.skywalking.collector.worker.segment.logic.SegmentDeserialize;
+import com.a.eye.skywalking.collector.worker.storage.EsClient;
+import com.a.eye.skywalking.collector.worker.storage.MergeData;
+import com.a.eye.skywalking.collector.worker.tools.CollectionTools;
+import com.a.eye.skywalking.trace.TraceId.DistributedTraceId;
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import org.elasticsearch.action.get.GetResponse;
+import org.elasticsearch.client.Client;
+
+import java.util.List;
+
+/**
+ * @author pengys5
+ */
+public class SegmentTopSearchWithGlobalTraceId extends AbstractLocalSyncWorker {
+
+ private Gson gson = new Gson();
+
+ private SegmentTopSearchWithGlobalTraceId(Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
+ super(role, clusterContext, selfContext);
+ }
+
+ @Override
+ public void preStart() throws ProviderNotFoundException {
+ getClusterContext().findProvider(SegmentExceptionWithSegId.WorkerRole.INSTANCE).create(this);
+ }
+
+ @Override
+ protected void onWork(Object request, Object response) throws Exception {
+ if (request instanceof RequestEntity) {
+ RequestEntity search = (RequestEntity) request;
+ Client client = EsClient.getClient();
+
+ String globalTraceData = client.prepareGet(GlobalTraceIndex.Index, GlobalTraceIndex.Type_Record, search.globalTraceId).get().getSourceAsString();
+ JsonObject globalTraceObj = gson.fromJson(globalTraceData, JsonObject.class);
+
+ JsonObject topSegPaging = new JsonObject();
+ topSegPaging.addProperty("recordsTotal", 0);
+
+ JsonArray topSegArray = new JsonArray();
+ topSegPaging.add("data", topSegArray);
+
+ if (globalTraceObj != null && globalTraceObj.has(GlobalTraceIndex.SubSegIds)) {
+ String subSegIdsStr = globalTraceObj.get(GlobalTraceIndex.SubSegIds).getAsString();
+ String[] subSegIds = subSegIdsStr.split(MergeData.Split);
+
+ topSegPaging.addProperty("recordsTotal", subSegIds.length);
+
+ int num = search.from;
+ int limit = search.limit;
+ if (search.limit >= subSegIds.length) {
+ limit = subSegIds.length;
+ }
+
+ for (int i = num; i < limit; i++) {
+ GetResponse getResponse = client.prepareGet(SegmentCostIndex.Index, SegmentCostIndex.Type_Record, subSegIds[num]).get();
+
+ JsonObject topSegmentJson = new JsonObject();
+ topSegmentJson.addProperty("num", num);
+ String segId = (String) getResponse.getSource().get(SegmentCostIndex.SegId);
+ topSegmentJson.addProperty(SegmentCostIndex.SegId, segId);
+ topSegmentJson.addProperty(SegmentCostIndex.StartTime, (Number) getResponse.getSource().get(SegmentCostIndex.StartTime));
+ if (getResponse.getSource().containsKey(SegmentCostIndex.EndTime)) {
+ topSegmentJson.addProperty(SegmentCostIndex.EndTime, (Number) getResponse.getSource().get(SegmentCostIndex.EndTime));
+ }
+
+ topSegmentJson.addProperty(SegmentCostIndex.OperationName, (String) getResponse.getSource().get(SegmentCostIndex.OperationName));
+ topSegmentJson.addProperty(SegmentCostIndex.Cost, (Number) getResponse.getSource().get(SegmentCostIndex.Cost));
+
+ String segmentSource = client.prepareGet(SegmentIndex.Index, SegmentIndex.Type_Record, segId).get().getSourceAsString();
+ Segment segment = SegmentDeserialize.INSTANCE.deserializeFromES(segmentSource);
+ List distributedTraceIdList = segment.getRelatedGlobalTraces();
+
+ JsonArray distributedTraceIdArray = new JsonArray();
+ if (CollectionTools.isNotEmpty(distributedTraceIdList)) {
+ for (DistributedTraceId distributedTraceId : distributedTraceIdList) {
+ distributedTraceIdArray.add(distributedTraceId.get());
+ }
+ }
+ topSegmentJson.add("traceIds", distributedTraceIdArray);
+
+ boolean isError = false;
+ JsonObject resJsonObj = new JsonObject();
+ getSelfContext().lookup(SegmentExceptionWithSegId.WorkerRole.INSTANCE).ask(new SegmentExceptionWithSegId.RequestEntity(segId), resJsonObj);
+ if (resJsonObj.has("result")) {
+ JsonObject segExJson = resJsonObj.get("result").getAsJsonObject();
+ if (segExJson.has(SegmentExceptionIndex.IsError)) {
+ isError = segExJson.get(SegmentExceptionIndex.IsError).getAsBoolean();
+ }
+ }
+ topSegmentJson.addProperty(SegmentExceptionIndex.IsError, isError);
+
+ num++;
+ topSegArray.add(topSegmentJson);
+ }
+ }
+
+
+ JsonObject resJsonObj = (JsonObject) response;
+ resJsonObj.add("result", topSegPaging);
+ }
+ }
+
+ public static class RequestEntity {
+ private int from;
+ private int limit;
+ private String globalTraceId;
+
+ public RequestEntity(String globalTraceId, int from, int limit) {
+ this.from = from;
+ this.limit = limit;
+ this.globalTraceId = globalTraceId;
+ }
+ }
+
+ public static class Factory extends AbstractLocalSyncWorkerProvider {
+ public static Factory INSTANCE = new Factory();
+
+ @Override
+ public Role role() {
+ return WorkerRole.INSTANCE;
+ }
+
+ @Override
+ public SegmentTopSearchWithGlobalTraceId workerInstance(ClusterWorkerContext clusterContext) {
+ return new SegmentTopSearchWithGlobalTraceId(role(), clusterContext, new LocalWorkerContext());
+ }
+ }
+
+ public enum WorkerRole implements Role {
+ INSTANCE;
+
+ @Override
+ public String roleName() {
+ return SegmentTopSearchWithGlobalTraceId.class.getSimpleName();
+ }
+
+ @Override
+ public WorkerSelector workerSelector() {
+ return new RollingSelector();
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentTopSearchWithTimeSlice.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentTopSearchWithTimeSlice.java
new file mode 100644
index 000000000..0b3095af8
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentTopSearchWithTimeSlice.java
@@ -0,0 +1,172 @@
+package com.a.eye.skywalking.collector.worker.segment.persistence;
+
+import com.a.eye.skywalking.collector.actor.*;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.actor.selector.WorkerSelector;
+import com.a.eye.skywalking.collector.worker.segment.SegmentCostIndex;
+import com.a.eye.skywalking.collector.worker.segment.SegmentExceptionIndex;
+import com.a.eye.skywalking.collector.worker.segment.SegmentIndex;
+import com.a.eye.skywalking.collector.worker.segment.logic.Segment;
+import com.a.eye.skywalking.collector.worker.segment.logic.SegmentDeserialize;
+import com.a.eye.skywalking.collector.worker.storage.EsClient;
+import com.a.eye.skywalking.collector.worker.tools.CollectionTools;
+import com.a.eye.skywalking.trace.TraceId.DistributedTraceId;
+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.BoolQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.search.SearchHit;
+import org.elasticsearch.search.sort.SortOrder;
+
+import java.util.List;
+
+/**
+ * @author pengys5
+ */
+public class SegmentTopSearchWithTimeSlice extends AbstractLocalSyncWorker {
+
+ private SegmentTopSearchWithTimeSlice(Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
+ super(role, clusterContext, selfContext);
+ }
+
+ @Override
+ public void preStart() throws ProviderNotFoundException {
+ getClusterContext().findProvider(SegmentExceptionWithSegId.WorkerRole.INSTANCE).create(this);
+ }
+
+ @Override
+ protected void onWork(Object request, Object response) throws Exception {
+ if (request instanceof RequestEntity) {
+ RequestEntity search = (RequestEntity) request;
+
+ SearchRequestBuilder searchRequestBuilder = EsClient.getClient().prepareSearch(SegmentCostIndex.Index);
+ searchRequestBuilder.setTypes(SegmentCostIndex.Type_Record);
+ searchRequestBuilder.setSearchType(SearchType.DFS_QUERY_THEN_FETCH);
+ BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
+ searchRequestBuilder.setQuery(boolQueryBuilder);
+ boolQueryBuilder.must().add(QueryBuilders.rangeQuery(SegmentCostIndex.Time_Slice).gte(search.startTime).lte(search.endTime));
+ if (search.minCost != -1 || search.maxCost != -1) {
+ RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(SegmentCostIndex.Cost);
+ if (search.minCost != -1) {
+ rangeQueryBuilder.gte(search.minCost);
+ }
+ if (search.maxCost != -1) {
+ rangeQueryBuilder.lte(search.maxCost);
+ }
+ boolQueryBuilder.must().add(rangeQueryBuilder);
+ }
+
+ searchRequestBuilder.addSort(SegmentCostIndex.Cost, SortOrder.DESC);
+ searchRequestBuilder.setSize(search.limit);
+ searchRequestBuilder.setFrom(search.from);
+
+ SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
+
+ JsonObject topSegPaging = new JsonObject();
+ topSegPaging.addProperty("recordsTotal", searchResponse.getHits().totalHits());
+
+ JsonArray topSegArray = new JsonArray();
+ topSegPaging.add("data", topSegArray);
+
+ int num = search.from;
+ for (SearchHit searchHit : searchResponse.getHits().getHits()) {
+ JsonObject topSegmentJson = new JsonObject();
+ topSegmentJson.addProperty("num", num);
+ String segId = (String) searchHit.getSource().get(SegmentCostIndex.SegId);
+ topSegmentJson.addProperty(SegmentCostIndex.SegId, segId);
+ topSegmentJson.addProperty(SegmentCostIndex.StartTime, (Number) searchHit.getSource().get(SegmentCostIndex.StartTime));
+ if (searchHit.getSource().containsKey(SegmentCostIndex.EndTime)) {
+ topSegmentJson.addProperty(SegmentCostIndex.EndTime, (Number) searchHit.getSource().get(SegmentCostIndex.EndTime));
+ }
+
+ topSegmentJson.addProperty(SegmentCostIndex.OperationName, (String) searchHit.getSource().get(SegmentCostIndex.OperationName));
+ topSegmentJson.addProperty(SegmentCostIndex.Cost, (Number) searchHit.getSource().get(SegmentCostIndex.Cost));
+
+ String segmentSource = EsClient.getClient().prepareGet(SegmentIndex.Index, SegmentIndex.Type_Record, segId).get().getSourceAsString();
+ Segment segment = SegmentDeserialize.INSTANCE.deserializeFromES(segmentSource);
+ List distributedTraceIdList = segment.getRelatedGlobalTraces();
+
+ JsonArray distributedTraceIdArray = new JsonArray();
+ if (CollectionTools.isNotEmpty(distributedTraceIdList)) {
+ for (DistributedTraceId distributedTraceId : distributedTraceIdList) {
+ distributedTraceIdArray.add(distributedTraceId.get());
+ }
+ }
+ topSegmentJson.add("traceIds", distributedTraceIdArray);
+
+ boolean isError = false;
+ JsonObject resJsonObj = new JsonObject();
+ getSelfContext().lookup(SegmentExceptionWithSegId.WorkerRole.INSTANCE).ask(new SegmentExceptionWithSegId.RequestEntity(segId), resJsonObj);
+ if (resJsonObj.has("result")) {
+ JsonObject segExJson = resJsonObj.get("result").getAsJsonObject();
+ if (segExJson.has(SegmentExceptionIndex.IsError)) {
+ isError = segExJson.get(SegmentExceptionIndex.IsError).getAsBoolean();
+ }
+ }
+ topSegmentJson.addProperty(SegmentExceptionIndex.IsError, isError);
+
+ num++;
+ topSegArray.add(topSegmentJson);
+ }
+
+ JsonObject resJsonObj = (JsonObject) response;
+ resJsonObj.add("result", topSegPaging);
+ }
+ }
+
+ public static class RequestEntity {
+ private int from;
+ private int limit;
+ private long startTime;
+ private long endTime;
+ private int minCost;
+ private int maxCost;
+
+ public RequestEntity(int from, int limit, long startTime, long endTime) {
+ this.from = from;
+ this.limit = limit;
+ this.startTime = startTime;
+ this.endTime = endTime;
+ }
+
+ public void setMinCost(int minCost) {
+ this.minCost = minCost;
+ }
+
+ public void setMaxCost(int maxCost) {
+ this.maxCost = maxCost;
+ }
+ }
+
+ public static class Factory extends AbstractLocalSyncWorkerProvider {
+ public static Factory INSTANCE = new Factory();
+
+ @Override
+ public Role role() {
+ return WorkerRole.INSTANCE;
+ }
+
+ @Override
+ public SegmentTopSearchWithTimeSlice workerInstance(ClusterWorkerContext clusterContext) {
+ return new SegmentTopSearchWithTimeSlice(role(), clusterContext, new LocalWorkerContext());
+ }
+ }
+
+ public enum WorkerRole implements Role {
+ INSTANCE;
+
+ @Override
+ public String roleName() {
+ return SegmentTopSearchWithTimeSlice.class.getSimpleName();
+ }
+
+ @Override
+ public WorkerSelector workerSelector() {
+ return new RollingSelector();
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/span/SpanGetWithId.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/span/SpanGetWithId.java
new file mode 100644
index 000000000..e5ff6cf99
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/span/SpanGetWithId.java
@@ -0,0 +1,86 @@
+package com.a.eye.skywalking.collector.worker.span;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
+import com.a.eye.skywalking.collector.actor.Role;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.actor.selector.WorkerSelector;
+import com.a.eye.skywalking.collector.worker.httpserver.AbstractGet;
+import com.a.eye.skywalking.collector.worker.httpserver.AbstractGetProvider;
+import com.a.eye.skywalking.collector.worker.span.persistence.SpanSearchWithId;
+import com.a.eye.skywalking.collector.worker.tools.ParameterTools;
+import com.google.gson.JsonObject;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Arrays;
+import java.util.Map;
+
+/**
+ * @author pengys5
+ */
+public class SpanGetWithId extends AbstractGet {
+
+ private Logger logger = LogManager.getFormatterLogger(SpanGetWithId.class);
+
+ private SpanGetWithId(Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
+ super(role, clusterContext, selfContext);
+ }
+
+ @Override
+ public void preStart() throws ProviderNotFoundException {
+ getClusterContext().findProvider(SpanSearchWithId.WorkerRole.INSTANCE).create(this);
+ }
+
+ @Override
+ protected void onSearch(Map request, JsonObject response) throws Exception {
+ if (!request.containsKey("segId") || !request.containsKey("spanId")) {
+ throw new IllegalArgumentException("the request parameter must contains segId, spanId");
+ }
+ logger.debug("segId: %s, spanId: %s", Arrays.toString(request.get("segId")), Arrays.toString(request.get("spanId")));
+
+ int maxCost = -1;
+ if (request.containsKey("maxCost")) {
+ maxCost = Integer.valueOf(ParameterTools.INSTANCE.toString(request, "maxCost"));
+ }
+
+ String segId = ParameterTools.INSTANCE.toString(request, "segId");
+ String spanId = ParameterTools.INSTANCE.toString(request, "spanId");
+
+ SpanSearchWithId.RequestEntity requestEntity = new SpanSearchWithId.RequestEntity(segId, spanId);
+ getSelfContext().lookup(SpanSearchWithId.WorkerRole.INSTANCE).ask(requestEntity, response);
+ }
+
+ public static class Factory extends AbstractGetProvider {
+
+ @Override
+ public Role role() {
+ return WorkerRole.INSTANCE;
+ }
+
+ @Override
+ public SpanGetWithId workerInstance(ClusterWorkerContext clusterContext) {
+ return new SpanGetWithId(role(), clusterContext, new LocalWorkerContext());
+ }
+
+ @Override
+ public String servletPath() {
+ return "/span/spanId";
+ }
+ }
+
+ public enum WorkerRole implements Role {
+ INSTANCE;
+
+ @Override
+ public String roleName() {
+ return SpanGetWithId.class.getSimpleName();
+ }
+
+ @Override
+ public WorkerSelector workerSelector() {
+ return new RollingSelector();
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/span/persistence/SpanSearchWithId.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/span/persistence/SpanSearchWithId.java
new file mode 100644
index 000000000..5129b4f2c
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/span/persistence/SpanSearchWithId.java
@@ -0,0 +1,88 @@
+package com.a.eye.skywalking.collector.worker.span.persistence;
+
+import com.a.eye.skywalking.collector.actor.*;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.actor.selector.WorkerSelector;
+import com.a.eye.skywalking.collector.worker.segment.SegmentIndex;
+import com.a.eye.skywalking.collector.worker.segment.logic.Segment;
+import com.a.eye.skywalking.collector.worker.segment.logic.SegmentDeserialize;
+import com.a.eye.skywalking.collector.worker.storage.EsClient;
+import com.a.eye.skywalking.trace.Span;
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import org.elasticsearch.action.get.GetResponse;
+
+import java.util.List;
+
+/**
+ * @author pengys5
+ */
+public class SpanSearchWithId extends AbstractLocalSyncWorker {
+
+ private Gson gson = new Gson();
+
+ private SpanSearchWithId(Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
+ super(role, clusterContext, selfContext);
+ }
+
+ @Override
+ protected void onWork(Object request, Object response) throws Exception {
+ if (request instanceof RequestEntity) {
+ RequestEntity search = (RequestEntity) request;
+ GetResponse getResponse = EsClient.getClient().prepareGet(SegmentIndex.Index, SegmentIndex.Type_Record, search.segId).get();
+ Segment segment = SegmentDeserialize.INSTANCE.deserializeFromES(getResponse.getSourceAsString());
+ List spanList = segment.getSpans();
+
+ getResponse.getSource();
+ JsonObject dataJson = new JsonObject();
+
+ for (Span span : spanList) {
+ if (String.valueOf(span.getSpanId()).equals(search.spanId)) {
+ String spanJsonStr = gson.toJson(span);
+ dataJson = gson.fromJson(spanJsonStr, JsonObject.class);
+ }
+ }
+
+ JsonObject resJsonObj = (JsonObject) response;
+ resJsonObj.add("result", dataJson);
+ }
+ }
+
+ public static class RequestEntity {
+ private String segId;
+ private String spanId;
+
+ public RequestEntity(String segId, String spanId) {
+ this.segId = segId;
+ this.spanId = spanId;
+ }
+ }
+
+ public static class Factory extends AbstractLocalSyncWorkerProvider {
+ public static Factory INSTANCE = new Factory();
+
+ @Override
+ public Role role() {
+ return WorkerRole.INSTANCE;
+ }
+
+ @Override
+ public SpanSearchWithId workerInstance(ClusterWorkerContext clusterContext) {
+ return new SpanSearchWithId(role(), clusterContext, new LocalWorkerContext());
+ }
+ }
+
+ public enum WorkerRole implements Role {
+ INSTANCE;
+
+ @Override
+ public String roleName() {
+ return SpanSearchWithId.class.getSimpleName();
+ }
+
+ @Override
+ public WorkerSelector workerSelector() {
+ return new RollingSelector();
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/AbstractIndex.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/AbstractIndex.java
new file mode 100644
index 000000000..8f4ade7da
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/AbstractIndex.java
@@ -0,0 +1,90 @@
+package com.a.eye.skywalking.collector.worker.storage;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
+import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse;
+import org.elasticsearch.action.admin.indices.mapping.put.PutMappingResponse;
+import org.elasticsearch.client.IndicesAdminClient;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentFactory;
+import org.elasticsearch.index.IndexNotFoundException;
+
+import java.io.IOException;
+
+/**
+ * @author pengys5
+ */
+public abstract class AbstractIndex {
+
+ private Logger logger = LogManager.getFormatterLogger(AbstractIndex.class);
+
+ public static final String Type_Minute = "minute";
+ public static final String Type_Hour = "hour";
+ public static final String Type_Day = "day";
+
+ public static final String Type_Record = "record";
+
+ public static final String AGG_COLUMN = "aggId";
+ public static final String Time_Slice = "timeSlice";
+
+ final public XContentBuilder createSettingBuilder() throws IOException {
+ XContentBuilder settingsBuilder = XContentFactory.jsonBuilder()
+ .startObject()
+ .field("index.number_of_shards", 2)
+ .field("index.number_of_replicas", 0)
+ .endObject();
+ return settingsBuilder;
+ }
+
+ public abstract boolean isRecord();
+
+ public abstract XContentBuilder createMappingBuilder() throws IOException;
+
+ final public void createIndex() {
+ // settings
+ String settingSource = "";
+
+ // mapping
+ XContentBuilder mappingBuilder = null;
+ try {
+ XContentBuilder settingsBuilder = createSettingBuilder();
+
+ settingSource = settingsBuilder.string();
+
+ mappingBuilder = createMappingBuilder();
+ logger.info("mapping builder str: %s", mappingBuilder.string());
+ } catch (Exception e) {
+ logger.error("create %s index mapping builder error", index());
+ }
+ Settings settings = Settings.builder().loadFromSource(settingSource).build();
+ IndicesAdminClient client = EsClient.getClient().admin().indices();
+
+ if (isRecord()) {
+ CreateIndexResponse response = client.prepareCreate(index()).setSettings(settings).addMapping(Type_Record, mappingBuilder).get();
+ logger.info("create %s index with type of %s finished, isAcknowledged: %s", index(), Type_Record, response.isAcknowledged());
+ } else {
+ CreateIndexResponse response = client.prepareCreate(index()).setSettings(settings).addMapping(Type_Minute, mappingBuilder).get();
+ logger.info("create %s index with type of %s finished, isAcknowledged: %s", index(), Type_Minute, response.isAcknowledged());
+ PutMappingResponse putMappingResponse = client.preparePutMapping(index()).setType(Type_Hour).setSource(mappingBuilder).get();
+ logger.info("create %s index with type of %s finished, isAcknowledged: %s", index(), Type_Hour, putMappingResponse.isAcknowledged());
+ putMappingResponse = client.preparePutMapping(index()).setType(Type_Day).setSource(mappingBuilder).get();
+ logger.info("create %s index with type of %s finished, isAcknowledged: %s", index(), Type_Day, putMappingResponse.isAcknowledged());
+ }
+ }
+
+ final public boolean deleteIndex() {
+ IndicesAdminClient client = EsClient.getClient().admin().indices();
+ try {
+ DeleteIndexResponse response = client.prepareDelete(index()).get();
+ logger.info("delete %s index finished, isAcknowledged: %s", index(), response.isAcknowledged());
+ return response.isAcknowledged();
+ } catch (IndexNotFoundException e) {
+ logger.info("%s index not found", index());
+ }
+ return false;
+ }
+
+ public abstract String index();
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/AbstractTimeSlice.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/AbstractTimeSlice.java
index bb0ade6e1..2920b58e8 100644
--- a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/AbstractTimeSlice.java
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/AbstractTimeSlice.java
@@ -5,10 +5,14 @@ package com.a.eye.skywalking.collector.worker.storage;
*/
public abstract class AbstractTimeSlice {
private final long minute;
+ private final long hour;
+ private final long day;
private final int second;
- public AbstractTimeSlice(long minute, int second) {
+ public AbstractTimeSlice(long minute, long hour, long day, int second) {
this.minute = minute;
+ this.hour = hour;
+ this.day = day;
this.second = second;
}
@@ -16,6 +20,14 @@ public abstract class AbstractTimeSlice {
return minute;
}
+ public long getHour() {
+ return hour;
+ }
+
+ public long getDay() {
+ return day;
+ }
+
public int getSecond() {
return second;
}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/EsClient.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/EsClient.java
index badd094e9..27a0a8e80 100644
--- a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/EsClient.java
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/EsClient.java
@@ -2,6 +2,8 @@ package com.a.eye.skywalking.collector.worker.storage;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
+import org.elasticsearch.action.admin.indices.refresh.RefreshRequest;
+import org.elasticsearch.action.admin.indices.refresh.RefreshResponse;
import org.elasticsearch.client.Client;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
@@ -15,14 +17,13 @@ import java.net.UnknownHostException;
*/
public class EsClient {
- private static Logger logger = LogManager.getFormatterLogger(EsClient.class);
-
private static Client client;
public static void boot() throws UnknownHostException {
Settings settings = Settings.builder()
.put("cluster.name", "CollectorCluster")
- .put("client.transport.sniff", true).build();
+ .put("client.transport.sniff", true)
+ .build();
client = new PreBuiltTransportClient(settings)
.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("localhost"), 9300));
@@ -31,4 +32,15 @@ public class EsClient {
public static Client getClient() {
return client;
}
+
+ public static void indexRefresh(String... indexName) {
+ Logger logger = LogManager.getFormatterLogger(EsClient.class);
+ RefreshResponse response = client.admin().indices().refresh(new RefreshRequest(indexName)).actionGet();
+ if (response.getShardFailures().length == response.getTotalShards()) {
+ logger.error("All elasticsearch shard index refresh failure, reason: %s", response.getShardFailures());
+ } else if (response.getShardFailures().length > 0) {
+ logger.error("In parts of elasticsearch shard index refresh failure, reason: %s", response.getShardFailures());
+ }
+ logger.info("elasticsearch index refresh success");
+ }
}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/IndexCreator.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/IndexCreator.java
new file mode 100644
index 000000000..b8312881f
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/IndexCreator.java
@@ -0,0 +1,50 @@
+package com.a.eye.skywalking.collector.worker.storage;
+
+import com.a.eye.skywalking.collector.worker.globaltrace.GlobalTraceIndex;
+import com.a.eye.skywalking.collector.worker.node.NodeCompIndex;
+import com.a.eye.skywalking.collector.worker.node.NodeMappingIndex;
+import com.a.eye.skywalking.collector.worker.noderef.NodeRefIndex;
+import com.a.eye.skywalking.collector.worker.noderef.NodeRefResSumIndex;
+import com.a.eye.skywalking.collector.worker.segment.SegmentCostIndex;
+import com.a.eye.skywalking.collector.worker.segment.SegmentExceptionIndex;
+import com.a.eye.skywalking.collector.worker.segment.SegmentIndex;
+
+/**
+ * @author pengys5
+ */
+public enum IndexCreator {
+ INSTANCE;
+
+ public void create() {
+ SegmentIndex segmentIndex = new SegmentIndex();
+ segmentIndex.deleteIndex();
+
+ GlobalTraceIndex globalTraceIndex = new GlobalTraceIndex();
+ globalTraceIndex.deleteIndex();
+ globalTraceIndex.createIndex();
+
+ SegmentCostIndex segmentCostIndex = new SegmentCostIndex();
+ segmentCostIndex.deleteIndex();
+ segmentCostIndex.createIndex();
+
+ SegmentExceptionIndex segmentExceptionIndex = new SegmentExceptionIndex();
+ segmentExceptionIndex.deleteIndex();
+ segmentExceptionIndex.createIndex();
+
+ NodeCompIndex nodeCompIndex = new NodeCompIndex();
+ nodeCompIndex.deleteIndex();
+ nodeCompIndex.createIndex();
+
+ NodeMappingIndex nodeMappingIndex = new NodeMappingIndex();
+ nodeMappingIndex.deleteIndex();
+ nodeMappingIndex.createIndex();
+
+ NodeRefIndex nodeRefIndex = new NodeRefIndex();
+ nodeRefIndex.deleteIndex();
+ nodeRefIndex.createIndex();
+
+ NodeRefResSumIndex nodeRefResSumIndex = new NodeRefResSumIndex();
+ nodeRefResSumIndex.deleteIndex();
+ nodeRefResSumIndex.createIndex();
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MergeData.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MergeData.java
new file mode 100644
index 000000000..b33a10b54
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MergeData.java
@@ -0,0 +1,79 @@
+package com.a.eye.skywalking.collector.worker.storage;
+
+import com.a.eye.skywalking.collector.actor.selector.AbstractHashMessage;
+
+import java.util.*;
+
+/**
+ * @author pengys5
+ */
+public class MergeData extends AbstractHashMessage {
+
+ public static final String Split = ",";
+
+ private String id;
+
+ private Map> mergeData = new HashMap<>();
+
+ public MergeData(String key) {
+ super(key);
+ this.id = key;
+ }
+
+ public String getId() {
+ return id;
+ }
+
+ public void setMergeData(String column, String value) {
+ if (!mergeData.containsKey(column)) {
+ mergeData.put(column, new HashSet<>());
+ }
+ mergeData.get(column).add(value);
+ }
+
+ public void merge(MergeData data) {
+ for (Map.Entry> entry : data.mergeData.entrySet()) {
+ String column = entry.getKey();
+ Set value = entry.getValue();
+ Iterator iterator = value.iterator();
+ while (iterator.hasNext()) {
+ setMergeData(column, iterator.next());
+ }
+ }
+ }
+
+ public void merge(Map dbData) {
+ for (Map.Entry entry : dbData.entrySet()) {
+ if (!AbstractIndex.Time_Slice.equals(entry.getKey())
+ && !AbstractIndex.AGG_COLUMN.equals(entry.getKey())) {
+ String dbValue = String.valueOf(entry.getValue());
+ String[] dbValues = dbValue.split(Split);
+ for (String value : dbValues) {
+ setMergeData(entry.getKey(), value);
+ }
+ }
+ }
+ }
+
+ public Map toMap() {
+ Map source = new HashMap<>();
+ for (Map.Entry> entry : mergeData.entrySet()) {
+ String column = entry.getKey();
+ Iterator iterator = entry.getValue().iterator();
+ StringBuffer value = new StringBuffer();
+
+ int i = 0;
+ while (iterator.hasNext()) {
+ if (i == 0) {
+ value.append(iterator.next());
+ } else {
+ value.append(Split).append(iterator.next());
+ }
+ i++;
+ }
+ source.put(column, value.toString());
+ }
+
+ return source;
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MergePersistenceData.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MergePersistenceData.java
new file mode 100644
index 000000000..9d9aa9ec7
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MergePersistenceData.java
@@ -0,0 +1,55 @@
+package com.a.eye.skywalking.collector.worker.storage;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+
+/**
+ * @author pengys5
+ */
+public class MergePersistenceData implements Iterable {
+
+ private Map persistenceData = new HashMap();
+
+ public MergeData getElseCreate(String id) {
+ if (!persistenceData.containsKey(id)) {
+ persistenceData.put(id, new MergeData(id));
+ }
+ return persistenceData.get(id);
+ }
+
+ public int size() {
+ return persistenceData.size();
+ }
+
+ public void clear() {
+ persistenceData.clear();
+ }
+
+ public boolean hasNext() {
+ return persistenceData.entrySet().iterator().hasNext();
+ }
+
+ public MergeData pushOne() {
+ MergeData one = persistenceData.entrySet().iterator().next().getValue();
+ persistenceData.remove(one.getId());
+ return one;
+ }
+
+ @Override
+ public void forEach(Consumer action) {
+ throw new UnsupportedOperationException("forEach");
+ }
+
+ @Override
+ public Spliterator spliterator() {
+ throw new UnsupportedOperationException("spliterator");
+ }
+
+ @Override
+ public Iterator> iterator() {
+ return persistenceData.entrySet().iterator();
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MetricData.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MetricData.java
index 89341c910..041f6b0b3 100644
--- a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MetricData.java
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MetricData.java
@@ -1,6 +1,7 @@
package com.a.eye.skywalking.collector.worker.storage;
import com.a.eye.skywalking.collector.actor.selector.AbstractHashMessage;
+import com.a.eye.skywalking.collector.worker.Const;
import java.util.HashMap;
import java.util.Map;
@@ -10,97 +11,62 @@ import java.util.Map;
*/
public class MetricData extends AbstractHashMessage {
- public MetricData(String key) {
- super(key);
- this.id = key;
+ private String id;
+ private Map value;
+
+ public MetricData(String id) {
+ super(id);
+ this.id = id;
+ value = new HashMap<>();
+
+ String[] ids = id.split(Const.IDS_SPLIT);
+ String slice = ids[0];
+ String aggId = "";
+ for (int i = 1; i < ids.length; i++) {
+ if (i == 1) {
+ aggId = ids[i];
+ } else {
+ aggId = aggId + Const.ID_SPLIT + ids[i];
+ }
+ }
+
+ value.put(AbstractIndex.Time_Slice, Long.valueOf(slice));
+ value.put(AbstractIndex.AGG_COLUMN, aggId);
}
- private String id;
-
- private static final String s10 = "s10";
- private static final String s20 = "s20";
- private static final String s30 = "s30";
- private static final String s40 = "s40";
- private static final String s50 = "s50";
- private static final String s60 = "s60";
-
- private Long s10Value = 0L;
- private Long s20Value = 0L;
- private Long s30Value = 0L;
- private Long s40Value = 0L;
- private Long s50Value = 0L;
- private Long s60Value = 0L;
-
- public void setMetric(int second, Long value) {
- if (second <= 10) {
- s10Value += value;
- } else if (second > 10 && second <= 20) {
- s20Value += value;
- } else if (second > 20 && second <= 30) {
- s30Value += value;
- } else if (second > 30 && second <= 40) {
- s40Value += value;
- } else if (second > 40 && second <= 50) {
- s50Value += value;
- } else {
- s60Value += value;
+ public void setMetric(String column, Long value) {
+ long valueAdd = value;
+ if (this.value.containsKey(column) && !AbstractIndex.Time_Slice.equals(column)
+ && !AbstractIndex.AGG_COLUMN.equals(column)) {
+ valueAdd += (Long) this.value.get(column);
}
+ this.value.put(column, valueAdd);
}
public void merge(MetricData metricData) {
- s10Value += metricData.s10Value;
- s20Value += metricData.s20Value;
- s30Value += metricData.s30Value;
- s40Value += metricData.s40Value;
- s50Value += metricData.s50Value;
- s60Value += metricData.s60Value;
+ for (Map.Entry entry : metricData.value.entrySet()) {
+ if (!AbstractIndex.Time_Slice.equals(entry.getKey())
+ && !AbstractIndex.AGG_COLUMN.equals(entry.getKey())) {
+ setMetric(entry.getKey(), (Long) entry.getValue());
+ }
+ }
}
public void merge(Map dbData) {
- s10Value += Long.valueOf(dbData.get(s10).toString());
- s20Value += Long.valueOf(dbData.get(s20).toString());
- s30Value += Long.valueOf(dbData.get(s30).toString());
- s40Value += Long.valueOf(dbData.get(s40).toString());
- s50Value += Long.valueOf(dbData.get(s50).toString());
- s60Value += Long.valueOf(dbData.get(s60).toString());
+ for (Map.Entry entry : dbData.entrySet()) {
+ if (!AbstractIndex.Time_Slice.equals(entry.getKey())
+ && !AbstractIndex.AGG_COLUMN.equals(entry.getKey())) {
+ long dbValue = ((Number) entry.getValue()).longValue();
+ setMetric(entry.getKey(), dbValue);
+ }
+ }
}
- public Map toMap() {
- Map map = new HashMap<>();
- map.put(s10, s10Value);
- map.put(s20, s20Value);
- map.put(s30, s30Value);
- map.put(s40, s40Value);
- map.put(s50, s50Value);
- map.put(s60, s60Value);
- return map;
+ public Map toMap() {
+ return value;
}
public String getId() {
return id;
}
-
- protected Long getS10Value() {
- return s10Value;
- }
-
- protected Long getS20Value() {
- return s20Value;
- }
-
- protected Long getS30Value() {
- return s30Value;
- }
-
- protected Long getS40Value() {
- return s40Value;
- }
-
- protected Long getS50Value() {
- return s50Value;
- }
-
- protected Long getS60Value() {
- return s60Value;
- }
}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MetricPersistenceData.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MetricPersistenceData.java
index 0b2467f68..3f9cdedd5 100644
--- a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MetricPersistenceData.java
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/MetricPersistenceData.java
@@ -4,7 +4,6 @@ import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Spliterator;
-import java.util.function.Consumer;
/**
* @author pengys5
@@ -34,11 +33,6 @@ public class MetricPersistenceData implements Iterable {
return one;
}
- @Override
- public void forEach(Consumer action) {
- throw new UnsupportedOperationException("forEach");
- }
-
@Override
public Spliterator spliterator() {
throw new UnsupportedOperationException("spliterator");
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/RecordData.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/RecordData.java
index 8eba5110b..0135977b5 100644
--- a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/RecordData.java
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/storage/RecordData.java
@@ -1,6 +1,7 @@
package com.a.eye.skywalking.collector.worker.storage;
import com.a.eye.skywalking.collector.actor.selector.AbstractHashMessage;
+import com.a.eye.skywalking.collector.worker.Const;
import com.google.gson.JsonObject;
/**
@@ -9,11 +10,20 @@ import com.google.gson.JsonObject;
public class RecordData extends AbstractHashMessage {
private String id;
+ private String aggId;
private JsonObject record;
public RecordData(String key) {
super(key);
this.id = key;
+ String[] ids = id.split(Const.IDS_SPLIT);
+ for (int i = 1; i < ids.length; i++) {
+ if (i == 1) {
+ this.aggId = ids[i];
+ } else {
+ this.aggId = this.aggId + Const.ID_SPLIT + ids[i];
+ }
+ }
}
public String getId() {
@@ -21,6 +31,7 @@ public class RecordData extends AbstractHashMessage {
}
public JsonObject getRecord() {
+ record.addProperty(AbstractIndex.AGG_COLUMN, this.aggId);
return record;
}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/ClientSpanIsLeafTools.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/ClientSpanIsLeafTools.java
new file mode 100644
index 000000000..9a536e083
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/ClientSpanIsLeafTools.java
@@ -0,0 +1,28 @@
+package com.a.eye.skywalking.collector.worker.tools;
+
+import com.a.eye.skywalking.trace.Span;
+import com.a.eye.skywalking.trace.tag.Tags;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+/**
+ * @author pengys5
+ */
+public class ClientSpanIsLeafTools {
+
+ private static Logger logger = LogManager.getFormatterLogger(ClientSpanIsLeafTools.class);
+
+ public static boolean isLeaf(int spanId, List spanList) {
+ boolean isLeaf = true;
+ for (Span span : spanList) {
+ if (span.getParentSpanId() == spanId && Tags.SPAN_KIND_CLIENT.equals(Tags.SPAN_KIND.get(span))) {
+ logger.debug("current spanId=%s, merge spanId=%s, span kind=%s", spanId, span.getSpanId(), Tags.SPAN_KIND.get(span));
+ isLeaf = false;
+ }
+ }
+
+ return isLeaf;
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/CollectionTools.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/CollectionTools.java
new file mode 100644
index 000000000..5f7c34cc0
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/CollectionTools.java
@@ -0,0 +1,25 @@
+package com.a.eye.skywalking.collector.worker.tools;
+
+import java.util.List;
+
+/**
+ * @author pengys5
+ */
+public class CollectionTools {
+
+ public static boolean isEmpty(List list) {
+ if (list == null || list.size() == 0) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public static boolean isNotEmpty(List list) {
+ if (list == null || list.size() == 0) {
+ return false;
+ } else {
+ return true;
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/DateTools.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/DateTools.java
index bf61c67cf..c5fcff2ca 100644
--- a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/DateTools.java
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/DateTools.java
@@ -2,26 +2,51 @@ package com.a.eye.skywalking.collector.worker.tools;
import java.text.SimpleDateFormat;
import java.util.Calendar;
+import java.util.TimeZone;
/**
* @author pengys5
*/
public class DateTools {
- private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmm");
+ private static final SimpleDateFormat dayDateFormat = new SimpleDateFormat("yyyyMMdd");
+ private static final SimpleDateFormat hourDateFormat = new SimpleDateFormat("yyyyMMddHH");
+ private static final SimpleDateFormat minuteDateFormat = new SimpleDateFormat("yyyyMMddHHmm");
- public static final String Time_Slice_Column_Name = "timeSlice";
-
- public static int timeStampToSecond(long time) {
+ public static int getSecond(long time) {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(time);
return calendar.get(Calendar.SECOND);
}
- public static long timeStampToTimeSlice(long time) {
- Calendar calendar = Calendar.getInstance();
+ public static long getMinuteSlice(long time) {
+ Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("GMT+8:00"));
calendar.setTimeInMillis(time);
- String timeStr = sdf.format(calendar.getTime());
+ String timeStr = minuteDateFormat.format(calendar.getTime());
return Long.valueOf(timeStr);
}
+
+ public static long getHourSlice(long time) {
+ Calendar calendar = Calendar.getInstance();
+ calendar.setTimeInMillis(time);
+ String timeStr = hourDateFormat.format(calendar.getTime()) + "00";
+ return Long.valueOf(timeStr);
+ }
+
+ public static long getDaySlice(long time) {
+ Calendar calendar = Calendar.getInstance();
+ calendar.setTimeInMillis(time);
+ String timeStr = dayDateFormat.format(calendar.getTime()) + "0000";
+ return Long.valueOf(timeStr);
+ }
+
+ public static long changeToUTCSlice(long timeSlice) {
+ String timeSliceStr = String.valueOf(timeSlice);
+
+ if (TimeZone.getDefault().getID().equals("GMT+08:00") || timeSliceStr.endsWith("0000")) {
+ return timeSlice;
+ } else {
+ return timeSlice - 800;
+ }
+ }
}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/JsonFileReader.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/JsonFileReader.java
new file mode 100644
index 000000000..2716c0b68
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/JsonFileReader.java
@@ -0,0 +1,20 @@
+package com.a.eye.skywalking.collector.worker.tools;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParser;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+
+/**
+ * @author pengys5
+ */
+public enum JsonFileReader {
+ INSTANCE;
+
+ public String read(String path) throws FileNotFoundException {
+ JsonParser jsonParser = new JsonParser();
+ JsonElement jsonElement = jsonParser.parse(new FileReader(path));
+ return jsonElement.toString();
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/ParameterTools.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/ParameterTools.java
new file mode 100644
index 000000000..d80458c4d
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/ParameterTools.java
@@ -0,0 +1,19 @@
+package com.a.eye.skywalking.collector.worker.tools;
+
+import java.util.Map;
+
+/**
+ * @author pengys5
+ */
+public enum ParameterTools {
+ INSTANCE;
+
+ public String toString(Map request, String key) {
+ if (request.get(key) != null) {
+ return request.get(key)[0];
+ } else {
+ return "";
+ }
+ }
+
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/SpanPeersTools.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/SpanPeersTools.java
new file mode 100644
index 000000000..55afd7219
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/SpanPeersTools.java
@@ -0,0 +1,21 @@
+package com.a.eye.skywalking.collector.worker.tools;
+
+import com.a.eye.skywalking.api.util.StringUtil;
+import com.a.eye.skywalking.collector.worker.Const;
+import com.a.eye.skywalking.trace.Span;
+import com.a.eye.skywalking.trace.tag.Tags;
+
+/**
+ * @author pengys5
+ */
+public class SpanPeersTools {
+ public static String getPeers(Span span) {
+ if (StringUtil.isEmpty(Tags.PEERS.get(span))) {
+ String host = Tags.PEER_HOST.get(span);
+ int port = Tags.PEER_PORT.get(span);
+ return Const.PEERS_FRONT_SPLIT + host + ":" + port + Const.PEERS_BEHIND_SPLIT;
+ } else {
+ return Const.PEERS_FRONT_SPLIT + Tags.PEERS.get(span) + Const.PEERS_BEHIND_SPLIT;
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/UrlTools.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/UrlTools.java
new file mode 100644
index 000000000..42d659269
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tools/UrlTools.java
@@ -0,0 +1,46 @@
+package com.a.eye.skywalking.collector.worker.tools;
+
+/**
+ * @author pengys5
+ */
+public class UrlTools {
+
+ private static final String HttpUrlHead = "http://";
+ private static final String HttpsUrlHead = "https://";
+ private static final String MotanUrlHead = "motan://";
+
+ public static String parse(String url, String component) {
+ if ("Tomcat".equals(component)) {
+ return parseTomcat(url);
+ } else if ("Motan".equals(component)) {
+ return parseMotan(url);
+ }
+ return null;
+ }
+
+ private static String parseTomcat(String url) {
+ if (url.startsWith(HttpUrlHead)) {
+ String suffix = url.substring(7, url.length());
+ String[] urlSplit = suffix.split("/");
+ return HttpUrlHead + urlSplit[0];
+ } else if (url.startsWith(HttpsUrlHead)) {
+ String suffix = url.substring(8, url.length());
+ String[] urlSplit = suffix.split("/");
+ return HttpsUrlHead + urlSplit[0];
+ } else if (url.contains(":")) {
+ return url.split("/")[0];
+ } else {
+ return url;
+ }
+ }
+
+ private static String parseMotan(String url) {
+ if (url.startsWith(MotanUrlHead)) {
+ String suffix = url.substring(8, url.length());
+ String[] urlSplit = suffix.split("/");
+ return MotanUrlHead + urlSplit[0];
+ } else {
+ return url;
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tracedag/TraceDagDataBuilder.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tracedag/TraceDagDataBuilder.java
new file mode 100644
index 000000000..ce7796c09
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tracedag/TraceDagDataBuilder.java
@@ -0,0 +1,125 @@
+package com.a.eye.skywalking.collector.worker.tracedag;
+
+import com.a.eye.skywalking.collector.worker.Const;
+import com.a.eye.skywalking.collector.worker.node.NodeCompIndex;
+import com.a.eye.skywalking.collector.worker.node.NodeMappingIndex;
+import com.a.eye.skywalking.collector.worker.noderef.NodeRefIndex;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author pengys5
+ */
+public class TraceDagDataBuilder {
+
+ private Logger logger = LogManager.getFormatterLogger(TraceDagDataBuilder.class);
+
+ private Integer nodeId = new Integer(-1);
+ private Map mappingMap = new HashMap<>();
+ private Map nodeCompMap = new HashMap<>();
+ private Map resSumMap = new HashMap<>();
+ private Map 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(NodeRefIndex.Front).getAsString();
+ String behind = nodeRefJsonObj.get(NodeRefIndex.Behind).getAsString();
+
+ String behindCode = findRealCode(behind);
+ logger.debug("behind: %s, behindCode: %s", 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: %s", lineJsonObj);
+ }
+
+ JsonObject dagJsonObj = new JsonObject();
+ dagJsonObj.add("nodes", pointArray);
+ dagJsonObj.add("nodeRefs", lineArray);
+ return dagJsonObj;
+ }
+
+ private Integer findOrCreateNode(String peers) {
+ if (nodeIdMap.containsKey(peers)) {
+ 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: %s", 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(NodeMappingIndex.Code).getAsString();
+ String peers = nodesMappingJsonObj.get(NodeMappingIndex.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);
+ String component = nodesJsonObj.get(NodeCompIndex.Name).getAsString();
+ String peers = nodesJsonObj.get(NodeCompIndex.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);
+ }
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tracedag/TraceDagGetWithTimeSlice.java b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tracedag/TraceDagGetWithTimeSlice.java
new file mode 100644
index 000000000..28cfac4f2
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/tracedag/TraceDagGetWithTimeSlice.java
@@ -0,0 +1,120 @@
+package com.a.eye.skywalking.collector.worker.tracedag;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
+import com.a.eye.skywalking.collector.actor.Role;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.actor.selector.WorkerSelector;
+import com.a.eye.skywalking.collector.worker.Const;
+import com.a.eye.skywalking.collector.worker.httpserver.AbstractGet;
+import com.a.eye.skywalking.collector.worker.httpserver.AbstractGetProvider;
+import com.a.eye.skywalking.collector.worker.node.persistence.NodeCompLoad;
+import com.a.eye.skywalking.collector.worker.node.persistence.NodeMappingSearchWithTimeSlice;
+import com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefResSumSearchWithTimeSlice;
+import com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefSearchWithTimeSlice;
+import com.a.eye.skywalking.collector.worker.tools.ParameterTools;
+import com.google.gson.JsonObject;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Arrays;
+import java.util.Map;
+
+/**
+ * @author pengys5
+ */
+public class TraceDagGetWithTimeSlice extends AbstractGet {
+
+ private Logger logger = LogManager.getFormatterLogger(TraceDagGetWithTimeSlice.class);
+
+ TraceDagGetWithTimeSlice(Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
+ super(role, clusterContext, selfContext);
+ }
+
+ @Override
+ public void preStart() throws ProviderNotFoundException {
+ getClusterContext().findProvider(NodeCompLoad.WorkerRole.INSTANCE).create(this);
+ getClusterContext().findProvider(NodeMappingSearchWithTimeSlice.WorkerRole.INSTANCE).create(this);
+ getClusterContext().findProvider(NodeRefSearchWithTimeSlice.WorkerRole.INSTANCE).create(this);
+ getClusterContext().findProvider(NodeRefResSumSearchWithTimeSlice.WorkerRole.INSTANCE).create(this);
+ }
+
+ @Override
+ protected void onSearch(Map request, JsonObject response) throws Exception {
+ if (!request.containsKey("startTime") || !request.containsKey("endTime") || !request.containsKey("timeSliceType")) {
+ throw new IllegalArgumentException("the request parameter must contains startTime,endTime,timeSliceType");
+ }
+ logger.debug("startTime: %s, endTime: %s, timeSliceType: %s", Arrays.toString(request.get("startTime")),
+ Arrays.toString(request.get("endTime")), Arrays.toString(request.get("timeSliceType")));
+
+ long startTime;
+ try {
+ startTime = Long.valueOf(ParameterTools.INSTANCE.toString(request, "startTime"));
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException("the request parameter startTime must numeric with long type");
+ }
+
+ long endTime;
+ try {
+ endTime = Long.valueOf(ParameterTools.INSTANCE.toString(request, "endTime"));
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException("the request parameter endTime must numeric with long type");
+ }
+
+ String timeSliceType = ParameterTools.INSTANCE.toString(request, "timeSliceType");
+
+ JsonObject compResponse = new JsonObject();
+ getSelfContext().lookup(NodeCompLoad.WorkerRole.INSTANCE).ask(null, compResponse);
+
+ JsonObject nodeMappingResponse = new JsonObject();
+ NodeMappingSearchWithTimeSlice.RequestEntity nodeMappingEntity = new NodeMappingSearchWithTimeSlice.RequestEntity(timeSliceType, startTime, endTime);
+ getSelfContext().lookup(NodeMappingSearchWithTimeSlice.WorkerRole.INSTANCE).ask(nodeMappingEntity, nodeMappingResponse);
+
+ JsonObject nodeRefResponse = new JsonObject();
+ NodeRefSearchWithTimeSlice.RequestEntity nodeReftEntity = new NodeRefSearchWithTimeSlice.RequestEntity(timeSliceType, startTime, endTime);
+ getSelfContext().lookup(NodeRefSearchWithTimeSlice.WorkerRole.INSTANCE).ask(nodeReftEntity, nodeRefResponse);
+
+ JsonObject resSumResponse = new JsonObject();
+ NodeRefResSumSearchWithTimeSlice.RequestEntity resSumEntity = new NodeRefResSumSearchWithTimeSlice.RequestEntity(timeSliceType, startTime, endTime);
+ getSelfContext().lookup(NodeRefResSumSearchWithTimeSlice.WorkerRole.INSTANCE).ask(resSumEntity, resSumResponse);
+
+ TraceDagDataBuilder builder = new TraceDagDataBuilder();
+ JsonObject result = builder.build(compResponse.get(Const.RESULT).getAsJsonArray(), nodeMappingResponse.get(Const.RESULT).getAsJsonArray(),
+ nodeRefResponse.get(Const.RESULT).getAsJsonArray(), resSumResponse.get(Const.RESULT).getAsJsonArray());
+
+ response.add(Const.RESULT, result);
+ }
+
+ public static class Factory extends AbstractGetProvider {
+
+ @Override
+ public Role role() {
+ return WorkerRole.INSTANCE;
+ }
+
+ @Override
+ public TraceDagGetWithTimeSlice workerInstance(ClusterWorkerContext clusterContext) {
+ return new TraceDagGetWithTimeSlice(role(), clusterContext, new LocalWorkerContext());
+ }
+
+ @Override
+ public String servletPath() {
+ return "/traceDag/timeSlice";
+ }
+ }
+
+ public enum WorkerRole implements Role {
+ INSTANCE;
+
+ @Override
+ public String roleName() {
+ return TraceDagGetWithTimeSlice.class.getSimpleName();
+ }
+
+ @Override
+ public WorkerSelector workerSelector() {
+ return new RollingSelector();
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.actor.AbstractClusterWorkerProvider b/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.actor.AbstractClusterWorkerProvider
new file mode 100644
index 000000000..608ec478f
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.actor.AbstractClusterWorkerProvider
@@ -0,0 +1,15 @@
+com.a.eye.skywalking.collector.worker.globaltrace.persistence.GlobalTraceAgg$Factory
+
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefDayAgg$Factory
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefHourAgg$Factory
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefMinuteAgg$Factory
+
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefResSumDayAgg$Factory
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefResSumHourAgg$Factory
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefResSumMinuteAgg$Factory
+
+com.a.eye.skywalking.collector.worker.node.persistence.NodeCompAgg$Factory
+
+com.a.eye.skywalking.collector.worker.node.persistence.NodeMappingDayAgg$Factory
+com.a.eye.skywalking.collector.worker.node.persistence.NodeMappingHourAgg$Factory
+com.a.eye.skywalking.collector.worker.node.persistence.NodeMappingMinuteAgg$Factory
\ No newline at end of file
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.actor.AbstractLocalWorkerProvider b/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.actor.AbstractLocalWorkerProvider
new file mode 100644
index 000000000..30b0397fe
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.actor.AbstractLocalWorkerProvider
@@ -0,0 +1,44 @@
+com.a.eye.skywalking.collector.worker.segment.persistence.SegmentSave$Factory
+com.a.eye.skywalking.collector.worker.segment.persistence.SegmentCostSave$Factory
+com.a.eye.skywalking.collector.worker.segment.persistence.SegmentExceptionSave$Factory
+com.a.eye.skywalking.collector.worker.segment.persistence.SegmentExceptionWithSegId$Factory
+com.a.eye.skywalking.collector.worker.segment.persistence.SegmentTopSearchWithTimeSlice$Factory
+com.a.eye.skywalking.collector.worker.segment.persistence.SegmentTopSearchWithGlobalTraceId$Factory
+
+com.a.eye.skywalking.collector.worker.noderef.analysis.NodeRefDayAnalysis$Factory
+com.a.eye.skywalking.collector.worker.noderef.analysis.NodeRefHourAnalysis$Factory
+com.a.eye.skywalking.collector.worker.noderef.analysis.NodeRefMinuteAnalysis$Factory
+
+com.a.eye.skywalking.collector.worker.noderef.analysis.NodeRefResSumDayAnalysis$Factory
+com.a.eye.skywalking.collector.worker.noderef.analysis.NodeRefResSumHourAnalysis$Factory
+com.a.eye.skywalking.collector.worker.noderef.analysis.NodeRefResSumMinuteAnalysis$Factory
+
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefDaySave$Factory
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefHourSave$Factory
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefMinuteSave$Factory
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefSearchWithTimeSlice$Factory
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefResSumSearchWithTimeSlice$Factory
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefResSumGroupWithTimeSlice$Factory
+
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefResSumDaySave$Factory
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefResSumHourSave$Factory
+com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefResSumMinuteSave$Factory
+
+com.a.eye.skywalking.collector.worker.node.analysis.NodeCompAnalysis$Factory
+com.a.eye.skywalking.collector.worker.node.persistence.NodeCompSave$Factory
+com.a.eye.skywalking.collector.worker.node.persistence.NodeCompLoad$Factory
+
+com.a.eye.skywalking.collector.worker.node.analysis.NodeMappingDayAnalysis$Factory
+com.a.eye.skywalking.collector.worker.node.analysis.NodeMappingHourAnalysis$Factory
+com.a.eye.skywalking.collector.worker.node.analysis.NodeMappingMinuteAnalysis$Factory
+
+com.a.eye.skywalking.collector.worker.node.persistence.NodeMappingDaySave$Factory
+com.a.eye.skywalking.collector.worker.node.persistence.NodeMappingHourSave$Factory
+com.a.eye.skywalking.collector.worker.node.persistence.NodeMappingMinuteSave$Factory
+com.a.eye.skywalking.collector.worker.node.persistence.NodeMappingSearchWithTimeSlice$Factory
+
+com.a.eye.skywalking.collector.worker.globaltrace.analysis.GlobalTraceAnalysis$Factory
+com.a.eye.skywalking.collector.worker.globaltrace.persistence.GlobalTraceSave$Factory
+com.a.eye.skywalking.collector.worker.globaltrace.persistence.GlobalTraceSearchWithGlobalId$Factory
+
+com.a.eye.skywalking.collector.worker.span.persistence.SpanSearchWithId$Factory
\ No newline at end of file
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.actor.AbstractWorkerProvider b/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.actor.AbstractWorkerProvider
deleted file mode 100644
index 1416bc9e5..000000000
--- a/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.actor.AbstractWorkerProvider
+++ /dev/null
@@ -1,6 +0,0 @@
-com.a.eye.skywalking.collector.worker.receiver.TraceSegmentReceiver$Factory
-com.a.eye.skywalking.collector.worker.application.receiver.DAGNodeReceiver$Factory
-com.a.eye.skywalking.collector.worker.application.receiver.NodeInstanceReceiver$Factory
-com.a.eye.skywalking.collector.worker.application.receiver.ResponseCostReceiver$Factory
-com.a.eye.skywalking.collector.worker.application.receiver.ResponseSummaryReceiver$Factory
-com.a.eye.skywalking.collector.worker.applicationref.receiver.DAGNodeRefReceiver$Factory
\ No newline at end of file
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.worker.httpserver.AbstractGetProvider b/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.worker.httpserver.AbstractGetProvider
new file mode 100644
index 000000000..ea63a29ac
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.worker.httpserver.AbstractGetProvider
@@ -0,0 +1,8 @@
+com.a.eye.skywalking.collector.worker.noderef.NodeRefGetWithTimeSlice$Factory
+com.a.eye.skywalking.collector.worker.noderef.NodeRefResSumGetWithTimeSlice$Factory
+com.a.eye.skywalking.collector.worker.noderef.NodeRefResSumGetGroupWithTimeSlice$Factory
+com.a.eye.skywalking.collector.worker.segment.SegmentTopGetWithTimeSlice$Factory
+com.a.eye.skywalking.collector.worker.globaltrace.GlobalTraceGetWithGlobalId$Factory
+com.a.eye.skywalking.collector.worker.segment.SegmentTopGetWithGlobalTraceId$Factory
+com.a.eye.skywalking.collector.worker.span.SpanGetWithId$Factory
+com.a.eye.skywalking.collector.worker.tracedag.TraceDagGetWithTimeSlice$Factory
\ No newline at end of file
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.worker.httpserver.AbstractPostProvider b/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.worker.httpserver.AbstractPostProvider
new file mode 100644
index 000000000..4918285cd
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.worker.httpserver.AbstractPostProvider
@@ -0,0 +1 @@
+com.a.eye.skywalking.collector.worker.segment.SegmentPost$Factory
\ No newline at end of file
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.worker.httpserver.ControllerProvider b/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.worker.httpserver.ControllerProvider
deleted file mode 100644
index 64fd663e3..000000000
--- a/skywalking-collector/skywalking-collector-worker/src/main/resources/META-INF/services/com.a.eye.skywalking.collector.worker.httpserver.ControllerProvider
+++ /dev/null
@@ -1 +0,0 @@
-com.a.eye.skywalking.collector.worker.httpserver.controller.DagController$Factory
\ No newline at end of file
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/resources/collector.config b/skywalking-collector/skywalking-collector-worker/src/main/resources/collector.config
index 459b5d9bd..159b51eee 100644
--- a/skywalking-collector/skywalking-collector-worker/src/main/resources/collector.config
+++ b/skywalking-collector/skywalking-collector-worker/src/main/resources/collector.config
@@ -1,4 +1,7 @@
cluster.current.hostname=127.0.0.1
cluster.current.port=1000
-cluster.current.roles=[WorkersListener, TraceSegmentReceiver, NodeInstancePersistence]
-cluster.seed_nodes=["akka.tcp://CollectorSystem@127.0.0.1:1000", "akka.tcp://CollectorSystem@127.0.0.1:1001", "akka.tcp://CollectorSystem@127.0.0.1:1002"]
+cluster.current.roles=[WorkersListener]
+#cluster.seed_nodes=["akka.tcp://CollectorSystem@127.0.0.1:1000"]
+
+es.cluster.name=
+es.cluster.nodes=
diff --git a/skywalking-collector/skywalking-collector-worker/src/main/resources/log4j2.xml b/skywalking-collector/skywalking-collector-worker/src/main/resources/log4j2.xml
index e8fc5bbdb..a97644db3 100644
--- a/skywalking-collector/skywalking-collector-worker/src/main/resources/log4j2.xml
+++ b/skywalking-collector/skywalking-collector-worker/src/main/resources/log4j2.xml
@@ -1,13 +1,19 @@
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/AnalysisMemberTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/AnalysisMemberTestCase.java
new file mode 100644
index 000000000..3e3583acc
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/AnalysisMemberTestCase.java
@@ -0,0 +1,32 @@
+package com.a.eye.skywalking.collector.worker;
+
+import com.a.eye.skywalking.collector.queue.EndOfBatchCommand;
+import org.junit.Test;
+
+import static org.mockito.Mockito.*;
+
+/**
+ * @author pengys5
+ */
+public class AnalysisMemberTestCase {
+
+ @Test
+ public void testCommandOnWork() throws Exception {
+ AnalysisMember member = mock(AnalysisMember.class);
+
+ EndOfBatchCommand command = new EndOfBatchCommand();
+ member.onWork(command);
+ verify(member, times(1)).aggregation();
+ verify(member, never()).analyse(anyObject());
+ }
+
+ @Test
+ public void testAnalyse() throws Exception {
+ AnalysisMember member = mock(AnalysisMember.class);
+
+ Object message = new Object();
+ member.onWork(message);
+ verify(member, never()).aggregation();
+ verify(member, times(1)).analyse(anyObject());
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/MergeAnalysisMemberTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/MergeAnalysisMemberTestCase.java
new file mode 100644
index 000000000..bf667754f
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/MergeAnalysisMemberTestCase.java
@@ -0,0 +1,63 @@
+package com.a.eye.skywalking.collector.worker;
+
+import com.a.eye.skywalking.collector.worker.storage.MergeData;
+import com.a.eye.skywalking.collector.worker.storage.MergePersistenceData;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import static org.powermock.api.mockito.PowerMockito.*;
+
+/**
+ * @author pengys5
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(MergeAnalysisMember.class)
+public class MergeAnalysisMemberTestCase {
+
+ private MergeAnalysisMember member;
+ private MergePersistenceData persistenceData;
+
+ @Before
+ public void init() throws Exception {
+ member = mock(MergeAnalysisMember.class);
+ persistenceData = mock(MergePersistenceData.class);
+ MergeData mergeData = mock(MergeData.class);
+
+ when(member, "getPersistenceData").thenReturn(persistenceData);
+ when(persistenceData.getElseCreate(Mockito.anyString())).thenReturn(mergeData);
+
+ doCallRealMethod().when(member).setMergeData(Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
+ }
+
+ @Test
+ public void testSetMergeDataNotFull() throws Exception {
+ when(persistenceData.size()).thenReturn(WorkerConfig.Persistence.Data.size - 1);
+
+ member.setMergeData("segment_1", "column", "value");
+ Mockito.verify(member, Mockito.never()).aggregation();
+ }
+
+ @Test
+ public void testSetMergeDataFull() throws Exception {
+ when(persistenceData.size()).thenReturn(WorkerConfig.Persistence.Data.size);
+
+ member.setMergeData("segment_1", "column", "value");
+ Mockito.verify(member, Mockito.times(1)).aggregation();
+ }
+
+ @Test
+ public void testPushOne() throws Exception {
+ MergePersistenceData persistenceData = new MergePersistenceData();
+ persistenceData.getElseCreate("segment_1").setMergeData("column", "value");
+
+ when(member, "getPersistenceData").thenReturn(persistenceData);
+ doCallRealMethod().when(member).pushOne();
+
+ Assert.assertEquals("segment_1", member.pushOne().getId());
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/StartUpTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/StartUpTestCase.java
index 417310df4..fabd68d2c 100644
--- a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/StartUpTestCase.java
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/StartUpTestCase.java
@@ -5,7 +5,7 @@ import akka.actor.ActorSelection;
import akka.actor.ActorSystem;
import com.a.eye.skywalking.collector.cluster.ClusterConfig;
import com.a.eye.skywalking.collector.cluster.ClusterConfigInitializer;
-import com.a.eye.skywalking.collector.worker.receiver.TraceSegmentReceiver;
+import com.a.eye.skywalking.collector.worker.segment.SegmentPost;
import com.a.eye.skywalking.collector.worker.storage.EsClient;
import com.a.eye.skywalking.sniffer.mock.trace.TraceSegmentBuilderFactory;
import com.a.eye.skywalking.trace.TraceSegment;
@@ -18,7 +18,7 @@ import com.typesafe.config.ConfigFactory;
public class StartUpTestCase {
public void test() throws Exception {
- System.out.println(TraceSegmentReceiver.class.getSimpleName());
+ System.out.println(SegmentPost.class.getSimpleName());
ClusterConfigInitializer.initialize("collector.config");
System.out.println(ClusterConfig.Cluster.Current.roles);
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/globaltrace/GlobalTraceSearchTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/globaltrace/GlobalTraceSearchTestCase.java
new file mode 100644
index 000000000..57ead136f
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/globaltrace/GlobalTraceSearchTestCase.java
@@ -0,0 +1,60 @@
+package com.a.eye.skywalking.collector.worker.globaltrace;
+
+import com.a.eye.skywalking.collector.worker.globaltrace.persistence.GlobalTraceSearchWithGlobalId;
+import com.a.eye.skywalking.collector.worker.segment.SegmentIndex;
+import com.a.eye.skywalking.collector.worker.storage.EsClient;
+import com.a.eye.skywalking.collector.worker.tools.JsonFileReader;
+import com.google.gson.JsonObject;
+import org.elasticsearch.action.get.GetRequestBuilder;
+import org.elasticsearch.action.get.GetResponse;
+import org.elasticsearch.client.Client;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import static org.powermock.api.mockito.PowerMockito.*;
+
+/**
+ * @author pengys5
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({EsClient.class})
+@PowerMockIgnore("javax.management.*")
+public class GlobalTraceSearchTestCase {
+
+ @Test
+ public void testSearchWithGlobalId() throws Exception {
+ Client client = mock(Client.class);
+ mockStatic(EsClient.class);
+ when(EsClient.getClient()).thenReturn(client);
+
+ String globalTraceId = "Global.1";
+ String segment_1 = "SEGMENT.1";
+ String segment_2 = "SEGMENT.2";
+
+// String globalData = JsonFileReader.INSTANCE.read(this.getClass().getResource("/").getPath() + "/json/globaltrace/global.json");
+// mockSegment(client, GlobalTraceIndex.Index, GlobalTraceIndex.Type_Record, globalTraceId, globalData);
+//
+// String segment_1_Data = JsonFileReader.INSTANCE.read(this.getClass().getResource("/").getPath() + "/json/globaltrace/segment_1.json");
+// mockSegment(client, SegmentIndex.Index, SegmentIndex.Type_Record, segment_1, segment_1_Data);
+//
+// String segment_2_Data = JsonFileReader.INSTANCE.read(this.getClass().getResource("/").getPath() + "/json/globaltrace/segment_2.json");
+// mockSegment(client, SegmentIndex.Index, SegmentIndex.Type_Record, segment_2, segment_2_Data);
+//
+// GlobalTraceSearchWithGlobalId search = new GlobalTraceSearchWithGlobalId(null, null, null);
+//
+// JsonObject responseObj = new JsonObject();
+// search.allocateJob(globalTraceId, responseObj);
+// System.out.println(responseObj);
+ }
+
+ private void mockSegment(Client client, String index, String type, String segmentId, String source) {
+ GetRequestBuilder builder = mock(GetRequestBuilder.class);
+ when(client.prepareGet(index, type, segmentId)).thenReturn(builder);
+ GetResponse response = mock(GetResponse.class);
+ when(builder.get()).thenReturn(response);
+ when(response.getSourceAsString()).thenReturn(source);
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/mock/MockEsBulkClient.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/mock/MockEsBulkClient.java
new file mode 100644
index 000000000..1221f6624
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/mock/MockEsBulkClient.java
@@ -0,0 +1,42 @@
+package com.a.eye.skywalking.collector.worker.mock;
+
+import com.a.eye.skywalking.collector.worker.storage.EsClient;
+import org.elasticsearch.action.ListenableActionFuture;
+import org.elasticsearch.action.bulk.BulkRequestBuilder;
+import org.elasticsearch.action.bulk.BulkResponse;
+import org.elasticsearch.action.index.IndexRequestBuilder;
+import org.elasticsearch.client.Client;
+import org.mockito.Mockito;
+
+import static org.powermock.api.mockito.PowerMockito.*;
+
+/**
+ * @author pengys5
+ */
+public class MockEsBulkClient {
+
+ public IndexRequestBuilder indexRequestBuilder;
+
+ public void createMock() {
+ Client client = mock(Client.class);
+ mockStatic(EsClient.class);
+ when(EsClient.getClient()).thenReturn(client);
+
+ BulkRequestBuilder bulkRequestBuilder = mock(BulkRequestBuilder.class);
+ when(client.prepareBulk()).thenReturn(bulkRequestBuilder);
+
+ ListenableActionFuture listenableActionFuture = mock(ListenableActionFuture.class);
+ when(bulkRequestBuilder.execute()).thenReturn(listenableActionFuture);
+
+ BulkResponse responses = mock(BulkResponse.class);
+ when(listenableActionFuture.actionGet()).thenReturn(responses);
+
+ when(responses.hasFailures()).thenReturn(true);
+
+ indexRequestBuilder = mock(IndexRequestBuilder.class);
+
+ when(client.prepareIndex(Mockito.anyString(), Mockito.anyString(), Mockito.anyString())).thenReturn(indexRequestBuilder);
+
+ when(indexRequestBuilder.setSource(Mockito.anyString())).thenReturn(indexRequestBuilder);
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/mock/RecordDataAnswer.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/mock/RecordDataAnswer.java
new file mode 100644
index 000000000..4dc379aef
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/mock/RecordDataAnswer.java
@@ -0,0 +1,40 @@
+package com.a.eye.skywalking.collector.worker.mock;
+
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author pengys5
+ */
+public class RecordDataAnswer implements Answer {
+
+ public RecordObj recordObj = new RecordObj();
+
+ @Override
+ public Object answer(InvocationOnMock invocation) throws Throwable {
+ RecordData recordData = (RecordData) invocation.getArguments()[0];
+ recordObj.setSource(recordData);
+ return null;
+ }
+
+ public class RecordObj {
+ private List recordDataList;
+
+ private RecordObj() {
+ recordDataList = new ArrayList<>();
+ }
+
+ public List getRecordData() {
+ return recordDataList;
+ }
+
+ private void setSource(RecordData recordData) {
+ this.recordDataList.add(recordData);
+ System.out.printf("id: %s, data: %s \n", recordData.getId(), recordData.getRecord().toString());
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/mock/SaveToEsSourceAnswer.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/mock/SaveToEsSourceAnswer.java
new file mode 100644
index 000000000..6fd4625ca
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/mock/SaveToEsSourceAnswer.java
@@ -0,0 +1,46 @@
+package com.a.eye.skywalking.collector.worker.mock;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+/**
+ * @author pengys5
+ */
+public class SaveToEsSourceAnswer implements Answer {
+
+ private Logger logger = LogManager.getFormatterLogger(SaveToEsSourceAnswer.class);
+
+ public SourceObj sourceObj = new SourceObj();
+
+ @Override
+ public Object answer(InvocationOnMock invocation) throws Throwable {
+ Gson gson = new Gson();
+ String source = (String) invocation.getArguments()[0];
+ JsonObject sourceJsonObj = gson.fromJson(source, JsonObject.class);
+ logger.debug("sourceJsonObj: %s", sourceJsonObj.toString());
+
+ sourceObj.setSource(sourceJsonObj);
+ return null;
+ }
+
+ public class SourceObj {
+ private JsonArray source;
+
+ public SourceObj() {
+ source = new JsonArray();
+ }
+
+ public JsonArray getSource() {
+ return source;
+ }
+
+ public void setSource(JsonObject source) {
+ this.source.add(source);
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeAnalysisVerify.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeAnalysisVerify.java
new file mode 100644
index 000000000..6ea40d7eb
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeAnalysisVerify.java
@@ -0,0 +1,72 @@
+package com.a.eye.skywalking.collector.worker.node.analysis;
+
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.RecordDataTool;
+import org.junit.Assert;
+
+import java.util.List;
+
+/**
+ * @author pengys5
+ */
+public enum NodeAnalysisVerify {
+ INSTANCE;
+
+ public void verify(List recordDataList, long timeSlice) {
+ Assert.assertEquals(9, recordDataList.size());
+
+ RecordData data_1 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..[localhost:-1]");
+ Assert.assertEquals("H2", data_1.getRecord().get("component").getAsString());
+ Assert.assertEquals("[localhost:-1]", data_1.getRecord().get("peers").getAsString());
+ Assert.assertEquals("[localhost:-1]", data_1.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_1.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_2 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..portal-service");
+ Assert.assertEquals("Tomcat", data_2.getRecord().get("component").getAsString());
+ Assert.assertEquals("portal-service", data_2.getRecord().get("peers").getAsString());
+ Assert.assertEquals("portal-service", data_2.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_2.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_3 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..persistence-service");
+ Assert.assertEquals(false, data_3.getRecord().has("component"));
+ Assert.assertEquals("persistence-service", data_3.getRecord().get("peers").getAsString());
+ Assert.assertEquals("persistence-service", data_3.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_3.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_4 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..[10.128.35.80:20880]");
+ Assert.assertEquals("HttpClient", data_4.getRecord().get("component").getAsString());
+ Assert.assertEquals("[10.128.35.80:20880]", data_4.getRecord().get("peers").getAsString());
+ Assert.assertEquals("[10.128.35.80:20880]", data_4.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_4.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_5 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..[127.0.0.1:6379]");
+ Assert.assertEquals("Redis", data_5.getRecord().get("component").getAsString());
+ Assert.assertEquals("[127.0.0.1:6379]", data_5.getRecord().get("peers").getAsString());
+ Assert.assertEquals("[127.0.0.1:6379]", data_5.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_5.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_6 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..[127.0.0.1:8002]");
+ Assert.assertEquals("Motan", data_6.getRecord().get("component").getAsString());
+ Assert.assertEquals("[127.0.0.1:8002]", data_6.getRecord().get("peers").getAsString());
+ Assert.assertEquals("[127.0.0.1:8002]", data_6.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_6.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_7 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..User");
+ Assert.assertEquals(false, data_7.getRecord().has("component"));
+ Assert.assertEquals("User", data_7.getRecord().get("peers").getAsString());
+ Assert.assertEquals("User", data_7.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_7.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_8 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..[127.0.0.1:3307]");
+ Assert.assertEquals("Mysql", data_8.getRecord().get("component").getAsString());
+ Assert.assertEquals("[127.0.0.1:3307]", data_8.getRecord().get("peers").getAsString());
+ Assert.assertEquals("[127.0.0.1:3307]", data_8.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_8.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_9 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..cache-service");
+ Assert.assertEquals(false, data_9.getRecord().has("component"));
+ Assert.assertEquals("cache-service", data_9.getRecord().get("peers").getAsString());
+ Assert.assertEquals("cache-service", data_9.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_9.getRecord().get("timeSlice").getAsLong());
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeMappingAnalysisVerify.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeMappingAnalysisVerify.java
new file mode 100644
index 000000000..e3705ce39
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeMappingAnalysisVerify.java
@@ -0,0 +1,30 @@
+package com.a.eye.skywalking.collector.worker.node.analysis;
+
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.RecordDataTool;
+import org.junit.Assert;
+
+import java.util.List;
+
+/**
+ * @author pengys5
+ */
+public enum NodeMappingAnalysisVerify {
+ INSTANCE;
+
+ public void verify(List recordDataList, long timeSlice) {
+ Assert.assertEquals(2, recordDataList.size());
+
+ RecordData data_1 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..persistence-service..-..[10.128.35.80:20880]");
+ Assert.assertEquals("persistence-service", data_1.getRecord().get("code").getAsString());
+ Assert.assertEquals("[10.128.35.80:20880]", data_1.getRecord().get("peers").getAsString());
+ Assert.assertEquals("persistence-service..-..[10.128.35.80:20880]", data_1.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_1.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_2 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..cache-service..-..[127.0.0.1:8002]");
+ Assert.assertEquals("cache-service", data_2.getRecord().get("code").getAsString());
+ Assert.assertEquals("[127.0.0.1:8002]", data_2.getRecord().get("peers").getAsString());
+ Assert.assertEquals("cache-service..-..[127.0.0.1:8002]", data_2.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_2.getRecord().get("timeSlice").getAsLong());
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeMappingDayAnalysisTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeMappingDayAnalysisTestCase.java
new file mode 100644
index 000000000..70d5bfe3c
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeMappingDayAnalysisTestCase.java
@@ -0,0 +1,99 @@
+package com.a.eye.skywalking.collector.worker.node.analysis;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.WorkerRefs;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.queue.EndOfBatchCommand;
+import com.a.eye.skywalking.collector.worker.WorkerConfig;
+import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
+import com.a.eye.skywalking.collector.worker.node.persistence.NodeMappingDayAgg;
+import com.a.eye.skywalking.collector.worker.segment.SegmentPost;
+import com.a.eye.skywalking.collector.worker.segment.mock.SegmentMock;
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.DateTools;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.List;
+
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.powermock.api.mockito.PowerMockito.when;
+
+/**
+ * @author pengys5
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({ClusterWorkerContext.class})
+@PowerMockIgnore({"javax.management.*"})
+public class NodeMappingDayAnalysisTestCase {
+
+ private NodeMappingDayAnalysis nodeMappingDayAnalysis;
+ private SegmentMock segmentMock = new SegmentMock();
+ private RecordDataAnswer recordDataAnswer;
+
+ @Before
+ public void init() throws Exception {
+ ClusterWorkerContext clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
+ WorkerRefs workerRefs = mock(WorkerRefs.class);
+ recordDataAnswer = new RecordDataAnswer();
+ doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
+
+ when(clusterWorkerContext.lookup(NodeMappingDayAgg.Role.INSTANCE)).thenReturn(workerRefs);
+
+ LocalWorkerContext localWorkerContext = new LocalWorkerContext();
+ nodeMappingDayAnalysis = new NodeMappingDayAnalysis(NodeMappingDayAnalysis.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
+ }
+
+ @Test
+ public void testRole() {
+ Assert.assertEquals(NodeMappingDayAnalysis.class.getSimpleName(), NodeMappingDayAnalysis.Role.INSTANCE.roleName());
+ Assert.assertEquals(RollingSelector.class.getSimpleName(), NodeMappingDayAnalysis.Role.INSTANCE.workerSelector().getClass().getSimpleName());
+ }
+
+ @Test
+ public void testFactory() {
+ Assert.assertEquals(NodeMappingDayAnalysis.class.getSimpleName(), NodeMappingDayAnalysis.Factory.INSTANCE.role().roleName());
+ Assert.assertEquals(NodeMappingDayAnalysis.class.getSimpleName(), NodeMappingDayAnalysis.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
+
+ int testSize = 10;
+ WorkerConfig.Queue.Node.NodeMappingDayAnalysis.Size = testSize;
+ Assert.assertEquals(testSize, NodeMappingDayAnalysis.Factory.INSTANCE.queueSize());
+ }
+
+ @Test
+ public void testAnalyse() throws Exception {
+ List cacheServiceSegment = segmentMock.mockCacheServiceSegmentSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : cacheServiceSegment) {
+ nodeMappingDayAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List portalService = segmentMock.mockPortalServiceSegmentSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : portalService) {
+ nodeMappingDayAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List persistenceService = segmentMock.mockPersistenceServiceSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : persistenceService) {
+ nodeMappingDayAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List cacheServiceException = segmentMock.mockCacheServiceExceptionSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : cacheServiceException) {
+ nodeMappingDayAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List portalServiceException = segmentMock.mockPortalServiceExceptionSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : portalServiceException) {
+ nodeMappingDayAnalysis.analyse(segmentWithTimeSlice);
+ }
+
+ nodeMappingDayAnalysis.onWork(new EndOfBatchCommand());
+
+ NodeMappingAnalysisVerify.INSTANCE.verify(recordDataAnswer.recordObj.getRecordData(), DateTools.changeToUTCSlice(201703310000L));
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeMappingHourAnalysisTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeMappingHourAnalysisTestCase.java
new file mode 100644
index 000000000..ecc0454aa
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeMappingHourAnalysisTestCase.java
@@ -0,0 +1,100 @@
+package com.a.eye.skywalking.collector.worker.node.analysis;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.WorkerRefs;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.queue.EndOfBatchCommand;
+import com.a.eye.skywalking.collector.worker.WorkerConfig;
+import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
+import com.a.eye.skywalking.collector.worker.node.persistence.NodeMappingDayAgg;
+import com.a.eye.skywalking.collector.worker.node.persistence.NodeMappingHourAgg;
+import com.a.eye.skywalking.collector.worker.segment.SegmentPost;
+import com.a.eye.skywalking.collector.worker.segment.mock.SegmentMock;
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.DateTools;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.List;
+
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.powermock.api.mockito.PowerMockito.when;
+
+/**
+ * @author pengys5
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({ClusterWorkerContext.class})
+@PowerMockIgnore({"javax.management.*"})
+public class NodeMappingHourAnalysisTestCase {
+
+ private NodeMappingHourAnalysis nodeMappingHourAnalysis;
+ private SegmentMock segmentMock = new SegmentMock();
+ private RecordDataAnswer recordDataAnswer;
+
+ @Before
+ public void init() throws Exception {
+ ClusterWorkerContext clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
+ WorkerRefs workerRefs = mock(WorkerRefs.class);
+ recordDataAnswer = new RecordDataAnswer();
+ doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
+
+ when(clusterWorkerContext.lookup(NodeMappingHourAgg.Role.INSTANCE)).thenReturn(workerRefs);
+
+ LocalWorkerContext localWorkerContext = new LocalWorkerContext();
+ nodeMappingHourAnalysis = new NodeMappingHourAnalysis(NodeMappingHourAnalysis.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
+ }
+
+ @Test
+ public void testRole() {
+ Assert.assertEquals(NodeMappingHourAnalysis.class.getSimpleName(), NodeMappingHourAnalysis.Role.INSTANCE.roleName());
+ Assert.assertEquals(RollingSelector.class.getSimpleName(), NodeMappingHourAnalysis.Role.INSTANCE.workerSelector().getClass().getSimpleName());
+ }
+
+ @Test
+ public void testFactory() {
+ Assert.assertEquals(NodeMappingHourAnalysis.class.getSimpleName(), NodeMappingHourAnalysis.Factory.INSTANCE.role().roleName());
+ Assert.assertEquals(NodeMappingHourAnalysis.class.getSimpleName(), NodeMappingHourAnalysis.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
+
+ int testSize = 10;
+ WorkerConfig.Queue.Node.NodeMappingHourAnalysis.Size = testSize;
+ Assert.assertEquals(testSize, NodeMappingHourAnalysis.Factory.INSTANCE.queueSize());
+ }
+
+ @Test
+ public void testAnalyse() throws Exception {
+ List cacheServiceSegment = segmentMock.mockCacheServiceSegmentSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : cacheServiceSegment) {
+ nodeMappingHourAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List portalService = segmentMock.mockPortalServiceSegmentSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : portalService) {
+ nodeMappingHourAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List persistenceService = segmentMock.mockPersistenceServiceSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : persistenceService) {
+ nodeMappingHourAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List cacheServiceException = segmentMock.mockCacheServiceExceptionSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : cacheServiceException) {
+ nodeMappingHourAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List portalServiceException = segmentMock.mockPortalServiceExceptionSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : portalServiceException) {
+ nodeMappingHourAnalysis.analyse(segmentWithTimeSlice);
+ }
+
+ nodeMappingHourAnalysis.onWork(new EndOfBatchCommand());
+
+ NodeMappingAnalysisVerify.INSTANCE.verify(recordDataAnswer.recordObj.getRecordData(), DateTools.changeToUTCSlice(201703310900L));
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeMappingMinuteAnalysisTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeMappingMinuteAnalysisTestCase.java
new file mode 100644
index 000000000..1e8ac9802
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/analysis/NodeMappingMinuteAnalysisTestCase.java
@@ -0,0 +1,124 @@
+package com.a.eye.skywalking.collector.worker.node.analysis;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.WorkerRefs;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.queue.EndOfBatchCommand;
+import com.a.eye.skywalking.collector.worker.WorkerConfig;
+import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
+import com.a.eye.skywalking.collector.worker.node.persistence.NodeMappingMinuteAgg;
+import com.a.eye.skywalking.collector.worker.segment.SegmentPost;
+import com.a.eye.skywalking.collector.worker.segment.mock.SegmentMock;
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.DateTools;
+import com.a.eye.skywalking.collector.worker.tools.RecordDataTool;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.List;
+
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.powermock.api.mockito.PowerMockito.when;
+
+/**
+ * @author pengys5
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({ClusterWorkerContext.class})
+@PowerMockIgnore({"javax.management.*"})
+public class NodeMappingMinuteAnalysisTestCase {
+
+ private NodeMappingMinuteAnalysis nodeMappingMinuteAnalysis;
+ private SegmentMock segmentMock = new SegmentMock();
+ private RecordDataAnswer recordDataAnswer;
+
+ @Before
+ public void init() throws Exception {
+ ClusterWorkerContext clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
+ WorkerRefs workerRefs = mock(WorkerRefs.class);
+ recordDataAnswer = new RecordDataAnswer();
+ doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
+
+ when(clusterWorkerContext.lookup(NodeMappingMinuteAgg.Role.INSTANCE)).thenReturn(workerRefs);
+
+ LocalWorkerContext localWorkerContext = new LocalWorkerContext();
+ nodeMappingMinuteAnalysis = new NodeMappingMinuteAnalysis(NodeMappingMinuteAnalysis.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
+ }
+
+ @Test
+ public void testRole() {
+ Assert.assertEquals(NodeMappingMinuteAnalysis.class.getSimpleName(), NodeMappingMinuteAnalysis.Role.INSTANCE.roleName());
+ Assert.assertEquals(RollingSelector.class.getSimpleName(), NodeMappingMinuteAnalysis.Role.INSTANCE.workerSelector().getClass().getSimpleName());
+ }
+
+ @Test
+ public void testFactory() {
+ Assert.assertEquals(NodeMappingMinuteAnalysis.class.getSimpleName(), NodeMappingMinuteAnalysis.Factory.INSTANCE.role().roleName());
+ Assert.assertEquals(NodeMappingMinuteAnalysis.class.getSimpleName(), NodeMappingMinuteAnalysis.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
+
+ int testSize = 10;
+ WorkerConfig.Queue.Node.NodeMappingMinuteAnalysis.Size = testSize;
+ Assert.assertEquals(testSize, NodeMappingMinuteAnalysis.Factory.INSTANCE.queueSize());
+ }
+
+ @Test
+ public void testAnalyse() throws Exception {
+ List cacheServiceSegment = segmentMock.mockCacheServiceSegmentSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : cacheServiceSegment) {
+ nodeMappingMinuteAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List portalService = segmentMock.mockPortalServiceSegmentSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : portalService) {
+ nodeMappingMinuteAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List persistenceService = segmentMock.mockPersistenceServiceSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : persistenceService) {
+ nodeMappingMinuteAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List cacheServiceException = segmentMock.mockCacheServiceExceptionSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : cacheServiceException) {
+ nodeMappingMinuteAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List portalServiceException = segmentMock.mockPortalServiceExceptionSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : portalServiceException) {
+ nodeMappingMinuteAnalysis.analyse(segmentWithTimeSlice);
+ }
+
+ nodeMappingMinuteAnalysis.onWork(new EndOfBatchCommand());
+
+ Assert.assertEquals(3, recordDataAnswer.recordObj.getRecordData().size());
+ this.verify_1(recordDataAnswer.recordObj.getRecordData(), DateTools.changeToUTCSlice(201703310915L));
+ this.verify_2(recordDataAnswer.recordObj.getRecordData(), DateTools.changeToUTCSlice(201703310916L));
+ }
+
+ public void verify_1(List recordDataList, long timeSlice) {
+ RecordData data_1 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..persistence-service..-..[10.128.35.80:20880]");
+ Assert.assertEquals("persistence-service", data_1.getRecord().get("code").getAsString());
+ Assert.assertEquals("[10.128.35.80:20880]", data_1.getRecord().get("peers").getAsString());
+ Assert.assertEquals("persistence-service..-..[10.128.35.80:20880]", data_1.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_1.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_2 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..cache-service..-..[127.0.0.1:8002]");
+ Assert.assertEquals("cache-service", data_2.getRecord().get("code").getAsString());
+ Assert.assertEquals("[127.0.0.1:8002]", data_2.getRecord().get("peers").getAsString());
+ Assert.assertEquals("cache-service..-..[127.0.0.1:8002]", data_2.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_2.getRecord().get("timeSlice").getAsLong());
+ }
+
+ public void verify_2(List recordDataList, long timeSlice) {
+ RecordData data_2 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..cache-service..-..[127.0.0.1:8002]");
+ Assert.assertEquals("cache-service", data_2.getRecord().get("code").getAsString());
+ Assert.assertEquals("[127.0.0.1:8002]", data_2.getRecord().get("peers").getAsString());
+ Assert.assertEquals("cache-service..-..[127.0.0.1:8002]", data_2.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_2.getRecord().get("timeSlice").getAsLong());
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeCompWithTimeSliceUseDB.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeCompWithTimeSliceUseDB.java
new file mode 100644
index 000000000..c34c841ee
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeCompWithTimeSliceUseDB.java
@@ -0,0 +1,33 @@
+package com.a.eye.skywalking.collector.worker.node.persistence;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.worker.storage.EsClient;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+/**
+ * @author pengys5
+ */
+public class NodeCompWithTimeSliceUseDB {
+
+ public static void main(String[] args) throws Exception {
+ EsClient.boot();
+
+ ClusterWorkerContext clusterWorkerContext = new ClusterWorkerContext(null);
+ LocalWorkerContext localWorkerContext = new LocalWorkerContext();
+ NodeCompLoad nodeCompLoad =
+ new NodeCompLoad(NodeCompLoad.WorkerRole.INSTANCE, clusterWorkerContext, localWorkerContext);
+
+ JsonObject response = new JsonObject();
+ nodeCompLoad.onWork(null, response);
+
+ JsonArray nodeArray = response.get("result").getAsJsonArray();
+ System.out.println(nodeArray.size());
+ System.out.println(nodeArray.toString());
+ for (int i = 0; i < nodeArray.size(); i++) {
+ JsonObject nodeJsonObj = nodeArray.get(i).getAsJsonObject();
+ System.out.println(nodeJsonObj);
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingDayAggTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingDayAggTestCase.java
new file mode 100644
index 000000000..092f43765
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingDayAggTestCase.java
@@ -0,0 +1,88 @@
+package com.a.eye.skywalking.collector.worker.node.persistence;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.WorkerRefs;
+import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
+import com.a.eye.skywalking.collector.worker.Const;
+import com.a.eye.skywalking.collector.worker.WorkerConfig;
+import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.RecordDataTool;
+import com.google.gson.JsonObject;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.List;
+
+import static org.mockito.Mockito.*;
+
+/**
+ * @author pengys5
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({LocalWorkerContext.class})
+@PowerMockIgnore({"javax.management.*"})
+public class NodeMappingDayAggTestCase {
+
+ private NodeMappingDayAgg nodeMappingDayAgg;
+ private RecordDataAnswer recordDataAnswer;
+
+ @Before
+ public void init() throws Exception {
+ ClusterWorkerContext clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
+
+ LocalWorkerContext localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
+ WorkerRefs workerRefs = mock(WorkerRefs.class);
+
+ recordDataAnswer = new RecordDataAnswer();
+ doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
+
+ when(localWorkerContext.lookup(NodeMappingDaySave.Role.INSTANCE)).thenReturn(workerRefs);
+ nodeMappingDayAgg = new NodeMappingDayAgg(NodeMappingDayAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
+ }
+
+ @Test
+ public void testRole() {
+ Assert.assertEquals(NodeMappingDayAgg.class.getSimpleName(), NodeMappingDayAgg.Role.INSTANCE.roleName());
+ Assert.assertEquals(HashCodeSelector.class.getSimpleName(), NodeMappingDayAgg.Role.INSTANCE.workerSelector().getClass().getSimpleName());
+ }
+
+ @Test
+ public void testFactory() {
+ Assert.assertEquals(NodeMappingDayAgg.class.getSimpleName(), NodeMappingDayAgg.Factory.INSTANCE.role().roleName());
+ Assert.assertEquals(NodeMappingDayAgg.class.getSimpleName(), NodeMappingDayAgg.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
+
+ int testSize = 10;
+ WorkerConfig.WorkerNum.Node.NodeMappingDayAgg.Value = testSize;
+ Assert.assertEquals(testSize, NodeMappingDayAgg.Factory.INSTANCE.workerNum());
+ }
+
+ @Test
+ public void testOnWork() throws Exception {
+ String id = "2017" + Const.ID_SPLIT + "TestNodeMappingDayAgg";
+ JsonObject record = new JsonObject();
+ record.addProperty("Column", "TestData");
+
+ RecordData recordData = new RecordData(id);
+ recordData.setRecord(record);
+ nodeMappingDayAgg.onWork(recordData);
+
+ List recordDataList = recordDataAnswer.recordObj.getRecordData();
+ RecordData data = RecordDataTool.INSTANCE.getRecord(recordDataList, id);
+ Assert.assertEquals("TestNodeMappingDayAgg", data.getRecord().get("aggId").getAsString());
+ Assert.assertEquals("TestData", data.getRecord().get("Column").getAsString());
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testOnWorkError() throws Exception {
+ nodeMappingDayAgg.onWork(new Object());
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingHourAggTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingHourAggTestCase.java
new file mode 100644
index 000000000..c12e17ca2
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingHourAggTestCase.java
@@ -0,0 +1,88 @@
+package com.a.eye.skywalking.collector.worker.node.persistence;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.WorkerRefs;
+import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
+import com.a.eye.skywalking.collector.worker.Const;
+import com.a.eye.skywalking.collector.worker.WorkerConfig;
+import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.RecordDataTool;
+import com.google.gson.JsonObject;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.List;
+
+import static org.mockito.Mockito.*;
+
+/**
+ * @author pengys5
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({LocalWorkerContext.class})
+@PowerMockIgnore({"javax.management.*"})
+public class NodeMappingHourAggTestCase {
+
+ private NodeMappingHourAgg nodeMappingHourAgg;
+ private RecordDataAnswer recordDataAnswer;
+
+ @Before
+ public void init() throws Exception {
+ ClusterWorkerContext clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
+
+ LocalWorkerContext localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
+ WorkerRefs workerRefs = mock(WorkerRefs.class);
+
+ recordDataAnswer = new RecordDataAnswer();
+ doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
+
+ when(localWorkerContext.lookup(NodeMappingHourSave.Role.INSTANCE)).thenReturn(workerRefs);
+ nodeMappingHourAgg = new NodeMappingHourAgg(NodeMappingHourAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
+ }
+
+ @Test
+ public void testRole() {
+ Assert.assertEquals(NodeMappingHourAgg.class.getSimpleName(), NodeMappingHourAgg.Role.INSTANCE.roleName());
+ Assert.assertEquals(HashCodeSelector.class.getSimpleName(), NodeMappingHourAgg.Role.INSTANCE.workerSelector().getClass().getSimpleName());
+ }
+
+ @Test
+ public void testFactory() {
+ Assert.assertEquals(NodeMappingHourAgg.class.getSimpleName(), NodeMappingHourAgg.Factory.INSTANCE.role().roleName());
+ Assert.assertEquals(NodeMappingHourAgg.class.getSimpleName(), NodeMappingHourAgg.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
+
+ int testSize = 10;
+ WorkerConfig.WorkerNum.Node.NodeMappingHourAgg.Value = testSize;
+ Assert.assertEquals(testSize, NodeMappingHourAgg.Factory.INSTANCE.workerNum());
+ }
+
+ @Test
+ public void testOnWork() throws Exception {
+ String id = "2017" + Const.ID_SPLIT + "TestNodeMappingHourAgg";
+ JsonObject record = new JsonObject();
+ record.addProperty("Column", "TestData");
+
+ RecordData recordData = new RecordData(id);
+ recordData.setRecord(record);
+ nodeMappingHourAgg.onWork(recordData);
+
+ List recordDataList = recordDataAnswer.recordObj.getRecordData();
+ RecordData data = RecordDataTool.INSTANCE.getRecord(recordDataList, id);
+ Assert.assertEquals("TestNodeMappingHourAgg", data.getRecord().get("aggId").getAsString());
+ Assert.assertEquals("TestData", data.getRecord().get("Column").getAsString());
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testOnWorkError() throws Exception {
+ nodeMappingHourAgg.onWork(new Object());
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingMinuteAggTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingMinuteAggTestCase.java
new file mode 100644
index 000000000..f48a5f67a
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingMinuteAggTestCase.java
@@ -0,0 +1,88 @@
+package com.a.eye.skywalking.collector.worker.node.persistence;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.WorkerRefs;
+import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
+import com.a.eye.skywalking.collector.worker.Const;
+import com.a.eye.skywalking.collector.worker.WorkerConfig;
+import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.RecordDataTool;
+import com.google.gson.JsonObject;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.List;
+
+import static org.mockito.Mockito.*;
+
+/**
+ * @author pengys5
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({LocalWorkerContext.class})
+@PowerMockIgnore({"javax.management.*"})
+public class NodeMappingMinuteAggTestCase {
+
+ private NodeMappingMinuteAgg nodeMappingMinuteAgg;
+ private RecordDataAnswer recordDataAnswer;
+
+ @Before
+ public void init() throws Exception {
+ ClusterWorkerContext clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
+
+ LocalWorkerContext localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
+ WorkerRefs workerRefs = mock(WorkerRefs.class);
+
+ recordDataAnswer = new RecordDataAnswer();
+ doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
+
+ when(localWorkerContext.lookup(NodeMappingMinuteSave.Role.INSTANCE)).thenReturn(workerRefs);
+ nodeMappingMinuteAgg = new NodeMappingMinuteAgg(NodeMappingMinuteAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
+ }
+
+ @Test
+ public void testRole() {
+ Assert.assertEquals(NodeMappingMinuteAgg.class.getSimpleName(), NodeMappingMinuteAgg.Role.INSTANCE.roleName());
+ Assert.assertEquals(HashCodeSelector.class.getSimpleName(), NodeMappingMinuteAgg.Role.INSTANCE.workerSelector().getClass().getSimpleName());
+ }
+
+ @Test
+ public void testFactory() {
+ Assert.assertEquals(NodeMappingMinuteAgg.class.getSimpleName(), NodeMappingMinuteAgg.Factory.INSTANCE.role().roleName());
+ Assert.assertEquals(NodeMappingMinuteAgg.class.getSimpleName(), NodeMappingMinuteAgg.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
+
+ int testSize = 10;
+ WorkerConfig.WorkerNum.Node.NodeMappingMinuteAgg.Value = testSize;
+ Assert.assertEquals(testSize, NodeMappingMinuteAgg.Factory.INSTANCE.workerNum());
+ }
+
+ @Test
+ public void testOnWork() throws Exception {
+ String id = "2017" + Const.ID_SPLIT + "TestNodeMappingMinuteAgg";
+ JsonObject record = new JsonObject();
+ record.addProperty("Column", "TestData");
+
+ RecordData recordData = new RecordData(id);
+ recordData.setRecord(record);
+ nodeMappingMinuteAgg.onWork(recordData);
+
+ List recordDataList = recordDataAnswer.recordObj.getRecordData();
+ RecordData data = RecordDataTool.INSTANCE.getRecord(recordDataList, id);
+ Assert.assertEquals("TestNodeMappingMinuteAgg", data.getRecord().get("aggId").getAsString());
+ Assert.assertEquals("TestData", data.getRecord().get("Column").getAsString());
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testOnWorkError() throws Exception {
+ nodeMappingMinuteAgg.onWork(new Object());
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingSearchWithTimeSliceUseDB.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingSearchWithTimeSliceUseDB.java
new file mode 100644
index 000000000..974bfac7d
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingSearchWithTimeSliceUseDB.java
@@ -0,0 +1,38 @@
+package com.a.eye.skywalking.collector.worker.node.persistence;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.worker.node.NodeMappingIndex;
+import com.a.eye.skywalking.collector.worker.storage.EsClient;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+/**
+ * @author pengys5
+ */
+public class NodeMappingSearchWithTimeSliceUseDB {
+
+ public static void main(String[] args) throws Exception {
+ EsClient.boot();
+
+ ClusterWorkerContext clusterWorkerContext = new ClusterWorkerContext(null);
+ LocalWorkerContext localWorkerContext = new LocalWorkerContext();
+ NodeMappingSearchWithTimeSlice nodeMappingSearch =
+ new NodeMappingSearchWithTimeSlice(NodeMappingSearchWithTimeSlice.WorkerRole.INSTANCE, clusterWorkerContext, localWorkerContext);
+
+ long startTime = 201703310910L;
+ long endTime = 201703310920L;
+ JsonObject response = new JsonObject();
+ NodeMappingSearchWithTimeSlice.RequestEntity requestEntity =
+ new NodeMappingSearchWithTimeSlice.RequestEntity(NodeMappingIndex.Type_Minute, startTime, endTime);
+ nodeMappingSearch.onWork(requestEntity, response);
+
+ JsonArray nodeArray = response.get("result").getAsJsonArray();
+ System.out.println(nodeArray.size());
+ System.out.println(nodeArray.toString());
+ for (int i = 0; i < nodeArray.size(); i++) {
+ JsonObject nodeJsonObj = nodeArray.get(i).getAsJsonObject();
+ System.out.println(nodeJsonObj);
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/analysis/NodeRefAnalysisVerify.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/analysis/NodeRefAnalysisVerify.java
new file mode 100644
index 000000000..50971406f
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/analysis/NodeRefAnalysisVerify.java
@@ -0,0 +1,66 @@
+package com.a.eye.skywalking.collector.worker.noderef.analysis;
+
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.RecordDataTool;
+import org.junit.Assert;
+
+import java.util.List;
+
+/**
+ * @author pengys5
+ */
+public enum NodeRefAnalysisVerify {
+ INSTANCE;
+
+ public void verify(List recordDataList, long timeSlice) {
+ Assert.assertEquals(6, recordDataList.size());
+
+ RecordData data_1 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..portal-service..-..[10.128.35.80:20880]");
+ Assert.assertEquals(true, data_1.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(false, data_1.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("portal-service", data_1.getRecord().get("front").getAsString());
+ Assert.assertEquals("[10.128.35.80:20880]", data_1.getRecord().get("behind").getAsString());
+ Assert.assertEquals("portal-service..-..[10.128.35.80:20880]", data_1.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_1.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_2 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..cache-service..-..[127.0.0.1:6379]");
+ Assert.assertEquals(true, data_2.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(false, data_2.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("cache-service", data_2.getRecord().get("front").getAsString());
+ Assert.assertEquals("[127.0.0.1:6379]", data_2.getRecord().get("behind").getAsString());
+ Assert.assertEquals("cache-service..-..[127.0.0.1:6379]", data_2.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_2.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_3 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..cache-service..-..[localhost:-1]");
+ Assert.assertEquals(true, data_3.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(false, data_3.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("cache-service", data_3.getRecord().get("front").getAsString());
+ Assert.assertEquals("[localhost:-1]", data_3.getRecord().get("behind").getAsString());
+ Assert.assertEquals("cache-service..-..[localhost:-1]", data_3.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_3.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_4 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..User..-..portal-service");
+ Assert.assertEquals(true, data_4.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(true, data_4.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("User", data_4.getRecord().get("front").getAsString());
+ Assert.assertEquals("portal-service", data_4.getRecord().get("behind").getAsString());
+ Assert.assertEquals("User..-..portal-service", data_4.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_4.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_5 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..portal-service..-..[127.0.0.1:8002]");
+ Assert.assertEquals(true, data_5.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(false, data_5.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("portal-service", data_5.getRecord().get("front").getAsString());
+ Assert.assertEquals("[127.0.0.1:8002]", data_5.getRecord().get("behind").getAsString());
+ Assert.assertEquals("portal-service..-..[127.0.0.1:8002]", data_5.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_5.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_6 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..persistence-service..-..[127.0.0.1:3307]");
+ Assert.assertEquals(true, data_6.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(false, data_6.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("persistence-service", data_6.getRecord().get("front").getAsString());
+ Assert.assertEquals("[127.0.0.1:3307]", data_6.getRecord().get("behind").getAsString());
+ Assert.assertEquals("persistence-service..-..[127.0.0.1:3307]", data_6.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_6.getRecord().get("timeSlice").getAsLong());
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/analysis/NodeRefDayAnalysisTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/analysis/NodeRefDayAnalysisTestCase.java
new file mode 100644
index 000000000..8017ba940
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/analysis/NodeRefDayAnalysisTestCase.java
@@ -0,0 +1,102 @@
+package com.a.eye.skywalking.collector.worker.noderef.analysis;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.WorkerRefs;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.queue.EndOfBatchCommand;
+import com.a.eye.skywalking.collector.worker.WorkerConfig;
+import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
+import com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefDayAgg;
+import com.a.eye.skywalking.collector.worker.segment.SegmentPost;
+import com.a.eye.skywalking.collector.worker.segment.mock.SegmentMock;
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.DateTools;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.List;
+
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.powermock.api.mockito.PowerMockito.when;
+
+/**
+ * @author pengys5
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({ClusterWorkerContext.class})
+@PowerMockIgnore({"javax.management.*"})
+public class NodeRefDayAnalysisTestCase {
+
+ private NodeRefDayAnalysis nodeRefDayAnalysis;
+ private SegmentMock segmentMock = new SegmentMock();
+ private RecordDataAnswer recordDataAnswer;
+
+ @Before
+ public void init() throws Exception {
+ ClusterWorkerContext clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
+ WorkerRefs workerRefs = mock(WorkerRefs.class);
+ recordDataAnswer = new RecordDataAnswer();
+ doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
+
+ when(clusterWorkerContext.lookup(NodeRefDayAgg.Role.INSTANCE)).thenReturn(workerRefs);
+
+ LocalWorkerContext localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
+ WorkerRefs nodeRefResSumWorkerRefs = mock(WorkerRefs.class);
+ when(localWorkerContext.lookup(NodeRefResSumDayAnalysis.Role.INSTANCE)).thenReturn(nodeRefResSumWorkerRefs);
+ nodeRefDayAnalysis = new NodeRefDayAnalysis(NodeRefDayAnalysis.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
+ }
+
+ @Test
+ public void testRole() {
+ Assert.assertEquals(NodeRefDayAnalysis.class.getSimpleName(), NodeRefDayAnalysis.Role.INSTANCE.roleName());
+ Assert.assertEquals(RollingSelector.class.getSimpleName(), NodeRefDayAnalysis.Role.INSTANCE.workerSelector().getClass().getSimpleName());
+ }
+
+ @Test
+ public void testFactory() {
+ Assert.assertEquals(NodeRefDayAnalysis.class.getSimpleName(), NodeRefDayAnalysis.Factory.INSTANCE.role().roleName());
+ Assert.assertEquals(NodeRefDayAnalysis.class.getSimpleName(), NodeRefDayAnalysis.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
+
+ int testSize = 10;
+ WorkerConfig.Queue.Node.NodeRefDayAnalysis.Size = testSize;
+ Assert.assertEquals(testSize, NodeRefDayAnalysis.Factory.INSTANCE.queueSize());
+ }
+
+ @Test
+ public void testAnalyse() throws Exception {
+ List cacheServiceSegment = segmentMock.mockCacheServiceSegmentSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : cacheServiceSegment) {
+ nodeRefDayAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List portalService = segmentMock.mockPortalServiceSegmentSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : portalService) {
+ nodeRefDayAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List persistenceService = segmentMock.mockPersistenceServiceSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : persistenceService) {
+ nodeRefDayAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List cacheServiceException = segmentMock.mockCacheServiceExceptionSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : cacheServiceException) {
+ nodeRefDayAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List portalServiceException = segmentMock.mockPortalServiceExceptionSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : portalServiceException) {
+ nodeRefDayAnalysis.analyse(segmentWithTimeSlice);
+ }
+
+ nodeRefDayAnalysis.onWork(new EndOfBatchCommand());
+
+ List recordDataList = recordDataAnswer.recordObj.getRecordData();
+ NodeRefAnalysisVerify.INSTANCE.verify(recordDataList, DateTools.changeToUTCSlice(201703310000L));
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/analysis/NodeRefHourAnalysisTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/analysis/NodeRefHourAnalysisTestCase.java
new file mode 100644
index 000000000..b40ef99f0
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/analysis/NodeRefHourAnalysisTestCase.java
@@ -0,0 +1,102 @@
+package com.a.eye.skywalking.collector.worker.noderef.analysis;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.WorkerRefs;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.queue.EndOfBatchCommand;
+import com.a.eye.skywalking.collector.worker.WorkerConfig;
+import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
+import com.a.eye.skywalking.collector.worker.node.analysis.NodeAnalysisVerify;
+import com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefHourAgg;
+import com.a.eye.skywalking.collector.worker.segment.SegmentPost;
+import com.a.eye.skywalking.collector.worker.segment.mock.SegmentMock;
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.DateTools;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.List;
+
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.powermock.api.mockito.PowerMockito.when;
+
+/**
+ * @author pengys5
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({ClusterWorkerContext.class})
+@PowerMockIgnore({"javax.management.*"})
+public class NodeRefHourAnalysisTestCase {
+
+ private NodeRefHourAnalysis nodeRefHourAnalysis;
+ private SegmentMock segmentMock = new SegmentMock();
+ private RecordDataAnswer recordDataAnswer;
+
+ @Before
+ public void init() throws Exception {
+ ClusterWorkerContext clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
+ WorkerRefs workerRefs = mock(WorkerRefs.class);
+ recordDataAnswer = new RecordDataAnswer();
+ doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
+
+ when(clusterWorkerContext.lookup(NodeRefHourAgg.Role.INSTANCE)).thenReturn(workerRefs);
+
+ LocalWorkerContext localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
+ WorkerRefs nodeRefResSumWorkerRefs = mock(WorkerRefs.class);
+ when(localWorkerContext.lookup(NodeRefResSumHourAnalysis.Role.INSTANCE)).thenReturn(nodeRefResSumWorkerRefs);
+ nodeRefHourAnalysis = new NodeRefHourAnalysis(NodeRefHourAnalysis.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
+ }
+
+ @Test
+ public void testRole() {
+ Assert.assertEquals(NodeRefHourAnalysis.class.getSimpleName(), NodeRefHourAnalysis.Role.INSTANCE.roleName());
+ Assert.assertEquals(RollingSelector.class.getSimpleName(), NodeRefHourAnalysis.Role.INSTANCE.workerSelector().getClass().getSimpleName());
+ }
+
+ @Test
+ public void testFactory() {
+ Assert.assertEquals(NodeRefHourAnalysis.class.getSimpleName(), NodeRefHourAnalysis.Factory.INSTANCE.role().roleName());
+ Assert.assertEquals(NodeRefHourAnalysis.class.getSimpleName(), NodeRefHourAnalysis.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
+
+ int testSize = 10;
+ WorkerConfig.Queue.Node.NodeRefHourAnalysis.Size = testSize;
+ Assert.assertEquals(testSize, NodeRefHourAnalysis.Factory.INSTANCE.queueSize());
+ }
+
+ @Test
+ public void testAnalyse() throws Exception {
+ List cacheServiceSegment = segmentMock.mockCacheServiceSegmentSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : cacheServiceSegment) {
+ nodeRefHourAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List portalService = segmentMock.mockPortalServiceSegmentSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : portalService) {
+ nodeRefHourAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List persistenceService = segmentMock.mockPersistenceServiceSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : persistenceService) {
+ nodeRefHourAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List cacheServiceException = segmentMock.mockCacheServiceExceptionSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : cacheServiceException) {
+ nodeRefHourAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List portalServiceException = segmentMock.mockPortalServiceExceptionSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : portalServiceException) {
+ nodeRefHourAnalysis.analyse(segmentWithTimeSlice);
+ }
+
+ nodeRefHourAnalysis.onWork(new EndOfBatchCommand());
+
+ NodeRefAnalysisVerify.INSTANCE.verify(recordDataAnswer.recordObj.getRecordData(), DateTools.changeToUTCSlice(201703310900L));
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/analysis/NodeRefMinuteAnalysisTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/analysis/NodeRefMinuteAnalysisTestCase.java
new file mode 100644
index 000000000..829abc5da
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/analysis/NodeRefMinuteAnalysisTestCase.java
@@ -0,0 +1,174 @@
+package com.a.eye.skywalking.collector.worker.noderef.analysis;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.WorkerRefs;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.queue.EndOfBatchCommand;
+import com.a.eye.skywalking.collector.worker.WorkerConfig;
+import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
+import com.a.eye.skywalking.collector.worker.node.analysis.NodeAnalysisVerify;
+import com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefMinuteAgg;
+import com.a.eye.skywalking.collector.worker.segment.SegmentPost;
+import com.a.eye.skywalking.collector.worker.segment.mock.SegmentMock;
+import com.a.eye.skywalking.collector.worker.storage.RecordData;
+import com.a.eye.skywalking.collector.worker.tools.DateTools;
+import com.a.eye.skywalking.collector.worker.tools.RecordDataTool;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.powermock.api.mockito.PowerMockito.when;
+
+/**
+ * @author pengys5
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({ClusterWorkerContext.class})
+@PowerMockIgnore({"javax.management.*"})
+public class NodeRefMinuteAnalysisTestCase {
+
+ private NodeRefMinuteAnalysis nodeRefMinuteAnalysis;
+ private SegmentMock segmentMock = new SegmentMock();
+ private RecordDataAnswer recordDataAnswer;
+
+ @Before
+ public void init() throws Exception {
+ ClusterWorkerContext clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
+ WorkerRefs workerRefs = mock(WorkerRefs.class);
+ recordDataAnswer = new RecordDataAnswer();
+ doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
+
+ when(clusterWorkerContext.lookup(NodeRefMinuteAgg.Role.INSTANCE)).thenReturn(workerRefs);
+
+ LocalWorkerContext localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
+ WorkerRefs nodeRefResSumWorkerRefs = mock(WorkerRefs.class);
+ when(localWorkerContext.lookup(NodeRefResSumMinuteAnalysis.Role.INSTANCE)).thenReturn(nodeRefResSumWorkerRefs);
+ nodeRefMinuteAnalysis = new NodeRefMinuteAnalysis(NodeRefMinuteAnalysis.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
+ }
+
+ @Test
+ public void testRole() {
+ Assert.assertEquals(NodeRefMinuteAnalysis.class.getSimpleName(), NodeRefMinuteAnalysis.Role.INSTANCE.roleName());
+ Assert.assertEquals(RollingSelector.class.getSimpleName(), NodeRefMinuteAnalysis.Role.INSTANCE.workerSelector().getClass().getSimpleName());
+ }
+
+ @Test
+ public void testFactory() {
+ Assert.assertEquals(NodeRefMinuteAnalysis.class.getSimpleName(), NodeRefMinuteAnalysis.Factory.INSTANCE.role().roleName());
+ Assert.assertEquals(NodeRefMinuteAnalysis.class.getSimpleName(), NodeRefMinuteAnalysis.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
+
+ int testSize = 10;
+ WorkerConfig.Queue.Node.NodeRefMinuteAnalysis.Size = testSize;
+ Assert.assertEquals(testSize, NodeRefMinuteAnalysis.Factory.INSTANCE.queueSize());
+ }
+
+ @Test
+ public void testAnalyse() throws Exception {
+ List cacheServiceSegment = segmentMock.mockCacheServiceSegmentSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : cacheServiceSegment) {
+ nodeRefMinuteAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List portalService = segmentMock.mockPortalServiceSegmentSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : portalService) {
+ nodeRefMinuteAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List persistenceService = segmentMock.mockPersistenceServiceSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : persistenceService) {
+ nodeRefMinuteAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List cacheServiceException = segmentMock.mockCacheServiceExceptionSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : cacheServiceException) {
+ nodeRefMinuteAnalysis.analyse(segmentWithTimeSlice);
+ }
+ List portalServiceException = segmentMock.mockPortalServiceExceptionSegmentTimeSlice();
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : portalServiceException) {
+ nodeRefMinuteAnalysis.analyse(segmentWithTimeSlice);
+ }
+
+ nodeRefMinuteAnalysis.onWork(new EndOfBatchCommand());
+
+ Assert.assertEquals(8, recordDataAnswer.recordObj.getRecordData().size());
+ this.verify_1(recordDataAnswer.recordObj.getRecordData(), DateTools.changeToUTCSlice(201703310915L));
+ this.verify_2(recordDataAnswer.recordObj.getRecordData(), DateTools.changeToUTCSlice(201703310916L));
+ }
+
+ public void verify_1(List recordDataList, long timeSlice) {
+ RecordData data_5 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..portal-service..-..[127.0.0.1:8002]");
+ Assert.assertEquals(true, data_5.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(false, data_5.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("portal-service", data_5.getRecord().get("front").getAsString());
+ Assert.assertEquals("[127.0.0.1:8002]", data_5.getRecord().get("behind").getAsString());
+ Assert.assertEquals("portal-service..-..[127.0.0.1:8002]", data_5.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_5.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_3 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..cache-service..-..[localhost:-1]");
+ Assert.assertEquals(true, data_3.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(false, data_3.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("cache-service", data_3.getRecord().get("front").getAsString());
+ Assert.assertEquals("[localhost:-1]", data_3.getRecord().get("behind").getAsString());
+ Assert.assertEquals("cache-service..-..[localhost:-1]", data_3.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_3.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_4 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..User..-..portal-service");
+ Assert.assertEquals(true, data_4.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(true, data_4.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("User", data_4.getRecord().get("front").getAsString());
+ Assert.assertEquals("portal-service", data_4.getRecord().get("behind").getAsString());
+ Assert.assertEquals("User..-..portal-service", data_4.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_4.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_2 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..cache-service..-..[127.0.0.1:6379]");
+ Assert.assertEquals(true, data_2.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(false, data_2.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("cache-service", data_2.getRecord().get("front").getAsString());
+ Assert.assertEquals("[127.0.0.1:6379]", data_2.getRecord().get("behind").getAsString());
+ Assert.assertEquals("cache-service..-..[127.0.0.1:6379]", data_2.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_2.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_1 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..portal-service..-..[10.128.35.80:20880]");
+ Assert.assertEquals(true, data_1.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(false, data_1.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("portal-service", data_1.getRecord().get("front").getAsString());
+ Assert.assertEquals("[10.128.35.80:20880]", data_1.getRecord().get("behind").getAsString());
+ Assert.assertEquals("portal-service..-..[10.128.35.80:20880]", data_1.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_1.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_6 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..persistence-service..-..[127.0.0.1:3307]");
+ Assert.assertEquals(true, data_6.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(false, data_6.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("persistence-service", data_6.getRecord().get("front").getAsString());
+ Assert.assertEquals("[127.0.0.1:3307]", data_6.getRecord().get("behind").getAsString());
+ Assert.assertEquals("persistence-service..-..[127.0.0.1:3307]", data_6.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_6.getRecord().get("timeSlice").getAsLong());
+ }
+
+ public void verify_2(List recordDataList, long timeSlice) {
+ RecordData data_5 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..portal-service..-..[127.0.0.1:8002]");
+ Assert.assertEquals(true, data_5.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(false, data_5.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("portal-service", data_5.getRecord().get("front").getAsString());
+ Assert.assertEquals("[127.0.0.1:8002]", data_5.getRecord().get("behind").getAsString());
+ Assert.assertEquals("portal-service..-..[127.0.0.1:8002]", data_5.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_5.getRecord().get("timeSlice").getAsLong());
+
+ RecordData data_4 = RecordDataTool.INSTANCE.getRecord(recordDataList, timeSlice + "..-..User..-..portal-service");
+ Assert.assertEquals(true, data_4.getRecord().get("frontIsRealCode").getAsBoolean());
+ Assert.assertEquals(true, data_4.getRecord().get("behindIsRealCode").getAsBoolean());
+ Assert.assertEquals("User", data_4.getRecord().get("front").getAsString());
+ Assert.assertEquals("portal-service", data_4.getRecord().get("behind").getAsString());
+ Assert.assertEquals("User..-..portal-service", data_4.getRecord().get("aggId").getAsString());
+ Assert.assertEquals(timeSlice, data_4.getRecord().get("timeSlice").getAsLong());
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefResSumGroupWithTimeSliceUseDB.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefResSumGroupWithTimeSliceUseDB.java
new file mode 100644
index 000000000..b8e9b2008
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefResSumGroupWithTimeSliceUseDB.java
@@ -0,0 +1,37 @@
+package com.a.eye.skywalking.collector.worker.noderef.persistence;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.worker.noderef.NodeRefIndex;
+import com.a.eye.skywalking.collector.worker.storage.EsClient;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+/**
+ * @author pengys5
+ */
+public class NodeRefResSumGroupWithTimeSliceUseDB {
+
+ public static void main(String[] args) throws Exception {
+ EsClient.boot();
+
+ ClusterWorkerContext clusterWorkerContext = new ClusterWorkerContext(null);
+ LocalWorkerContext localWorkerContext = new LocalWorkerContext();
+ NodeRefResSumGroupWithTimeSlice nodeRefSearch =
+ new NodeRefResSumGroupWithTimeSlice(NodeRefResSumGroupWithTimeSlice.WorkerRole.INSTANCE, clusterWorkerContext, localWorkerContext);
+
+ long startTime = 201703310910L;
+ long endTime = 201703310920L;
+ JsonObject response = new JsonObject();
+ NodeRefResSumGroupWithTimeSlice.RequestEntity requestEntity =
+ new NodeRefResSumGroupWithTimeSlice.RequestEntity(NodeRefIndex.Type_Minute, startTime, endTime);
+ nodeRefSearch.onWork(requestEntity, response);
+
+ JsonArray nodeRefArray = response.get("result").getAsJsonArray();
+ System.out.println(nodeRefArray.toString());
+ for (int i = 0; i < nodeRefArray.size(); i++) {
+ JsonObject nodeRefJsonObj = nodeRefArray.get(i).getAsJsonObject();
+ System.out.println(nodeRefJsonObj);
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefResSumSearchWithTimeSliceUseDB.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefResSumSearchWithTimeSliceUseDB.java
new file mode 100644
index 000000000..140c9ff03
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefResSumSearchWithTimeSliceUseDB.java
@@ -0,0 +1,37 @@
+package com.a.eye.skywalking.collector.worker.noderef.persistence;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.worker.noderef.NodeRefIndex;
+import com.a.eye.skywalking.collector.worker.storage.EsClient;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+/**
+ * @author pengys5
+ */
+public class NodeRefResSumSearchWithTimeSliceUseDB {
+
+ public static void main(String[] args) throws Exception {
+ EsClient.boot();
+
+ ClusterWorkerContext clusterWorkerContext = new ClusterWorkerContext(null);
+ LocalWorkerContext localWorkerContext = new LocalWorkerContext();
+ NodeRefResSumSearchWithTimeSlice nodeRefSearch =
+ new NodeRefResSumSearchWithTimeSlice(NodeRefResSumSearchWithTimeSlice.WorkerRole.INSTANCE, clusterWorkerContext, localWorkerContext);
+
+ long startTime = 201703310910L;
+ long endTime = 201703310920L;
+ JsonObject response = new JsonObject();
+ NodeRefResSumSearchWithTimeSlice.RequestEntity requestEntity =
+ new NodeRefResSumSearchWithTimeSlice.RequestEntity(NodeRefIndex.Type_Minute, startTime, endTime);
+ nodeRefSearch.onWork(requestEntity, response);
+
+ JsonArray nodeRefArray = response.get("result").getAsJsonArray();
+ System.out.println(nodeRefArray.toString());
+ for (int i = 0; i < nodeRefArray.size(); i++) {
+ JsonObject nodeRefJsonObj = nodeRefArray.get(i).getAsJsonObject();
+ System.out.println(nodeRefJsonObj);
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefSearchWithTimeSliceUseDB.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefSearchWithTimeSliceUseDB.java
new file mode 100644
index 000000000..5b85da58e
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefSearchWithTimeSliceUseDB.java
@@ -0,0 +1,37 @@
+package com.a.eye.skywalking.collector.worker.noderef.persistence;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.worker.noderef.NodeRefIndex;
+import com.a.eye.skywalking.collector.worker.storage.EsClient;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+/**
+ * @author pengys5
+ */
+public class NodeRefSearchWithTimeSliceUseDB {
+
+ public static void main(String[] args) throws Exception {
+ EsClient.boot();
+
+ ClusterWorkerContext clusterWorkerContext = new ClusterWorkerContext(null);
+ LocalWorkerContext localWorkerContext = new LocalWorkerContext();
+ NodeRefSearchWithTimeSlice nodeRefSearch =
+ new NodeRefSearchWithTimeSlice(NodeRefSearchWithTimeSlice.WorkerRole.INSTANCE, clusterWorkerContext, localWorkerContext);
+
+ long startTime = 201703310910L;
+ long endTime = 201703310920L;
+ JsonObject response = new JsonObject();
+ NodeRefSearchWithTimeSlice.RequestEntity requestEntity =
+ new NodeRefSearchWithTimeSlice.RequestEntity(NodeRefIndex.Type_Minute, startTime, endTime);
+ nodeRefSearch.onWork(requestEntity, response);
+
+ JsonArray nodeRefArray = response.get("result").getAsJsonArray();
+ System.out.println(nodeRefArray.toString());
+ for (int i = 0; i < nodeRefArray.size(); i++) {
+ JsonObject nodeRefJsonObj = nodeRefArray.get(i).getAsJsonObject();
+ System.out.println(nodeRefJsonObj);
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/HttpClientTools.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/HttpClientTools.java
new file mode 100644
index 000000000..ce28e6729
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/HttpClientTools.java
@@ -0,0 +1,79 @@
+package com.a.eye.skywalking.collector.worker.segment;
+
+import org.apache.http.Consts;
+import org.apache.http.HttpEntity;
+import org.apache.http.NameValuePair;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.util.EntityUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+import java.net.URI;
+import java.util.List;
+
+/**
+ * @author pengys5
+ */
+public enum HttpClientTools {
+ INSTANCE;
+
+ private Logger logger = LogManager.getFormatterLogger(HttpClientTools.class);
+
+ public String get(String url, List params) throws IOException {
+ CloseableHttpClient httpClient = HttpClients.createDefault();
+ try {
+ HttpGet httpget = new HttpGet(url);
+ String paramStr = EntityUtils.toString(new UrlEncodedFormEntity(params));
+ httpget.setURI(new URI(httpget.getURI().toString() + "?" + paramStr));
+ logger.debug("executing get request %s", httpget.getURI());
+
+ try (CloseableHttpResponse response = httpClient.execute(httpget)) {
+ HttpEntity entity = response.getEntity();
+ System.out.println(response.getStatusLine());
+ if (entity != null) {
+ return EntityUtils.toString(entity);
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ } finally {
+ try {
+ httpClient.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ return null;
+ }
+
+ public String post(String url, String data) throws IOException {
+ CloseableHttpClient httpClient = HttpClients.createDefault();
+ try {
+ HttpPost httppost = new HttpPost(url);
+ httppost.setEntity(new StringEntity(data, Consts.UTF_8));
+ logger.debug("executing post request %s", httppost.getURI());
+ try (CloseableHttpResponse response = httpClient.execute(httppost)) {
+ HttpEntity entity = response.getEntity();
+ if (entity != null) {
+ return EntityUtils.toString(entity);
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ } finally {
+ try {
+ httpClient.close();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ return null;
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/SegmentPostTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/SegmentPostTestCase.java
new file mode 100644
index 000000000..11bf29106
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/SegmentPostTestCase.java
@@ -0,0 +1,270 @@
+package com.a.eye.skywalking.collector.worker.segment;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.WorkerRef;
+import com.a.eye.skywalking.collector.worker.globaltrace.analysis.GlobalTraceAnalysis;
+import com.a.eye.skywalking.collector.worker.node.analysis.NodeCompAnalysis;
+import com.a.eye.skywalking.collector.worker.node.analysis.NodeMappingDayAnalysis;
+import com.a.eye.skywalking.collector.worker.node.analysis.NodeMappingHourAnalysis;
+import com.a.eye.skywalking.collector.worker.node.analysis.NodeMappingMinuteAnalysis;
+import com.a.eye.skywalking.collector.worker.noderef.analysis.NodeRefDayAnalysis;
+import com.a.eye.skywalking.collector.worker.noderef.analysis.NodeRefHourAnalysis;
+import com.a.eye.skywalking.collector.worker.noderef.analysis.NodeRefMinuteAnalysis;
+import com.a.eye.skywalking.collector.worker.segment.mock.SegmentMock;
+import com.a.eye.skywalking.collector.worker.segment.persistence.SegmentCostSave;
+import com.a.eye.skywalking.collector.worker.segment.persistence.SegmentExceptionSave;
+import com.a.eye.skywalking.collector.worker.segment.persistence.SegmentSave;
+import com.a.eye.skywalking.collector.worker.tools.DateTools;
+import com.google.gson.JsonObject;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import static org.powermock.api.mockito.PowerMockito.*;
+
+/**
+ * @author pengys5
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({LocalWorkerContext.class, WorkerRef.class})
+@PowerMockIgnore({"javax.management.*"})
+public class SegmentPostTestCase {
+
+ private Logger logger = LogManager.getFormatterLogger(SegmentPostTestCase.class);
+
+ private SegmentMock segmentMock;
+ private SegmentPost segmentPost;
+ private LocalWorkerContext localWorkerContext;
+
+ @Before
+ public void init() throws Exception {
+ segmentMock = new SegmentMock();
+
+ ClusterWorkerContext clusterWorkerContext = new ClusterWorkerContext(null);
+ localWorkerContext = new LocalWorkerContext();
+
+ initSegmentSave();
+ initSegmentCostSave();
+ initGlobalTraceAnalysis();
+ initSegmentExceptionSave();
+ initNodeRefAnalysis();
+ initNodeCompAnalysis();
+ initNodeNodeMappingAnalysis();
+
+ segmentPost = spy(new SegmentPost(SegmentPost.WorkerRole.INSTANCE, clusterWorkerContext, localWorkerContext));
+ }
+
+ private SegmentSaveAnswer segmentSaveAnswer_1;
+ private SegmentSaveAnswer segmentSaveAnswer_2;
+
+ public void initSegmentSave() throws Exception {
+ WorkerRef segmentSave = mock(WorkerRef.class);
+ doReturn(SegmentSave.Role.INSTANCE).when(segmentSave, "getRole");
+ localWorkerContext.put(segmentSave);
+
+ segmentSaveAnswer_1 = new SegmentSaveAnswer();
+ doAnswer(segmentSaveAnswer_1).when(segmentSave).tell(Mockito.argThat(new IsCacheServiceSegment_1()));
+
+ segmentSaveAnswer_2 = new SegmentSaveAnswer();
+ doAnswer(segmentSaveAnswer_2).when(segmentSave).tell(Mockito.argThat(new IsCacheServiceSegment_2()));
+ }
+
+ private SegmentOtherAnswer segmentCostSaveAnswer;
+
+ public void initSegmentCostSave() throws Exception {
+ WorkerRef segmentCostSave = mock(WorkerRef.class);
+ doReturn(SegmentCostSave.Role.INSTANCE).when(segmentCostSave, "getRole");
+ localWorkerContext.put(segmentCostSave);
+
+ segmentCostSaveAnswer = new SegmentOtherAnswer();
+ doAnswer(segmentCostSaveAnswer).when(segmentCostSave).tell(Mockito.argThat(new IsSegmentWithTimeSlice()));
+ }
+
+ private SegmentOtherAnswer globalTraceAnalysisAnswer;
+
+ public void initGlobalTraceAnalysis() throws Exception {
+ WorkerRef globalTraceAnalysis = mock(WorkerRef.class);
+ doReturn(GlobalTraceAnalysis.Role.INSTANCE).when(globalTraceAnalysis, "getRole");
+ localWorkerContext.put(globalTraceAnalysis);
+
+ globalTraceAnalysisAnswer = new SegmentOtherAnswer();
+ doAnswer(globalTraceAnalysisAnswer).when(globalTraceAnalysis).tell(Mockito.argThat(new IsSegmentWithTimeSlice()));
+ }
+
+ private SegmentOtherAnswer segmentExceptionSaveAnswer;
+
+ public void initSegmentExceptionSave() throws Exception {
+ WorkerRef segmentExceptionSave = mock(WorkerRef.class);
+ doReturn(SegmentExceptionSave.Role.INSTANCE).when(segmentExceptionSave, "getRole");
+ localWorkerContext.put(segmentExceptionSave);
+
+ segmentExceptionSaveAnswer = new SegmentOtherAnswer();
+ doAnswer(segmentExceptionSaveAnswer).when(segmentExceptionSave).tell(Mockito.argThat(new IsSegmentWithTimeSlice()));
+ }
+
+ private SegmentOtherAnswer nodeRefMinuteAnalysisAnswer;
+ private SegmentOtherAnswer nodeRefHourAnalysisAnswer;
+ private SegmentOtherAnswer nodeRefDayAnalysisAnswer;
+
+ public void initNodeRefAnalysis() throws Exception {
+ WorkerRef nodeRefMinuteAnalysis = mock(WorkerRef.class);
+ doReturn(NodeRefMinuteAnalysis.Role.INSTANCE).when(nodeRefMinuteAnalysis, "getRole");
+ localWorkerContext.put(nodeRefMinuteAnalysis);
+
+ nodeRefMinuteAnalysisAnswer = new SegmentOtherAnswer();
+ doAnswer(nodeRefMinuteAnalysisAnswer).when(nodeRefMinuteAnalysis).tell(Mockito.argThat(new IsSegmentWithTimeSlice()));
+
+ WorkerRef nodeRefHourAnalysis = mock(WorkerRef.class);
+ doReturn(NodeRefHourAnalysis.Role.INSTANCE).when(nodeRefHourAnalysis, "getRole");
+ localWorkerContext.put(nodeRefHourAnalysis);
+
+ nodeRefHourAnalysisAnswer = new SegmentOtherAnswer();
+ doAnswer(nodeRefHourAnalysisAnswer).when(nodeRefHourAnalysis).tell(Mockito.argThat(new IsSegmentWithTimeSlice()));
+
+ WorkerRef nodeRefDayAnalysis = mock(WorkerRef.class);
+ doReturn(NodeRefDayAnalysis.Role.INSTANCE).when(nodeRefDayAnalysis, "getRole");
+ localWorkerContext.put(nodeRefDayAnalysis);
+
+ nodeRefDayAnalysisAnswer = new SegmentOtherAnswer();
+ doAnswer(nodeRefDayAnalysisAnswer).when(nodeRefDayAnalysis).tell(Mockito.argThat(new IsSegmentWithTimeSlice()));
+ }
+
+ private SegmentOtherAnswer nodeCompAnalysisAnswer;
+
+ public void initNodeCompAnalysis() throws Exception {
+ WorkerRef nodeMinuteAnalysis = mock(WorkerRef.class);
+ doReturn(NodeCompAnalysis.Role.INSTANCE).when(nodeMinuteAnalysis, "getRole");
+ localWorkerContext.put(nodeMinuteAnalysis);
+
+ nodeCompAnalysisAnswer = new SegmentOtherAnswer();
+ doAnswer(nodeCompAnalysisAnswer).when(nodeMinuteAnalysis).tell(Mockito.argThat(new IsSegmentWithTimeSlice()));
+ }
+
+ private SegmentOtherAnswer nodeMappingMinuteAnalysisAnswer;
+ private SegmentOtherAnswer nodeMappingHourAnalysisAnswer;
+ private SegmentOtherAnswer nodeMappingDayAnalysisAnswer;
+
+ public void initNodeNodeMappingAnalysis() throws Exception {
+ WorkerRef nodeMappingMinuteAnalysis = mock(WorkerRef.class);
+ doReturn(NodeMappingMinuteAnalysis.Role.INSTANCE).when(nodeMappingMinuteAnalysis, "getRole");
+ localWorkerContext.put(nodeMappingMinuteAnalysis);
+
+ nodeMappingMinuteAnalysisAnswer = new SegmentOtherAnswer();
+ doAnswer(nodeMappingMinuteAnalysisAnswer).when(nodeMappingMinuteAnalysis).tell(Mockito.argThat(new IsSegmentWithTimeSlice()));
+
+ WorkerRef nodeMappingHourAnalysis = mock(WorkerRef.class);
+ doReturn(NodeMappingHourAnalysis.Role.INSTANCE).when(nodeMappingHourAnalysis, "getRole");
+ localWorkerContext.put(nodeMappingHourAnalysis);
+
+ nodeMappingHourAnalysisAnswer = new SegmentOtherAnswer();
+ doAnswer(nodeMappingHourAnalysisAnswer).when(nodeMappingHourAnalysis).tell(Mockito.argThat(new IsSegmentWithTimeSlice()));
+
+ WorkerRef nodeMappingDayAnalysis = mock(WorkerRef.class);
+ doReturn(NodeMappingDayAnalysis.Role.INSTANCE).when(nodeMappingDayAnalysis, "getRole");
+ localWorkerContext.put(nodeMappingDayAnalysis);
+
+ nodeMappingDayAnalysisAnswer = new SegmentOtherAnswer();
+ doAnswer(nodeMappingDayAnalysisAnswer).when(nodeMappingDayAnalysis).tell(Mockito.argThat(new IsSegmentWithTimeSlice()));
+ }
+
+ @Test
+ public void testOnReceive() throws Exception {
+ String cacheServiceSegmentAsString = segmentMock.mockCacheServiceSegmentAsString();
+
+ segmentPost.onReceive(cacheServiceSegmentAsString);
+
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310915L), segmentSaveAnswer_1.minute);
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310900L), segmentSaveAnswer_1.hour);
+ Assert.assertEquals(201703310000L, segmentSaveAnswer_1.day);
+
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310915L), segmentSaveAnswer_2.minute);
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310900L), segmentSaveAnswer_2.hour);
+ Assert.assertEquals(201703310000L, segmentSaveAnswer_2.day);
+
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310915L), segmentCostSaveAnswer.segmentWithTimeSlice.getMinute());
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310900L), segmentCostSaveAnswer.segmentWithTimeSlice.getHour());
+ Assert.assertEquals(201703310000L, segmentCostSaveAnswer.segmentWithTimeSlice.getDay());
+
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310915L), globalTraceAnalysisAnswer.segmentWithTimeSlice.getMinute());
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310900L), globalTraceAnalysisAnswer.segmentWithTimeSlice.getHour());
+ Assert.assertEquals(201703310000L, globalTraceAnalysisAnswer.segmentWithTimeSlice.getDay());
+
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310915L), segmentExceptionSaveAnswer.segmentWithTimeSlice.getMinute());
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310900L), segmentExceptionSaveAnswer.segmentWithTimeSlice.getHour());
+ Assert.assertEquals(201703310000L, segmentExceptionSaveAnswer.segmentWithTimeSlice.getDay());
+
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310915L), nodeRefMinuteAnalysisAnswer.segmentWithTimeSlice.getMinute());
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310900L), nodeRefMinuteAnalysisAnswer.segmentWithTimeSlice.getHour());
+ Assert.assertEquals(201703310000L, nodeRefMinuteAnalysisAnswer.segmentWithTimeSlice.getDay());
+
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310915L), nodeRefHourAnalysisAnswer.segmentWithTimeSlice.getMinute());
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310900L), nodeRefHourAnalysisAnswer.segmentWithTimeSlice.getHour());
+ Assert.assertEquals(201703310000L, nodeRefHourAnalysisAnswer.segmentWithTimeSlice.getDay());
+
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310915L), nodeRefDayAnalysisAnswer.segmentWithTimeSlice.getMinute());
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310900L), nodeRefDayAnalysisAnswer.segmentWithTimeSlice.getHour());
+ Assert.assertEquals(201703310000L, nodeRefDayAnalysisAnswer.segmentWithTimeSlice.getDay());
+ }
+
+ public class SegmentOtherAnswer implements Answer {
+
+ SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice;
+
+ @Override
+ public Object answer(InvocationOnMock invocation) throws Throwable {
+ segmentWithTimeSlice = (SegmentPost.SegmentWithTimeSlice) invocation.getArguments()[0];
+ return null;
+ }
+ }
+
+ public class SegmentSaveAnswer implements Answer {
+ long minute = 0;
+ long hour = 0;
+ long day = 0;
+
+ @Override
+ public Object answer(InvocationOnMock invocation) throws Throwable {
+ JsonObject jsonObject = (JsonObject) invocation.getArguments()[0];
+ logger.info("SegmentSave json: " + jsonObject.toString());
+ minute = jsonObject.get("minute").getAsLong();
+ hour = jsonObject.get("hour").getAsLong();
+ day = jsonObject.get("day").getAsLong();
+ return null;
+ }
+ }
+
+ class IsCacheServiceSegment_1 extends ArgumentMatcher {
+ private static final String SegId = "Segment.1490922929258.927784221.5991.27.1";
+
+ public boolean matches(Object para) {
+ JsonObject paraJson = (JsonObject) para;
+ return SegId.equals(paraJson.get("ts").getAsString());
+ }
+ }
+
+ class IsCacheServiceSegment_2 extends ArgumentMatcher {
+ private static final String SegId = "Segment.1490922929298.927784221.5991.28.1";
+
+ public boolean matches(Object para) {
+ JsonObject paraJson = (JsonObject) para;
+ return SegId.equals(paraJson.get("ts").getAsString());
+ }
+ }
+
+ class IsSegmentWithTimeSlice extends ArgumentMatcher {
+ public boolean matches(Object para) {
+ return para instanceof SegmentPost.SegmentWithTimeSlice;
+ }
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/SegmentRealPost.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/SegmentRealPost.java
new file mode 100644
index 000000000..f0c6cfdeb
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/SegmentRealPost.java
@@ -0,0 +1,27 @@
+package com.a.eye.skywalking.collector.worker.segment;
+
+import com.a.eye.skywalking.collector.worker.segment.mock.SegmentMock;
+
+/**
+ * @author pengys5
+ */
+public class SegmentRealPost {
+
+ public static void main(String[] args) throws Exception {
+ SegmentMock mock = new SegmentMock();
+// String cacheServiceExceptionSegmentAsString = mock.mockCacheServiceExceptionSegmentAsString();
+// HttpClientTools.INSTANCE.post("http://localhost:7001/segments", cacheServiceExceptionSegmentAsString);
+//
+// String portalServiceExceptionSegmentAsString = mock.mockPortalServiceExceptionSegmentAsString();
+// HttpClientTools.INSTANCE.post("http://localhost:7001/segments", portalServiceExceptionSegmentAsString);
+
+ String cacheServiceSegmentAsString = mock.mockCacheServiceSegmentAsString();
+ HttpClientTools.INSTANCE.post("http://localhost:7001/segments", cacheServiceSegmentAsString);
+
+ String persistenceServiceSegmentAsString = mock.mockPersistenceServiceSegmentAsString();
+ HttpClientTools.INSTANCE.post("http://localhost:7001/segments", persistenceServiceSegmentAsString);
+
+ String portalServiceSegmentAsString = mock.mockPortalServiceSegmentAsString();
+ HttpClientTools.INSTANCE.post("http://localhost:7001/segments", portalServiceSegmentAsString);
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/mock/SegmentMock.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/mock/SegmentMock.java
new file mode 100644
index 000000000..2b31d9eb8
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/mock/SegmentMock.java
@@ -0,0 +1,116 @@
+package com.a.eye.skywalking.collector.worker.segment.mock;
+
+import com.a.eye.skywalking.collector.worker.segment.SegmentPost;
+import com.a.eye.skywalking.collector.worker.tools.DateTools;
+import com.a.eye.skywalking.collector.worker.tools.JsonFileReader;
+import com.a.eye.skywalking.trace.SegmentsMessage;
+import com.a.eye.skywalking.trace.TraceSegment;
+import com.google.gson.Gson;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author pengys5
+ */
+public class SegmentMock {
+
+ private Logger logger = LogManager.getFormatterLogger(SegmentMock.class);
+
+ private Gson gson = new Gson();
+ private String path = this.getClass().getResource("/").getPath();
+
+ private final String CacheServiceJsonFile = path + "/json/segment/post/normal/cache-service.json";
+ private final String PersistenceServiceJsonFile = path + "/json/segment/post/normal/persistence-service.json";
+ private final String PortalServiceJsonFile = path + "/json/segment/post/normal/portal-service.json";
+
+ private final String CacheServiceExceptionJsonFile = path + "/json/segment/post/exception/cache-service.json";
+ private final String PortalServiceExceptionJsonFile = path + "/json/segment/post/exception/portal-service.json";
+
+ private final String SpecialJsonFile = path + "/json/segment/post/special/special.json";
+
+ public String mockSpecialSegmentAsString() throws FileNotFoundException {
+ return JsonFileReader.INSTANCE.read(SpecialJsonFile);
+ }
+
+ public String mockCacheServiceSegmentAsString() throws FileNotFoundException {
+ return JsonFileReader.INSTANCE.read(CacheServiceJsonFile);
+ }
+
+ public String mockPersistenceServiceSegmentAsString() throws FileNotFoundException {
+ return JsonFileReader.INSTANCE.read(PersistenceServiceJsonFile);
+ }
+
+ public String mockPortalServiceSegmentAsString() throws FileNotFoundException {
+ return JsonFileReader.INSTANCE.read(PortalServiceJsonFile);
+ }
+
+ public String mockCacheServiceExceptionSegmentAsString() throws FileNotFoundException {
+ return JsonFileReader.INSTANCE.read(CacheServiceExceptionJsonFile);
+ }
+
+ public String mockPortalServiceExceptionSegmentAsString() throws FileNotFoundException {
+ return JsonFileReader.INSTANCE.read(PortalServiceExceptionJsonFile);
+ }
+
+ public List mockSpecialSegmentTimeSlice() throws FileNotFoundException {
+ String specialSegmentAsString = mockSpecialSegmentAsString();
+ logger.debug(specialSegmentAsString);
+ return createSegmentWithTimeSliceList(specialSegmentAsString);
+ }
+
+ public List mockCacheServiceExceptionSegmentTimeSlice() throws FileNotFoundException {
+ String cacheServiceExceptionSegmentAsString = mockCacheServiceExceptionSegmentAsString();
+ logger.debug(cacheServiceExceptionSegmentAsString);
+ return createSegmentWithTimeSliceList(cacheServiceExceptionSegmentAsString);
+ }
+
+ public List mockPortalServiceExceptionSegmentTimeSlice() throws FileNotFoundException {
+ String portalServiceExceptionSegmentAsString = mockPortalServiceExceptionSegmentAsString();
+ logger.debug(portalServiceExceptionSegmentAsString);
+ return createSegmentWithTimeSliceList(portalServiceExceptionSegmentAsString);
+ }
+
+ public List mockCacheServiceSegmentSegmentTimeSlice() throws FileNotFoundException {
+ String cacheServiceSegmentAsString = mockCacheServiceSegmentAsString();
+ logger.debug(cacheServiceSegmentAsString);
+ return createSegmentWithTimeSliceList(cacheServiceSegmentAsString);
+ }
+
+ public List mockPersistenceServiceSegmentTimeSlice() throws FileNotFoundException {
+ String persistenceServiceSegmentAsString = mockPersistenceServiceSegmentAsString();
+ logger.debug(persistenceServiceSegmentAsString);
+ return createSegmentWithTimeSliceList(persistenceServiceSegmentAsString);
+ }
+
+ public List mockPortalServiceSegmentSegmentTimeSlice() throws FileNotFoundException {
+ String portalServiceSegmentAsString = mockPortalServiceSegmentAsString();
+ logger.debug(portalServiceSegmentAsString);
+ return createSegmentWithTimeSliceList(portalServiceSegmentAsString);
+ }
+
+ private List createSegmentWithTimeSliceList(String segmentJsonStr) {
+ SegmentsMessage segmentsMessage = gson.fromJson(segmentJsonStr, SegmentsMessage.class);
+ List segmentList = segmentsMessage.getSegments();
+
+ List segmentWithTimeSliceList = new ArrayList<>();
+ for (TraceSegment newSegment : segmentList) {
+ SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice = createSegmentWithTimeSlice(newSegment);
+ segmentWithTimeSliceList.add(segmentWithTimeSlice);
+ }
+ return segmentWithTimeSliceList;
+ }
+
+ private SegmentPost.SegmentWithTimeSlice createSegmentWithTimeSlice(TraceSegment newSegment) {
+ long minuteSlice = DateTools.getMinuteSlice(newSegment.getStartTime());
+ long hourSlice = DateTools.getHourSlice(newSegment.getStartTime());
+ long daySlice = DateTools.getDaySlice(newSegment.getStartTime());
+ int second = DateTools.getSecond(newSegment.getStartTime());
+
+ SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice = new SegmentPost.SegmentWithTimeSlice(newSegment, minuteSlice, hourSlice, daySlice, second);
+ return segmentWithTimeSlice;
+ }
+}
diff --git a/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentCostSaveTestCase.java b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentCostSaveTestCase.java
new file mode 100644
index 000000000..71b31908b
--- /dev/null
+++ b/skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/persistence/SegmentCostSaveTestCase.java
@@ -0,0 +1,206 @@
+package com.a.eye.skywalking.collector.worker.segment.persistence;
+
+import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
+import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
+import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
+import com.a.eye.skywalking.collector.worker.WorkerConfig;
+import com.a.eye.skywalking.collector.worker.mock.MockEsBulkClient;
+import com.a.eye.skywalking.collector.worker.mock.SaveToEsSourceAnswer;
+import com.a.eye.skywalking.collector.worker.segment.SegmentCostIndex;
+import com.a.eye.skywalking.collector.worker.segment.SegmentPost;
+import com.a.eye.skywalking.collector.worker.segment.mock.SegmentMock;
+import com.a.eye.skywalking.collector.worker.storage.EsClient;
+import com.a.eye.skywalking.collector.worker.tools.DateTools;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import org.apache.logging.log4j.LogManager;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.List;
+
+import static org.powermock.api.mockito.PowerMockito.when;
+
+/**
+ * @author pengys5
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({EsClient.class, LogManager.class})
+@PowerMockIgnore({"javax.management.*"})
+public class SegmentCostSaveTestCase {
+
+ private SegmentCostSave segmentCostSave;
+ private SegmentMock segmentMock = new SegmentMock();
+ private MockEsBulkClient mockEsBulkClient = new MockEsBulkClient();
+
+ private SaveToEsSourceAnswer saveToEsSourceAnswer;
+
+ @Before
+ public void init() throws Exception {
+ mockEsBulkClient.createMock();
+
+ saveToEsSourceAnswer = new SaveToEsSourceAnswer();
+ when(mockEsBulkClient.indexRequestBuilder.setSource(Mockito.anyString())).thenAnswer(saveToEsSourceAnswer);
+
+ ClusterWorkerContext clusterWorkerContext = new ClusterWorkerContext(null);
+ LocalWorkerContext localWorkerContext = new LocalWorkerContext();
+ segmentCostSave = new SegmentCostSave(SegmentCostSave.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
+ }
+
+ @Test
+ public void testEsIndex() {
+ Assert.assertEquals(SegmentCostIndex.Index, segmentCostSave.esIndex());
+ }
+
+ @Test
+ public void testEsType() {
+ Assert.assertEquals(SegmentCostIndex.Type_Record, segmentCostSave.esType());
+ }
+
+ @Test
+ public void testRole() {
+ Assert.assertEquals(SegmentCostSave.class.getSimpleName(), SegmentCostSave.Role.INSTANCE.roleName());
+ Assert.assertEquals(RollingSelector.class.getSimpleName(), SegmentCostSave.Role.INSTANCE.workerSelector().getClass().getSimpleName());
+ }
+
+ @Test
+ public void testFactory() {
+ Assert.assertEquals(SegmentCostSave.class.getSimpleName(), SegmentCostSave.Factory.INSTANCE.role().roleName());
+ Assert.assertEquals(SegmentCostSave.class.getSimpleName(), SegmentCostSave.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
+
+ int testSize = 10;
+ WorkerConfig.Queue.Segment.SegmentCostSave.Size = testSize;
+ Assert.assertEquals(testSize, SegmentCostSave.Factory.INSTANCE.queueSize());
+ }
+
+ @Test
+ public void testPersistenceServiceAnalyse() throws Exception {
+ WorkerConfig.Persistence.Data.size = 1;
+
+ List segmentWithTimeSliceList = segmentMock.mockPersistenceServiceSegmentTimeSlice();
+
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : segmentWithTimeSliceList) {
+ segmentCostSave.analyse(segmentWithTimeSlice);
+ }
+
+ JsonArray sourceArray = saveToEsSourceAnswer.sourceObj.getSource();
+ Assert.assertEquals(1, sourceArray.size());
+
+ JsonObject costJsonObj = sourceArray.get(0).getAsJsonObject();
+ Assert.assertEquals("Segment.1490922929274.1382198130.5997.47.1", costJsonObj.get("segId").getAsString());
+ Assert.assertEquals(1490922929274L, costJsonObj.get("startTime").getAsLong());
+ Assert.assertEquals(1490922929288L, costJsonObj.get("EndTime").getAsLong());
+ Assert.assertEquals("/persistence/query", costJsonObj.get("operationName").getAsString());
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310915L), costJsonObj.get("timeSlice").getAsLong());
+ Assert.assertEquals(14, costJsonObj.get("cost").getAsInt());
+ }
+
+ @Test
+ public void testCacheServiceAnalyse() throws Exception {
+ WorkerConfig.Persistence.Data.size = 2;
+
+ List segmentWithTimeSliceList = segmentMock.mockCacheServiceSegmentSegmentTimeSlice();
+
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : segmentWithTimeSliceList) {
+ segmentCostSave.analyse(segmentWithTimeSlice);
+ }
+
+ JsonArray sourceArray = saveToEsSourceAnswer.sourceObj.getSource();
+ Assert.assertEquals(2, sourceArray.size());
+
+ JsonObject costJsonObj_0 = null;
+ JsonObject costJsonObj_1 = null;
+ for (int i = 0; i < sourceArray.size(); i++) {
+ JsonObject costJsonObj = sourceArray.get(i).getAsJsonObject();
+ if (costJsonObj.get("segId").getAsString().equals("Segment.1490922929258.927784221.5991.27.1")) {
+ costJsonObj_0 = costJsonObj;
+ } else if (costJsonObj.get("segId").getAsString().equals("Segment.1490922929298.927784221.5991.28.1")) {
+ costJsonObj_1 = costJsonObj;
+ }
+ }
+
+ Assert.assertEquals(1490922929258L, costJsonObj_0.get("startTime").getAsLong());
+ Assert.assertEquals(1490922929261L, costJsonObj_0.get("EndTime").getAsLong());
+ Assert.assertEquals("com.a.eye.skywalking.test.cache.CacheService.findCache(java.lang.String)", costJsonObj_0.get("operationName").getAsString());
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310915L), costJsonObj_0.get("timeSlice").getAsLong());
+ Assert.assertEquals(3, costJsonObj_0.get("cost").getAsInt());
+
+ Assert.assertEquals(1490922929298L, costJsonObj_1.get("startTime").getAsLong());
+ Assert.assertEquals(1490922929303L, costJsonObj_1.get("EndTime").getAsLong());
+ Assert.assertEquals("com.a.eye.skywalking.test.cache.CacheService.updateCache(java.lang.String,java.lang.String)", costJsonObj_1.get("operationName").getAsString());
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310915L), costJsonObj_1.get("timeSlice").getAsLong());
+ Assert.assertEquals(5, costJsonObj_1.get("cost").getAsInt());
+ }
+
+ @Test
+ public void testPortalServiceAnalyse() throws Exception {
+ WorkerConfig.Persistence.Data.size = 1;
+
+ List segmentWithTimeSliceList = segmentMock.mockPortalServiceSegmentSegmentTimeSlice();
+
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : segmentWithTimeSliceList) {
+ segmentCostSave.analyse(segmentWithTimeSlice);
+ }
+
+ JsonArray sourceArray = saveToEsSourceAnswer.sourceObj.getSource();
+ Assert.assertEquals(1, sourceArray.size());
+
+ JsonObject costJsonObj = sourceArray.get(0).getAsJsonObject();
+ Assert.assertEquals("Segment.1490922929254.1797892356.6003.69.1", costJsonObj.get("segId").getAsString());
+ Assert.assertEquals(1490922929254L, costJsonObj.get("startTime").getAsLong());
+ Assert.assertEquals(1490922929306L, costJsonObj.get("EndTime").getAsLong());
+ Assert.assertEquals("/portal/", costJsonObj.get("operationName").getAsString());
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310915L), costJsonObj.get("timeSlice").getAsLong());
+ Assert.assertEquals(52, costJsonObj.get("cost").getAsInt());
+ }
+
+ @Test
+ public void testCacheServiceExceptionAnalyse() throws Exception {
+ WorkerConfig.Persistence.Data.size = 1;
+
+ List segmentWithTimeSliceList = segmentMock.mockCacheServiceExceptionSegmentTimeSlice();
+
+ for (SegmentPost.SegmentWithTimeSlice segmentWithTimeSlice : segmentWithTimeSliceList) {
+ segmentCostSave.analyse(segmentWithTimeSlice);
+ }
+
+ JsonArray sourceArray = saveToEsSourceAnswer.sourceObj.getSource();
+ Assert.assertEquals(1, sourceArray.size());
+
+ JsonObject costJsonObj = sourceArray.get(0).getAsJsonObject();
+ Assert.assertEquals("Segment.1490923010328.927784221.5991.32.1", costJsonObj.get("segId").getAsString());
+ Assert.assertEquals(1490923010328L, costJsonObj.get("startTime").getAsLong());
+ Assert.assertEquals(1490923010329L, costJsonObj.get("EndTime").getAsLong());
+ Assert.assertEquals("com.a.eye.skywalking.test.cache.CacheService.findCacheWithException(java.lang.String)", costJsonObj.get("operationName").getAsString());
+ Assert.assertEquals(DateTools.changeToUTCSlice(201703310916L), costJsonObj.get("timeSlice").getAsLong());
+ Assert.assertEquals(1, costJsonObj.get("cost").getAsInt());
+ }
+
+ @Test
+ public void testPortalServiceExceptionAnalyse() throws Exception {
+ WorkerConfig.Persistence.Data.size = 1;
+
+ List
+
+
SkyWalking: Large-Scale Distributed Systems Tracing Infrastructure, also known Distributed Tracer.
@@ -13,81 +13,46 @@ SkyWalking: Large-Scale Distributed Systems Tracing Infrastructure, also known D
[](http://opentracing.io)
[](https://github.com/wu-sheng/sky-walking/releases)
-# News
-* sky-walking v3.0 iteration begins... The top 2 important features are: [`Update the trace-structure`](https://github.com/wu-sheng/sky-walking/issues/83) and [`Analyze trace, and bring metric/analytic/cause up`](https://github.com/wu-sheng/sky-walking/issues/84)
-* See feature codes at [branch feature/3.0](https://github.com/wu-sheng/sky-walking/tree/feature/3.0)
-* The new UI release on [wu-sheng/sky-walking-ui](https://github.com/wu-sheng/sky-walking-ui)
-# Abstract
-* An open source Large-Scale Distributed Systems Tracing Infrastructure, also known a ditributed tracer.
-* Based on [Google Dapper Paper: Dapper, a Large-Scale Distributed Systems Tracing Infrastructure](http://research.google.com/pubs/pub36356.html), read [Simplified Chinese Version](http://duanple.blog.163.com/blog/static/70971767201329113141336/)
-* Support popular rpc frameworks, such as [dubbo](https://github.com/alibaba/dubbo), [dubbox](https://github.com/dangdangdotcom/dubbox), [motan](https://github.com/weibocom/motan) etc., trigger email-alert when application occurs unexpected exception.
-* Auto-instrumentation mechenism, **no need to CHANGE any application source code**.
-* Easy to deploy, **even in product mode** (since 2.0) . No need of Hadoop, HBase, or Cassandra Cluster.
-* Pure Java server implementation. provide gRPC (since 2.0) and HTTP (since 2.1) cross-platform spans collecting service.
-
-
-# Supported components
-
-### web containers
-* Tomcat 7
-* Tomcat 8
-
-### databases
-* mysql
-* oracle
-* h2
-* easily extend to support sybase, sqlserver, jtds, db2, informix
-
-### rpc frameworks
-* dubbo
-* dubbox
-* httpClient
-* motan
-
-### cache
-* jedis
-
-### opentracing supported frameworks
-* motan
-* hprose-java
-
-# Contributors
-* 吴晟 [wusheng](https://github.com/wu-sheng) wu.sheng@foxmail.com
-* 张鑫 [zhangxin](https://github.com/ascrutae)
-
-
-_Chinese Articles about sky-walking and distributed tracer_
-
-
-
-_If you are Chinese Developer, you can join QQ Group: 392443393, and **Tagged** Sky-Walking._
+* Auto-instrumentation mechanism, **no need to CHANGE any application source code**. Supported [frameworks](https://github.com/wu-sheng/sky-walking/wiki/3.0-supported-list).
+* Pure Java server implementation, with RESTful Web service.
+* High performance streaming analysis.
+* The UI released on [wu-sheng/sky-walking-ui](https://github.com/wu-sheng/sky-walking-ui)
___
-
-
+- Trace query.
+
-
+- Span detail.
+
-* alarm mail
-
-
# Document
* [WIKI](https://github.com/wu-sheng/sky-walking/wiki)
+
+_Chat with us on gitter, in English. As a Chinese Developer, you can join QQ Group: 392443393, and **Tagged** Sky-Walking._
diff --git a/docs/donate.jpg b/docs/donate.jpg
deleted file mode 100644
index d739d34ed..000000000
Binary files a/docs/donate.jpg and /dev/null differ
diff --git a/docs/resources/SkyWalkingArch.jpg b/docs/resources/SkyWalkingArch.jpg
deleted file mode 100644
index d63fadade..000000000
Binary files a/docs/resources/SkyWalkingArch.jpg and /dev/null differ
diff --git a/docs/resources/alarmMail.png b/docs/resources/alarmMail.png
deleted file mode 100644
index 0e62fdcf0..000000000
Binary files a/docs/resources/alarmMail.png and /dev/null differ
diff --git a/docs/resources/callChain.png b/docs/resources/callChain.png
deleted file mode 100644
index 8be0fa7f2..000000000
Binary files a/docs/resources/callChain.png and /dev/null differ
diff --git a/docs/resources/callChainDetail.png b/docs/resources/callChainDetail.png
deleted file mode 100644
index 06297c610..000000000
Binary files a/docs/resources/callChainDetail.png and /dev/null differ
diff --git a/docs/resources/callChainLog.png b/docs/resources/callChainLog.png
deleted file mode 100644
index 05a42fe9f..000000000
Binary files a/docs/resources/callChainLog.png and /dev/null differ
diff --git a/docs/resources/demo-application-cluster-tracer.jpg b/docs/resources/demo-application-cluster-tracer.jpg
deleted file mode 100644
index 8be0fa7f2..000000000
Binary files a/docs/resources/demo-application-cluster-tracer.jpg and /dev/null differ
diff --git a/docs/resources/oneapm-award.png b/docs/resources/oneapm-award.png
deleted file mode 100644
index 142ae190e..000000000
Binary files a/docs/resources/oneapm-award.png and /dev/null differ
diff --git a/docs/resources/skywalking.png b/docs/resources/skywalking.png
deleted file mode 100644
index 3e26a5766..000000000
Binary files a/docs/resources/skywalking.png and /dev/null differ
diff --git a/docs/resources/skywalking_ot.png b/docs/resources/skywalking_ot.png
deleted file mode 100644
index 37be52ced..000000000
Binary files a/docs/resources/skywalking_ot.png and /dev/null differ
diff --git a/docs/resources/toutiao.JPG b/docs/resources/toutiao.JPG
deleted file mode 100644
index 533a2f521..000000000
Binary files a/docs/resources/toutiao.JPG and /dev/null differ
diff --git a/pom.xml b/pom.xml
index a10be42bd..2445e2397 100644
--- a/pom.xml
+++ b/pom.xml
@@ -24,6 +24,21 @@