diff --git a/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/application/dao/ApplicationH2DAO.java b/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/application/dao/ApplicationH2DAO.java index 6f45a62cba05221a59c7a2527627622a01aaa9e0..41cfe84937af2640341c22eb9dfee8491b5af387 100644 --- a/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/application/dao/ApplicationH2DAO.java +++ b/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/application/dao/ApplicationH2DAO.java @@ -16,7 +16,7 @@ import java.text.MessageFormat; public class ApplicationH2DAO extends H2DAO implements IApplicationDAO { private final Logger logger = LoggerFactory.getLogger(ApplicationH2DAO.class); private static final String INSERT_APPLICATION_SQL = "insert into {0}({1}, {2}) values(?, ?)"; -; @Override + @Override public int getApplicationId(String applicationCode) { logger.info("get the application id with application code = {}", applicationCode); String sql = "select " + ApplicationTable.COLUMN_APPLICATION_ID + " from " + diff --git a/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/instance/dao/InstanceH2DAO.java b/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/instance/dao/InstanceH2DAO.java index 6b7ccc612ca9a30c2c00892260b4ef0cc4ae4f7c..d90036ce388c057699d1b4ce10a8b9b6243dca4c 100644 --- a/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/instance/dao/InstanceH2DAO.java +++ b/apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/instance/dao/InstanceH2DAO.java @@ -1,23 +1,19 @@ package org.skywalking.apm.collector.agentregister.worker.instance.dao; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.HashMap; +import java.util.Map; + import org.skywalking.apm.collector.client.h2.H2Client; import org.skywalking.apm.collector.client.h2.H2ClientException; -import org.skywalking.apm.collector.core.stream.Data; -import org.skywalking.apm.collector.storage.define.jvm.CpuMetricTable; -import org.skywalking.apm.collector.storage.define.register.ApplicationTable; import org.skywalking.apm.collector.storage.define.register.InstanceDataDefine; import org.skywalking.apm.collector.storage.define.register.InstanceTable; -import org.skywalking.apm.collector.storage.define.serviceref.ServiceReferenceTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.text.MessageFormat; -import java.util.HashMap; -import java.util.Map; - /** * @author pengys5 */ diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/mapping/dao/NodeMappingH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/mapping/dao/NodeMappingH2DAO.java index 2f8712c3d3a21b528a0ec37636aab9494ba352cd..63ed2655121640dfc34a693bac3a8db4718a4bdc 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/mapping/dao/NodeMappingH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/mapping/dao/NodeMappingH2DAO.java @@ -51,6 +51,7 @@ public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO, IPersist source.put(NodeMappingTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); String sql = getBatchInsertSql(NodeMappingTable.TABLE, source.keySet()); entity.setSql(sql); + entity.setParams(source.values().toArray(new Object[0])); return entity; } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/noderef/dao/NodeReferenceH2DAO.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/noderef/dao/NodeReferenceH2DAO.java index f03932c9f6f4863535923c41acf42e9c559a2149..8ca8bf048de7c578180a04963046b7a00d902396 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/noderef/dao/NodeReferenceH2DAO.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/noderef/dao/NodeReferenceH2DAO.java @@ -1,25 +1,94 @@ package org.skywalking.apm.collector.agentstream.worker.noderef.dao; +import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.client.h2.H2ClientException; import org.skywalking.apm.collector.core.stream.Data; import org.skywalking.apm.collector.storage.define.DataDefine; +import org.skywalking.apm.collector.storage.define.node.NodeMappingTable; +import org.skywalking.apm.collector.storage.define.noderef.NodeReferenceTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity; import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + /** * @author pengys5 */ public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO, IPersistenceDAO { private final Logger logger = LoggerFactory.getLogger(NodeReferenceH2DAO.class); + private static final String GET_SQL = "select * from {0} where {1} = ?"; @Override public Data get(String id, DataDefine dataDefine) { + H2Client client = getClient(); + String sql = MessageFormat.format(GET_SQL, NodeReferenceTable.TABLE, "id"); + Object[] params = new Object[]{id}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + Data data = dataDefine.build(id); + data.setDataInteger(0, rs.getInt(NodeReferenceTable.COLUMN_FRONT_APPLICATION_ID)); + data.setDataInteger(1, rs.getInt(NodeReferenceTable.COLUMN_BEHIND_APPLICATION_ID)); + data.setDataString(1, rs.getString(NodeReferenceTable.COLUMN_BEHIND_PEER)); + data.setDataInteger(2, rs.getInt(NodeReferenceTable.COLUMN_S1_LTE)); + data.setDataInteger(3, rs.getInt(NodeReferenceTable.COLUMN_S3_LTE)); + data.setDataInteger(4, rs.getInt(NodeReferenceTable.COLUMN_S5_LTE)); + data.setDataInteger(5, rs.getInt(NodeReferenceTable.COLUMN_S5_GT)); + data.setDataInteger(6, rs.getInt(NodeReferenceTable.COLUMN_SUMMARY)); + data.setDataInteger(7, rs.getInt(NodeReferenceTable.COLUMN_ERROR)); + data.setDataLong(0, rs.getLong(NodeReferenceTable.COLUMN_TIME_BUCKET)); + return data; + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return null; } @Override public H2SqlEntity prepareBatchInsert(Data data) { - return null; + Map source = new HashMap<>(); + H2SqlEntity entity = new H2SqlEntity(); + source.put("id", data.getDataString(0)); + source.put(NodeReferenceTable.COLUMN_FRONT_APPLICATION_ID, data.getDataInteger(0)); + source.put(NodeReferenceTable.COLUMN_BEHIND_APPLICATION_ID, data.getDataInteger(1)); + source.put(NodeReferenceTable.COLUMN_BEHIND_PEER, data.getDataString(1)); + source.put(NodeReferenceTable.COLUMN_S1_LTE, data.getDataInteger(2)); + source.put(NodeReferenceTable.COLUMN_S3_LTE, data.getDataInteger(3)); + source.put(NodeReferenceTable.COLUMN_S5_LTE, data.getDataInteger(4)); + source.put(NodeReferenceTable.COLUMN_S5_GT, data.getDataInteger(5)); + source.put(NodeReferenceTable.COLUMN_SUMMARY, data.getDataInteger(6)); + source.put(NodeReferenceTable.COLUMN_ERROR, data.getDataInteger(7)); + source.put(NodeReferenceTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); + String sql = getBatchInsertSql(NodeMappingTable.TABLE, source.keySet()); + entity.setSql(sql); + + entity.setParams(source.values().toArray(new Object[0])); + return entity; } @Override public H2SqlEntity prepareBatchUpdate(Data data) { - return null; + Map source = new HashMap<>(); + H2SqlEntity entity = new H2SqlEntity(); + source.put(NodeReferenceTable.COLUMN_FRONT_APPLICATION_ID, data.getDataInteger(0)); + source.put(NodeReferenceTable.COLUMN_BEHIND_APPLICATION_ID, data.getDataInteger(1)); + source.put(NodeReferenceTable.COLUMN_BEHIND_PEER, data.getDataString(1)); + source.put(NodeReferenceTable.COLUMN_S1_LTE, data.getDataInteger(2)); + source.put(NodeReferenceTable.COLUMN_S3_LTE, data.getDataInteger(3)); + source.put(NodeReferenceTable.COLUMN_S5_LTE, data.getDataInteger(4)); + source.put(NodeReferenceTable.COLUMN_S5_GT, data.getDataInteger(5)); + source.put(NodeReferenceTable.COLUMN_SUMMARY, data.getDataInteger(6)); + source.put(NodeReferenceTable.COLUMN_ERROR, data.getDataInteger(7)); + source.put(NodeReferenceTable.COLUMN_TIME_BUCKET, data.getDataLong(0)); + String id = data.getDataString(0); + String sql = getBatchUpdateSql(NodeMappingTable.TABLE, source.keySet(), "id"); + entity.setSql(sql); + List values = new ArrayList<>(source.values()); + values.add(id); + entity.setParams(values.toArray(new Object[0])); + return entity; } } diff --git a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/noderef/define/NodeReferenceH2TableDefine.java b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/noderef/define/NodeReferenceH2TableDefine.java index 43b8377c8cf4aa5b70ea5760aa277789b306bb3f..cfa8d9174c40598887bff44c6fc16c4ae33bd5e5 100644 --- a/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/noderef/define/NodeReferenceH2TableDefine.java +++ b/apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/noderef/define/NodeReferenceH2TableDefine.java @@ -14,6 +14,7 @@ public class NodeReferenceH2TableDefine extends H2TableDefine { } @Override public void initialize() { + addColumn(new H2ColumnDefine(NodeReferenceTable.COLUMN_ID, H2ColumnDefine.Type.Varchar.name())); addColumn(new H2ColumnDefine(NodeReferenceTable.COLUMN_FRONT_APPLICATION_ID, H2ColumnDefine.Type.Int.name())); addColumn(new H2ColumnDefine(NodeReferenceTable.COLUMN_BEHIND_APPLICATION_ID, H2ColumnDefine.Type.Int.name())); addColumn(new H2ColumnDefine(NodeReferenceTable.COLUMN_BEHIND_PEER, H2ColumnDefine.Type.Varchar.name())); diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ApplicationH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ApplicationH2DAO.java index 149d732025962022c2fb9b55ae1e26cc83227874..4aa3f2c7acbefeb8fa36903d0cbbacaf0f55435f 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ApplicationH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ApplicationH2DAO.java @@ -13,7 +13,7 @@ import java.sql.SQLException; import java.text.MessageFormat; /** - * @author pengys5 + * @author pengys5, clevertension */ public class ApplicationH2DAO extends H2DAO implements IApplicationDAO { diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/CpuMetricH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/CpuMetricH2DAO.java index 6cd0092089b55702e0d54a47a8743dcbd9f10299..fe378dc61696fb0e7b3122c683d02193847e7d39 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/CpuMetricH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/CpuMetricH2DAO.java @@ -1,18 +1,11 @@ package org.skywalking.apm.collector.ui.dao; import com.google.gson.JsonArray; -import org.elasticsearch.action.get.GetResponse; -import org.elasticsearch.action.get.MultiGetItemResponse; -import org.elasticsearch.action.get.MultiGetRequestBuilder; -import org.elasticsearch.action.get.MultiGetResponse; import org.skywalking.apm.collector.client.h2.H2Client; import org.skywalking.apm.collector.client.h2.H2ClientException; import org.skywalking.apm.collector.core.util.Const; import org.skywalking.apm.collector.core.util.TimeBucketUtils; import org.skywalking.apm.collector.storage.define.jvm.CpuMetricTable; -import org.skywalking.apm.collector.storage.define.register.InstanceDataDefine; -import org.skywalking.apm.collector.storage.define.register.InstanceTable; -import org.skywalking.apm.collector.storage.elasticsearch.dao.EsDAO; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -24,16 +17,16 @@ import java.util.ArrayList; import java.util.List; /** - * @author pengys5 + * @author pengys5, clevertension */ public class CpuMetricH2DAO extends H2DAO implements ICpuMetricDAO { private final Logger logger = LoggerFactory.getLogger(InstanceH2DAO.class); - private static final String GET_METRIC_SQL = "select * from {0} where {1} = ?"; - private static final String GET_METRICS_SQL = "select * from {0} where {1} in ("; + private static final String GET_CPU_METRIC_SQL = "select * from {0} where {1} = ?"; + private static final String GET_CPU_METRICS_SQL = "select * from {0} where {1} in ("; @Override public int getMetric(int instanceId, long timeBucket) { String id = timeBucket + Const.ID_SPLIT + instanceId; H2Client client = getClient(); - String sql = MessageFormat.format(GET_METRIC_SQL, CpuMetricTable.TABLE, "id"); + String sql = MessageFormat.format(GET_CPU_METRIC_SQL, CpuMetricTable.TABLE, "id"); Object[] params = new Object[]{id}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { @@ -47,7 +40,7 @@ public class CpuMetricH2DAO extends H2DAO implements ICpuMetricDAO { @Override public JsonArray getMetric(int instanceId, long startTimeBucket, long endTimeBucket) { H2Client client = getClient(); - String sql = MessageFormat.format(GET_METRICS_SQL, CpuMetricTable.TABLE, "id"); + String sql = MessageFormat.format(GET_CPU_METRICS_SQL, CpuMetricTable.TABLE, "id"); long timeBucket = startTimeBucket; List idList = new ArrayList<>(); @@ -59,7 +52,7 @@ public class CpuMetricH2DAO extends H2DAO implements ICpuMetricDAO { while (timeBucket <= endTimeBucket); StringBuilder builder = new StringBuilder(); - for( int i = 0 ; i < idList.size(); i++ ) { + for (int i = 0; i < idList.size(); i++) { builder.append("?,"); } builder.delete(builder.length() - 1, builder.length()); diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/GCMetricH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/GCMetricH2DAO.java index bf38132df31a2e3f07f1743d759b1685076128cc..614a886d85686e10ba5fa48533e7e638a22e1333 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/GCMetricH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/GCMetricH2DAO.java @@ -1,27 +1,156 @@ package org.skywalking.apm.collector.ui.dao; +import com.google.gson.JsonArray; import com.google.gson.JsonObject; +import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.client.h2.H2ClientException; +import org.skywalking.apm.collector.core.util.Const; +import org.skywalking.apm.collector.core.util.TimeBucketUtils; +import org.skywalking.apm.collector.storage.define.jvm.GCMetricTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.skywalking.apm.network.proto.GCPhrase; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.ArrayList; +import java.util.List; + /** - * @author pengys5 + * @author pengys5, clevertension */ public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO { private final Logger logger = LoggerFactory.getLogger(GCMetricH2DAO.class); - private static final String GET_GC_COUNT_SQL = "select sum({0}) as cnt, {1} from {2} where {3} > ? group by {1}"; + private static final String GET_GC_COUNT_SQL = "select {1}, sum({0}) as cnt, {1} from {2} where {3} = ? and {4} in ("; + private static final String GET_GC_METRIC_SQL = "select * from {0} where {1} = ?"; + private static final String GET_GC_METRICS_SQL = "select * from {0} where {1} in ("; @Override public GCCount getGCCount(long[] timeBuckets, int instanceId) { GCCount gcCount = new GCCount(); + H2Client client = getClient(); + String sql = GET_GC_COUNT_SQL; + StringBuilder builder = new StringBuilder(); + for (int i = 0; i < timeBuckets.length; i++) { + builder.append("?,"); + } + builder.delete(builder.length() - 1, builder.length()); + builder.append(")"); + sql = sql + builder + " group by {1}"; + sql = MessageFormat.format(sql, GCMetricTable.COLUMN_COUNT, GCMetricTable.COLUMN_PHRASE, + GCMetricTable.TABLE, GCMetricTable.COLUMN_INSTANCE_ID, "id"); + Object[] params = new Object[timeBuckets.length + 1]; + for (int i = 0; i < timeBuckets.length; i++) { + params[i + 1] = timeBuckets[i]; + } + params[0] = instanceId; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + int phrase = rs.getInt(GCMetricTable.COLUMN_PHRASE); + int count = rs.getInt("cnt"); + if (phrase == GCPhrase.NEW_VALUE) { + gcCount.setYoung(count); + } else if (phrase == GCPhrase.OLD_VALUE) { + gcCount.setOld(count); + } + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return gcCount; } @Override public JsonObject getMetric(int instanceId, long timeBucket) { - return null; + JsonObject response = new JsonObject(); + H2Client client = getClient(); + String sql = MessageFormat.format(GET_GC_METRIC_SQL, GCMetricTable.TABLE, "id"); + String youngId = timeBucket + Const.ID_SPLIT + GCPhrase.NEW_VALUE + instanceId; + Object[] params = new Object[]{youngId}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + response.addProperty("ygc", rs.getInt(GCMetricTable.COLUMN_COUNT)); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + String oldId = timeBucket + Const.ID_SPLIT + GCPhrase.OLD_VALUE + instanceId; + Object[] params1 = new Object[]{oldId}; + try (ResultSet rs = client.executeQuery(sql, params1)) { + if (rs.next()) { + response.addProperty("ogc", rs.getInt(GCMetricTable.COLUMN_COUNT)); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + + return response; } @Override public JsonObject getMetric(int instanceId, long startTimeBucket, long endTimeBucket) { - return null; + JsonObject response = new JsonObject(); + H2Client client = getClient(); + String sql = MessageFormat.format(GET_GC_METRICS_SQL, GCMetricTable.TABLE, "id"); + long timeBucket = startTimeBucket; + List idList = new ArrayList<>(); + do { + timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1); + String youngId = timeBucket + Const.ID_SPLIT + instanceId + Const.ID_SPLIT + GCPhrase.NEW_VALUE; + idList.add(youngId); + } + while (timeBucket <= endTimeBucket); + StringBuilder builder = new StringBuilder(); + for (int i = 0; i < idList.size(); i++) { + builder.append("?,"); + } + builder.delete(builder.length() - 1, builder.length()); + builder.append(")"); + sql = sql + builder; + Object[] params = idList.toArray(new String[0]); + + JsonArray youngArray = new JsonArray(); + try (ResultSet rs = client.executeQuery(sql, params)) { + while (rs.next()) { + youngArray.add(rs.getInt(GCMetricTable.COLUMN_COUNT)); + } + if (youngArray.size() == 0) { + youngArray.add(0); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + response.add("ygc", youngArray); + List idList1 = new ArrayList<>(); + timeBucket = startTimeBucket; + do { + timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1); + String oldId = timeBucket + Const.ID_SPLIT + instanceId + Const.ID_SPLIT + GCPhrase.OLD_VALUE; + idList1.add(oldId); + } + while (timeBucket <= endTimeBucket); + String sql1 = MessageFormat.format(GET_GC_METRICS_SQL, GCMetricTable.TABLE, "id"); + StringBuilder builder1 = new StringBuilder(); + for (int i = 0; i < idList1.size(); i++) { + builder1.append("?,"); + } + builder1.delete(builder1.length() - 1, builder1.length()); + builder1.append(")"); + sql1 = sql1 + builder1; + Object[] params1 = idList.toArray(new String[0]); + JsonArray oldArray = new JsonArray(); + + try (ResultSet rs = client.executeQuery(sql1, params1)) { + while (rs.next()) { + oldArray.add(rs.getInt(GCMetricTable.COLUMN_COUNT)); + } + if (oldArray.size() == 0) { + oldArray.add(0); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + response.add("ogc", oldArray); + + return response; } } diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/GlobalTraceH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/GlobalTraceH2DAO.java index 5e408238683c6679da840833578c75b48e3f42d6..6d8c3977b1e8cfde5e0094943b6d747108d06b7d 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/GlobalTraceH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/GlobalTraceH2DAO.java @@ -1,17 +1,58 @@ package org.skywalking.apm.collector.ui.dao; -import java.util.List; +import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.client.h2.H2ClientException; +import org.skywalking.apm.collector.storage.define.global.GlobalTraceTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.ArrayList; +import java.util.List; /** - * @author pengys5 + * @author pengys5, clevertension */ public class GlobalTraceH2DAO extends H2DAO implements IGlobalTraceDAO { + private final Logger logger = LoggerFactory.getLogger(GlobalTraceH2DAO.class); + private static final String GET_GLOBAL_TRACE_ID_SQL = "select {0} from {1} where {2} = ? limit 10"; + private static final String GET_SEGMENT_IDS_SQL = "select {0} from {1} where {2} = ? limit 10"; @Override public List getGlobalTraceId(String segmentId) { - return null; + List globalTraceIds = new ArrayList<>(); + H2Client client = getClient(); + String sql = MessageFormat.format(GET_GLOBAL_TRACE_ID_SQL, GlobalTraceTable.COLUMN_GLOBAL_TRACE_ID, + GlobalTraceTable.TABLE, GlobalTraceTable.COLUMN_SEGMENT_ID); + Object[] params = new Object[]{segmentId}; + try (ResultSet rs = client.executeQuery(sql, params)) { + while (rs.next()) { + String globalTraceId = rs.getString(GlobalTraceTable.COLUMN_GLOBAL_TRACE_ID); + logger.debug("segmentId: {}, global trace id: {}", segmentId, globalTraceId); + globalTraceIds.add(globalTraceId); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return globalTraceIds; } @Override public List getSegmentIds(String globalTraceId) { - return null; + List segmentIds = new ArrayList<>(); + H2Client client = getClient(); + String sql = MessageFormat.format(GET_SEGMENT_IDS_SQL, GlobalTraceTable.COLUMN_SEGMENT_ID, + GlobalTraceTable.TABLE, GlobalTraceTable.COLUMN_GLOBAL_TRACE_ID); + Object[] params = new Object[]{globalTraceId}; + try (ResultSet rs = client.executeQuery(sql, params)) { + while (rs.next()) { + String segmentId = rs.getString(GlobalTraceTable.COLUMN_SEGMENT_ID); + logger.debug("segmentId: {}, global trace id: {}", segmentId, globalTraceId); + segmentIds.add(globalTraceId); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return segmentIds; } } diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/InstPerformanceH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/InstPerformanceH2DAO.java index c11ac37c90d095c711d53aab25dd7d463d428b14..a09ee871c396f8150bdf3d770fda1709bf82cd1f 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/InstPerformanceH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/InstPerformanceH2DAO.java @@ -6,9 +6,6 @@ import org.skywalking.apm.collector.client.h2.H2ClientException; import org.skywalking.apm.collector.core.util.Const; import org.skywalking.apm.collector.core.util.TimeBucketUtils; import org.skywalking.apm.collector.storage.define.instance.InstPerformanceTable; -import org.skywalking.apm.collector.storage.define.jvm.CpuMetricTable; -import org.skywalking.apm.collector.storage.define.register.InstanceDataDefine; -import org.skywalking.apm.collector.storage.define.register.InstanceTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -20,7 +17,7 @@ import java.util.ArrayList; import java.util.List; /** - * @author pengys5 + * @author pengys5, clevertension */ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO { private final Logger logger = LoggerFactory.getLogger(InstPerformanceH2DAO.class); @@ -32,14 +29,14 @@ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO { logger.info("the inst performance inst id = {}", instanceId); String sql = MessageFormat.format(GET_INST_PERF_SQL, InstPerformanceTable.TABLE, InstPerformanceTable.COLUMN_INSTANCE_ID, InstPerformanceTable.COLUMN_TIME_BUCKET); StringBuilder builder = new StringBuilder(); - for( int i = 0 ; i < timeBuckets.length; i++ ) { + for (int i = 0; i < timeBuckets.length; i++) { builder.append("?,"); } builder.delete(builder.length() - 1, builder.length()); builder.append(")"); sql = sql + builder; Object[] params = new Object[timeBuckets.length + 1]; - for(int i = 0; i < timeBuckets.length; i++) { + for (int i = 0; i < timeBuckets.length; i++) { params[i + 1] = timeBuckets[i]; } params[0] = instanceId; @@ -56,6 +53,7 @@ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO { } @Override public int getTpsMetric(int instanceId, long timeBucket) { + logger.info("getTpMetric instanceId = {}, startTimeBucket = {}", instanceId, timeBucket); H2Client client = getClient(); String sql = MessageFormat.format(GET_TPS_METRIC_SQL, InstPerformanceTable.TABLE, "id"); Object[] params = new Object[]{instanceId}; @@ -70,6 +68,7 @@ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO { } @Override public JsonArray getTpsMetric(int instanceId, long startTimeBucket, long endTimeBucket) { + logger.info("getTpsMetric instanceId = {}, startTimeBucket = {}, endTimeBucket = {}", instanceId, startTimeBucket, endTimeBucket); H2Client client = getClient(); String sql = MessageFormat.format(GET_TPS_METRICS_SQL, InstPerformanceTable.TABLE, "id"); @@ -83,7 +82,7 @@ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO { while (timeBucket <= endTimeBucket); StringBuilder builder = new StringBuilder(); - for( int i = 0 ; i < idList.size(); i++ ) { + for (int i = 0; i < idList.size(); i++) { builder.append("?,"); } builder.delete(builder.length() - 1, builder.length()); @@ -133,7 +132,7 @@ public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO { while (timeBucket <= endTimeBucket); StringBuilder builder = new StringBuilder(); - for( int i = 0 ; i < idList.size(); i++ ) { + for (int i = 0; i < idList.size(); i++) { builder.append("?,"); } builder.delete(builder.length() - 1, builder.length()); diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/InstanceH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/InstanceH2DAO.java index 02412a367e35597f376a1240adca5d05160dfbfa..88a563c1efb276e1bff87efbc9217486c8935f4b 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/InstanceH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/InstanceH2DAO.java @@ -1,19 +1,10 @@ package org.skywalking.apm.collector.ui.dao; import com.google.gson.JsonArray; - -import java.sql.ResultSet; -import java.sql.SQLException; -import java.text.MessageFormat; -import java.util.LinkedList; -import java.util.List; - import com.google.gson.JsonObject; import org.skywalking.apm.collector.client.h2.H2Client; import org.skywalking.apm.collector.client.h2.H2ClientException; -import org.skywalking.apm.collector.core.util.StringUtils; import org.skywalking.apm.collector.core.util.TimeBucketUtils; -import org.skywalking.apm.collector.storage.define.node.NodeComponentTable; import org.skywalking.apm.collector.storage.define.register.InstanceDataDefine; import org.skywalking.apm.collector.storage.define.register.InstanceTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; @@ -21,8 +12,14 @@ import org.skywalking.apm.collector.ui.cache.ApplicationCache; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.LinkedList; +import java.util.List; + /** - * @author pengys5 + * @author pengys5, clevertension */ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { private final Logger logger = LoggerFactory.getLogger(InstanceH2DAO.class); @@ -55,7 +52,7 @@ public class InstanceH2DAO extends H2DAO implements IInstanceDAO { long fiveMinuteBefore = System.currentTimeMillis() - 5 * 60 * 1000; fiveMinuteBefore = TimeBucketUtils.INSTANCE.getSecondTimeBucket(fiveMinuteBefore); String sql = MessageFormat.format(GET_INST_LAST_HEARTBEAT_TIME_SQL, InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.TABLE, - InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.COLUMN_APPLICATION_ID); + InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.COLUMN_INSTANCE_ID); Object[] params = new Object[]{fiveMinuteBefore, applicationInstanceId}; try (ResultSet rs = client.executeQuery(sql, params)) { if (rs.next()) { diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/MemoryMetricH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/MemoryMetricH2DAO.java new file mode 100644 index 0000000000000000000000000000000000000000..0a94da62fa3241057230f04e5142d5138b5ae21a --- /dev/null +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/MemoryMetricH2DAO.java @@ -0,0 +1,89 @@ +package org.skywalking.apm.collector.ui.dao; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.client.h2.H2ClientException; +import org.skywalking.apm.collector.core.util.Const; +import org.skywalking.apm.collector.core.util.TimeBucketUtils; +import org.skywalking.apm.collector.storage.define.jvm.MemoryMetricTable; +import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.ArrayList; +import java.util.List; + +/** + * @author clevertension + */ +public class MemoryMetricH2DAO extends H2DAO implements IMemoryMetricDAO { + private final Logger logger = LoggerFactory.getLogger(InstanceH2DAO.class); + private static final String GET_MEMORY_METRIC_SQL = "select * from {0} where {1} =?"; + private static final String GET_MEMORY_METRICS_SQL = "select * from {0} where {1} in ("; + @Override public JsonObject getMetric(int instanceId, long timeBucket, boolean isHeap) { + H2Client client = getClient(); + String id = timeBucket + Const.ID_SPLIT + instanceId + Const.ID_SPLIT + isHeap; + String sql = MessageFormat.format(GET_MEMORY_METRIC_SQL, MemoryMetricTable.TABLE, "id"); + Object[] params = new Object[]{id}; + JsonObject metric = new JsonObject(); + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + metric.addProperty("max", rs.getInt(MemoryMetricTable.COLUMN_MAX)); + metric.addProperty("init", rs.getInt(MemoryMetricTable.COLUMN_INIT)); + metric.addProperty("used", rs.getInt(MemoryMetricTable.COLUMN_USED)); + } else { + metric.addProperty("max", 0); + metric.addProperty("init", 0); + metric.addProperty("used", 0); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return metric; + } + + @Override public JsonObject getMetric(int instanceId, long startTimeBucket, long endTimeBucket, boolean isHeap) { + H2Client client = getClient(); + String sql = MessageFormat.format(GET_MEMORY_METRICS_SQL, MemoryMetricTable.TABLE, "id"); + List idList = new ArrayList<>(); + long timeBucket = startTimeBucket; + do { + timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1); + String id = timeBucket + Const.ID_SPLIT + instanceId + Const.ID_SPLIT + isHeap; + idList.add(id); + } + while (timeBucket <= endTimeBucket); + + StringBuilder builder = new StringBuilder(); + for (int i = 0; i < idList.size(); i++) { + builder.append("?,"); + } + builder.delete(builder.length() - 1, builder.length()); + builder.append(")"); + sql = sql + builder; + Object[] params = idList.toArray(new String[0]); + JsonObject metric = new JsonObject(); + JsonArray usedMetric = new JsonArray(); + try (ResultSet rs = client.executeQuery(sql, params)) { + while (rs.next()) { + metric.addProperty("max", rs.getLong(MemoryMetricTable.COLUMN_MAX)); + metric.addProperty("init", rs.getLong(MemoryMetricTable.COLUMN_INIT)); + usedMetric.add(rs.getLong(MemoryMetricTable.COLUMN_USED)); + } + if (usedMetric.size() == 0) { + metric.addProperty("max", 0); + metric.addProperty("init",0); + usedMetric.add(0); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + + metric.add("used", usedMetric); + return metric; + } +} diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/MemoryPoolMetricH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/MemoryPoolMetricH2DAO.java new file mode 100644 index 0000000000000000000000000000000000000000..cde5bfcc0f8a75abe8c93cab84707106c171d2b0 --- /dev/null +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/MemoryPoolMetricH2DAO.java @@ -0,0 +1,89 @@ +package org.skywalking.apm.collector.ui.dao; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.client.h2.H2ClientException; +import org.skywalking.apm.collector.core.util.Const; +import org.skywalking.apm.collector.core.util.TimeBucketUtils; +import org.skywalking.apm.collector.storage.define.jvm.MemoryPoolMetricTable; +import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.ArrayList; +import java.util.List; + +/** + * @author clevertension + */ +public class MemoryPoolMetricH2DAO extends H2DAO implements IMemoryPoolMetricDAO { + private final Logger logger = LoggerFactory.getLogger(InstanceH2DAO.class); + private static final String GET_MEMORY_POOL_METRIC_SQL = "select * from {0} where {1} =?"; + private static final String GET_MEMORY_POOL_METRICS_SQL = "select * from {0} where {1} in ("; + @Override public JsonObject getMetric(int instanceId, long timeBucket, int poolType) { + H2Client client = getClient(); + String id = timeBucket + Const.ID_SPLIT + instanceId + Const.ID_SPLIT + poolType; + String sql = MessageFormat.format(GET_MEMORY_POOL_METRIC_SQL, MemoryPoolMetricTable.TABLE, "id"); + Object[] params = new Object[]{id}; + JsonObject metric = new JsonObject(); + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + metric.addProperty("max", rs.getInt(MemoryPoolMetricTable.COLUMN_MAX)); + metric.addProperty("init", rs.getInt(MemoryPoolMetricTable.COLUMN_INIT)); + metric.addProperty("used", rs.getInt(MemoryPoolMetricTable.COLUMN_USED)); + } else { + metric.addProperty("max", 0); + metric.addProperty("init", 0); + metric.addProperty("used", 0); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return metric; + } + + @Override public JsonObject getMetric(int instanceId, long startTimeBucket, long endTimeBucket, int poolType) { + H2Client client = getClient(); + String sql = MessageFormat.format(GET_MEMORY_POOL_METRICS_SQL, MemoryPoolMetricTable.TABLE, "id"); + List idList = new ArrayList<>(); + long timeBucket = startTimeBucket; + do { + timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1); + String id = timeBucket + Const.ID_SPLIT + instanceId + Const.ID_SPLIT + poolType; + idList.add(id); + } + while (timeBucket <= endTimeBucket); + + StringBuilder builder = new StringBuilder(); + for (int i = 0; i < idList.size(); i++) { + builder.append("?,"); + } + builder.delete(builder.length() - 1, builder.length()); + builder.append(")"); + sql = sql + builder; + Object[] params = idList.toArray(new String[0]); + JsonObject metric = new JsonObject(); + JsonArray usedMetric = new JsonArray(); + try (ResultSet rs = client.executeQuery(sql, params)) { + while (rs.next()) { + metric.addProperty("max", rs.getLong(MemoryPoolMetricTable.COLUMN_MAX)); + metric.addProperty("init", rs.getLong(MemoryPoolMetricTable.COLUMN_INIT)); + usedMetric.add(rs.getLong(MemoryPoolMetricTable.COLUMN_USED)); + } + if (usedMetric.size() == 0) { + metric.addProperty("max", 0); + metric.addProperty("init",0); + usedMetric.add(0); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + + metric.add("used", usedMetric); + return metric; + } +} diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeComponentH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeComponentH2DAO.java index e3f818691d9834cd2c626212c87857cf4188e1ef..a5cc16bc0d0964520ec1ce31d1bc95ae320291c1 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeComponentH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeComponentH2DAO.java @@ -16,7 +16,7 @@ import java.sql.SQLException; import java.text.MessageFormat; /** - * @author pengys5 + * @author pengys5, clevertension */ public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO { private final Logger logger = LoggerFactory.getLogger(NodeComponentH2DAO.class); diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeMappingH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeMappingH2DAO.java index 6fb2cea3c3b427fbe7712a509ea4819d0407f10e..95cacb37a3a63fc11e9dc9aefa82e1927624c3a4 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeMappingH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeMappingH2DAO.java @@ -16,7 +16,7 @@ import java.sql.SQLException; import java.text.MessageFormat; /** - * @author pengys5 + * @author pengys5, clevertension */ public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO { private final Logger logger = LoggerFactory.getLogger(NodeMappingH2DAO.class); diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeReferenceH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeReferenceH2DAO.java index ab9df2fdbbe3e828416eeca76e89ed5fb32bf8c6..f6e1169cd00b99b8f67bc256f331f17df558a06e 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeReferenceH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeReferenceH2DAO.java @@ -5,7 +5,6 @@ import com.google.gson.JsonObject; import org.skywalking.apm.collector.client.h2.H2Client; import org.skywalking.apm.collector.client.h2.H2ClientException; import org.skywalking.apm.collector.core.util.StringUtils; -import org.skywalking.apm.collector.storage.define.node.NodeMappingTable; import org.skywalking.apm.collector.storage.define.noderef.NodeReferenceTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; import org.skywalking.apm.collector.ui.cache.ApplicationCache; @@ -17,7 +16,7 @@ import java.sql.SQLException; import java.text.MessageFormat; /** - * @author pengys5 + * @author pengys5, clevertension */ public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO { private final Logger logger = LoggerFactory.getLogger(NodeReferenceH2DAO.class); diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/SegmentCostH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/SegmentCostH2DAO.java index 1621927b2725d58e0b535a8a1a9ae4dd4eeddd11..21443371f3667f899b42b710b6a860239ae6a6a3 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/SegmentCostH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/SegmentCostH2DAO.java @@ -1,15 +1,136 @@ package org.skywalking.apm.collector.ui.dao; +import com.google.gson.JsonArray; import com.google.gson.JsonObject; -import java.util.List; +import org.elasticsearch.search.sort.SortOrder; +import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.client.h2.H2ClientException; +import org.skywalking.apm.collector.core.util.CollectionUtils; +import org.skywalking.apm.collector.core.util.StringUtils; +import org.skywalking.apm.collector.storage.dao.DAOContainer; +import org.skywalking.apm.collector.storage.define.global.GlobalTraceTable; +import org.skywalking.apm.collector.storage.define.segment.SegmentCostTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.ArrayList; +import java.util.List; /** - * @author pengys5 + * @author pengys5, clevertension */ public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO { + private final Logger logger = LoggerFactory.getLogger(SegmentCostH2DAO.class); + private static final String GET_SEGMENT_COST_SQL = "select * from {0} where {1} >= ? and {1} <= ?"; @Override public JsonObject loadTop(long startTime, long endTime, long minCost, long maxCost, String operationName, Error error, int applicationId, List segmentIds, int limit, int from, Sort sort) { - return null; + H2Client client = getClient(); + String sql = GET_SEGMENT_COST_SQL; + List params = new ArrayList<>(); + List columns = new ArrayList<>(); + params.add(startTime); + params.add(endTime); + int paramIndex = 1; + if (minCost != -1 || maxCost != -1) { + if (minCost != -1) { + paramIndex++; + sql = sql + " and {" + paramIndex + "} >= ?"; + params.add(minCost); + columns.add(SegmentCostTable.COLUMN_COST); + } + if (maxCost != -1) { + paramIndex++; + sql = sql + " and {" + paramIndex + "} <= ?"; + params.add(maxCost); + columns.add(SegmentCostTable.COLUMN_COST); + } + } + if (StringUtils.isNotEmpty(operationName)) { + paramIndex++; + sql = sql + " and {" + paramIndex + "} = ?"; + params.add(operationName); + columns.add(SegmentCostTable.COLUMN_SERVICE_NAME); + } + if (CollectionUtils.isNotEmpty(segmentIds)) { + paramIndex++; + sql = sql + " and {" + paramIndex + "} in ("; + columns.add(SegmentCostTable.COLUMN_SEGMENT_ID); + StringBuilder builder = new StringBuilder(); + for (int i = 0; i < segmentIds.size(); i++) { + builder.append("?,"); + } + builder.delete(builder.length() - 1, builder.length()); + builder.append(")"); + sql = sql + builder; + for (String segmentId : segmentIds) { + params.add(segmentId); + } + } + if (Error.True.equals(error)) { + paramIndex++; + sql = sql + " and {" + paramIndex + "} = ?"; + params.add(true); + columns.add(SegmentCostTable.COLUMN_IS_ERROR); + } else if (Error.False.equals(error)) { + paramIndex++; + sql = sql + " and {" + paramIndex + "} = ?"; + params.add(false); + columns.add(SegmentCostTable.COLUMN_IS_ERROR); + } + if (applicationId != 0) { + paramIndex++; + sql = sql + " and {" + paramIndex + "} = ?"; + params.add(applicationId); + columns.add(SegmentCostTable.COLUMN_APPLICATION_ID); + } + + if (Sort.Cost.equals(sort)) { + sql = sql + " order by " + SegmentCostTable.COLUMN_COST + " " + SortOrder.DESC; + } else if (Sort.Time.equals(sort)) { + sql = sql + " order by " + SegmentCostTable.COLUMN_START_TIME + " " + SortOrder.DESC; + } + + sql = sql + " limit " + from + "," + limit; + sql = MessageFormat.format(sql, SegmentCostTable.TABLE, SegmentCostTable.COLUMN_TIME_BUCKET, columns); + Object[] p = params.toArray(new Object[0]); + + JsonObject topSegPaging = new JsonObject(); + + + JsonArray topSegArray = new JsonArray(); + topSegPaging.add("data", topSegArray); + int cnt = 0; + int num = from; + try (ResultSet rs = client.executeQuery(sql, p)) { + JsonObject topSegmentJson = new JsonObject(); + topSegmentJson.addProperty("num", num); + String segmentId = rs.getString(SegmentCostTable.COLUMN_SEGMENT_ID); + topSegmentJson.addProperty(SegmentCostTable.COLUMN_SEGMENT_ID, segmentId); + topSegmentJson.addProperty(SegmentCostTable.COLUMN_START_TIME, rs.getLong(SegmentCostTable.COLUMN_START_TIME)); + topSegmentJson.addProperty(SegmentCostTable.COLUMN_END_TIME, rs.getLong(SegmentCostTable.COLUMN_END_TIME)); + + IGlobalTraceDAO globalTraceDAO = (IGlobalTraceDAO) DAOContainer.INSTANCE.get(IGlobalTraceDAO.class.getName()); + List globalTraces = globalTraceDAO.getGlobalTraceId(segmentId); + if (CollectionUtils.isNotEmpty(globalTraces)) { + topSegmentJson.addProperty(GlobalTraceTable.COLUMN_GLOBAL_TRACE_ID, globalTraces.get(0)); + } + + topSegmentJson.addProperty(SegmentCostTable.COLUMN_APPLICATION_ID, rs.getInt(SegmentCostTable.COLUMN_APPLICATION_ID)); + topSegmentJson.addProperty(SegmentCostTable.COLUMN_SERVICE_NAME, rs.getString(SegmentCostTable.COLUMN_SERVICE_NAME)); + topSegmentJson.addProperty(SegmentCostTable.COLUMN_COST, rs.getLong(SegmentCostTable.COLUMN_COST)); + topSegmentJson.addProperty(SegmentCostTable.COLUMN_IS_ERROR, rs.getBoolean(SegmentCostTable.COLUMN_IS_ERROR)); + + num++; + topSegArray.add(topSegmentJson); + cnt++; + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + topSegPaging.addProperty("recordsTotal", cnt); + return topSegPaging; } } diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/SegmentH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/SegmentH2DAO.java index 06b55d904f017a547b09e8216290a3b72e556135..fd58c0fdf376fb78acbd839401af0415fc743f41 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/SegmentH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/SegmentH2DAO.java @@ -1,13 +1,46 @@ package org.skywalking.apm.collector.ui.dao; +import com.google.protobuf.InvalidProtocolBufferException; +import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.client.h2.H2ClientException; +import org.skywalking.apm.collector.core.util.StringUtils; +import org.skywalking.apm.collector.storage.define.segment.SegmentTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; import org.skywalking.apm.network.proto.TraceSegmentObject; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.Base64; /** - * @author pengys5 + * @author pengys5, clevertension */ public class SegmentH2DAO extends H2DAO implements ISegmentDAO { + private final Logger logger = LoggerFactory.getLogger(SegmentH2DAO.class); + private static final String GET_SEGMENT_SQL = "select {0} from {1} where {2} = ?"; @Override public TraceSegmentObject load(String segmentId) { + H2Client client = getClient(); + String sql = MessageFormat.format(GET_SEGMENT_SQL, SegmentTable.COLUMN_DATA_BINARY, + SegmentTable.TABLE, "id"); + Object[] params = new Object[]{segmentId}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + String dataBinaryBase64 = rs.getString(SegmentTable.COLUMN_DATA_BINARY); + if (StringUtils.isNotEmpty(dataBinaryBase64)) { + byte[] dataBinary = Base64.getDecoder().decode(dataBinaryBase64); + try { + return TraceSegmentObject.parseFrom(dataBinary); + } catch (InvalidProtocolBufferException e) { + logger.error(e.getMessage(), e); + } + } + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return null; } } diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceEntryH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceEntryH2DAO.java index da811365d4821a5a22fd560afd8012a8baf60569..8c6bb83e03d60b5394f9cdf8718da558fafaf4cb 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceEntryH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceEntryH2DAO.java @@ -1,14 +1,78 @@ package org.skywalking.apm.collector.ui.dao; +import com.google.gson.JsonArray; import com.google.gson.JsonObject; +import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.client.h2.H2ClientException; +import org.skywalking.apm.collector.core.util.ColumnNameUtils; +import org.skywalking.apm.collector.core.util.StringUtils; +import org.skywalking.apm.collector.storage.define.service.ServiceEntryTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.skywalking.apm.collector.ui.cache.ApplicationCache; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.util.ArrayList; +import java.util.List; /** * @author pengys5 */ public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO { + private final Logger logger = LoggerFactory.getLogger(SegmentH2DAO.class); + private static final String GET_SERVICE_ENTRY_SQL = "select * from {0} where {1} >= ? and {2} <= ?"; @Override public JsonObject load(int applicationId, String entryServiceName, long startTime, long endTime, int from, int size) { - return null; + H2Client client = getClient(); + String sql = GET_SERVICE_ENTRY_SQL; + List params = new ArrayList<>(); + List columns = new ArrayList<>(); + params.add(startTime); + params.add(endTime); + int paramIndex = 2; + if (applicationId != 0) { + paramIndex++; + sql = sql + " and {" + paramIndex + "} = ?"; + params.add(applicationId); + columns.add(ServiceEntryTable.COLUMN_APPLICATION_ID); + } + if (StringUtils.isNotEmpty(entryServiceName)) { + paramIndex++; + sql = sql + " and {" + paramIndex + "} = ?"; + params.add(entryServiceName); + columns.add(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME); + } + sql = sql + " limit " + from + "," + size; + sql = MessageFormat.format(sql, ServiceEntryTable.TABLE, ServiceEntryTable.COLUMN_NEWEST_TIME, + ServiceEntryTable.COLUMN_REGISTER_TIME, columns); + Object[] p = params.toArray(new Object[0]); + JsonArray serviceArray = new JsonArray(); + JsonObject response = new JsonObject(); + int index = 0; + try (ResultSet rs = client.executeQuery(sql, p)) { + while (rs.next()) { + int appId = rs.getInt(ServiceEntryTable.COLUMN_APPLICATION_ID); + int entryServiceId = rs.getInt(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID); + String applicationCode = ApplicationCache.getForUI(applicationId); + String entryServiceName1 = rs.getString(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME); + + JsonObject row = new JsonObject(); + row.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID), entryServiceId); + row.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME), entryServiceName1); + row.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceEntryTable.COLUMN_APPLICATION_ID), appId); + row.addProperty("applicationCode", applicationCode); + serviceArray.add(row); + index++; + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + response.addProperty("total", index); + response.add("array", serviceArray); + + return response; } } diff --git a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceNameH2DAO.java b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceNameH2DAO.java index f0f585651bac57495d27401a20f118d142a150c7..71db6ffc00d585178546479af971fc607a7a02d6 100644 --- a/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceNameH2DAO.java +++ b/apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceNameH2DAO.java @@ -1,17 +1,52 @@ package org.skywalking.apm.collector.ui.dao; +import org.skywalking.apm.collector.client.h2.H2Client; +import org.skywalking.apm.collector.client.h2.H2ClientException; +import org.skywalking.apm.collector.core.util.Const; +import org.skywalking.apm.collector.storage.define.register.ServiceNameTable; import org.skywalking.apm.collector.storage.h2.dao.H2DAO; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; /** - * @author pengys5 + * @author pengys5, clevertension */ public class ServiceNameH2DAO extends H2DAO implements IServiceNameDAO { - + private final Logger logger = LoggerFactory.getLogger(ServiceNameH2DAO.class); + private static final String GET_SERVICE_NAME_SQL = "select {0} from {1} where {2} = ?"; + private static final String GET_SERVICE_ID_SQL = "select {0} from {1} where {2} = ? and {3} = ? limit 1"; @Override public String getServiceName(int serviceId) { - return null; + H2Client client = getClient(); + String sql = MessageFormat.format(GET_SERVICE_NAME_SQL, ServiceNameTable.COLUMN_SERVICE_NAME, + ServiceNameTable.TABLE, ServiceNameTable.COLUMN_SERVICE_ID); + Object[] params = new Object[]{serviceId}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + return rs.getString(ServiceNameTable.COLUMN_SERVICE_NAME); + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } + return Const.UNKNOWN; } @Override public int getServiceId(int applicationId, String serviceName) { + H2Client client = getClient(); + String sql = MessageFormat.format(GET_SERVICE_ID_SQL, ServiceNameTable.COLUMN_SERVICE_ID, + ServiceNameTable.TABLE, ServiceNameTable.COLUMN_APPLICATION_ID, ServiceNameTable.COLUMN_SERVICE_NAME); + Object[] params = new Object[]{applicationId, serviceName}; + try (ResultSet rs = client.executeQuery(sql, params)) { + if (rs.next()) { + int serviceId = rs.getInt(ServiceNameTable.COLUMN_SERVICE_ID); + return serviceId; + } + } catch (SQLException | H2ClientException e) { + logger.error(e.getMessage(), e); + } return 0; } } diff --git a/apm-collector/apm-collector-ui/src/main/resources/META-INF/defines/h2_dao.define b/apm-collector/apm-collector-ui/src/main/resources/META-INF/defines/h2_dao.define index d110e3684bf5fa76217c622638a8999b82f88c12..742176e4dc9eff76dd69f1b3892cf170d6c8fa9e 100644 --- a/apm-collector/apm-collector-ui/src/main/resources/META-INF/defines/h2_dao.define +++ b/apm-collector/apm-collector-ui/src/main/resources/META-INF/defines/h2_dao.define @@ -8,6 +8,9 @@ org.skywalking.apm.collector.ui.dao.ApplicationH2DAO org.skywalking.apm.collector.ui.dao.ServiceNameH2DAO org.skywalking.apm.collector.ui.dao.InstanceH2DAO org.skywalking.apm.collector.ui.dao.InstPerformanceH2DAO +org.skywalking.apm.collector.ui.dao.CpuMetricH2DAO org.skywalking.apm.collector.ui.dao.GCMetricH2DAO +org.skywalking.apm.collector.ui.dao.MemoryMetricH2DAO +org.skywalking.apm.collector.ui.dao.MemoryPoolMetricH2DAO org.skywalking.apm.collector.ui.dao.ServiceEntryH2DAO org.skywalking.apm.collector.ui.dao.ServiceReferenceH2DAO \ No newline at end of file